BRNSystems/factorygame
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Some more hopefully working progress

Browse Source
This commit is contained in:
Bruno Rybársky
2025-05-31 23:54:55 +02:00
parent 0c9698879b
commit 6b6e7df035
26 changed files with 659 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files

264
main.c
View File

@@ -4,18 +4,45 @@
#include "util/font.h"
#include "util/audio.h"
#include "tiles/tile.h"
#include "tiles/belt.h"
#include "items/item.h"
#include "stdlib.h"
#include "player/player.h"
typedef struct {
Player player;
Tile tileMap[MAP_HEIGHT][MAP_WIDTH];
} GameState;
GameState gameState;
void loadGameState(char *filename, Player *plr) {
printf("hello from load\n");
fflush(stdout);
FILE *gameSave = fopen(filename, "rb");
if (gameSave) {
fread(&gameState, sizeof(gameState), 1, gameSave);
fclose(gameSave);
memcpy(tileMap, gameState.tileMap, sizeof(tileMap));
memcpy(plr, &gameState.player, sizeof(gameState.player));
}
}
void saveGameState(char *filename, Player *plr) {
memcpy(&gameState.player, plr, sizeof(gameState.player));
memcpy(gameState.tileMap, tileMap, sizeof(gameState.tileMap));
FILE *gameSave = fopen(filename, "wb");
if (!gameSave) {
perror("Failed to open file for saving");
return;
}
fwrite(&gameState, sizeof(gameState), 1, gameSave);
fclose(gameSave);
}
Player player;
float currentScale = 1;
//Screen dimension constants
#define SCREEN_WIDTH DISPLAY_WIDTH / currentScale
#define SCREEN_HEIGHT DISPLAY_HEIGHT/ currentScale
const int targetFPS = 60;
const int delayNeeded = 1000 / targetFPS;
@@ -24,6 +51,8 @@ const int delayNeeded = 1000 / targetFPS;
#define smallerFont fonts[2]
#define smallestFont fonts[3]
const char *autosaveName = "autosave.dat";
unsigned long frames = 0;
bool cursor = true;
@@ -35,11 +64,16 @@ void msleep(unsigned int milliseconds) {
nanosleep(&ts, NULL);
}
SDL_GLContext glContext;
int init() {
//Initialize SDL
screenRect.x = 0;
screenRect.y = 0;
screenRect.w = DISPLAY_WIDTH;
screenRect.h = DISPLAY_HEIGHT;
srand(0);
@@ -59,24 +93,24 @@ int init() {
}
//Create window
window = SDL_CreateWindow("Factory game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
window = SDL_CreateWindow("Factory game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, DISPLAY_WIDTH,
DISPLAY_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if (window == NULL) {
printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
return 1;
}
//Get window surface
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (renderer == NULL) {
mainRenderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
if (mainRenderer == NULL) {
printf("Renderer could not be created SDL_Error: %s\n", SDL_GetError());
return 1;
}
loadTiles(renderer);
loadItems(renderer);
loadTiles(mainRenderer);
loadItems(mainRenderer);
// Create OpenGL context
SDL_GLContext glContext = SDL_GL_CreateContext(window);
glContext = SDL_GL_CreateContext(window);
if (!glContext) {
fprintf(stderr, "SDL_GL_CreateContext failed: %s\n", SDL_GetError());
exit(1);
@@ -101,30 +135,32 @@ int init() {
SDL_PauseAudioDevice(dev, 0);
SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(mainRenderer, 0, 0, 0, 255);
SDL_RenderClear(mainRenderer);
SDL_Rect viewport = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
SDL_RenderSetViewport(renderer, &viewport);
SDL_Rect viewport = {0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT};
SDL_RenderSetViewport(mainRenderer, &viewport);
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
biggerFont = prepText(renderer, 16, "assets/PublicPixel.ttf", 255, 255, 255, 255);
smallFont = prepText(renderer, 12, "assets/PublicPixel.ttf", 255, 255, 255, 255);
smallerFont = prepText(renderer, 8, "assets/PublicPixel.ttf", 255, 255, 255, 255);
smallestFont = prepText(renderer, 4, "assets/PublicPixel.ttf", 255, 255, 255, 255);
SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH, SCREEN_HEIGHT);
SDL_SetRenderDrawBlendMode(mainRenderer, SDL_BLENDMODE_BLEND);
biggerFont = prepText(mainRenderer, 16, "assets/PublicPixel.ttf", 255, 255, 255, 255);
smallFont = prepText(mainRenderer, 12, "assets/PublicPixel.ttf", 255, 255, 255, 255);
smallerFont = prepText(mainRenderer, 8, "assets/PublicPixel.ttf", 255, 255, 255, 255);
smallestFont = prepText(mainRenderer, 4, "assets/PublicPixel.ttf", 255, 255, 255, 255);
SDL_RenderSetLogicalSize(mainRenderer, DISPLAY_WIDTH, DISPLAY_HEIGHT);
initPlayer(&player);
generateTestMap();
initTiles();
//generateTestMap();
return 0;
}
int render() {
SDL_SetRenderDrawColor(renderer, 32, 32, 32, 255);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(mainRenderer, 32, 32, 32, 255);
SDL_RenderClear(mainRenderer);
SDL_Rect rect2;
rect2.x = 20;
@@ -132,12 +168,17 @@ int render() {
rect2.w = 0;
rect2.h = 0;
renderAllBelts(renderer);
renderAllTiles(mainRenderer, player.rect);
SDL_RenderCopy(mainRenderer, tilesTexture, &screenRect, &screenRect);
SDL_RenderCopy(mainRenderer, itemsTexture, &screenRect, &screenRect);
SDL_RenderCopy(mainRenderer, entityTexture, &screenRect, &screenRect);
SDL_RenderCopy(mainRenderer, hudTexture, &screenRect, &screenRect);
renderPlayer(&player);
SDL_RenderPresent(renderer);
SDL_RenderPresent(mainRenderer);
frames++;
if (!(frames % 60)) {
cursor = !cursor;
@@ -154,10 +195,11 @@ int processEvent(SDL_Event e) {
// Adjust the viewport to match the new window size;
SDL_Rect viewport = {0, 0, newWidth, newHeight};
SDL_RenderSetViewport(renderer, &viewport);
SDL_RenderSetViewport(mainRenderer, &viewport);
} else if (e.type == SDL_KEYDOWN) {
int keySym = e.key.keysym.sym;
int keyMod = e.key.keysym.mod;
SDL_KeyCode keySym = e.key.keysym.sym;
SDL_Scancode scanCode = e.key.keysym.scancode;
SDL_Keymod keyMod = e.key.keysym.mod;
cursor = true;
switch (keySym) {
case SDLK_p:
@@ -172,6 +214,12 @@ int processEvent(SDL_Event e) {
player.cursor.targetTile->direction = player.cursor.direction;
}
break;
case SDLK_u:
laneTarget = !laneTarget;
break;
case SDLK_F3:
debugMode = !debugMode;
break;
default:
break;
}
@@ -203,7 +251,7 @@ int processEvent(SDL_Event e) {
void processMousePosition() {
SDL_Rect viewport;
SDL_RenderGetViewport(renderer, &viewport);
SDL_RenderGetViewport(mainRenderer, &viewport);
uint32_t mouseButtons = SDL_GetMouseState(&player.cursor.windowX, &player.cursor.windowY);
if (mouseButtons & SDL_BUTTON_LMASK) {
@@ -228,14 +276,12 @@ void processMousePosition() {
}
if (player.cursor.targetTile->type == TYPE_BELT) {
for (int lane = 0; lane < 2; lane++) {
for (int slot = 0; slot < 2; slot++) {
if (player.cursor.targetTile->items[lane][slot].active) {
int itemType = player.cursor.targetTile->items[lane][slot].type;
if (itemType < itemRegistryIndex) {
player.inventory.slotCounts[itemType]++;
}
player.cursor.targetTile->items[lane][slot].active = false;
if (player.cursor.targetTile->items[lane].type != 0) {
int itemType = player.cursor.targetTile->items[lane].type;
if (itemType < itemRegistryIndex) {
player.inventory.slotCounts[itemType]++;
}
player.cursor.targetTile->items[lane].type = 0;
}
}
}
@@ -261,12 +307,20 @@ void processMousePosition() {
}
// Translate mouseRect coordinates to viewport space
player.cursor.windowX = ((player.cursor.windowX - viewport.x) * SCREEN_WIDTH) / viewport.w;
player.cursor.windowY = (player.cursor.windowY - viewport.y) * SCREEN_HEIGHT / viewport.h;
player.cursor.tileX = (player.cursor.windowX + playerX) / TILE_SIZE - (SCREEN_WIDTH / TILE_SIZE / 2);
player.cursor.tileY = (player.cursor.windowY + playerY) / TILE_SIZE - (SCREEN_HEIGHT / TILE_SIZE / 2);
player.cursor.windowX = ((player.cursor.windowX - viewport.x) * DISPLAY_WIDTH) / viewport.w;
player.cursor.windowY = (player.cursor.windowY - viewport.y) * DISPLAY_HEIGHT / viewport.h;
player.cursor.tileX = (player.cursor.windowX + player.rect.x) / TILE_SIZE - (DISPLAY_WIDTH / TILE_SIZE / 2);
player.cursor.tileY = (player.cursor.windowY + player.rect.y) / TILE_SIZE - (DISPLAY_HEIGHT / TILE_SIZE / 2);
player.cursor.prevTargetTile = player.cursor.targetTile;
player.cursor.targetTile = &tileMap[player.cursor.tileY][player.cursor.tileX];
player.cursor.targetTileRect.x = player.cursor.tileX * TILE_SIZE;
player.cursor.targetTileRect.y = player.cursor.tileY * TILE_SIZE;
player.cursor.tileDiffX = player.cursor.tileX - playerTileX;
player.cursor.tileDiffY = player.cursor.tileY - playerTileY;
player.cursor.tileDiff = floorf(sqrtf(powf(player.cursor.tileDiffX, 2) + powf(player.cursor.tileDiffY, 2)));
player.cursor.canReach = player.cursor.tileDiff <= playerReach;
adjustRect(&player.cursor.targetTileRect, player.rect);
}
void processKeyboardHeld() {
@@ -281,29 +335,54 @@ void processKeyboardHeld() {
cameraSpeed /= 2;
}
if (keyboardState[SDL_SCANCODE_W]) {
// Example: move up
playerY -= cameraSpeed;
if (playerY < (SCREEN_HEIGHT / 2)) {
playerY = (SCREEN_HEIGHT / 2);
if (player.cursor.breakingProgress == 0) {
if (keyboardState[SDL_SCANCODE_W]) {
// Example: move up
player.rect.y -= cameraSpeed;
if (player.rect.y < (DISPLAY_HEIGHT / 2)) {
player.rect.y = (DISPLAY_HEIGHT / 2);
}
}
if (keyboardState[SDL_SCANCODE_S]) {
player.rect.y += cameraSpeed;
if (player.rect.y > (MAP_HEIGHT * TILE_SIZE) - (DISPLAY_HEIGHT / 2)) {
player.rect.y = (MAP_HEIGHT * TILE_SIZE) - (DISPLAY_HEIGHT / 2);
}
}
if (keyboardState[SDL_SCANCODE_A]) {
player.rect.x -= cameraSpeed;
if (player.rect.x < (DISPLAY_WIDTH / 2)) {
player.rect.x = (DISPLAY_WIDTH / 2);
}
}
if (keyboardState[SDL_SCANCODE_D]) {
player.rect.x += cameraSpeed;
if (player.rect.x > (MAP_WIDTH * TILE_SIZE) - (DISPLAY_WIDTH / 2)) {
player.rect.x = (MAP_WIDTH * TILE_SIZE) - (DISPLAY_WIDTH / 2);
}
}
}
if (keyboardState[SDL_SCANCODE_S]) {
playerY += cameraSpeed;
if (playerY > (MAP_HEIGHT * TILE_SIZE) - (SCREEN_HEIGHT / 2)) {
playerY = (MAP_HEIGHT * TILE_SIZE) - (SCREEN_HEIGHT / 2);
}
}
if (keyboardState[SDL_SCANCODE_A]) {
playerX -= cameraSpeed;
if (playerX < (SCREEN_WIDTH / 2)) {
playerX = (SCREEN_WIDTH / 2);
}
}
if (keyboardState[SDL_SCANCODE_D]) {
playerX += cameraSpeed;
if (playerX > (MAP_WIDTH * TILE_SIZE) - (SCREEN_WIDTH / 2)) {
playerX = (MAP_WIDTH * TILE_SIZE) - (SCREEN_WIDTH / 2);
if (keyboardState[SDL_SCANCODE_F]) {
for (int x = player.rect.x - 1; x < player.rect.x + 1; player.rect.x++) {
if (x < 0) {
continue;
}
for (int y = player.rect.y - 1; y < player.rect.y + 1; player.rect.y++) {
if (y < 0) {
continue;
}
Tile *t = &tileMap[y][x];
if (t->type == TYPE_BELT) {
for (uint8_t lane = 0; lane < 2; lane++) {
ItemOnBelt *item = &t->items[lane];
if (item->type != 0) {
player.inventory.slotCounts[item->type]++;
item->type = 0;
}
}
}
}
}
}
@@ -315,22 +394,46 @@ void processKeyboardHeld() {
if (keyboardState[SDL_SCANCODE_Y]) {
if (player.cursor.canReach && player.cursor.targetTile->type == TYPE_BELT &&
player.inventory.slotCounts[player.inventory.activeSlotIndex] > 0) {
bool done = false;
for (uint8_t lane = 0; lane < 2; lane++) {
for (uint8_t slot = 0; slot < 2; slot++) {
if (!player.cursor.targetTile->items[lane][slot].active) {
putItem(player.cursor.tileX, player.cursor.tileY, player.inventory.activeSlotIndex, lane, slot);
player.inventory.slotCounts[player.inventory.activeSlotIndex]--;
done = true;
break;
}
}
if (done) {
for (uint8_t lane = 0; lane < 1; lane++) {
if (player.cursor.targetTile->items[lane].type == 0) {
putItem(player.cursor.tileX, player.cursor.tileY, player.inventory.activeSlotIndex, lane);
player.inventory.slotCounts[player.inventory.activeSlotIndex]--;
break;
}
}
}
}
unsigned int slot = 0;
if (keyboardState[SDL_SCANCODE_GRAVE]) {
slot = 1;
} else if (keyboardState[SDL_SCANCODE_1]) {
slot = 2;
} else if (keyboardState[SDL_SCANCODE_2]) {
slot = 3;
} else if (keyboardState[SDL_SCANCODE_3]) {
slot = 4;
} else if (keyboardState[SDL_SCANCODE_4]) {
slot = 5;
} else if (keyboardState[SDL_SCANCODE_5]) {
slot = 6;
} else if (keyboardState[SDL_SCANCODE_6]) {
slot = 7;
} else if (keyboardState[SDL_SCANCODE_7]) {
slot = 8;
} else if (keyboardState[SDL_SCANCODE_8]) {
slot = 9;
} else if (keyboardState[SDL_SCANCODE_9]) {
slot = 10;
} else if (keyboardState[SDL_SCANCODE_0]) {
slot = 11;
} else if (keyboardState[SDL_SCANCODE_MINUS]) {
slot = 12;
} else if (keyboardState[SDL_SCANCODE_EQUALS]) {
slot = 13;
}
if (slot > 0 && slot < itemRegistryIndex) {
setActivePlayerSlot(&player, slot);
}
}
int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[]) {
@@ -338,13 +441,7 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[])
if (status) {
return status;
}
uint8_t type = 0;
for (int x = 142; x < 154; x += 3) {
for (int y = 80; y < 94; y += 3) {
putItem(x, y, type++ % ITEMREGISTRY_SIZE, 0, 0);
}
}
loadGameState(autosaveName, &player);
//Hack to get window to stay up
@@ -375,12 +472,15 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[])
}
}
saveGameState(autosaveName, &player);
for (uint8_t i = 0; i < fontCount; i++) {
destroyFont(&fonts[i]);
}
puts(SDL_GetError());
if (renderer) SDL_DestroyRenderer(renderer);
if (mainRenderer) SDL_DestroyRenderer(mainRenderer);
if (window) SDL_DestroyWindow(window);
if (glContext) SDL_GL_DeleteContext(glContext);
SDL_Quit();