j/snake-pp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement game.c, food.c and map.c

Browse Source 
- Implemented the functions in the above files
 - game and map are partially tested
 - food is extensively tested using the created test-function
- Also added DELAY(ms) macro to common.c
This commit is contained in:
jonny_jr9 2023-11-11 11:06:36 +01:00
parent 71c054f092
commit 061b4431c7
8 changed files with 482 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
include/common.h
View File

@ -10,15 +10,34 @@
//conditional logging when DEBUG_OUTPUT_ENABLED is defined in config.h
//example: LOGD("game: %d", count)
#ifdef DEBUG_OUTPUT_ENABLED
#define LOGD(format, ...) printf(format, ##__VA_ARGS__)
#define LOGD(format, ...) printf("[D] " format, ##__VA_ARGS__)
#else
#define LOGD(format, ...) do {} while (0)
#endif
//conditional logging when INFO_OUTPUT_ENABLED is defined in config.h
//example: LOGD("game: %d", count)
//example: LOGI("game: %d", count)
#ifdef INFO_OUTPUT_ENABLED
#define LOGI(format, ...) printf(format, ##__VA_ARGS__)
#define LOGI(format, ...) printf("[I] " format, ##__VA_ARGS__)
#else
#define LOGI(format, ...) do {} while (0)
#endif
//===========================
//========== DELAY ==========
//===========================
//macro for DELAY(ms) function that works on Windows and Linux
#ifdef _WIN32
#include <windows.h>
#else
#include <unistd.h>
#endif
#ifdef _WIN32
#include <windows.h>
#define DELAY(ms) Sleep(ms)
#else
#include <unistd.h>
#define DELAY(ms) usleep((ms) * 1000)
#endif

5
include/config.h
View File

