mk600ry/pvjc25
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upload files to "a3"

Browse Source
This commit is contained in:
Martin Kačmár 2025-04-30 09:08:53 +00:00
parent 0ed079bd69
commit 8504ddbd91
6 changed files with 615 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
a3/Makefile Normal file
View File

@ -0,0 +1,14 @@
CFLAGS=-std=c99 -Wall -g
all: game
%.o: %.c
gcc $(CFLAGS) -c $< -o $@
clean:
rm *.o
rm game
game: main.o world.o snake.o
gcc -rdynamic -g main.o world.o snake.o -lcurses -lm -o game

80
a3/main.c Normal file
View File

@ -0,0 +1,80 @@
#include "snake.h"
#include "world.h"
#include <stdlib.h>
struct state* game_state;
void* init_game() {
game_state = malloc(sizeof(struct state));
if (!game_state) return NULL;
game_state->width = COLS;
game_state->height = LINES;
game_state->sx = 1;
game_state->sy = 0;
// Inicializuj hada do stredu
int start_x = game_state->width / 2;
int start_y = game_state->height / 2;
game_state->snake = add_snake(NULL, start_x, start_y);
// Náhodné jedlo
for (int i = 0; i < FOOD_COUNT; ++i) {
game_state->foodx[i] = rand() % game_state->width;
game_state->foody[i] = rand() % game_state->height;
}
return game_state;
}
void destroy_game(void* game) {
struct state* st = (struct state*)game;
free_snake(st->snake);
free(st);
}
int world_event(struct event* event, void* game) {
struct state* st = (struct state*)game;
if (event->type == EVENT_KEY) {
if (event->key == KEY_UP) {
st->sx = 0; st->sy = -1;
} else if (event->key == KEY_DOWN) {
st->sx = 0; st->sy = 1;
} else if (event->key == KEY_LEFT) {
st->sx = -1; st->sy = 0;
} else if (event->key == KEY_RIGHT) {
st->sx = 1; st->sy = 0;
}
} else if (event->type == EVENT_ESC || event->type == EVENT_END) {
return 1;
} else if (event->type == EVENT_TIMEOUT) {
int status = step_state(st);
if (status != END_CONTINUE) {
set_message("Koniec hry!", st->width / 2 - 5, st->height / 2);
return 1;
}
clear_screen();
// Zobraz hada
struct snake* s = st->snake;
while (s) {
set_cell('O', s->x, s->y);
s = s->next;
}
// Zobraz jedlo
for (int i = 0; i < FOOD_COUNT; ++i) {
if (st->foodx[i] >= 0 && st->foody[i] >= 0) {
set_color_cell('*', st->foodx[i], st->foody[i], COLOR_RED, COLOR_BLACK);
}
}
}
return 0;
}
int main() {
return start_world(init_game, world_event, destroy_game);
}

87
a3/snake.c Normal file
View File

