Hopefully last commit

2025-06-11 23:01:05 +02:00
parent 78bccd6c6f
commit 8bbe17491b
74 changed files with 1306 additions and 516 deletions
--- a/main.c
+++ b/main.c
@@ -7,73 +7,12 @@
 #include "items/item.h"
 #include "stdlib.h"
 #include "player/player.h"
-#include "util/perlin.h"
 #include "util/atlas.h"
 #include "entity/entity.h"
+#include "util/gamestate.h"
+#include "util/button.h"

-typedef struct GameState {
-    Player player;
-    Tile tileMap[MAP_HEIGHT][MAP_WIDTH];
-    BackgroundTile backgroundTileMap[MAP_HEIGHT][MAP_WIDTH];
-    AudioData audioData;
-    TileArray neededUpdates;
-    EntityArray entities;
-    Node openList[MAX_OPEN_NODES];
-    int openCount;
-} GameState;
-GameState gameState;
-
-int loadGameState(char *filename, Player *plr) {
-    fflush(stdout);
-    FILE *gameSave = fopen(filename, "rb");
-    if (gameSave) {
-        fseek(gameSave, 0L, SEEK_END);
-        long sz = ftell(gameSave);
-        if (sz != sizeof(gameState)) {
-            return 1;
-        }
-        rewind(gameSave);
-        fread(&gameState, sizeof(gameState), 1, gameSave);
-        fclose(gameSave);
-        memcpy(plr, &gameState.player, sizeof(gameState.player));
-        memcpy(tileMap, gameState.tileMap, sizeof(tileMap));
-        memcpy(backgroundMap, gameState.backgroundTileMap, sizeof(backgroundMap));
-        SDL_Rect *tmp = audioData.playerRect;
-        memcpy(&audioData, &gameState.audioData, sizeof(gameState.audioData));
-        audioData.playerRect = tmp;
-        audioData.totalSamples = 0;
-        memcpy(&neededUpdates, &gameState.neededUpdates, sizeof(gameState.neededUpdates));
-        memcpy(&entities, &gameState.entities, sizeof(gameState.entities));
-        openCount = gameState.openCount;
-        memcpy(&openList, &gameState.openList, sizeof(gameState.openList));
-        plr->cursor.targetTile = NULL;
-        plr->cursor.prevTargetTile = NULL;
-        return 0;
-    }
-    return 1;
-}
-
-void saveGameState(char *filename, Player *plr) {
-    memcpy(&gameState.player, plr, sizeof(gameState.player));
-    memcpy(gameState.tileMap, tileMap, sizeof(gameState.tileMap));
-    memcpy(gameState.backgroundTileMap, backgroundMap, sizeof(gameState.backgroundTileMap));
-    memcpy(&gameState.audioData, &audioData, sizeof(gameState.audioData));
-    memcpy(&gameState.neededUpdates, &neededUpdates, sizeof(neededUpdates));
-    memcpy(&gameState.entities, &entities, sizeof(entities));
-    memcpy(&gameState.openList, &openList, sizeof(openList));
-    gameState.openCount = openCount;
-
-    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;
+#define GAME_NAME "FactoCraft"

 //Screen dimension constants
 const int targetFPS = 60;
@@ -85,8 +24,7 @@ const int delayNeeded = 1000 / targetFPS;
 #define smallestFont fonts[3]
 #define reallySmallestFont fonts[4]

-char *autosaveName = "autosave.dat";
-
+bool largeScreen = false;

 unsigned long frames = 0;
 bool cursor = true;
@@ -100,17 +38,9 @@ void msleep(unsigned int milliseconds) {

 SDL_GLContext glContext;

-void genInitMap();
-
 int init() {
    //Initialize SDL

-
-    screenRect.x = 0;
-    screenRect.y = 0;
-    screenRect.w = DISPLAY_WIDTH;
-    screenRect.h = DISPLAY_HEIGHT;
-
    srand(time(NULL));

    memset(tileMap, 0, sizeof(tileMap));
@@ -133,8 +63,13 @@ int init() {
    }

    //Create window
-    window = SDL_CreateWindow("Factory game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, DISPLAY_WIDTH,
-                              DISPLAY_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
+    window = SDL_CreateWindow(GAME_NAME, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, DISPLAY_WIDTH,
+                              DISPLAY_HEIGHT, SDL_WINDOW_SHOWN);
+
+    SDL_Surface *surf = IMG_Load("./assets/icon.png");
+
+    SDL_SetWindowIcon(window, surf);
+    SDL_FreeSurface(surf);

    if (window == NULL) {
        printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
@@ -146,22 +81,6 @@ int init() {
        printf("Renderer could not be created SDL_Error: %s\n", SDL_GetError());
        return 1;
    }
-
-    initAtlas(mainRenderer);
-
-    loadBackgroundTiles(mainRenderer);
-    loadTiles(mainRenderer);
-    preSetupTiles();
-    loadItems(mainRenderer);
-    loadEntities(mainRenderer);
-    setupTiles();
-
-
-//    for (ItemType i = 0; i < ITEMREGISTRY_SIZE; i++) {
-//        if (strlen(ItemRegistry[i].name)) {
-//            printf("%d -> %s\n", i, ItemRegistry[i].name);
-//        }
-//    }
    // Create OpenGL context
    glContext = SDL_GL_CreateContext(window);
    if (!glContext) {
@@ -172,14 +91,13 @@ int init() {
 // Use OpenGL context
    SDL_GL_MakeCurrent(window, glContext);  // Make sure OpenGL context is current before any OpenGL rendering

-    audioData.playerRect = &player.rect;
-    audioData.maxPanDistance = DISPLAY_WIDTH / 2;
+    audioData.playerRect = &mainPlayer.rect;

    SDL_AudioSpec spec = {0};
    spec.freq = SAMPLE_RATE;
    spec.format = AUDIO_F32;
    spec.channels = 2;
-    spec.samples = 4096;
+    spec.samples = 8192;
    spec.callback = audio_callback;
    spec.userdata = &audioData;

@@ -204,8 +122,9 @@ int init() {
    SDL_SetRenderDrawColor(mainRenderer, 0, 0, 0, 255);
    SDL_RenderClear(mainRenderer);

-    SDL_Rect viewport = {0, 0, DISPLAY_WIDTH, DISPLAY_HEIGHT};
-    SDL_RenderSetViewport(mainRenderer, &viewport);
+    //generateTestMap();
+
+    setTileView(30,15);

    SDL_SetRenderDrawBlendMode(mainRenderer, SDL_BLENDMODE_BLEND);
    biggerFont = prepText(mainRenderer, 32, "assets/PublicPixel.ttf");
@@ -213,65 +132,50 @@ int init() {
    smallerFont = prepText(mainRenderer, 12, "assets/PublicPixel.ttf");
    smallestFont = prepText(mainRenderer, 8, "assets/PublicPixel.ttf");
    reallySmallestFont = prepText(mainRenderer, 4, "assets/PublicPixel.ttf");
-    SDL_RenderSetLogicalSize(mainRenderer, DISPLAY_WIDTH, DISPLAY_HEIGHT);
-
-    initPlayer(&player);
-
-    for (ItemType i = 0; i < 13; i++) {
-        player.inventory.hotKeySlots[i] = i;
-    }
-
-    initTiles();
-
-    //generateTestMap();

    return 0;
 }

+bool lateInitDone = false;
+
+void lateInit() {
+    if (lateInitDone) {
+        return;
+    }
+    lateInitDone = true;
+    initAtlas(mainRenderer);
+
+    loadBackgroundTiles(mainRenderer);
+    loadTiles(mainRenderer);
+    preSetupTiles();
+    loadItems(mainRenderer);
+    loadEntities(mainRenderer);
+    setupTiles();
+    initTiles();
+
+    initPlayer(&mainPlayer);
+
+    for (ItemType i = 0; i < 13; i++) {
+        mainPlayer.inventory.hotKeySlots[i] = i;
+    }
+    initWaveInfo(&waveInfo);
+}
+

 int render() {
-    SDL_SetRenderDrawColor(mainRenderer, 32, 32, 32, 255);
-    SDL_RenderClear(mainRenderer);

-    SDL_Rect rect2;
-    rect2.x = 0;
-    rect2.y = 0;
-    rect2.w = ATLAS_SIZE;
-    rect2.h = ATLAS_SIZE;
-
-    renderAllTiles(mainRenderer, player.rect);
-    renderEntities(mainRenderer, player.rect);
-    renderPlayer(&player);
+    renderAllTiles(mainRenderer, mainPlayer.rect);
+    renderEntities(mainRenderer, mainPlayer.rect);
+    renderPlayer(&mainPlayer);


-    if (renderAtlas == 0) {
-        SDL_RenderCopy(mainRenderer, backgroundTexture, &screenRect, &screenRect);
-        SDL_RenderCopy(mainRenderer, tilesTexture, &screenRect, &screenRect);
-        SDL_RenderCopy(mainRenderer, itemsTexture, &screenRect, &screenRect);
-        SDL_RenderCopy(mainRenderer, entityTexture, &screenRect, &screenRect);
-        SDL_RenderCopy(mainRenderer, hudTexture, &screenRect, &screenRect);
-
-    } else {
-        SDL_RenderCopy(mainRenderer, atlasTexture, &rect2, &rect2);
-        unsigned int ix = ATLAS_SIZE;
-        for (unsigned char i = 1; i < fontCount; i++) {
-            SDL_Rect tmpRectFont = fonts[i].atlasRect;
-            tmpRectFont.x += ix;
-            SDL_RenderCopy(mainRenderer, fonts[i].atlas, &fonts[i].atlasRect, &tmpRectFont);
-            ix += fonts[i].atlasRect.w;
-        }
-        SDL_Rect tmpRectFont = fonts[0].atlasRect;
-        tmpRectFont.x += ATLAS_SIZE;
-        tmpRectFont.y = fonts[1].atlasRect.h;
-        SDL_RenderCopy(mainRenderer, fonts[0].atlas, &fonts[0].atlasRect, &tmpRectFont);
-    }
+    SDL_RenderCopy(mainRenderer, backgroundTexture, &screenRect, &screenRect);
+    SDL_RenderCopy(mainRenderer, tilesTexture, &screenRect, &screenRect);
+    SDL_RenderCopy(mainRenderer, itemsTexture, &screenRect, &screenRect);
+    SDL_RenderCopy(mainRenderer, entityTexture, &screenRect, &screenRect);
+    SDL_RenderCopy(mainRenderer, hudTexture, &screenRect, &screenRect);


-    SDL_RenderPresent(mainRenderer);
-    frames++;
-    if (!(frames % 60)) {
-        cursor = !cursor;
-    }
    return 0;
 }

@@ -283,186 +187,189 @@ int processEvent(SDL_Event e) {
        int newHeight = e.window.data2;

        // Adjust the viewport to match the new window size;
-        SDL_Rect viewport = {0, 0, newWidth, newHeight};
-        SDL_RenderSetViewport(mainRenderer, &viewport);
-    } else if (e.type == SDL_KEYDOWN) {
-        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:
-                speed = speed == 0 ? 0.004f : 0;
-                break;
-            case SDLK_r:
-                if (player.inventory.activeSlotIndex == 0 && player.cursor.canReach &&
-                    player.cursor.targetTile->type != TYPE_AIR) {
-                    player.cursor.direction = player.cursor.targetTile->direction;
-                }
-                player.cursor.direction = (player.cursor.direction + 2) % ORIENT_DIRECTION_COUNT;
-                if (player.inventory.activeSlotIndex == 0 && player.cursor.canReach) {
-                    player.cursor.targetTile->direction = player.cursor.direction;
-                }
-                break;
-            case SDLK_u:
-                laneTarget = !laneTarget;
-                break;
-            case SDLK_F3:
-                debugMode = !debugMode;
-                break;
-            case SDLK_F10:
-                renderAtlas = !renderAtlas;
-                break;
-            case SDLK_F11:
-                printf("Enemy is at tile X:%d, Y:%d\n", entities.entities[0].tileRect.x,
-                       entities.entities[0].tileRect.y);
-                break;
-
-            case SDLK_F2:
-                Entity entTest;
-                memset(&entTest, 0, sizeof(Entity));
-                entTest.tileRect = player.tileRect;
-                entTest.renderRect.w = TILE_SIZE;
-                entTest.renderRect.h = TILE_SIZE;
-                entTest.target.x = -1;
-                entTest.target.y = -1;
-                entTest.health = 100;
-                entTest.type = GHOST;
-                entTest.health = 100;
-                add_entity(&entities, entTest);
-                break;
-
-            case SDLK_F4:
-                Tile *tile = &tileMap[playerTileY][playerTileX];
-                break;
-            case SDLK_LALT:
-                itemViewing = !itemViewing;
-                break;
-            default:
-                break;
+        if (newWidth > 1900 && newHeight > 1000) {
+            largeScreen = true;
+        } else {
+            largeScreen = false;
        }
-    } else if (e.type == SDL_MOUSEWHEEL) {
-        int dAmount = 0;
-        if (e.wheel.y > 0) {
-            dAmount = 1;
-        } else if (e.wheel.y < 0) {
-            dAmount = -1;
+        setTileView(largeScreen ? 60 : 30, largeScreen ? 31 : 15);
+
+    }
+//    }
+
+    if (e.type == SDL_KEYUP) {
+        if (e.key.keysym.mod & KMOD_ALT && e.key.keysym.scancode == SDL_SCANCODE_RETURN) {
+            largeScreen = !largeScreen;
+            setTileView(largeScreen ? 60 : 30, largeScreen ? 31 : 15);
        }
-        const Uint8 *keyboardState = SDL_GetKeyboardState(NULL);
-        if (keyboardState[SDL_SCANCODE_LCTRL] || keyboardState[SDL_SCANCODE_RCTRL]) {
+    }
+
+    switch (screenType) {
+        case SCREEN_GAME:
+            if (e.type == SDL_KEYDOWN) {
+                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:
+                        speed = speed == 0 ? 0.004f : 0;
+                        break;
+                    case SDLK_r:
+                        if (mainPlayer.inventory.activeSlotIndex == 0 && mainPlayer.cursor.canReach &&
+                            mainPlayer.cursor.targetTile->type != TYPE_AIR) {
+                            mainPlayer.cursor.direction = mainPlayer.cursor.targetTile->direction;
+                        }
+                        mainPlayer.cursor.direction = (mainPlayer.cursor.direction + 2) % ORIENT_DIRECTION_COUNT;
+                        if (mainPlayer.inventory.activeSlotIndex == 0 && mainPlayer.cursor.canReach) {
+                            mainPlayer.cursor.targetTile->direction = mainPlayer.cursor.direction;
+                        }
+                        break;
+                    case SDLK_u:
+                        laneTarget = !laneTarget;
+                        break;
+                    case SDLK_F3:
+                        debugMode = !debugMode;
+                        break;
+                    case SDLK_F11:
+                        printf("Enemy is at tile X:%d, Y:%d\n", entities.entities[0].tileRect.x,
+                               entities.entities[0].tileRect.y);
+                        break;
+
+                    case SDLK_F4:
+                        Tile *tile = &tileMap[playerTileY][playerTileX];
+                        break;
+                    case SDLK_LALT:
+                        itemViewing = !itemViewing;
+                        break;
+                    default:
+                        break;
+                }
+            } else if (e.type == SDL_MOUSEWHEEL) {
+                int dAmount = 0;
+                if (e.wheel.y > 0) {
+                    dAmount = 1;
+                } else if (e.wheel.y < 0) {
+                    dAmount = -1;
+                }
+                const Uint8 *keyboardState = SDL_GetKeyboardState(NULL);
+                if (keyboardState[SDL_SCANCODE_LCTRL] || keyboardState[SDL_SCANCODE_RCTRL]) {
 //            currentScale += dAmount / 10.0f;
 //            if (currentScale > 4) {
 //                currentScale = 4;
 //            } else if (currentScale < 0.5f) {
 //                currentScale = 0.5f;
 //            }
-            //setZoom(currentScale);
+                    //setZoom(currentScale);


-        } else {
-            moveActivePlayerSlot(&player, dAmount == -1,
-                                 !(keyboardState[SDL_SCANCODE_LSHIFT] || keyboardState[SDL_SCANCODE_RSHIFT]));
-        }
+                } else {
+                    moveActivePlayerSlot(&mainPlayer, dAmount == -1,
+                                         !(keyboardState[SDL_SCANCODE_LSHIFT] || keyboardState[SDL_SCANCODE_RSHIFT]));
+                }
+            }
+            break;
+        case SCREEN_MENU:
+            break;
+        case SCREEN_FONTS:
+            break;
+        case SCREEN_ATLAS:
+            break;
    }
    return 1;
 }

 void processMousePosition() {
-    SDL_Rect viewport;
-    SDL_RenderGetViewport(mainRenderer, &viewport);
+    mainPlayer.cursor.tileX = (mainPlayer.cursor.windowX + mainPlayer.rect.x) / TILE_SIZE - (DISPLAY_WIDTH / TILE_SIZE / 2);
+    mainPlayer.cursor.tileY = (mainPlayer.cursor.windowY + mainPlayer.rect.y) / TILE_SIZE - (DISPLAY_HEIGHT / TILE_SIZE / 2);

-    uint32_t mouseButtons = SDL_GetMouseState(&player.cursor.windowX, &player.cursor.windowY);
-    if (mouseButtons & SDL_BUTTON_LMASK) {
-        if (player.cursor.canReach && player.cursor.targetTile->type == TYPE_AIR &&
-            player.inventory.activeSlotIndex < tileTypeIndex) {
-            if (player.inventory.slotCounts[player.inventory.activeSlotIndex] > 0) {
-                player.inventory.slotCounts[player.inventory.activeSlotIndex]--;
-                player.cursor.targetTile->type = player.inventory.activeSlotIndex;
-                player.cursor.targetTile->health = TileRegistry[player.inventory.activeSlotIndex].maxHealth;
-                player.cursor.targetTile->rect.x = player.cursor.tileX;
-                player.cursor.targetTile->rect.y = player.cursor.tileY;
-                if (TileRegistry[player.inventory.activeSlotIndex].needsTicks) {
-                    player.cursor.targetTile->neededUpdateIndex = add_tile(&neededUpdates,
-                                                                           player.cursor.targetTile->rect);
+    if (mainPlayer.cursor.tileX < 0) {
+        mainPlayer.cursor.tileX = 0;
+    }
+    if (mainPlayer.cursor.tileY < 0) {
+        mainPlayer.cursor.tileY = 0;
+    }
+    if (mainPlayer.cursor.tileX >= MAP_WIDTH) {
+        mainPlayer.cursor.tileX = MAP_WIDTH - 1;
+    }
+    if (mainPlayer.cursor.tileY >= MAP_HEIGHT) {
+        mainPlayer.cursor.tileY = MAP_HEIGHT - 1;
+    }
+
+    mainPlayer.cursor.prevTargetTile = mainPlayer.cursor.targetTile;
+    mainPlayer.cursor.targetTile = &tileMap[mainPlayer.cursor.tileY][mainPlayer.cursor.tileX];
+    mainPlayer.cursor.targetTileRect.x = mainPlayer.cursor.tileX * TILE_SIZE;
+    mainPlayer.cursor.targetTileRect.y = mainPlayer.cursor.tileY * TILE_SIZE;
+    mainPlayer.cursor.tileDiffX = mainPlayer.cursor.tileX - playerTileX;
+    mainPlayer.cursor.tileDiffY = mainPlayer.cursor.tileY - playerTileY;
+    mainPlayer.cursor.tileDiff = floorf(sqrtf(powf(mainPlayer.cursor.tileDiffX, 2) + powf(mainPlayer.cursor.tileDiffY, 2)));
+    mainPlayer.cursor.canReach = mainPlayer.cursor.tileDiff <= playerReach;
+    adjustRect(&mainPlayer.cursor.targetTileRect, mainPlayer.rect);
+
+    if (mainPlayer.mouseButtons & SDL_BUTTON_LMASK) {
+        if (mainPlayer.cursor.canReach && mainPlayer.cursor.targetTile->type == TYPE_AIR &&
+            mainPlayer.inventory.activeSlotIndex < tileTypeIndex) {
+            if (mainPlayer.inventory.slotCounts[mainPlayer.inventory.activeSlotIndex] > 0) {
+                mainPlayer.inventory.slotCounts[mainPlayer.inventory.activeSlotIndex]--;
+                mainPlayer.cursor.targetTile->type = mainPlayer.inventory.activeSlotIndex;
+                mainPlayer.cursor.targetTile->health = TileRegistry[mainPlayer.inventory.activeSlotIndex].maxHealth;
+                mainPlayer.cursor.targetTile->rect.x = mainPlayer.cursor.tileX;
+                mainPlayer.cursor.targetTile->rect.y = mainPlayer.cursor.tileY;
+                if (TileRegistry[mainPlayer.inventory.activeSlotIndex].needsTicks) {
+                    mainPlayer.cursor.targetTile->neededUpdateIndex = add_tile(&neededUpdates,
+                                                                               mainPlayer.cursor.targetTile->rect);
                }
-                player.cursor.targetTile->direction = player.cursor.direction;
+                mainPlayer.cursor.targetTile->direction = mainPlayer.cursor.direction;
            }
-        } else if (player.cursor.targetTile->type == player.inventory.activeSlotIndex) {
-            player.cursor.targetTile->direction = player.cursor.direction;
+        } else if (mainPlayer.cursor.targetTile->type == mainPlayer.inventory.activeSlotIndex) {
+            mainPlayer.cursor.targetTile->direction = mainPlayer.cursor.direction;
        }
    }
-    if (player.cursor.canReach && mouseButtons & SDL_BUTTON_RMASK) {
-        int tileIndex = player.cursor.targetTile->type;
+    if (mainPlayer.cursor.canReach && mainPlayer.mouseButtons & SDL_BUTTON_RMASK) {
+        int tileIndex = mainPlayer.cursor.targetTile->type;
        uint16_t targetBreakTime = TileRegistry[tileIndex].breakTime;
        if (targetBreakTime) {
-            if (player.cursor.breakingProgress >= targetBreakTime) {
-                if (player.cursor.targetTile->type < tileTypeIndex) {
-                    player.inventory.slotCounts[player.cursor.targetTile->type]++;
+            if (mainPlayer.cursor.breakingProgress >= targetBreakTime) {
+                if (mainPlayer.cursor.targetTile->type < tileTypeIndex) {
+                    mainPlayer.inventory.slotCounts[mainPlayer.cursor.targetTile->type]++;
                }
                for (int lane = 0; lane < 2; lane++) {
-                    if (player.cursor.targetTile->items[lane].type != 0) {
-                        int itemType = player.cursor.targetTile->items[lane].type;
+                    if (mainPlayer.cursor.targetTile->items[lane].type != 0) {
+                        int itemType = mainPlayer.cursor.targetTile->items[lane].type;
                        if (itemType < itemRegistryIndex) {
-                            player.inventory.slotCounts[itemType]++;
+                            mainPlayer.inventory.slotCounts[itemType]++;
                        }
-                        player.cursor.targetTile->items[lane].type = 0;
+                        mainPlayer.cursor.targetTile->items[lane].type = 0;
                    }
                }
-                audioData.synthVoices[player.cursor.targetTile->audioCh].volume = 0;
-                int neededIndex = player.cursor.targetTile->neededUpdateIndex;
-                if (TileRegistry[player.cursor.targetTile->type].needsTicks &&
-                    neededUpdates.tiles[neededIndex].x == player.cursor.targetTile->rect.x &&
-                    neededUpdates.tiles[neededIndex].y == player.cursor.targetTile->rect.y) {
+                audioData.synthVoices[mainPlayer.cursor.targetTile->audioCh].volume = 0;
+                int neededIndex = mainPlayer.cursor.targetTile->neededUpdateIndex;
+                if (TileRegistry[mainPlayer.cursor.targetTile->type].needsTicks &&
+                    neededUpdates.tiles[neededIndex].x == mainPlayer.cursor.targetTile->rect.x &&
+                    neededUpdates.tiles[neededIndex].y == mainPlayer.cursor.targetTile->rect.y) {
                    remove_tile(&neededUpdates, neededIndex);
                }
-                player.cursor.targetTile->type = TYPE_AIR;
-                player.cursor.breakingProgress = 0;
+                mainPlayer.cursor.targetTile->type = TYPE_AIR;
+                mainPlayer.cursor.breakingProgress = 0;
            } else {
-                player.cursor.breakingProgress++;
+                mainPlayer.cursor.breakingProgress++;
            }
-            //printf("Player breaking %d\n", player.cursor.breakingProgress);
+            //printf("Player breaking %d\n", mainPlayer.cursor.breakingProgress);
        }

    } else {
-        player.cursor.breakingProgress = 0;
+        mainPlayer.cursor.breakingProgress = 0;
    }
-    if (player.cursor.targetTile != player.cursor.prevTargetTile) {
-        player.cursor.breakingProgress = 0;
+    if (mainPlayer.cursor.targetTile != mainPlayer.cursor.prevTargetTile) {
+        mainPlayer.cursor.breakingProgress = 0;
    }
-    if (mouseButtons & SDL_BUTTON_MMASK) {
-        if (player.cursor.targetTile->type > 0) {
-            setActivePlayerSlot(&player, player.cursor.targetTile->type);
+    if (mainPlayer.mouseButtons & SDL_BUTTON_MMASK) {
+        if (mainPlayer.cursor.targetTile->type > 0) {
+            setActivePlayerSlot(&mainPlayer, mainPlayer.cursor.targetTile->type);
        }

    }
    // Translate mouseRect coordinates to viewport space
-
-    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);
-    if (player.cursor.tileX < 0) {
-        player.cursor.tileX = 0;
-    }
-    if (player.cursor.tileY < 0) {
-        player.cursor.tileY = 0;
-    }
-    if (player.cursor.tileX >= MAP_WIDTH) {
-        player.cursor.tileX = MAP_WIDTH - 1;
-    }
-    if (player.cursor.tileY >= MAP_HEIGHT) {
-        player.cursor.tileY = MAP_HEIGHT - 1;
-    }
-    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() {
@@ -478,49 +385,49 @@ void processKeyboardHeld() {
    }

    if (keyboardState[SDL_SCANCODE_F8]) {
-        if (player.cursor.targetTile->health) {
-            player.cursor.targetTile->health--;
+        if (mainPlayer.cursor.targetTile->health) {
+            mainPlayer.cursor.targetTile->health--;
        }
    }

-    if (player.cursor.breakingProgress == 0) {
-        SDL_Rect newRect = player.rect;
+    if (mainPlayer.cursor.breakingProgress == 0) {
+        SDL_Rect newRect = mainPlayer.rect;

        if (keyboardState[SDL_SCANCODE_W]) {
            newRect.y -= cameraSpeed;
            if (newRect.y >= 0 && canMoveWithRadius(newRect)) {
-                player.rect = newRect;
+                mainPlayer.rect = newRect;
            }
        }

        if (keyboardState[SDL_SCANCODE_S]) {
-            newRect = player.rect;
+            newRect = mainPlayer.rect;
            newRect.y += cameraSpeed;
            if (newRect.y + newRect.h <= MAP_HEIGHT * TILE_SIZE && canMoveWithRadius(newRect)) {
-                player.rect = newRect;
+                mainPlayer.rect = newRect;
            }
        }

        if (keyboardState[SDL_SCANCODE_A]) {
-            newRect = player.rect;
+            newRect = mainPlayer.rect;
            newRect.x -= cameraSpeed;
            if (newRect.x >= 0 && canMoveWithRadius(newRect)) {
-                player.rect = newRect;
+                mainPlayer.rect = newRect;
            }
        }

        if (keyboardState[SDL_SCANCODE_D]) {
-            newRect = player.rect;
+            newRect = mainPlayer.rect;
            newRect.x += cameraSpeed;
            if (newRect.x + newRect.w <= MAP_WIDTH * TILE_SIZE && canMoveWithRadius(newRect)) {
-                player.rect = newRect;
+                mainPlayer.rect = newRect;
            }
        }


        // Update tileRect only after actual movement
-        player.tileRect.x = player.rect.x / TILE_SIZE;
-        player.tileRect.y = player.rect.y / TILE_SIZE;
+        mainPlayer.tileRect.x = mainPlayer.rect.x / TILE_SIZE;
+        mainPlayer.tileRect.y = mainPlayer.rect.y / TILE_SIZE;
    }


@@ -544,7 +451,7 @@ void processKeyboardHeld() {
                    for (uint8_t lane = 0; lane < 2; lane++) {
                        ItemOnBelt *item = &t->items[lane];
                        if (item->type != 0) {
-                            player.inventory.slotCounts[item->type]++;
+                            mainPlayer.inventory.slotCounts[item->type]++;
                            item->type = 0;
                        }
                    }
@@ -554,15 +461,15 @@ void processKeyboardHeld() {
    }

    if (keyboardState[SDL_SCANCODE_Q]) {
-        if (player.cursor.targetTile->type > 0 && player.inventory.activeSlotIndex == 0) {
-            setActivePlayerSlot(&player, player.cursor.targetTile->type);
+        if (mainPlayer.cursor.targetTile->type > 0 && mainPlayer.inventory.activeSlotIndex == 0) {
+            setActivePlayerSlot(&mainPlayer, mainPlayer.cursor.targetTile->type);
        } else {
-            setActivePlayerSlot(&player, 0);
+            setActivePlayerSlot(&mainPlayer, 0);
        }
    }
    if (keyboardState[SDL_SCANCODE_E]) {
-        if (player.cursor.targetTile->health < TileRegistry[player.cursor.targetTile->type].maxHealth) {
-            player.cursor.targetTile->health++;
+        if (mainPlayer.cursor.targetTile->health < TileRegistry[mainPlayer.cursor.targetTile->type].maxHealth) {
+            mainPlayer.cursor.targetTile->health++;
        }
        for (int x = playerTileX - 2; x < playerTileX + 2; x++) {
            if (x < 0) {
@@ -586,15 +493,15 @@ void processKeyboardHeld() {
        }
    }
    if (keyboardState[SDL_SCANCODE_F9]) {
-        player.inventory.slotCounts[player.inventory.activeSlotIndex]++;
+        mainPlayer.inventory.slotCounts[mainPlayer.inventory.activeSlotIndex]++;
    }
    if (keyboardState[SDL_SCANCODE_Y]) {
-        if (player.cursor.canReach && player.cursor.targetTile->type == TYPE_BELT &&
-            player.inventory.slotCounts[player.inventory.activeSlotIndex] > 0) {
+        if (mainPlayer.cursor.canReach && mainPlayer.cursor.targetTile->type == TYPE_BELT &&
+            mainPlayer.inventory.slotCounts[mainPlayer.inventory.activeSlotIndex] > 0) {
            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]--;
+                if (mainPlayer.cursor.targetTile->items[lane].type == 0) {
+                    putItem(mainPlayer.cursor.tileX, mainPlayer.cursor.tileY, mainPlayer.inventory.activeSlotIndex, lane);
+                    mainPlayer.inventory.slotCounts[mainPlayer.inventory.activeSlotIndex]--;
                    break;
                }
            }
@@ -628,8 +535,19 @@ void processKeyboardHeld() {
    } else if (keyboardState[SDL_SCANCODE_EQUALS]) {
        slot = 13;
    }
-    if (slot > 0 && slot < sizeof(player.inventory.hotKeySlots) / sizeof(player.inventory.hotKeySlots[0])) {
-        setActivePlayerSlot(&player, player.inventory.hotKeySlots[slot]);
+    if (slot > 0 && slot < sizeof(mainPlayer.inventory.hotKeySlots) / sizeof(mainPlayer.inventory.hotKeySlots[0])) {
+        setActivePlayerSlot(&mainPlayer, mainPlayer.inventory.hotKeySlots[slot]);
+    }
+}
+
+void basicUtil() {
+    mainPlayer.mouseButtons = SDL_GetMouseState(&mainPlayer.cursor.windowX, &mainPlayer.cursor.windowY);
+
+    mainPlayer.cursor.windowX = ((mainPlayer.cursor.windowX - viewport.x) * DISPLAY_WIDTH) / viewport.w;
+    mainPlayer.cursor.windowY = (mainPlayer.cursor.windowY - viewport.y) * DISPLAY_HEIGHT / viewport.h;
+    SDL_Event e;
+    while (SDL_PollEvent(&e)) {
+        running = processEvent(e);
    }
 }

@@ -638,63 +556,98 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[])
    if (status) {
        return status;
    }
-    if (loadGameState(autosaveName, &player)) {
-        genInitMap();
-    }
-
-//    audioData.synthVoices[0].frequency = 1000;
-//    audioData.synthVoices[0].phase = 0;
-//    audioData.synthVoices[0].sourceRect.w = TILE_SIZE;
-//    audioData.synthVoices[0].sourceRect.h = TILE_SIZE;
-//    audioData.synthVoices[0].sourceRect.x = 100 * TILE_SIZE;
-//    audioData.synthVoices[0].sourceRect.y = 100 * TILE_SIZE;
-//    audioData.synthVoices[0].volume = 255;
-//    audioData.synthVoices[0].waveform = WAVE_SINE;

    //Hack to get window to stay up
-    SDL_Event e;
    Uint64 start;
    Uint64 end;
    while (running) {
        start = SDL_GetTicks64();

-        processMousePosition();
-        processKeyboardHeld();
+        basicUtil();
+        SDL_SetRenderDrawColor(mainRenderer, 32, 32, 32, 255);
+        SDL_RenderClear(mainRenderer);
+        switch (screenType) {

-        while (SDL_PollEvent(&e)) {
-            running = processEvent(e);
-        }
+            case SCREEN_MENU:
+                renderText(mainRenderer, fonts[0], GAME_NAME,
+                           DISPLAY_WIDTH / 2 - (strlen(GAME_NAME) * fonts[0].size / 2),
+                           DISPLAY_HEIGHT / 8 - fonts[0].size);

-        if (animationStep % 60 == 0) {
-            for (int i = 0; i < entities.activeCount; i++) {
-                int x = player.tileRect.x;
-                int y = player.tileRect.y;
-                x += (rand() % 10) - 5;
-                y += (rand() % 10) - 5;
-                if (x < 0) {
-                    x = 0;
+                break;
+            case SCREEN_FONTS:
+                unsigned int ix = 0;
+                for (unsigned char i = 0; i < fontCount; i++) {
+                    SDL_Rect tmpRectFont = fonts[i].atlasRect;
+                    tmpRectFont.x += ix;
+                    SDL_Rect tmpRectFontOut = tmpRectFont;
+                    if (DISPLAY_HEIGHT < 1000) {
+                        tmpRectFontOut.w /= 2;
+                        tmpRectFontOut.h /= 2;
+                    }
+                    SDL_RenderCopy(mainRenderer, fonts[i].atlas, &fonts[i].atlasRect, &tmpRectFontOut);
+                    ix += fonts[i].atlasRect.w / 2;
                }
-                if (y < 0) {
-                    y = 0;
+                break;
+            case SCREEN_ATLAS:
+                lateInit();
+                SDL_Rect rect2;
+                rect2.x = 0;
+                rect2.y = 0;
+                rect2.w = 2048;
+                rect2.h = 1024;
+                SDL_Rect tmpRectFontOut = rect2;
+                if (!largeScreen) {
+                    tmpRectFontOut.w /= 2;
+                    tmpRectFontOut.h /= 2;
                }
-                if (x >= MAP_WIDTH) {
-                    x = MAP_WIDTH - 1;
+                SDL_RenderCopy(mainRenderer, atlasTexture, &rect2, &tmpRectFontOut);
+                rect2.x = 0;
+                rect2.y = 1024;
+                rect2.w = 2048;
+                rect2.h = 1024;
+                tmpRectFontOut = rect2;
+                tmpRectFontOut.x = 1024;
+                if (!largeScreen) {
+                    tmpRectFontOut.x /= 2;
+                    tmpRectFontOut.w /= 2;
+                    tmpRectFontOut.h /= 2;
                }
-                if (y >= MAP_HEIGHT) {
-                    y = MAP_HEIGHT - 1;
+                SDL_RenderCopy(mainRenderer, atlasTexture, &rect2, &tmpRectFontOut);
+                break;
+            case SCREEN_CREDITS:
+                renderText(mainRenderer, fonts[0], GAME_NAME,
+                           DISPLAY_WIDTH / 2 - (strlen(GAME_NAME) * fonts[0].size / 2),
+                           DISPLAY_HEIGHT / 8 - fonts[0].size);
+                char *creditsString = "Code by BRNSystems\nArt by Simi11\nMalo sa to volat Minidustry\nale Simi11 mal iny nazor\n(a ikonu)\nMade for Mr. Kovacev";
+                renderText(mainRenderer, fonts[0], creditsString,
+                           0,
+                           DISPLAY_HEIGHT / 4 - fonts[0].size);
+                break;
+
+            case SCREEN_GAME:
+                lateInit();
+                processMousePosition();
+                processKeyboardHeld();
+
+
+                updateWaveLogic(&waveInfo);
+                updateItems();
+                updateEntities(&mainPlayer);
+                updatePlayer(&mainPlayer);
+                updateTiles();
+                animationStep++;
+                status = render();
+                if (status) {
+                    return status;
                }
-                entities.entities[i].target.x = x;
-                entities.entities[i].target.y = y;
-            }
+                break;
        }
-        updateItems();
-        updateEntities(&player);
-        updatePlayer(&player);
-        updateTiles();
-        animationStep++;
-        status = render();
-        if (status) {
-            return status;
+        renderButtons(mainRenderer, mainPlayer);
+
+        SDL_RenderPresent(mainRenderer);
+        frames++;
+        if (!(frames % 60)) {
+            cursor = !cursor;
        }

        end = SDL_GetTicks64();
@@ -702,9 +655,10 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[])
        if (timeNeeded < delayNeeded) {
            SDL_Delay(delayNeeded - timeNeeded);
        }
+
    }

-    saveGameState(autosaveName, &player);
+    saveGameState(autosaveName, &mainPlayer);

    for (uint8_t i = 0; i < fontCount; i++) {
        destroyFont(&fonts[i]);
@@ -718,93 +672,3 @@ int main(__attribute__((unused)) int argc, __attribute__((unused)) char *args[])

    return 0;
 }
-
-// Main generator:
-void genInitMap() {
-    const double terrainScale = 2;
-    const double humidityScale = 1;
-    const double oreScale = 2;
-    const int terrainOct = 4;
-    const int humidityOct = 4;
-    const int oreOct = 4;
-
-    int seedX = rand();
-    int seedY = rand();
-    int seedN = rand();
-
-    // Min/max trackers
-    double terrainMin = 1e9, terrainMax = -1e9;
-    double humidityMin = 1e9, humidityMax = -1e9;
-    double oreNrmMin = 1e9, oreNrmMax = -1e9;
-    for (uint16_t y = 0; y < MAP_HEIGHT; y++) {
-        for (uint16_t x = 0; x < MAP_WIDTH; x++) {
-            double terrain = pnoise2d(x + 1000 + seedX,
-                                      y + 1000 + seedY,
-                                      terrainScale, terrainOct, seedN);
-            double humidity = pnoise2d(x + seedX,
-                                       y + seedY,
-                                       humidityScale, humidityOct, seedN);
-            double oreNrm = pnoise2d(x + 9999 + seedX,
-                                     y + 1111 + seedY,
-                                     oreScale, oreOct, seedN);
-
-            // Track min/max
-            if (terrain < terrainMin) terrainMin = terrain;
-            if (terrain > terrainMax) terrainMax = terrain;
-
-            if (humidity < humidityMin) humidityMin = humidity;
-            if (humidity > humidityMax) humidityMax = humidity;
-
-            if (oreNrm < oreNrmMin) oreNrmMin = oreNrm;
-            if (oreNrm > oreNrmMax) oreNrmMax = oreNrm;
-
-            // [Same as your original terrain generation logic...]
-            BackgroundType baseType = BGType_COBBLE0;
-            if (terrain < 0.30) {
-                baseType = (humidity < 0.5) ? BGType_WATER_SHALLOW : BGType_WATER_DEEP;
-            } else if (terrain < 0.35) {
-                if (humidity < 0.3) baseType = BGType_SAND4;
-                else if (humidity < 0.6) baseType = BGType_SAND2;
-                else baseType = BGType_SAND7;
-            } else if (terrain < 0.7) {
-                double grassVal = (terrain - 0.35) / (0.70 - 0.35);
-                int idx = (int) (grassVal * 3.0);
-                if (idx >= 4) idx = 3;
-                if (humidity > 0.6 && ((rand() & 0xFF) < 10)) {
-                    int flowerIdx = rand() % 4;
-                    baseType = (BackgroundType) (BGType_GRASS_FLOWER0 + flowerIdx);
-                } else {
-                    baseType = (BackgroundType) (BGType_GRASS0 + idx);
-                }
-            } else if (terrain < 0.85) {
-                int idx = rand() % 4;
-                baseType = (BackgroundType) (BGType_COBBLE0 + idx);
-            } else {
-                int idx = rand() % 4;
-                baseType = (BackgroundType) (BGType_TILES0 + idx);
-            }
-
-            BackgroundType finalType = baseType;
-            if (baseType != BGType_WATER_SHALLOW && baseType != BGType_WATER_DEEP) {
-                if (oreNrm > 0.86) {
-                    double sub = (oreNrm - 0.86) / (1.0 - 0.86);
-                    if (sub < 0.25) finalType = BGType_IRON_ORE;
-                    else if (sub < 0.50) finalType = BGType_SILVER_ORE;
-                    else if (sub < 0.80) finalType = BGType_GOLD_ORE;
-                    else finalType = BGType_PLATINUM_ORE;
-                }
-            }
-
-            if (finalType > BGType_END) {
-                finalType = BGType_COBBLE0;
-            }
-            backgroundMap[y][x].type = finalType;
-        }
-    }
-
-    // Debug printout
-    printf("Terrain Noise: min = %f, max = %f\n", terrainMin, terrainMax);
-    printf("Humidity Noise: min = %f, max = %f\n", humidityMin, humidityMax);
-    printf("Ore Normalized: min = %f, max = %f\n", oreNrmMin, oreNrmMax);
-}
-