PixelDefense/game/main.c

#include <rlImGui.h>

#include "systems/systems.h"
#include "utils/building_types.h"
#include "components.h"
#include "game_state.h"
#include "map_init.h"
#include "map_layers.h"
#include "buildings.h"


Game *GAME = NULL;

bool init(Game *game);
void deinit(Game *game);

void update(float dt, Game *game);
void render(float dt, Game *game);
void imguiRender(float dt, Game *game);


bool bzMain(BzAppDesc *appDesc, int argc, const char **argv) {
    appDesc->width = 1280;
    appDesc->height = 720;
    appDesc->title = "PixelDefense";
    appDesc->fps = 60;

    appDesc->init = (BzAppInitFunc) init;
    appDesc->deinit = (BzAppDeinitFunc) deinit;
    appDesc->update = (BzAppUpdateFunc) update;
    appDesc->render = (BzAppRenderFunc) render;
    appDesc->imguiRender = (BzAppRenderFunc) imguiRender;

    GAME = bzAlloc(sizeof(*GAME));
    appDesc->userData = GAME;
    appDesc->useFlecs = true;

    return true;
}

bool init(Game *game) {
    int screenWidth = 1280;
    int screenHeight = 720;

    game->camera = (Camera2D){ 0 };
    game->camera.target = (Vector2) {0, 0};
    game->camera.offset = (Vector2) {screenWidth / 2.0f, screenHeight / 2.0f};
    game->camera.rotation = 0.0f;
    game->camera.zoom = 1.0f;

    game->terrainTileset = bzTilesetCreate( &(BzTilesetDesc) {
        .path="assets/terrain.tsj",
        .texturePath="assets/terrain.png"
    });
    game->buildingsTileset = bzTilesetCreate(&(BzTilesetDesc) {
        .path="assets/buildings.tsj",
        .texturePath="assets/buildings.png"
    });
    game->entitiesTileset = bzTilesetCreate(&(BzTilesetDesc) {
        .path="assets/entities.tsj",
        .texturePath="assets/entities.png"
    });

    game->map = bzTileMapCreate(&(BzTileMapDesc) {
        .path="assets/maps/test.tmj",
        .tilesets[0]=game->terrainTileset,
        .tilesets[1]=game->buildingsTileset,
        .tilesets[2]=game->entitiesTileset,

        .layers[LAYER_TERRAIN]=(BzTileLayerDesc) {"Terrain"},
        .layers[LAYER_FOLIAGE]=(BzTileLayerDesc) {"Foliage"},
        .layers[LAYER_TREES]=(BzTileLayerDesc) {"Trees"},
        .layers[LAYER_TREES2]=(BzTileLayerDesc) {"TreesS"},
        .layers[LAYER_BUILDINGS]=(BzTileLayerDesc) {"Buildings"},
        .layers[LAYER_BUILDING_OWNER]=(BzTileLayerDesc) {"BuildingOwnership", BZ_TILE_LAYER_SKIP_RENDER},

        .objectGroups[OBJECTS_GAME]=(BzTileObjectsDesc) {"Game"},
        .objectGroups[OBJECTS_ENTITIES]=(BzTileObjectsDesc ) {"Entities"}
    });

    bzTileMapOverrideLayer(&game->map, LAYER_BUILDING_OWNER, initBuildingsLayer);

    bzTileMapOverrideObjectGroup(&game->map, OBJECTS_GAME, initGameObjectsLayer);
    bzTileMapOverrideObjectGroup(&game->map, OBJECTS_ENTITIES, initEntityObjectsLayer);

    ECS_SYSTEM(ECS, updateAnimations, EcsOnUpdate, Animation, TextureRegion);
    ECS_SYSTEM(ECS, renderEntities, EcsOnUpdate, Position, Size, Rotation, TextureRegion);

    return true;
}
void deinit(Game *game) {
    bzTileMapDestroy(&game->map);
    bzTilesetDestroy(&game->terrainTileset);
    bzTilesetDestroy(&game->buildingsTileset);
    bzTilesetDestroy(&game->entitiesTileset);

    bzFree(GAME);
    GAME = NULL;
}


void update(float dt, Game *game) {
    char titleBuf[32];
    snprintf(titleBuf, sizeof(titleBuf), "FPS: %d | %.2f ms", GetFPS(), GetFrameTime() * 1000);
    SetWindowTitle(titleBuf);

    ImGuiIO *io = igGetIO();
    if (io->WantCaptureMouse || io->WantCaptureKeyboard)
        return;

    if (IsKeyDown(KEY_W)) game->camera.target.y -= 20;
    if (IsKeyDown(KEY_S)) game->camera.target.y += 20;
    if (IsKeyDown(KEY_A)) game->camera.target.x -= 20;
    if (IsKeyDown(KEY_D)) game->camera.target.x += 20;

    if (IsKeyDown(KEY_Q)) game->camera.rotation--;
    if (IsKeyDown(KEY_E)) game->camera.rotation++;

    game->camera.zoom += ((float) GetMouseWheelMove() * 0.05f);

    Vector2 worldPos = GetScreenToWorld2D(GetMousePosition(), game->camera);
    int tileX = (int) worldPos.x / 16;
    int tileY = (int) worldPos.y / 16;

    if (game->selectedBuilding) {
        BzTile sizeX = 0, sizeY = 0;
        getBuildingSize(game->selectedBuilding, &sizeX, &sizeY);

        bool canPlace = canPlaceBuilding(&game->map, game->selectedBuilding, tileX, tileY);
        /*
        Color placeColor = canPlace ?
                           (Color) {0, 255, 0, 200} :
                           (Color) {255, 0, 0, 200};

        DrawRectangleLines(tileX * 16, tileY * 16, sizeX * 16, sizeY * 16, placeColor);
         */

        if (canPlace && IsMouseButtonDown(MOUSE_BUTTON_LEFT)) {
            placeBuilding(&game->map, game->selectedBuilding, tileX, tileY);
        }

    }
}

void render(float dt, Game *game) {
    ClearBackground(RAYWHITE);
    BeginMode2D(game->camera);

    bzTileMapDraw(&game->map);
    bzTileMapDrawColliders(&game->map);

    ecs_progress(ECS, dt);

    EndMode2D();
}

void imguiRender(float dt, Game *game) {
    igSetNextWindowSize((ImVec2){300, 400}, ImGuiCond_FirstUseEver);
    igBegin("Debug Menu", NULL, 0);
    if (igCollapsingHeader_TreeNodeFlags("BuildMenu", 0)) {
        for (int i = 0; i < BUILDINGS_COUNT; i++) {
            if (igSelectable_Bool(getBuildingStr(i), game->selectedBuilding == i, 0, (ImVec2){0,0}))
                game->selectedBuilding = i;
        }

    }
    if (igCollapsingHeader_TreeNodeFlags("Entities", 0)) {

    }
    igEnd();
    igShowDemoWindow(NULL);
}