@ -0,0 +1,87 @@
#include "snake.h"
#include <stdlib.h>
struct snake* add_snake(struct snake* head, int x, int y) {
struct snake* node = (struct snake*)malloc(sizeof(struct snake));
if (!node) return NULL;
node->x = x;
node->y = y;
node->next = head;
return node;
}
struct snake* remove_snake(struct snake* head) {
if (!head) return NULL;
if (!head->next) {
free(head);
return NULL;
}
struct snake* current = head;
while (current->next && current->next->next) {
current = current->next;
}
free(current->next);
current->next = NULL;
return head;
}
void free_snake(struct snake* head) {
while (head) {
struct snake* temp = head;
head = head->next;
free(temp);
}
}
int is_snake(struct snake* head, int x, int y) {
struct snake* temp = head;
while (temp) {
if (temp->x == x && temp->y == y) {
return 1;
}
temp = temp->next;
}
return 0;
}
int step_state(struct state* st) {
int new_x = st->snake->x + st->sx;
int new_y = st->snake->y + st->sy;
// Collision with walls
if (new_x < 0 || new_y < 0 || new_x >= st->width || new_y >= st->height) {
return END_WALL;
}
// Collision with itself
if (is_snake(st->snake, new_x, new_y)) {
return END_SNAKE;
}
// Check food collision
for (int i = 0; i < FOOD_COUNT; ++i) {
if (st->foodx[i] == new_x && st->foody[i] == new_y) {
st->foodx[i] = -1;
st->foody[i] = -1;
st->snake = add_snake(st->snake, new_x, new_y);
int food_remaining = 0;
for (int j = 0; j < FOOD_COUNT; ++j) {
if (st->foodx[j] >= 0 && st->foody[j] >= 0) {
food_remaining = 1;
break;
}
}
return food_remaining ? END_CONTINUE : END_FOOD;
}
}
// Normal move: add head, remove tail
st->snake = add_snake(st->snake, new_x, new_y);
st->snake = remove_snake(st->snake);
return END_CONTINUE;
}

114
a3/snake.h Normal file
View File

@ -0,0 +1,114 @@
#ifndef snake_h_INCLUDED
#define snake_h_INCLUDED
// Number of food items on the plane
#define FOOD_COUNT 5
/**
* One part of the snake;
*
* The snake is a linked list;
*/
struct snake {
// x position of the snake part
int x;
// y position of the snake part
int y;
// Pointer to the next snake part.
// The last part of the snake has NULL pointer to the next part.
struct snake* next;
};
// End game reason constants, return value of step_state
enum endgame {
// Continue the game
END_CONTINUE = 0,
// Snake hit a wall
END_WALL,
// Snake hit itself
END_SNAKE,
// No food left
END_FOOD,
// Other reason to end
END_USER
};
/**
* State of the game.
*
* The state consists of the snake, its speed and food on the plane.
*
* The snake is a linked list of snake parts.
*
* Speed vector is a vector added to the last head position to create a new head.
*
* Food are points on the plane. Food with negative coordinates meads food is already eaten.
*/
struct state {
// Snake as a linked list
struct snake* snake;
// X of the food positions
int foodx[FOOD_COUNT];
// Y of the food positions
int foody[FOOD_COUNT];
int sx;
int sy;
int width;
int height;
};
/**
* Add a new snake part with given position. The new snake part becomes the new head.
*
* @param head of the snake.
* @param x coordinate of the new head;
* @param y coordinate of the new head.
* @return new head of the snake.
*/
struct snake* add_snake(struct snake* snake,int x,int y);
/**
* Remove the last snake part.
* The last snake part should always have NULL next pointer.
*
* @param head of the snake.
* @return new head of the snake.
*/
struct snake* remove_snake(struct snake* snake);
/**
* Finds out if given coordinates are part of the snake.
* @param snake
* @param x coordinate to search in snake
* @param y coordinate to search in snake
* @return True, if there is a snake part with coordinates x,y. False otherwise
*
*/
int is_snake(struct snake* snake,int x, int y);
/**
* Remove and free each snake part;
* @param head of the snake.
*/
void free_snake(struct snake* sn);
/**
* Change game state.
*
* The function shoud calculate new posision of the snake head
* from the current position and speed vector.
* Then it should modify snake parst or food coordinates according to the rules:
*
* - If the new position is on the snake, end the game, return END_SNAKE.
* - If the new position is on the food, mark food as eaten
* (set its coordinates to -1) and add new snake part on the position of the food. If there is no food left, return END_FOOD. else return END_CONTINUE.
* - If the new position is on the plane, add new snake part on the new position and remove the last part of the snake, return END_CONTINUE.
*
* @param current state of the game
* @return reason to end the game according to enum endgame.
*/
int step_state(struct state* state);
#endif // snake_h_INCLUDED

198
a3/world.c Normal file
View File

