// // Compilation instructions: // ----------------------------------------------- // 1. Save to snake.c // 2. Terminal~$: gcc -Wall -g -pedantic -O2 -pthread -o snake snake.c // 3. Terminal~$: ./snake // # include // Req for printf() # include // Req for rand() # include // Req for clock_t & clock() # include // Req for FILE_NO # include // Req for unbuffered input (GNU/Linux only) # include // Req for our event_thread (GNU/Linux only) // // A regular Unix terminal window is 80 x 24 characters // if your terminal window is larger you may wish to change // the width and height here! // # define TERMINAL_WIDTH (80) # define TERMINAL_HEIGHT (24) # define FPS (15) # define IS_HIGHSCORE(a, b) (((a) > (b)) ? (a) : (b)) // // This snake game requires that a row is left blank // to display score and receive input :-) // # define COL (TERMINAL_WIDTH) # define ROW (TERMINAL_HEIGHT-1) // Maximum dots our snake can hold # define MAX_DOTS (100) // // You can change your keybinds here! // enum keybinds { KEY_UP = 'w', KEY_DOWN = 's', KEY_LEFT = 'a', KEY_RIGHT = 'd', KEY_EXIT = 'q' }; // // A tiny list of all our game states // enum game_states { RUNNING_STATE, GAMEOVER_STATE, EXIT_STATE }; // // Contains the game state and our score // static struct game_state { unsigned short state:2; unsigned short score:8; unsigned short highscore:8; } game = { .state = RUNNING_STATE, .score = 0, .highscore = 0 }; // // Directions are mapped onto four bits: // --------------------------------- // Left = 0001 // Right = 0010 // Up = 0100 // Down = 1000 // --------------------------------- // enum snake_direction { MOVE_LEFT = (1 << 0), MOVE_RIGHT = (1 << 1), MOVE_UP = (1 << 2), MOVE_DOWN = (1 << 3) }; // // This snake structure holds two arrays // corresponding to a dot's x and y position on // the screen for all the 'dots' // along with a direction variable to keep track // of movement. // struct snake { unsigned short xpos[ MAX_DOTS ]; unsigned short ypos[ MAX_DOTS ]; unsigned short dots:8; unsigned short direction; }; // // Our apple contains an x and y position // struct apple { unsigned short xpos:8; unsigned short ypos:8; }; // // Our game map, which we draw to! // static char map[ROW][COL]; // GNU/Linux & Mac specific static struct termios control; // // GNU/Linux specific function to disable buffered input // for our terminal which is necessary to accept input // without having to enter a linebreak. // static void init_control ( void ) { tcgetattr( STDIN_FILENO, &control ); control.c_lflag &= ~ICANON; tcsetattr( STDIN_FILENO, TCSANOW, &control ); } // // Spawn the apple at a random location // on the screen. // static void spawn_apple( struct apple* apple ) { srand( time( NULL ) ); apple -> xpos = rand() % (COL-1); apple -> ypos = rand() % (ROW-1)+1; } // // Check if the snake ate the apple // static void check_apple( struct snake* snake, struct apple* apple ) { // // If the snake's head is on the same position // as the apple then we grow the snake, keep the score // and spawn another apple // if (snake -> xpos[0] == apple -> xpos && snake -> ypos[0] == apple -> ypos) { snake -> dots++; game.score = snake -> dots - 3; // -3 as we started out with 3 dots game.highscore = IS_HIGHSCORE(game.score, game.highscore); // new highscore? spawn_apple( apple ); } } static void snake_init( struct snake *snake ) { int i = 0; static int screen_width = COL; static int screen_height = ROW; // The snake starts off at the center of the screen // with 3 dots, we let the user-input determine // direction. snake -> direction = 0; snake -> dots = 3; for (i = 0; i < snake -> dots; i++) { snake -> xpos[i] = screen_width / 2; snake -> ypos[i] = screen_height / 2; } } static void snake_move( struct snake* snake ) { int i = 0; // // Update each dot position // for (i = snake->dots; i > 0; i--) { snake->xpos[ i ] = snake->xpos[ i-1 ]; snake->ypos[ i ] = snake->ypos[ i-1 ]; } // // Update our snake head's position // if (snake -> direction & MOVE_LEFT) snake -> xpos[ 0 ] -= 1; if (snake -> direction & MOVE_RIGHT) snake -> xpos[ 0 ] += 1; if (snake -> direction & MOVE_UP) snake -> ypos[ 0 ] -= 1; if (snake -> direction & MOVE_DOWN) snake -> ypos[ 0 ] += 1; } static void check_collision( struct snake* snake ) { int i = 0; static const int screen_width = COL-1; // don't cross the linebreaks static const int screen_height = ROW; // // Did the snake collide with its own tail? // for (i = snake->dots; i > 0; i--) if (snake -> xpos[ 0 ] == snake -> xpos[ i ] && snake -> ypos[ 0 ] == snake -> ypos[ i ] && (i > 4)) game.state = GAMEOVER_STATE; // // Did the snake collide with the walls? // if (snake -> xpos[ 0 ] < 0 || snake -> xpos[ 0 ] >= screen_width || snake -> ypos[ 0 ] < 1 || // +1, as we have a spare row that snake -> ypos[ 0 ] >= screen_height) // consumes the input keys game.state = GAMEOVER_STATE; // from our unbuffered input. } // // Initialize the map which we draw to and render // in our game loop. // // We append a newline character to the end of each // row, if you are on a Mac the linebreak character // may have to be changed (only tested on GNU/Linux). // static void init_map ( void ) { int row, col; for (row = 0; row < ROW; row++) { for (col = 0; col < COL; col++) { map[ row ][ col ] = ' '; } map[ row ][ col-1 ] = '\n'; // Add a linebreak } } // // Draw out each character of our map to the screen // static void draw_map ( void ) { int row, col; for (row = 0; row < ROW; row++) for (col = 0; col < COL; col++) putchar(map[ row ][ col ]); } // // We clear the map after each iteration in our game loop to // update the screen after each draw cycle. // That way, we dont have to worry about erasing our previous // draws. // static void clear_map ( void ) { init_map(); // Re-initialize the map } // // When we want to draw a character to the screen // we use this function. It assures the character is inside the // the screen before drawing to it. // // x coordinate is most often on the horizontal axis & // y coordinate on the vertical axis , but with columns and rows // the columns are horizontal and the rows are vertical, so // we flip the x and y in our map to prevent confusion! :-) // static void draw_char( int x, int y, char ch ) { // Do not draw outside of boundaries!! if (y >= 0 && y <= ROW && x >= 0 && x < COL) map[ y ][ x ] = ch; } // // Initialize the snake and spawn the apple. // static void init_game ( struct snake* snake, struct apple* apple ) { snake_init( snake ); spawn_apple( apple ); } // We need this to draw our game objects to the screen static void draw_game ( struct snake* snake, struct apple* apple ) { int i = 0; // Draws the apple which is a zero '0' character // if the font on your terminal makes it hard to // distinguish between the snake head and the apple // you can change it to something else, // ex: '#' or 'x'. draw_char(apple -> xpos, apple -> ypos, '0'); // Moves the snake snake_move( snake ); // For each snake-dot we draw a 'o' character unless it's // the head, then we draw a big 'O' for (i = 0; i < snake -> dots; i++ ) { // since there is only one head & many dots // we can optimize branch predictions by checking // for dots first draw_char(snake -> xpos[ i ], snake -> ypos[ i ], i > 0 ? 'o' : 'O'); } } // // If our snake collided, reset the game & start over! // static void reset_game ( struct snake* snake, struct apple* apple ) { clear_map(); // Clear the map init_game( snake, apple ); // Reset our snake & spawn an apple game.score = 0; // Reset our score game.state = RUNNING_STATE; // Set the game state! } // // Handle user input // static int handle_events ( struct snake* snake ) { int input = getchar(); // Read in a character unsigned short* move = &snake->direction; // // We use flags to set and unset bits in our direction // variable (unsigned short). // if (input == KEY_UP) { *move &= ~(MOVE_RIGHT | MOVE_LEFT | MOVE_DOWN); // Unset right, left, down *move |= MOVE_UP; // Set the MOVE_UP flag } else if (input == KEY_DOWN) { *move &= ~(MOVE_RIGHT | MOVE_LEFT | MOVE_UP); // ^ *move |= MOVE_DOWN; // ... } else if (input == KEY_LEFT) { *move &= ~(MOVE_UP | MOVE_DOWN | MOVE_RIGHT); // ... *move |= MOVE_LEFT; } else if (input == KEY_RIGHT) { *move &= ~(MOVE_UP | MOVE_DOWN | MOVE_LEFT); // ... *move |= MOVE_RIGHT; } else if (input == KEY_EXIT) { game.state = EXIT_STATE; // If the user presses the exit key return 0; // then our game state is set to EXIT_STATE } // and we exit our program. return 1; } // // Our thread calls this function which polls for user input // while we run our game. // static void* process_events( void* data ) { struct snake* p = (struct snake *)data; for (;;) { if (!handle_events(p)) break; usleep((1000 / FPS) * 1000); } return (void *)EXIT_STATE; } int main( int argc, char** argv ) { clock_t frame_start; // Keeps track of frame time clock_t frame_end; // Keeps track of frame time unsigned int fps = FPS; // Draw to the screen 15 times per sec. unsigned int frame_delay = 1000 / fps; // delay_time = 66ms delay for 15 fps unsigned int frame_end_ms = 0; // Holds frame_end time converted to ms. struct snake snake; // Our snake struct apple apple; // Our apple pthread_t event_thread; // Our event thread. // // Initialize the controls for our terminal window // init_control(); // // Initialize the game // init_game( &snake, &apple ); // // Create an event_thread which polls for user input // on a separate thread so we don't have to _wait_ for // key presses before the game can be updated. // if (pthread_create(&event_thread, NULL, process_events, (void *)&snake) < 0) { fprintf( stderr, "Failed to create event thread.\n" ); return -1; } // // Run our game loop until we get an EXIT_STATE // which is set if the user presses 'q' or whichever // key the KEY_QUIT is bound to :-) // while ( game.state != EXIT_STATE ) { frame_start = clock(); // Reference-point for the FPS cap // Clear the map before drawing to it clear_map(); // Collision checking check_collision( &snake ); check_apple( &snake, &apple ); if (game.state == GAMEOVER_STATE) reset_game( &snake, &apple ); // Draw our snake and our apple to the screen draw_game( &snake, &apple ); // Update the screen draw_map(); // Display our current score and the apple's location. printf("Score: %02d\tApple x:%02d y:%02d \tHighscore: %02d\n", game.score, apple.xpos, apple.ypos, game.highscore); // Measure how long it took to draw one frame. frame_end = clock() - frame_start; frame_end_ms = frame_end * 1000 / CLOCKS_PER_SEC; // If our frame was drawn in less than 66 ms (15 fps), // we want to subtract the time it took to draw the // frame with our delay time and sleep for that long. // // Ex: Our frame took 5 ms to complete, we want to sleep // 66 ms - 5 ms = 61 ms. if ( frame_end_ms < frame_delay ) usleep((frame_delay - frame_end_ms) * 1000); } // // Stop our event thread! // if ( pthread_join( event_thread, NULL ) < 0) { fprintf( stderr, "Failed to join thread.\n" ); return -2; } // Exit our game successfully! return 0; }

Snake Game in GNU/Linux Terminal