@ -1,12 +1,15 @@
#pragma once
// global configuration macros
#define MAX_MAP_SIZE 10
#define MAX_MAP_SIZE 20
#define MAX_MAP_FIELDS (MAX_MAP_SIZE*MAX_MAP_SIZE)
// logging settings
#define DEBUG_OUTPUT_ENABLED
#define INFO_OUTPUT_ENABLED
// struct for storing game configuration
typedef struct config_t
{

17
include/food.h
View File

@ -1,10 +1,19 @@
#pragma once
#include <stdbool.h>
//function that spawns food respecting the following rules:
// - not at Collision, Snake-tail, Snake-head, portal-in, portal-out position (objects)
// - not closer to an object than minDist (if possible)
// - not further from an object than maxDist (if possible)
// maxDist and minDist are currently defined in food.c
void placeFood();
// platziert zufällig (mit bestimmtem Algorithmus) Fressen auf dem Spielfeld
// darf nicht auf der Schlange oder auf Wänden sein
//function that returns true when snake head is at current food position
bool checkEaten();
// Überprüft, ob Snake gefressen hat -> true wenn gefressen
// Vergleich mit gameData_t foodX, foodY
// indefinitely spawn food and print the map to console until the program is killed
// for testing and adjusting the food placement algorithm
void startFoodPlacementTest();

43
include/game.h
View File

@ -5,6 +5,7 @@
#include "config.h"
#include "map.h"
// Enum that defines the current game state
typedef enum gameState_t
{
@ -18,32 +19,32 @@ typedef enum gameState_t
// Struct that stores all data of the running game (all game-related functions access it globally)
typedef struct gameData_t
{
snake_t snake;
map_t map; // definition der geladenen karte
bool mapIsLoaded; // true when config.map is valid
int foodX, foodY; // Positon des Futters (es gibt immer nur 1 Futter)
int lifesRemaining; // implementieren wir nicht!!
int timestampLastCycle;
gameState_t gameState;
snake_t snake; // data describing snake
map_t map; // loaded map
bool mapIsLoaded; // true when game.map is valid
int foodX, foodY; // current position of food
int lifesRemaining; // not implemented
int timestampLastCycle; // time last game cycle started
gameState_t gameState; // state the game is in
} gameData_t;
// global struct for storing all game data (defined in game.c)
extern gameData_t game;
// run once at game start and does the following:
// - init snake
// - load map
// - place initial food
void gameInit();
// berechnet BlockSizePx: windowSize/mapWidth
// ruft snakeInit auf
// ruft placeFood auf
// platziert Wände
void handlePortals(); //(local)
// Prüft, ob Snake sich auf einem Portal befindet
//if true: snakeSetHeadPos auf
void runGameCycle();
// checkCollision() auf
// ruft placeFood() auf
// ruft checkEaten() auf
// if checkEaten then snakeGrow()
// Snakemove(), TickTimerReset
//ruft am Ende vom gameCycle renderGame() auf
// when snake head is on a portal-input, sets snake head to portal-target
void handlePortals(); //(ran in gameCycle)
// function that is repeatedly run at every game tick
// - moves snake to next position
// - handles collision, portals, food
// - triggers frame update (render.c)
void runGameCycle();

41
include/map.h
View File

@ -1,6 +1,8 @@
#pragma once
#include <stdbool.h>
#include "config.h"
#include "snake.h"
// Struct that stores all information needed for one Portal on the map
@ -11,32 +13,57 @@ typedef struct portal_t
char *color;
} portal_t;
// Struct that stores all information needed for one Collision box on the map
typedef struct collisionBox_t
{
int posX, posY;
} collisionBox_t;
// Struct that describes an entire map
typedef struct map_t {
int width;
int height;
const char *name[128];
char name[128];
collisionBox_t collisions[MAX_MAP_FIELDS];
int collisionCount;
portal_t portals[MAX_MAP_FIELDS];
int portalCount;
} map_t;
//return true when provided coordinate matches a collision box
bool checkCollides(int x, int y);
//generate random map based on difficulty level
map_t generateMap(int difficulty);
//search and load map by name (if not found loads default map)
// search and load map by name in storedMaps[] (map.c)
// stops program when map not found!
void loadMapByName(char *name);
//load map by passed definition
void loadMap(map_t map);
//return true when provided coordinate matches the position of a collision box
bool checkCollides(map_t map, int x, int y);
// generate random map based on difficulty level
// NOT IMPLEMENTED
map_t generateMap(int difficulty, int sizeX, int sizeY);
void printMap(map_t map);
// function that prints a map to console (stdout)
// note: currently also prints snake and food which may be bugged/unintended
// function that renders all current game objects to one 2d int array
// NOTE: passed Array has to be zero-initialized! (int arr[][] = {{0}})
// useful for rendering game to console or sdl
// 1=collision, 2=portalIn, 3=portalOut, 4=snakeHead, 5=snakeTail
void renderGameToArray(int mapFrame[MAX_MAP_SIZE][MAX_MAP_SIZE], map_t map, snake_t snake);
// stored map presets can be globally accessed (maybe needed by menu.c)
// not: maps defined in map.c end of file
extern const map_t * storedMaps[16];
extern const int storedMapsCount;

146
src/food.c
View File

@ -1,14 +1,150 @@
#include "food.h"
#include <stdbool.h>
#include <math.h>
#include <stdlib.h>
#include "food.h"
#include "common.h"
#include "map.h"
#include "game.h"
// platziert zufällig (mit bestimmtem Algorithmus) Fressen auf dem Spielfeld
void placeFood(int count)
//--------------------------------------------
//----- getRandomPositionWithMinDistance -----
//--------------------------------------------
// local function used in placeFood that returns random coordinates that have
// at least in_minDist blocks distance to every Collision, portal and snake block on the current map.
void getRandomPositionWithMinDistance(int *outX, int *outY, float *out_minDist, int *out_triesNeeded, float in_minDist)
{
//--- config ---
static const int maxTries = 50; // each maxTries the limits above get loosened
//--- get game frame ---
// get 2d array containing position of all objects of current game state
int gameFrame[MAX_MAP_SIZE][MAX_MAP_SIZE] = {{0}};
renderGameToArray(gameFrame, game.map, game.snake);
int foodX, foodY;
//--- search random location ---
// search random location for food that is within the defined min distance
int tries = 0;
//stores distance to closest block for return value
float minActualDistance = MAX_MAP_SIZE;
newValues:
while (1)
{
// generate random coodinates within map range
foodX = rand() % game.map.width;
foodY = rand() % game.map.height;
tries++;
// loop through all coordinates of current game/map
for (int y = 0; y < game.map.height; y++)
{
for (int x = 0; x < game.map.width; x++)
{
if (gameFrame[y][x] > 0) // any object is present
{
// calculate from random-coordinate to current block
float dist = sqrt(pow(foodX - x, 2) + pow(foodY - y, 2));
// save minimum distance
if (dist < minActualDistance) minActualDistance = dist;
// verify minimum distance is kept
if (dist < in_minDist) //too close
{
LOGD("food: distance: min=%.1f now=%.1f => placed too close => reroll...\n", in_minDist, dist);
// prevent deadlock if no suitable position exists - loosen limits every k*maxTries
if (tries % maxTries == 0)
{
//decrease min distance but not below 1
if ((in_minDist -= 0.1) < 1) in_minDist = 1;
LOGI("[WARN] food: too much tries achieving min dist -> loosen limit to %.1f\n", in_minDist);
}
//reset stored distance and reroll coordinates
minActualDistance = MAX_MAP_SIZE;
goto newValues;
}
}
}
}
//success: no block closer than minDist to randomly generated coordinates -> break loop
break;
}
// return variables
*out_minDist = minActualDistance;
*outX = foodX;
*outY = foodY;
*out_triesNeeded = tries;
}
//=========================
//======= placeFood =======
//=========================
//function that spawns food respecting the following rules:
// - not at Collision, Snake-tail, Snake-head, portal-in, portal-out position (objects)
// - not closer to an object than minDist (if possible)
// - not further from an object than maxDist (if possible)
void placeFood()
{
//--- config ---
static const float minDist = 3; // new food has to be at least minDist blocks away from any object
float maxDist = 5; // new food has to be closer than maxDist to an object
static const int maxTries = 25; // each maxTries the limit maxDist get loosened (prevents deadlock)
// TODO calculate this range using configured difficulty level
// e.g. in hard difficulty the maxDist could be <2 so it is always placed close to a collision
//--- variables ---
int foodX, foodY, triesMax = 0, triesMin;
float currentMinDist;
//--- generate random food position within min/max range ---
LOGD("food: generating random position + verifying min/max distance...\n");
do
{
// prevent deadlock when position respecting maxDist not found
triesMax++;
if (triesMax % maxTries == 0)
{
maxDist += 0.1;
LOGI("[WARN] food: too many tries for MAX_DIST -> loosen limits to max=%.1f\n", maxDist);
}
// generate random coordinates respecting minimum distance to objects
getRandomPositionWithMinDistance(&foodX, &foodY, &currentMinDist, &triesMin, minDist);
//restart when max distance limit exceeded
} while (currentMinDist > maxDist);
//--- update position ---
LOGI("food: placed food at x=%d, y=%d (took %d = %d*%d tries)\n", foodX, foodY, triesMax * triesMin, triesMax, triesMin);
game.foodX = foodX;
game.foodY = foodY;
return;
}
// Überprüft, ob Snake gefressen hat
//=============================
//===== foodPlacementTest =====
//=============================
// indefinitely spawn food and print the map to console until the program is killed
// for testing and adjusting the food placement algorithm
void startFoodPlacementTest()
{
while (1)
{
loadMapByName("default");
placeFood();
printMap(game.map);
DELAY(100);
}
}
//==========================
//======= checkEaten =======
//==========================
//returns true when snake head is at current food position
bool checkEaten()
{
return 0;
return (game.snake.headX == game.foodX && game.snake.headY == game.foodY);
}

90
src/game.c
View File

@ -1,49 +1,113 @@
#include "game.h"
#include "map.h"
#include "common.h"
#include "menu.h"
#include "food.h"
#include "render.h"
// global struct for storing all game data
gameData_t game;
// default values where needed:
gameData_t game = {
.snake.length = 0,
.foodX = 0,
.foodY = 0,
.mapIsLoaded = false,
.lifesRemaining = 1,
.timestampLastCycle = 0,
.gameState = MENU
};
//========================
//======= gameInit =======
//========================
// run once at game start and does the following:
// - init snake
// - load map
// - place initial food
void gameInit()
{
LOGI("game: initializing game...\n");
//----- snake -----
// defines initial values of game.snake
// snakeInit(); FIXME: uncomment when implemented
snakeInit(); //TODO assign return value to game.snake?
//----- load map -----
//load default map if no map loaded yet
if (!game.mapIsLoaded){
char * defaultName = "default";
loadMapByName("default");
//loadMapByName("intermediate");
}
// place initial food
//placeFood(); FIXME uncomment when implemented
//----- initialize variables -----
game.lifesRemaining = 1;
// game.lifesRemaining = config.maxLifes; TODO: add maxLifes to config
// game.gameState = RUNNING; ??
game.timestampLastCycle = -config.cycleDurationMs; // next cycle starts immediately
//--- place initial food ---
placeFood();
LOGI("game: placed initial food at x=%d, y=%d\n", game.foodX, game.foodY);
}
//=========================
//===== handlePortals =====
//=========================
// when snake head is on a portal-input, sets snake head to portal-target
void handlePortals()
{
LOGD("game: handling portals...\n");
// loop through all existin portals in current map (game.map)
for (int i=0; i < game.map.portalCount; i++){
portal_t p = game.map.portals[i]; //copy curren portal (code more readable)
// is at portal
if (game.snake.headX == p.posX && game.snake.headY == p.posY){
snakeSetHeadPos(p.posX, p.posY);
LOGI("game: entered portal i=%d at x=%d, y=%d -> set head to x=%d y=%d\n", i, p.posX, p.posY, p.targetX, p.targetY);
return;
}
}
// snake not on any portal
return;
}
//==========================
//====== runGameCycle ======
//==========================
// function that is repeatedly run at every game tick
// - moves snake to next position
// - handles collision, portals, food
// - triggers frame update (render.c)
void runGameCycle()
{
if (checkCollides(game.snake.headX, game.snake.headY))
LOGD("game: starting GameCycle %d\n", game.timestampLastCycle);
//--- move snake ---
// move snake to next position
snakeMove();
//--- handle collision ---
//collision with map object or snake tail
if (checkCollides(game.map, game.snake.headX, game.snake.headY) || !snakeIsAlive()){
// show leaderboard when collided
// TODO consider game.lifesRemaining and reset if still good?
LOGI("game: collided with wall or self! => show leaderboard\n");
game.gameState = MENU;
showLeaderboard();
return;
}
//--- handle portals ---
handlePortals();
//--- handle food ---
if (checkEaten()) {
LOGI("game: picked up food at x=%d y=%d -> growing, placing food\n", game.foodX, game.foodY);
snakeGrow();
placeFood();
}
//--- update frame ---
renderGame();
return;
}

179
src/map.c
View File

@ -1,43 +1,202 @@
#include <string.h>
#include "map.h"
#include "game.h"
#include "common.h"
//===========================
//==== renderGameToArray ====
//===========================
// function that renders all current game objects to one 2d int array
// NOTE: passed Array has to be zero-initialized! (int arr[][] = {{0}})
// useful for rendering game to console or sdl
// 1=collision, 2=portalIn, 3=portalOut, 4=snakeHead, 5=snakeTail
void renderGameToArray(int mapFrame[MAX_MAP_SIZE][MAX_MAP_SIZE], map_t map, snake_t snake)
{
// copy collisions
for (int i = 0; i < map.collisionCount; i++)
{
mapFrame[map.collisions[i].posY][map.collisions[i].posX] = 1;
}
// copy portals
for (int i = 0; i < map.portalCount; i++)
{
mapFrame[map.portals[i].posY][map.portals[i].posX] = 2;
mapFrame[map.portals[i].targetY][map.portals[i].targetX] = 3;
}
// copy snake head
mapFrame[snake.headX][snake.headY] = 4;
// copy snake tail
for (int i = 0; i < snake.length; i++)
{
mapFrame[snake.tail[i][1]][snake.tail[i][0]] = 5;
}
// copy food
mapFrame[game.foodY][game.foodX] = 6;
return;
}
//========================
//======= printMap =======
//========================
// function that prints a map to console (stdout)
// note: currently also prints snake and food which may be bugged/unintended
void printMap(map_t map)
{
LOGI("map: Preview of map '%s' (%dx%d):\n", map.name, map.width, map.height);
int mapFrame[MAX_MAP_SIZE][MAX_MAP_SIZE] = {{0}};
renderGameToArray(mapFrame, map, game.snake);
// --- print top line ---
printf("+");
for (int i = 0; i < map.width; i++) printf("-");
printf("+\n");
// --- print field ---
// loop through rows (y)
for (int row = 0; row < map.height; row++)
{
printf("|"); // vert line left
// loop through line (x)
for (int column = 0; column < map.width; column++)
{
switch (mapFrame[row][column])
{
case 1: printf("X"); // collistion
break;
case 2: printf("O"); // portal-in
break;
case 3: printf("T"); // portal-out
break;
case 6: printf("F"); // food
break;
default: printf(" "); // empty
break;
}
}
printf("|\n"); // vert line right
}
// --- print bot line ---
printf("+");
for (int i = 0; i < map.width; i++)
printf("-");
printf("+\n");
}
//===========================
//======= generateMap =======
//===========================
// generate random map based on difficulty level
map_t generateMap(int difficulty)
// NOT IMPLEMENTED
map_t generateMap(int difficulty, int sizeX, int sizeY)
{
map_t newMap;
return newMap;
// TODO add map generator
}
// search and load map by name (if not found loads default map)
//===========================
//====== loadMapByName ======
//===========================
// search and load map by name in storedMaps[] (map.c)
// stops program when map not found!
void loadMapByName(char *name)
{
LOGI("map: loading map %s", name);
// loop through all stored maps
for (int i = 0; i < storedMapsCount; i++)
{
// compare name
if (strcmp(name, storedMaps[i]->name) == 0)
{
// load matched map
LOGI("map: found map '%s'\n", name);
loadMap(*storedMaps[i]);
return;
}
}
// map not found
printf("[FATAL ERROR] map: could not find '%s' in storedMaps!\n", name);
game.gameState = EXIT;
return;
// TODO add map presets
}
//===========================
//========= loadMap =========
//===========================
// load map by passed definition
void loadMap(map_t map)
{
LOGI("map: loading map '%s':\n", map.name);
#ifdef DEBUG_OUTPUT_ENABLED
printMap(map);
#endif
game.map = map;
game.mapIsLoaded = true;
return;
}
// check if there is collision at certain coordinate
bool checkCollides(int x, int y)
//===========================
//====== checkCollides ======
//===========================
// check if there is collision box at a certain coordinate
bool checkCollides(map_t map, int x, int y)
{
// loop through all collision boxes on the map
for (int i = 0; i < game.map.collisionCount; i++)
for (int i = 0; i < map.collisionCount; i++)
{
// return true if match found
if (game.map.collisions[i].posX == x && game.map.collisions[i].posY == y)
// LOGD("map: checking collision i=%d at x=%d y=%d\n", i, map.collisions[i].posX, map.collisions[i].posY);
if (map.collisions[i].posX == x && map.collisions[i].posY == y)
return true;
}
return false;
}
//TODO add map presets here:
//===========================
//======= MAP PRESETS =======
//===========================
// stored map presets
// TODO add more maps or map generator
static const map_t map_default = {
.width = 10,
.height = 10,
.name = "default",
.collisions = {{8, 9}, {8, 8}, {4, 5}, {0, 1}},
.collisionCount = 4,
.portals = {
{.posX = 5,
.posY = 8,
.targetX = 7,
.targetY = 1,
.color = "blue"}},
.portalCount = 1};
static const map_t map_intermediate = {
.width = 15,
.height = 15,
.name = "intermediate",
.collisions = {{8, 9}, {8, 8}, {4, 5}, {0, 1}, {9, 9}, {7, 5}, {4, 0}, {3, 0}, {12, 11}, {14, 13}},
.collisionCount = 10,
.portals = {
{.posX = 5,
.posY = 8,
.targetX = 7,
.targetY = 1,
.color = "blue"},
{.posX = 1,
.posY = 2,
.targetX = 2,
.targetY = 8,
.color = "red"}},
.portalCount = 2};
// global variables for accessing the stored maps
const map_t *storedMaps[16] = {&map_default, &map_intermediate};
const int storedMapsCount = 2;