@ -0,0 +1,198 @@
#include "world.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
int TIMEOUT;
void abort_game(const char* message){
endwin();
puts(message);
exit(1);
}
void check_bounds(const char* source,int x, int y){
char msg[200];
if (x < 0 || x >= COLS){
sprintf(msg,"%s:: width %d is out of bounds (0,%d)",source,x,COLS);
abort_game(msg);
}
if (y < 0 || y >= LINES){
sprintf(msg,"%s:: height %d is out of bounds (0,%d)",source,y,LINES);
abort_game(msg);
}
}
void clear_screen(){
// Clear screen
mvaddch(0,0,' ');
int screenchars = LINES*COLS;
for (int j = 1; j < screenchars;j++ ){
addch(' ');
}
}
void game_speed(int value){
if (value < 0){
abort_game("world_seed:: cannot be negative\n");
}
TIMEOUT =value;
}
void set_message(const char* message,int x,int y) {
int l = strlen(message);
for (int i = 0; i < l; i++){
check_bounds("set_message",x+i,y);
set_cell(message[i],x+i,y);
}
}
void assert_message(int event,const char* message){
if (event == 0){
abort_game(message);
}
}
void set_cell(int character,int x,int y) {
check_bounds("set_cell",x,y);
set_color_cell(character,x,y,COLOR_WHITE,COLOR_BLACK);
}
void set_color_cell(int character,int x,int y,short front_color,short back_color){
check_bounds("set_color_cell",x,y);
if (has_colors()){
int pair = COLOR_COUNT * front_color + back_color;
attron(COLOR_PAIR(pair));
mvaddch(y,x,character);
attroff(COLOR_PAIR(pair));
}
else{
mvaddch(y,x,character);
}
}
int start_world(void* (*init_game)(),int (*world_event)(struct event* event,void* game),void (*destroy_game)(void*)){
srand(time(NULL));
int r = 1;
// Speed global variable
TIMEOUT = 100;
if (initscr() == NULL){
// TODO Which Error?
puts("Curses Error.");
return -1;
}
noecho(); // Nevypisuj vstup na obrazovku
cbreak(); // Zabudni starý vstup
nodelay(stdscr,TRUE); // Nečakaj na stlačenie
keypad(stdscr,TRUE); // Aktivuje šípky
curs_set(FALSE); // Neviditeľný kurzor
/* Get all the mouse events */
mousemask(ALL_MOUSE_EVENTS, NULL);
MEVENT mouse_event;
if (has_colors()){ // Zistenie či terminál podporuje farby
start_color();
for (int i = 0; i < COLOR_COUNT;i++){
for (int j = 0; j < COLOR_COUNT;j++){
init_pair(i * COLOR_COUNT + j, i,j);
}
}
}
else {
puts("No colors!\n");
}
void* game = NULL;
if (init_game != NULL){
game = init_game();
assert_message(game != NULL,"init_game:: should return non null pointer");
}
timeout(TIMEOUT);
// Initial step
struct event event;
memset(&event,0,sizeof(struct event));
event.height = LINES;
event.width = COLS;
event.type = EVENT_START;
clock_t start_time = clock();
clock_t last_timeout = start_time;
clock_t next_timeout = last_timeout + TIMEOUT;
event.time_ms = start_time;
// Start event
r = world_event(&event,game);
refresh();
while (!r) {
memset(&event,0,sizeof(struct event));
event.height = LINES;
event.width = COLS;
event.key = getch();
// No key was pressed
if (event.key == ERR){
event.type = EVENT_TIMEOUT;
last_timeout = clock();
next_timeout = last_timeout + TIMEOUT;
}
// Mouse event
else if (event.key == KEY_MOUSE ){
event.type = EVENT_MOUSE;
if(getmouse(&mouse_event) == OK){
event.mouse_x = mouse_event.x;
event.mouse_y = mouse_event.y;
if(mouse_event.bstate & BUTTON1_PRESSED){
event.mouse_left = 1;
}
if(mouse_event.bstate & BUTTON2_PRESSED){
event.mouse_middle = 1;
}
if(mouse_event.bstate & BUTTON3_PRESSED){
event.mouse_right = 1;
}
}
}
else if (event.key == KEY_RESIZE) {
event.type = EVENT_RESIZE;
}
else{
event.type = EVENT_KEY;
if (event.key == 27){
int k = getch();
if (k == -1){
// Esc Was pressed
event.type = EVENT_ESC;
}
else {
// Alt was pressed
event.key = k;
event.alt_key = 1;
}
}
}
// Draw new world
event.time_ms = clock();
r = world_event(&event,game);
refresh();
event.time_ms = clock();
// set new timeout
int nt = next_timeout - event.time_ms;
//printf("%d\n",nt);
if (nt > 0){
timeout(nt);
}
else {
timeout(TIMEOUT);
next_timeout = event.time_ms + TIMEOUT;
}
}
memset(&event,0,sizeof(struct event));
event.height = LINES;
event.width = COLS;
event.type = EVENT_END;
event.time_ms = clock();
world_event(&event,game);
if (destroy_game != NULL){
destroy_game(game);
}
endwin();
return r;
};

