void gameloop(int nrow, int ncol) {
timeout(1000 / SAMPLING_RATE);
const clock_t checkpoint = (clock_t) (CLOCKS_PER_SEC/GAME_SPEED);
clock_t last_update = clock();
struct snake * snake = new_snake(ncol/2, nrow/2);
struct point food_pos = generate_food(nrow, ncol, snake);
redraw(snake, food_pos);
for (;;) {
struct point tail_pos = snake->tail->pos;
int ch;
if ((ch = getch()) != ERR) {
switch (ch) {
case KEY_UP:
case KEY_DOWN:
case KEY_LEFT:
case KEY_RIGHT:
if (to_dir(ch) == reverse_dir(snake->heading)) {
break;
}
else {
snake->heading = to_dir(ch);
step_snake(snake);
tail_pos = snake->tail->pos;
redraw(snake, food_pos);
}
break;
default:
break;
}
}
if (clock() - last_update >= checkpoint) {
step_snake(snake);
tail_pos = snake->tail->pos;
redraw(snake, food_pos);
last_update = clock();
}
if (point_equal(snake->head->pos, food_pos)) {
grow_snake(snake, tail_pos);
food_pos = generate_food(nrow, ncol, snake);
redraw(snake, food_pos);
}
if (out_of_border(snake->head->pos, nrow, ncol)
|| eat_self(snake)) {
display_lose(nrow, ncol);
return;
}
if (snake->length == (nrow-2)*(ncol-2)) {
display_win(nrow, ncol);
return;
}
}
}
void init() {
screen = new_screen();
int x_pos = screen->max_x/2;
int y_pos = screen->max_y/2;
snake = new_snake(x_pos, y_pos);
move_list = new_move_list();
int i;
food_list = new_food_list();
for(i = 0; i < FOOD_COUNT; i++) {
add_food(screen->max_x, screen->max_y, food_list);
}
}
int main(int argc, char *argv[]){
int i,cnt,err;
snake s[MAXSNAKES];
err = 0;
for (i=1;i<argc;i++) { /* check options */
fprintf(stderr,"%s: unknown option\n",argv[i]);
err++;
}
if ( err ) {
fprintf(stderr,"usage: %s [-z]\n",argv[0]);
exit(err);
}
install_handler(SIGINT, (sigfun)kill_snake); /* SIGINT will kill a snake */
install_handler(SIGQUIT,(sigfun)lwp_stop); /* SIGQUIT will stop the system */
start_windowing(); /* start up curses windowing */
/* Initialize Snakes */
cnt = 0;
/* snake new_snake(int y, int x, int len, int dir, int color) ;*/
s[cnt++] = new_snake( 8,30,10, E,1);/* each starts a different color */
s[cnt++] = new_snake(10,30,10, E,2);
s[cnt++] = new_snake(12,30,10, E,3);
s[cnt++] = new_snake( 8,50,10, W,4);
s[cnt++] = new_snake(10,50,10, W,5);
s[cnt++] = new_snake(12,50,10, W,6);
s[cnt++] = new_snake( 4,40,10, S,7);
/* Draw each snake */
draw_all_snakes();
/* turn each snake loose as an individual LWP */
for(i=0;i<cnt;i++) {
s[i]->lw_pid = lwp_create((lwpfun)run_hungry_snake,(void*)(s+i),
INITIALSTACK);
}
lwp_start(); /* returns when the last lwp exits */
end_windowing(); /* close down curses windowing */
printf("Goodbye.\n"); /* Say goodbye, Gracie */
return err;
}
void play_client(config cfg) {
//time of the last step that occured. in ticks.
int ok; //signal we're waiting for before begining
char c; //key that is pressed
int ret; //value returned by 'read(0)', 0 if no new key was pressed
int ret_serv;
queue p1_queue = new_queue(MAX_INPUT_STACK); //queue used to stack player input
direction cur_dir;
direction* players_dir = malloc(cfg.nb_players*sizeof(direction));
//let's wait for server's signal
ret_serv = read(sockfd, &ok, 1*sizeof(int));
if(ret_serv < 0){
perror("handle_server read waiting for signal");
}
else if(ret_serv == 0){
printf("Server on socket %i closed connection.\n", sockfd); clear(); safe_quit(1);
}
if(ok != 1){
printf("Wrong signal recieved from server. Received %i.\n", ok); safe_quit(1);
}
printf("Signal received. Starting now\n");
//sleep(3);
//GO
clear();
mode_raw(1);
//creating field
field* map = new_field(WIDTH, HEIGHT);
//creating snakes
int i;
snake** snakes = malloc(cfg.nb_players*sizeof(snake*));
for(i = 0; i < cfg.nb_players; i++){
snakes[i] = new_snake(T_SNAKE, cfg.size, i, map);
}
fflush(stdout);
struct timeval last_step_time;
gettimeofday(&last_step_time, NULL);
struct timeval now;
int elapsed_time; //elapsed time
while(1){
//SUMMARY
//1 - let's check if it's time to retrieve input
//2 - let's retrieve and sort every input
//3 - let's send the server our direction
//4 - let's wait for server's directions
//5 - let's make snakes move
//6 - let's update last_step_time
//--------------------------------------
//1 - let's check if it's time to retrieve input
gettimeofday(&now, NULL);
elapsed_time = diff_time(now, last_step_time); //time elapsed since last round. in ms.
if(elapsed_time > TIME_STEP - PING){
//2 - let's retrieve and sort every input
while((ret = read(0, &c, sizeof(char))) != 0){
if(ret == -1){
perror("read in 'play()'"); safe_quit(1);
}
if(c == C_QUIT){
mode_raw(0);
clear();
free_queue(&p1_queue);
free_all_client(map, snakes, cfg.nb_players);
return;
}
else if(key_is_p1_dir(c)){
//if the key is a move key for player 1:
if(! queue_full(&p1_queue)){
enqueue(&p1_queue, key_to_dir(c));
}
}
else{
//key pressed was a useless key. Do nothing.
}
}
//3 - let's send the server our direction
cur_dir = (! queue_empty(&p1_queue)) ? dequeue(&p1_queue) : snakes[cfg.id]->dir;
cur_dir = (cur_dir == opposite(snakes[cfg.id]->dir)) ? snakes[cfg.id]->dir : cur_dir;
if(write(sockfd, &cur_dir, 1*sizeof(direction)) < 0){
perror("handle_server write"); safe_quit(1);
}
switch(cur_dir){
case 0:
write(2, "sent 0\n", 7*sizeof(char));
break;
case 1:
write(2, "sent 1\n", 7*sizeof(char));
break;
case 2:
write(2, "sent 2\n", 7*sizeof(char));
break;
case 3:
write(2, "sent 3\n", 7*sizeof(char));
break;
}
//4 - let's wait for server's directions
ret_serv = read(sockfd, players_dir, cfg.nb_players*sizeof(direction));
if(ret_serv == -1){
perror("handle_server read"); safe_quit(1);
}
else if(ret_serv == 0){
clear(); printf("Server closed connection.\n"); safe_quit(1);
}
//5 - let's make snakes move
for(i = 0; i<cfg.nb_players; i++){
if(players_dir[i] != 4){ //if the player is not dead (dir = 4 => dead player)
move(snakes[i], players_dir[i], map);
}
}
fflush(stdout);
//6 - let's update last_step_time
gettimeofday(&last_step_time, NULL);
}
else{
//sleep 90% of the remaining time
usleep( (((TIME_STEP - PING) - elapsed_time) * 0.9) * 1000);
}
}
}
