artsiom/minigame-menu
1
0
Fork 0
forked from snapshot112/minigame-menu
Code Pull Requests Activity

Got the minigame menu up, running and documented. Also split up the game file

Browse Source
This commit is contained in:
Jeroen Boxhoorn
2025-10-16 01:10:09 +02:00
parent 06e148a710
commit cfd4ccad64
15 changed files with 737 additions and 479 deletions
Download Patch File Download Diff File Expand all files Collapse all files

452
spel.c
View File

@@ -3,454 +3,22 @@
* UvAnetID: 16333969
* Studie: BSc Informatica
*
* This program loads in a maze from a text file and then lets you play that maze.
* A minigame menu that lets you play games on the grid game engine.
*
* Params when running the program:
* - The path to the text file containing the maze.
*
* How to play the game:
* - You are the '*' character.
* - Use either WSAD or the arrow keys to navigate through the maze.
* - The exit of the maze is marked with a '$'.
* - Walls are '#'.
* - Traps are 'X'. These kill you.
*
* You can quit the program at any time by pressing CTRL + C.
*
* Have fun playing!
* Currently the following games are included:
* - maze runner
* - snake
* - minesweeper
*/
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <ncurses.h>
#include <wchar.h>
#include <locale.h>
#include <string.h>
#include "rooster.h"
typedef enum {
GAME_QUIT,
GAME_MAZE_RUNNER,
GAME_SNAKE,
GAME_MINESWEEPER
} game;
typedef enum {
BLACK = 1,
WHITE = 2,
BLUE = 3,
GREEN = 4,
CYAN = 5,
MAGENTA = 6,
YELLOW = 7,
RED = 8//,
// LIME = 9
} game_colors;
typedef struct {
char name[100];
rooster *game_map;
} game_maps;
void toon_rooster_op_locatie(rooster *rp, int starting_x, int starting_y) {
int height = rooster_hoogte(rp);
for (int y = 0; y < height; y++) {
char *rij = rooster_vraag_rij(rp, y);
mvprintw(starting_y + y, starting_x, "%s", rij);
free(rij);
}
refresh();
}
/* Toont het gegeven rooster met ncurses.
*
* Input:
* rp: een pointer naar het rooster.
*
* Side effect:
* De console wordt geleegd en het rooster wordt erin gezet.
*/
void toon_rooster(rooster *rp) {
clear();
toon_rooster_op_locatie(rp, 0, 0);
}
void update_grid(rooster *rp, char c, int x, int y) {
if (rooster_plaats(rp, x, y, c) == 1) {
mvaddch(y, x, c);
}
}
void game_error(void) {
endwin();
exit(EXIT_FAILURE);
}
void quit_game(rooster *menu) {
if (menu != NULL) {
rooster_klaar(menu);
}
endwin();
exit(EXIT_SUCCESS);
}
/*
* Toont het victory screen.
*
* Side Effect:
* De victory message wordt op een schone console geprint.
*/
void display_victory(void) {
clear();
mvprintw(2,5, "YOU WON!!!!!");
refresh();
}
/*
* Toont het loss screen.
*
* Side Effect:
* De loss message wordt op een schone console geprint.
*/
void display_loss(void) {
clear();
mvprintw(2,5, "RIP, YOU DIED...");
refresh();
}
/*
* Toont het quit screen.
*
* Side Effect:
* De quit message wordt op een schone console geprint.
*/
void display_quit(void) {
clear();
mvprintw(2,5, "You quit the game");
refresh();
}
/*
* Toont het hackerman screen.
*
* Side Effect:
* De hackerman message wordt op een schone console geprint.
*/
void display_hackerman(void) {
clear();
mvprintw(2,5, "The hacker man strikes again...");
refresh();
}
/*
* Bepaalt afhankelijk van de eindtoestand van het rooster
* welk afsluitscherm er getoond moet worden en toont dan dat rooster.
*
* Input: Het rooster om de toestand uit af te lezen.
*
* Side Effects:
* Het end-of-game scherm wordt op een blanke console geprint.
*/
void game_exit_screen(rooster *rp) {
toestand current_state = rooster_vraag_toestand(rp);
switch (current_state) {
case STATE_GEWONNEN:
display_victory();
return;
case STATE_VERLOREN:
display_loss();
return;
case GAME_QUIT:
display_quit();
return;
}
display_hackerman();
}
/*
* Waits for the user to press an exit key 'q' before continuing.
*/
void graceful_exit(void) {
mvprintw(5, 0, "Press 'q' to exit the game.");
while (1) {
switch (getch()) {
case 'q':
return;
}
}
}
void speel_snake(void) {
mvprintw(0,0, "Snake has not yet been created");
graceful_exit();
}
void speel_minesweeper() {
mvprintw(0,0, "Minesweeper has not yet been created");
graceful_exit();
}
/* Voert de benodigde veranderingen in het rooster door als de speler in een
* bepaalde richting probeert te bewegen.
* Input:
* rp : een pointer naar het rooster
* dx,dy: de richting waarin de speler probeert te bewegen. De vier mogelijk-
* heden voor (dx,dy) zijn (-1,0), (1,0), (0,-1), (0,1) voor resp.
* links, rechts, omhoog en omlaag.
*
* Side effect: het rooster wordt aangepast op basis van de handeling van
* de speler.
*/
void maze_runner_beweeg(rooster *rp, int dx, int dy) {
int playerx;
int playery;
rooster_zoek(rp, '*', &playerx, &playery);
if (playerx == -1 || playery == -1) {
printf("Player not found!");
exit(1);
}
if (rooster_bevat(rp, playerx + dx, playery + dy) == 1) {
char new_location = rooster_kijk(rp, playerx + dx, playery + dy);
switch (new_location) {
case '#':
break;
case 'X':
update_grid(rp, ' ', playerx, playery);
rooster_zet_toestand(rp, STATE_VERLOREN);
break;
case ' ':
update_grid(rp, ' ', playerx, playery);
update_grid(rp, '*', playerx + dx, playery + dy);
break;
case '$':
update_grid(rp, ' ', playerx, playery);
rooster_zet_toestand(rp, STATE_GEWONNEN);
break;
}
refresh();
}
}
/*
* Speel een dolhof spel.
*
* Input:
* rp: Een pointer naar een rooster met een valide doolhof erin.
*
* Side Effects:
* Met WSAD en arrow keys kun je door het doolhof heen bewegen.
*
*/
void maze_runner(rooster *rp) {
while (rooster_vraag_toestand(rp) == STATE_AAN_HET_SPELEN)
{
switch (getch()) {
case KEY_UP: // fallthrough
case 'w':
maze_runner_beweeg(rp, 0, -1);
break;
case KEY_DOWN: // fallthrough
case 's':
maze_runner_beweeg(rp, 0, 1);
break;
case KEY_LEFT: // fallthrough
case 'a':
maze_runner_beweeg(rp, -1, 0);
break;
case KEY_RIGHT: // fallthrough
case 'd':
maze_runner_beweeg(rp, 1, 0);
break;
case KEY_BACKSPACE:
rooster_zet_toestand(rp, STATE_QUIT);
break;
}
}
}
rooster *choose_maze(void) {
// TODO: echt opties aanbieden in plaats van hardcoded 1 maze.
// Alternatief is om random een maze te genereren. dit is miss beter.
// 2. Open het doolhof bestand en lees het rooster.
FILE *fh = fopen("assets/voorbeeld_doolhof.txt", "r");
if (fh == NULL) {
perror("loading maze");
game_error();
}
rooster *rp = rooster_lees(fh);
fclose(fh);
// 3. Bepaal of het lezen van het rooster is gelukt.
if (rp == NULL) {
fprintf(stderr, "Kan rooster niet maken.\n");
game_error();
}
return rp;
}
/*
* Speelt het spel met een gegeven rooster tot de toestand niet langer
* AAN_HET_SPELEN is.
*/
void speel_maze(void) {
// Voorbereiding.
rooster *rp = choose_maze();
toon_rooster(rp);
rooster_zet_toestand(rp, STATE_AAN_HET_SPELEN);
// Game zelf.
maze_runner(rp);
// Exit game.
game_exit_screen(rp);
rooster_klaar(rp);
graceful_exit();
}
void launch_game(rooster *menu, const game game) {
switch (game) {
case GAME_MAZE_RUNNER:
speel_maze();
return;
case GAME_SNAKE:
speel_snake();
return;
case GAME_MINESWEEPER:
speel_minesweeper();
return;
case GAME_QUIT:
quit_game(menu);
}
}
void menu_highlight(rooster *rp, const game target, const int offset_x, const int offset_y) {
switch (target) {
case GAME_MAZE_RUNNER: // Fallthrough
case GAME_SNAKE: // Fallthrough
case GAME_MINESWEEPER: // Fallthrough
case GAME_QUIT: // Fallthrough
// TODO: Properly highlight this shit.
attron(COLOR_PAIR(HIGHLIGHT_COLOR));
mvaddch(y0 + y, x0 + x * 2, ' ');
addch(' ');
attroff(COLOR_PAIR(kleur));
char* row = rooster_vraag_rij(rp, target);
mvprintw(offset_y + (int)target, offset_x, row);
free(row);
}
}
game menu_try_move(const game selected_game, const int offset) {
switch (selected_game + offset) {
case GAME_MAZE_RUNNER:
return GAME_MAZE_RUNNER;
case GAME_SNAKE:
return GAME_SNAKE;
case GAME_MINESWEEPER:
return GAME_MINESWEEPER;
case GAME_QUIT:
return GAME_QUIT;
}
return selected_game;
}
void navigate_menu(rooster *menu, const game default_game, const int offset_x, const int offset_y) {
game selected_game = default_game;
while (true) {
switch (getch()) {
case KEY_UP: // fallthrough
case 'w':
selected_game = menu_try_move(selected_game, -1);
menu_highlight(menu, selected_game, offset_x, offset_y);
break;
case KEY_DOWN: // fallthrough
case 's':
selected_game = menu_try_move(selected_game, 1);
menu_highlight(menu, selected_game, offset_x, offset_y);
break;
case KEY_ENTER:
case 'p':
// select current game somehow
launch_game(menu, GAME_QUIT);
menu_highlight(menu, selected_game, offset_x, offset_y);
break;
case KEY_BACKSPACE:
launch_game(menu, GAME_QUIT);
break;
}
}
}
rooster *laad_menu(void) {
char menu[] = "Maze Runner\n"
" Snake \n"
"Minesweeper\n"
" Leave \n";
rooster *rp = rooster_maak(menu);
return rp;
}
void toon_menu(rooster *menu, const game default_game, const int offset_x, const int offset_y) {
toon_rooster_op_locatie(menu, offset_x, offset_y);
menu_highlight(menu, default_game, offset_x, offset_y);
refresh();
}
void menu(void) {
rooster *menu = laad_menu();
const game default_game = GAME_MAZE_RUNNER;
while (true) {
clear();
const int offset_x = 5;
const int offset_y = 5;
toon_menu(menu, default_game, offset_x, offset_y);
navigate_menu(menu, default_game, offset_x, offset_y);
}
}
void startup_sequence(void) {
// TODO: Nice entry screen
}
#include "grid_game_engine.h"
#include "minigame_menu.h"
int main(void) {
// 4. Initialiseer ncurses
setlocale(LC_ALL, "");
initscr();
cbreak(); // zodat je kunt onderbreken met Ctrl+C
keypad(stdscr, TRUE); // luister ook naar extra toetsen zoals pijltjes
noecho(); // druk niet de letters af die je intypt
curs_set(0); // hides the cursor// Don't mask any mouse events
// mousemask(ALL_MOUSE_EVENTS | REPORT_MOUSE_POSITION, NULL); // Don't mask any mouse events
// printf("\033[?1003h\n"); // Makes the terminal report mouse movement events
start_color();
init_pair(BLACK, COLOR_BLACK, COLOR_BLACK);
init_pair(WHITE, COLOR_BLACK, COLOR_WHITE);
init_pair(BLUE, COLOR_BLACK, COLOR_BLUE);
init_pair(GREEN, COLOR_BLACK, COLOR_GREEN);
init_pair(CYAN, COLOR_BLACK, COLOR_CYAN);
init_pair(MAGENTA, COLOR_BLACK, COLOR_MAGENTA);
init_pair(YELLOW, COLOR_BLACK, COLOR_YELLOW);
init_pair(RED, COLOR_BLACK, COLOR_RED);
// init_pair(LIME, COLOR_BLACK, COLOR_LIME);
init_engine();
// 5. Speel het spel.
startup_sequence();
menu();
minigame_menu();
// 6. Sluit af.
quit_game(NULL);
cleanup_engine();
}