122
a3/world.h Normal file
View File

@ -0,0 +1,122 @@
#ifndef _WORLD_H_
#define _WORLD_H_
#include <curses.h>
/**
* World represented as a rectangular matrix of colorful characters.
*
* Point [0,0] is displayed the upper left corner of the screen.
*
*/
enum event_type {
EVENT_START,
EVENT_TIMEOUT,
EVENT_KEY,
EVENT_MOUSE,
EVENT_RESIZE,
EVENT_ESC,
EVENT_END,
};
struct event {
/**
* Last width of the screen.
*/
int width;
/**
* Last height of the screen.
*/
int height;
/**
* Last pressed key or Curses event.
*
* Special event values:
* ERR if timeout,
* KEY_RESIZE if screen resize
* KEY_EVENT, other event,
* KEY_MOUSE, mouse clicked
*
* Key values:
*
* ' ' Space
* KEY_DOWN Arrow down
* KEY_UP Arrow up
* KEY_LEFT Arrow left
* KEY_RIGHT Arrow right
* KEY_A1 Upper left of keypad
* KEY_A3 Upper right of keypad
* KEY_B2 Center of keypad
* KEY_C1 Lower left of keypad
* KEY_C3 Lower right of keypad
*
* KEY_ENTER
* KEY_BACKSPACE
*/
int key;
int alt_key;
enum event_type type;
int mouse_x;
int mouse_y;
int mouse_left;
int mouse_right;
int mouse_middle;
long int time_ms;
};
/**
* Sets cell to a state.
* @param event
* @param x coordinate of cell
* @param y coordinate of cell
* @param new state of the cell
*/
void set_cell(int character,int x,int y);
/**
* COLOR_BLACK 0
* COLOR_RED 1
* COLOR_GREEN 2
* COLOR_YELLOW 3
* COLOR_BLUE 4
* COLOR_MAGENTA 5
* COLOR_CYAN 6
* COLOR_WHITE 7
*/
#define COLOR_COUNT 8
void set_color_cell(int character,int x,int y,short front_color,short back_color);
/**
*
* @param event
* @param number of commandline arguments
* @param init_world
* @param destroy_world
*
* void init_world(struct event* w);
* Initializes user state.
* Free user state.
* @param event
*/
int start_world(void* (*init_game)(),int (*world_event)(struct event* event,void* game),void (*destroy_game)(void* game));
/**
* Set timeout interval in miliseconds
*/
void game_speed(int value);
/*
* Prints a message in screen on a position x,y
*/
void set_message(const char* message,int x,int y);
/*
* Clears screen
*/
void clear_screen();
#endif