drake/serpent
1
0
Fork 0
Code Issues Pull requests Activity

Updated: better ncurses, new main menu, etc

Browse source
This commit is contained in:
Lian Drake 2023-12-08 05:02:48 -04:00
parent 2554dcac3e
commit 569dd8832e
2 changed files with 416 additions and 306 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

682
serpent.c
View file

@ -30,29 +30,45 @@
#include "serpent.h" #include "serpent.h"
/* */ /* */
/* Game variables */ /* global variables */
bool is_alive = true; /* variable to track if snake is alive */ bool isAlive = true; /* variable to track if snake is alive */
int SPEED = 100; /* speed of the game */ bool isRunning = true;
int MAX_SPEED = 60; /* max speed of the game */ unsigned int SPEED = 100; /* speed of the game */
unsigned int MAX_SPEED = 60; /* max speed of the game */
unsigned int terminalRows;
unsigned int terminalCols;
int startY;
int startX;
unsigned int score;
/* */ /* */
/* Initialize structs */ /* Initialize structs */
snake_t *snake; Snake *snake;
apple_t *apple; Apple *apple;
/* */ /* */
/* Function prototypes */ /* Function prototypes */
void appendSnakeNode(snake_t *new_snake); // structure functions
snake_t *startSnake(board_t *board); Snake *startSnake();
Apple *startApple();
void appendSnakeNode(Snake *new_snake);
void freeSnake(); void freeSnake();
bool snakeOccupies(int x, int y, bool excludeHead);
int snakeSize(); int snakeSize();
apple_t *startApple(board_t *board); // game logic
void moveApple(board_t *board); void updateSnake();
bool appleOccupies(int x, int y); void updateApple();
bool snakeCollision(int x, int y, bool excludeHead);
bool appleCollision(int x, int y);
// game i-o
void handleInput(int key); void handleInput(int key);
void moveSnake(board_t *board); void drawGame();
void draw(board_t *board); // game functions
void initializeGame();
void gameLoop();
void run();
void mainMenu(WINDOW *menuScreen, int menuType);
void cleanup();
// command line functions
void argControls(); void argControls();
void argHelp(); void argHelp();
void argVersion(); void argVersion();
@ -86,74 +102,77 @@ int main (int argc, char **argv) {
return 1; return 1;
} }
} }
/* */
/* Initialize board */ initializeGame();
board_t board = {
.border = BOARD_CHAR,
.boardHeight = SCREEN_HEIGHT,
.boardWidth = SCREEN_WIDTH
};
/* Initialize the snake doubly-linked list */ cleanup();
snake = startSnake(&board);
/* Initialize the apple */
apple = startApple(&board);
/* Initialize window settings with ncurses */
initscr();
cbreak();
noecho();
keypad(stdscr, TRUE);
curs_set(0);
nodelay(stdscr, TRUE);
/* Check if the board size is greater than the screen size */
if (board.boardWidth > COLS || board.boardHeight > LINES) {
endwin();
printf("ERROR: Board size is larger than the terminal window.\n");
return 1;
}
while (is_alive) {
/* Take arrow key inputs */
int c = getch();
if (c != ERR) {
handleInput(c);
}
/* Update the snake position */
moveSnake(&board);
/* Redraw the frame */
draw(&board);
/* Refresh the window */
refresh();
usleep(SPEED * 800L);
}
/* Game score */
int score = snakeSize();
/* Free memory allocated by snake */
freeSnake();
/* Free memory allocated by apple */
free(apple);
/* End ncurses window */
endwin();
/* Print final score out to terminal */
printf("Game over. Score: %d", score - START_SNAKE_SIZE);
return 0; return 0;
} }
void appendSnakeNode(snake_t *new_snake) { /* Function responsible of initializing the snake strucutre */
Snake *startSnake() {
/* Allocate memory for a new snake */
Snake *new_snake = malloc(sizeof(Snake));
/* Allocate memory for the head of the snake */
SnakeNode *head = malloc(sizeof(SnakeNode));
/* Initialize the snake's head and tail to the allocated head node */
new_snake->head = head;
new_snake->tail = head;
/* Set the head's previous and next pointers to NULL, as it's the only node in the beginning */
head->prev = NULL;
head->next = NULL;
/* Set the initial position of the snake's head at the center of the board */
head->pX = SCREEN_WIDTH / 2;
head->pY = SCREEN_HEIGHT / 2;
/* Initialize a node pointer to the head for iterating through the snake's body */
SnakeNode *node = head;
/* Create additional nodes to form the initial snake body */
for (int i = 1; i < START_SNAKE_SIZE; i++) {
/* Add a new node to the snake, updating the node pointer */
appendSnakeNode(new_snake);
node = node->next;
/* Copy the position of the previous node to maintain a straight line */
node->pX = node->prev->pX;
node->pY = node->prev->pY + 1;
}
/* Set the initial direction of the snake to move upward */
new_snake->direction = UP;
/* Return the initialized snake */
return new_snake;
}
/* Function responsible of initializing the apple structure */
Apple *startApple() {
/* Allocate memory for a new apple */
Apple *new_apple = malloc(sizeof(Apple));
/* Seed the random number generator with the current time */
srand(time(NULL));
/* Generate random coordinates for the new apple, ensuring it does not overlap with the snake */
do {
new_apple->pX = (random() % (SCREEN_WIDTH - 2)) + 1;
new_apple->pY = (random() % (SCREEN_HEIGHT - 2)) + 1;
} while (snakeCollision(new_apple->pX, new_apple->pY, false));
/* Return the initialized apple */
return new_apple;
}
/* Function responsible of adding a new node to the tail of the snake */
void appendSnakeNode(Snake *new_snake) {
/* Allocate memory for a new snake node */ /* Allocate memory for a new snake node */
snake_node *node_ptr = malloc(sizeof(snake_node)); SnakeNode *node_ptr = malloc(sizeof(SnakeNode));
/* Set the previous pointer of the new node to the current tail of the snake */ /* Set the previous pointer of the new node to the current tail of the snake */
node_ptr->prev = new_snake->tail; node_ptr->prev = new_snake->tail;
@ -168,51 +187,11 @@ void appendSnakeNode(snake_t *new_snake) {
new_snake->tail = node_ptr; new_snake->tail = node_ptr;
} }
snake_t *startSnake(board_t *board) { /* Function responsible of freeing the memory for the snake structure */
/* Allocate memory for a new snake */
snake_t *new_snake = malloc(sizeof(snake_t));
/* Allocate memory for the head of the snake */
snake_node *head = malloc(sizeof(snake_node));
/* Initialize the snake's head and tail to the allocated head node */
new_snake->head = head;
new_snake->tail = head;
/* Set the head's previous and next pointers to NULL, as it's the only node in the beginning */
head->prev = NULL;
head->next = NULL;
/* Set the initial position of the snake's head at the center of the board */
head->pX = board->boardWidth / 2;
head->pY = board->boardHeight / 2;
/* Initialize a node pointer to the head for iterating through the snake's body */
snake_node *node = head;
/* Create additional nodes to form the initial snake body */
for (int i = 1; i < START_SNAKE_SIZE; i++) {
/* Add a new node to the snake, updating the node pointer */
appendSnakeNode(new_snake);
node = node->next;
/* Copy the position of the previous node to maintain a straight line */
node->pX = node->prev->pX;
node->pY = node->prev->pY + 1;
}
/* Set the initial direction of the snake to move upward */
new_snake->dX = 0;
new_snake->dY = -1;
/* Return the initialized snake */
return new_snake;
}
void freeSnake() { void freeSnake() {
/* Initialize pointers to traverse the snake linked list */ /* Initialize pointers to traverse the snake linked list */
snake_node *snake_current = snake->head; SnakeNode *snake_current = snake->head;
snake_node *snake_next = snake->head->next; SnakeNode *snake_next = snake->head->next;
/* Traverse the snake linked list and free each node */ /* Traverse the snake linked list and free each node */
while (snake_next != NULL) { while (snake_next != NULL) {
@ -234,9 +213,109 @@ void freeSnake() {
snake = NULL; snake = NULL;
} }
bool snakeOccupies(int x, int y, bool excludeHead) { /* Function responsible of saving the size of the snake */
int snakeSize() {
/* Initialize a pointer to traverse the snake linked list */ /* Initialize a pointer to traverse the snake linked list */
snake_node *snake_ptr; SnakeNode *snake_ptr = snake->head;
/* Initialize a counter to keep track of the number of nodes in the snake linked list */
int counter = 0;
/* Traverse the snake linked list and count each node */
while (snake_ptr != NULL) {
counter++;
/* Move to the next node */
snake_ptr = snake_ptr->next;
}
/* Return the total size of the snake, which is the number of nodes in the linked list */
return counter;
}
/* Function responsible of handling the snake's movement */
void updateSnake() {
/* Check if the snake is moving (either horizontally or vertically) */
if ((ABS(snake->direction == LEFT ? -1 : snake->direction == RIGHT ? 1 : 0) > 0) ||
(ABS(snake->direction == UP ? -1 : snake->direction == DOWN ? 1 : 0) > 0)) {
/* Calculate the new coordinates for the head and tail of the snake */
int new_head_x = snake->head->pX + (snake->direction == LEFT ? -1 : snake->direction == RIGHT ? 1 : 0);
int new_head_y = snake->head->pY + (snake->direction == UP ? -1 : snake->direction == DOWN ? 1 : 0);
int new_tail_x = snake->tail->pX + (snake->direction == LEFT ? -1 : snake->direction == RIGHT ? 1 : 0);
int new_tail_y = snake->tail->pY + (snake->direction == UP ? -1 : snake->direction == DOWN ? 1 : 0);
/* Check if the new head position does not overlap with an apple */
if (!appleCollision(new_head_x, new_head_y)) {
/* Move the tail to the new head position */
snake->tail->pX = new_head_x;
snake->tail->pY = new_head_y;
/* Adjust the linked list to maintain the snake's continuity */
snake->tail->next = snake->head;
snake->head->prev = snake->tail;
snake->tail = snake->tail->prev;
snake->tail->next = NULL;
snake->head->prev->prev = NULL;
snake->head = snake->head->prev;
} else {
/* If the head overlaps with an apple (the snake ate an apple), move the apple to a new position */
updateApple();
/* Increase the speed if it hasn't reached the maximum */
if (SPEED >= MAX_SPEED) {
SPEED -= 1;
}
/* Create a new head node and update its position */
SnakeNode *new_head = malloc(sizeof(SnakeNode));
new_head->pX = new_head_x;
new_head->pY = new_head_y;
new_head->prev = NULL;
new_head->next = snake->head;
/* Update the linked list to include the new head */
snake->head->prev = new_head;
snake->head = new_head;
/* Add a new node to the snake's body */
appendSnakeNode(snake);
/* Set the position for the tail node */
snake->tail->pX = new_tail_x;
snake->tail->pY = new_tail_y;
}
/* Check for collision with the game borders or itself */
if (snakeCollision(new_head_x, new_head_y, false) ||
(new_head_x == 0) || (new_head_x == SCREEN_WIDTH - 1) ||
(new_head_y == 0) || (new_head_y == SCREEN_HEIGHT - 1)) {
/* If there is a collision, set the snake as not alive */
isAlive = false;
}
}
}
/* Function responsible of moving the apple to a new position */
void updateApple() {
/* Variables to store the new coordinates for the apple */
int new_x, new_y;
/* Generate new random coordinates for the apple, ensuring it does not overlap with the snake */
do {
new_x = (random() % (SCREEN_WIDTH - 2)) + 1;
new_y = (random() % (SCREEN_HEIGHT - 2)) + 1;
} while (snakeCollision(new_x, new_y, true));
/* Update the position of the existing apple to the new coordinates */
apple->pX = new_x;
apple->pY = new_y;
}
/* Function responsible of checking if the snake collided with itself */
bool snakeCollision(int x, int y, bool excludeHead) {
/* Initialize a pointer to traverse the snake linked list */
SnakeNode *snake_ptr;
/* Determine the starting point in the linked list based on whether the head should be excluded */ /* Determine the starting point in the linked list based on whether the head should be excluded */
if (excludeHead) { if (excludeHead) {
@ -261,58 +340,8 @@ bool snakeOccupies(int x, int y, bool excludeHead) {
return false; return false;
} }
int snakeSize() { /* Function to chech if the snake ate an apple */
/* Initialize a pointer to traverse the snake linked list */ bool appleCollision(int x, int y) {
snake_node *snake_ptr = snake->head;
/* Initialize a counter to keep track of the number of nodes in the snake linked list */
int counter = 0;
/* Traverse the snake linked list and count each node */
while (snake_ptr != NULL) {
counter++;
/* Move to the next node */
snake_ptr = snake_ptr->next;
}
/* Return the total size of the snake, which is the number of nodes in the linked list */
return counter;
}
apple_t *startApple(board_t *board) {
/* Allocate memory for a new apple */
apple_t *new_apple = malloc(sizeof(apple_t));
/* Seed the random number generator with the current time */
srand(time(NULL));
/* Generate random coordinates for the new apple, ensuring it does not overlap with the snake */
do {
new_apple->pX = (random() % (board->boardWidth - 2)) + 1;
new_apple->pY = (random() % (board->boardHeight - 2)) + 1;
} while (snakeOccupies(new_apple->pX, new_apple->pY, false));
/* Return the initialized apple */
return new_apple;
}
void moveApple(board_t *board) {
/* Variables to store the new coordinates for the apple */
int new_x, new_y;
/* Generate new random coordinates for the apple, ensuring it does not overlap with the snake */
do {
new_x = (random() % (board->boardWidth - 2)) + 1;
new_y = (random() % (board->boardHeight - 2)) + 1;
} while (snakeOccupies(new_x, new_y, true));
/* Update the position of the existing apple to the new coordinates */
apple->pX = new_x;
apple->pY = new_y;
}
bool appleOccupies(int x, int y) {
/* Check if the specified coordinates match the position of the apple */ /* Check if the specified coordinates match the position of the apple */
if (apple->pX == x && apple->pY == y) { if (apple->pX == x && apple->pY == y) {
/* The apple occupies the specified position */ /* The apple occupies the specified position */
@ -323,35 +352,32 @@ bool appleOccupies(int x, int y) {
return false; return false;
} }
/* Function responsible of handling user input */
void handleInput(int key) { void handleInput(int key) {
/* Handle different key inputs to change the snake's direction */ /* Handle different key inputs to change the snake's direction */
switch (key) { switch (key) {
case KEY_UP: case KEY_UP:
/* If the snake is not currently moving down, change its direction to up */ /* If the snake is not currently moving down, change its direction to up */
if (snake->dY == 0) { if (snake->direction != DOWN) {
snake->dY = -1; snake->direction = UP;
snake->dX = 0;
} }
break; break;
case KEY_DOWN: case KEY_DOWN:
/* If the snake is not currently moving up, change its direction to down */ /* If the snake is not currently moving up, change its direction to down */
if (snake->dY == 0) { if (snake->direction != UP) {
snake->dY = 1; snake->direction = DOWN;
snake->dX = 0;
} }
break; break;
case KEY_RIGHT: case KEY_RIGHT:
/* If the snake is not currently moving left, change its direction to right */ /* If the snake is not currently moving left, change its direction to right */
if (snake->dX == 0) { if (snake->direction != LEFT) {
snake->dX = 1; snake->direction = RIGHT;
snake->dY = 0;
} }
break; break;
case KEY_LEFT: case KEY_LEFT:
/* If the snake is not currently moving right, change its direction to left */ /* If the snake is not currently moving right, change its direction to left */
if (snake->dX == 0) { if (snake->direction != RIGHT) {
snake->dX = -1; snake->direction = LEFT;
snake->dY = 0;
} }
break; break;
default: default:
@ -361,128 +387,212 @@ void handleInput(int key) {
} }
} }
void moveSnake(board_t *board) { /* Function responsible of drawing each object in the screen */
/* Check if the snake is moving (either horizontally or vertically) */ void drawGame() {
if ((ABS(snake->dX) > 0) || (ABS(snake->dY) > 0)) {
/* Calculate the new coordinates for the head and tail of the snake */
int new_head_x = snake->head->pX + snake->dX;
int new_head_y = snake->head->pY + snake->dY;
int new_tail_x = snake->tail->pX + snake->dX;
int new_tail_y = snake->tail->pY + snake->dY;
/* Check if the new head position does not overlap with an apple */
if (!appleOccupies(new_head_x, new_head_y)) {
/* Move the tail to the new head position */
snake->tail->pX = new_head_x;
snake->tail->pY = new_head_y;
/* Adjust the linked list to maintain the snake's continuity */
snake->tail->next = snake->head;
snake->head->prev = snake->tail;
snake->tail = snake->tail->prev;
snake->tail->next = NULL;
snake->head->prev->prev = NULL;
snake->head = snake->head->prev;
} else {
/* If the head overlaps with an apple (the snake ate an apple), move the apple to a new position */
moveApple(board);
/* Increase the speed if it hasn't reached the maximum */
if (SPEED <= MAX_SPEED) {
SPEED -= 1;
}
/* Create a new head node and update its position */
snake_node *new_head = malloc(sizeof(snake_node));
new_head->pX = new_head_x;
new_head->pY = new_head_y;
new_head->prev = NULL;
new_head->next = snake->head;
/* Update the linked list to include the new head */
snake->head->prev = new_head;
snake->head = new_head;
/* Add a new node to the snake's body */
appendSnakeNode(snake);
/* Set the position for the tail node */
snake->tail->pX = new_tail_x;
snake->tail->pY = new_tail_y;
}
/* Check for collision with the game borders or itself */
if (snakeOccupies(new_head_x, new_head_y, false) ||
(new_head_x == 0) || (new_head_x == board->boardWidth - 1) ||
(new_head_y == 0) || (new_head_y == board->boardHeight - 1)) {
/* If there is a collision, set the snake as not alive */
is_alive = false;
}
}
}
void draw(board_t *board) {
/* Clear the terminal screen */ /* Clear the terminal screen */
erase(); erase();
/* Draw the borders of the game board */ // Calculate the center coordinates
for (int i = 0; i < board->boardHeight; i++) { int startY = (terminalRows - SCREEN_HEIGHT) / 2;
for (int j = 0; j < board->boardWidth; j++) { int startX = (terminalCols - SCREEN_WIDTH) / 2;
if (i == 0 || i == board->boardHeight - 1) {
/* Draw the top and bottom borders */ WINDOW *gameBoard = newwin(SCREEN_HEIGHT, SCREEN_WIDTH, startY, startX);
mvprintw(i, j, "%c", board->border); box(gameBoard, 0, 0);
} else if (j == 0 || j == board->boardWidth - 1) { refresh();
/* Draw the left and right borders */ wrefresh(gameBoard);
mvprintw(i, j, "%c", board->border);
} /* Draw the snake's head on the game board */
} SnakeNode *snake_ptr = snake->head;
switch (snake->direction) {
case LEFT:
mvaddch(snake_ptr->pY + startY, snake_ptr->pX + startX, SNAKE_HEAD_L);
break;
case RIGHT:
mvaddch(snake_ptr->pY + startY, snake_ptr->pX + startX, SNAKE_HEAD_R);
break;
case UP:
mvaddch(snake_ptr->pY + startY, snake_ptr->pX + startX, SNAKE_HEAD_U);
break;
case DOWN:
mvaddch(snake_ptr->pY + startY, snake_ptr->pX + startX, SNAKE_HEAD_D);
break;
} }
/* Draw the snake on the game board */
snake_node *snake_ptr = snake->head;
if (snake->dX == -1) {
/* Draw the snake head facing left */
mvaddch(snake_ptr->pY, snake_ptr->pX, SNAKE_HEAD_L);
} else if (snake->dX == 1) {
/* Draw the snake head facing right */
mvaddch(snake_ptr->pY, snake_ptr->pX, SNAKE_HEAD_R);
} else if (snake->dY == -1) {
/* Draw the snake head facing up */
mvaddch(snake_ptr->pY, snake_ptr->pX, SNAKE_HEAD_U);
} else if (snake->dY == 1) {
/* Draw the snake head facing down */
mvaddch(snake_ptr->pY, snake_ptr->pX, SNAKE_HEAD_D);
}
/* Move to the next node */ /* Move to the next node */
snake_ptr = snake_ptr->next; snake_ptr = snake_ptr->next;
/* Draw the snake body */ /* Draw the snake's body */
while(snake_ptr != NULL) { while(snake_ptr != NULL) {
mvaddch(snake_ptr->pY, snake_ptr->pX, SNAKE_BODY); mvaddch(snake_ptr->pY + startY, snake_ptr->pX + startX, SNAKE_BODY);
/* Move to the next node */ /* Move to the next node */
snake_ptr = snake_ptr->next; snake_ptr = snake_ptr->next;
} }
/* Draw the apple on the game board */ /* Draw the apple on the game board */
mvaddch(apple->pY, apple->pX, FOOD); mvaddch(apple->pY + startY, apple->pX + startX, FOOD);
/* Display the game score */ /* Display the game score */
mvprintw(board->boardHeight + 3, 0, "Score: %d", snakeSize() - START_SNAKE_SIZE); mvprintw(startY, startX + 1, "Score: %d", snakeSize() - START_SNAKE_SIZE);
}
/* Game loop function */
void gameLoop() {
/* Take arrow key inputs */
int c = getch();
if (c != ERR) {
handleInput(c);
}
/* Update the snake position */
updateSnake();
/* Redraw the frame */
drawGame();
/* Refresh the window */
refresh();
/* Introduce a delay for the game loop */
usleep(SPEED * 800L);
}
/* Function responsible of initializing the game */
void initializeGame() {
/* Initialize window settings with ncurses */
initscr();
cbreak();
noecho();
keypad(stdscr, TRUE);
curs_set(0);
nodelay(stdscr, TRUE);
getmaxyx(stdscr, terminalRows, terminalCols);
startY = (terminalRows - SCREEN_HEIGHT) / 2;
startX = (terminalCols - SCREEN_WIDTH) / 2;
/* Initialize the snake doubly-linked list */
snake = startSnake();
/* Initialize the apple */
apple = startApple();
run();
}
/* Starting point of the game */
void run() {
int choice;
WINDOW * menuScreen = newwin(SCREEN_HEIGHT, SCREEN_WIDTH, startY, startX);
refresh();
wrefresh(menuScreen);
while (isRunning) {
/* Display main menu */
mainMenu(menuScreen, 1);
/* Input validation loop */
do {
/* Use getch to get a single character */
choice = wgetch(menuScreen);
} while (choice < '1' || choice > '3');
switch (choice) {
case '1':
if (!isAlive) {
snake = startSnake();
isAlive = true;
}
/* Start the game loop */
while (isAlive) {
gameLoop();
}
score = snakeSize() - START_SNAKE_SIZE;
mainMenu(menuScreen, 3);
break;
case '2':
/* Show controls */
mainMenu(menuScreen, 2);
continue;
break;
case '3':
/* Exit the game */
isRunning = false;
break;
default:
break;
}
}
}
/* Function to display the main menu */
void mainMenu(WINDOW *menuScreen, int menuType) {
int menuY = (SCREEN_HEIGHT - startY) / 5;
int menuX = (SCREEN_WIDTH - startX) / 2;
wclear(menuScreen);
box(menuScreen, 0, 0);
mvwprintw(menuScreen, menuY - 1, menuX - 2, " ____ ");
mvwprintw(menuScreen, menuY, menuX - 2, " ________________________/ O \\___/");
mvwprintw(menuScreen, menuY + 1, menuX - 2, "<_____________________________/ \\");
mvwprintw(menuScreen, menuY + 2, menuX - 2, " __ _ ");
mvwprintw(menuScreen, menuY + 3, menuX - 2, "/ _\\ ___ _ __ _ __ ___ _ __ | |_ ");
mvwprintw(menuScreen, menuY + 4, menuX - 2, "\\ \\ / _ \\ '__| '_ \\ / _ \\ '_ \\| __|");
mvwprintw(menuScreen, menuY + 5, menuX - 2, "_\\ \\ __/ | | |_) | __/ | | | |_ ");
mvwprintw(menuScreen, menuY + 6, menuX - 2, "\\__/\\___|_| | .__/ \\___|_| |_|\\__|");
mvwprintw(menuScreen, menuY + 7, menuX - 2, " |_| ");
switch (menuType) {
case 1:
/* Print the main menu inside the menuScreen window */
mvwprintw(menuScreen, menuY + 9, menuX, "\tMain Menu");
mvwprintw(menuScreen, menuY + 10, menuX, "\t 1. Start Game");
mvwprintw(menuScreen, menuY + 11, menuX, "\t 2. Show Controls");
mvwprintw(menuScreen, menuY + 12, menuX, "\t 3. Exit Game");
mvwprintw(menuScreen, menuY + 13, menuX, "\tPress a key [1-3]...");
wrefresh(menuScreen);
break;
case 2:
/* Display controls */
mvwprintw(menuScreen, menuY + 9, menuX, "\tControls");
mvwprintw(menuScreen, menuY + 10, menuX, "\t Arrow Up: Move Up");
mvwprintw(menuScreen, menuY + 11, menuX, "\t Arrow Down: Move Down");
mvwprintw(menuScreen, menuY + 12, menuX, "\t Arrow Left: Move Left");
mvwprintw(menuScreen, menuY + 13, menuX, "\t Arrow Right: Move Right");
mvwprintw(menuScreen, menuY + 14, menuX, "\tPress a key to go back...");
wrefresh(menuScreen);
wgetch(menuScreen);
break;
case 3:
/* Display the final score on the main menu */
mvwprintw(menuScreen, menuY + 13, menuX, "\tFinal Score: %d", score);
mvwprintw(menuScreen, menuY + 14, menuX, "\tPress a key to go back...");
wgetch(menuScreen);
break;
}
}
/* Function responsible of cleaning the memory */
void cleanup() {
/* Free memory allocated by snake */
freeSnake();
/* Free memory allocated by apple */
free(apple);
/* End ncurses window */
endwin();
} }
/* Function for displaying the game controls in the command line */ /* Function for displaying the game controls in the command line */
void argControls() { void argControls() {
printf("%s controls.\n", NAME); printf("%s version: %.1lf\n", NAME, VERSION);
printf("Movement:\n"); printf("Controls:\n");
printf("\t↑: move up\n"); printf("\tArrow Up: move up\n");
printf("\t←: move to the left\n"); printf("\tArrow Down: move down\n");
printf("\t→: move to the right\n"); printf("\tArrow Left: move to the left\n");
printf("\t↓: move down\n"); printf("\tArrow Right: move to the right\n");
printf("Game:\n");
printf("\tq: quit\n");
printf("\tp: pause\n");
printf("\tr: restart\n");
} }
/* Function to display the help message in the command line */ /* Function to display the help message in the command line */

36
serpent.h
View file

@ -18,33 +18,33 @@
#define SNAKE_HEAD_L '>' /* head when going left */ #define SNAKE_HEAD_L '>' /* head when going left */
#define SNAKE_HEAD_R '<' /* head when going right */ #define SNAKE_HEAD_R '<' /* head when going right */
#define FOOD '@' /* normal food */ #define FOOD '@' /* normal food */
#define BOARD_CHAR '#' /* character at corners of border */ #define SCREEN_WIDTH 50 /* the virtual screen width */
#define SCREEN_WIDTH 40 /* the virtual screen width */ #define SCREEN_HEIGHT 20 /* the virtual screen height */
#define SCREEN_HEIGHT 30 /* the virtual screen height */
/* */ /* */
/* Board structure */ /* Possible directions for the snake */
typedef struct board_t { typedef enum {
char border; /* will use BOARD_CHAR */ UP,
unsigned int boardHeight; /* will use SCREEN_HEIGHT */ DOWN,
unsigned int boardWidth; /* will use SCREEN_WIDTH */ LEFT,
} board_t; RIGHT
} Direction;
/* Snake node structure (for dobly linked list) */ /* Snake node structure (for dobly linked list) */
typedef struct snake_node { typedef struct SnakeNode {
int pX, pY; /* represents the node's position on the board */ int pX, pY; /* represents the node's position on the board */
struct snake_node *next, *prev; /* pointers to the next and previous nodes */ struct SnakeNode *next, *prev; /* pointers to the next and previous nodes */
} snake_node; } SnakeNode;
/* Snake structure (dobly linked list) */ /* Snake structure (dobly linked list) */
typedef struct snake_t { typedef struct Snake {
int dX, dY; /* represents the snake's direction */ Direction direction;
snake_node *head, *tail; /* snake's nodes, dobly linked list */ SnakeNode *head, *tail; /* snake's nodes, dobly linked list */
} snake_t; } Snake;
/* Apple structure */ /* Apple structure */
typedef struct apple_t { typedef struct Food {
int pX, pY; /* represents the apple's position on the board */ int pX, pY; /* represents the apple's position on the board */
} apple_t; } Apple;
#endif //SERPENT_H #endif //SERPENT_H