266 lines
8.4 KiB
C
266 lines
8.4 KiB
C
#include "utils/building_types.h"
|
|
#include "components.h"
|
|
#include "game_state.h"
|
|
#include "map_init.h"
|
|
|
|
#include <rlImGui.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 canBuildOn(BzTileMap *map, i32 tileX, i32 tileY, i32 sizeX, i32 sizeY) {
|
|
// Ensure that it is within the map
|
|
if (tileX < 0 || tileX + sizeX > map->width ||
|
|
tileY < 0 || tileY + sizeY > map->height)
|
|
return false;
|
|
|
|
Rectangle buildArea = {tileX * map->tileWidth, tileY * map->tileHeight,
|
|
sizeX * map->tileWidth, sizeY * map->tileHeight};
|
|
|
|
// Need to check neighbour tiles
|
|
tileX -= 1;
|
|
tileY -= 1;
|
|
sizeX += 2;
|
|
sizeY += 2;
|
|
|
|
BzTileLayer *buildLayer = bzTileMapGetLayer(map, LAYER_BUILDINGS);
|
|
BzTileset *tileset = bzTileLayerGetTileset(map, buildLayer);
|
|
|
|
for (i32 y = tileY; y < tileY + sizeY; y++) {
|
|
for (i32 x = tileX; x < tileX + sizeX; x++) {
|
|
if (x != tileX && x != tileX + sizeX - 1 &&
|
|
y != tileY && y != tileY + sizeY - 1) {
|
|
// Without padding
|
|
BzTile tile = bzTileLayerGetTile(buildLayer, x, y);
|
|
tile = bzTilesetGetTile(tileset, tile);
|
|
tile = getTileBuilding(tile);
|
|
if (tile == BUILDINGS_ROAD)
|
|
return false;
|
|
}
|
|
BzTileCollider collider = bzTileMapGetCollider(map, x, y);
|
|
f32 posX = x * map->tileWidth;
|
|
f32 posY = y * map->tileHeight;
|
|
for (int i = 0; i < BZ_MAP_COLLIDER_DEPTH; i++) {
|
|
BzTileShape shape = collider.shapes[i];
|
|
shape.x += posX;
|
|
shape.y += posY;
|
|
switch (shape.type) {
|
|
case BZ_TILE_SHAPE_NONE:
|
|
case BZ_TILE_SHAPE_POINT:
|
|
break;
|
|
case BZ_TILE_SHAPE_RECT: {
|
|
Rectangle shapeRec = {shape.x, shape.y, shape.sizeX, shape.sizeY};
|
|
if (CheckCollisionRecs(buildArea, shapeRec))
|
|
return false;
|
|
break;
|
|
}
|
|
case BZ_TILE_SHAPE_ELLIPSE: {
|
|
Vector2 pos = {shape.x, shape.y};
|
|
f32 radius = (shape.sizeX + shape.sizeY) * 0.5f;
|
|
if (CheckCollisionCircleRec(pos, radius, buildArea))
|
|
return false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void placeBuilding(BzTileMap *map, BuildingType type, i32 posX, i32 posY, i32 sizeX, i32 sizeY) {
|
|
ECS_COMPONENT(ECS, TilePosition);
|
|
ECS_COMPONENT(ECS, TileSize);
|
|
ECS_COMPONENT(ECS, Owner);
|
|
|
|
BzTileLayer *buildingLayer = bzTileMapGetLayer(map, LAYER_BUILDINGS);
|
|
BzTileset *buildingTileset = bzTileLayerGetTileset(map, buildingLayer);
|
|
BzTile buildingTile = getBuildingTile(type);
|
|
BZ_ASSERT(buildingTile != -1);
|
|
|
|
// Create entity
|
|
ecs_entity_t e = ecs_new_id(ECS);
|
|
ecs_set(ECS, e, TilePosition, {.x=posX, .y=posY});
|
|
ecs_set(ECS, e, TileSize, {.sizeX=sizeX, .sizeY=sizeY});
|
|
ecs_set(ECS, e, Owner, {.playerID=BUILDINGS_PLAYER_RED});
|
|
|
|
for (i32 y = posY; y < posY + sizeY; y++) {
|
|
for (i32 x = posX; x < posX + sizeX; x++) {
|
|
BzTile layerTile = buildingTile + buildingTileset->startID;
|
|
bzTileLayerSetTile(buildingLayer, layerTile, x, y, 1, 1);
|
|
buildingTile++;
|
|
|
|
GAME->entityMap[y * buildingLayer->width + x] = e;
|
|
|
|
bzTileMapUpdateCollider(map, x, y);
|
|
}
|
|
buildingTile += buildingTileset->width - sizeX;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
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);
|
|
|
|
|
|
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 = canBuildOn(&game->map, tileX, tileY, sizeX, sizeY);
|
|
/*
|
|
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, sizeX, sizeY);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
void render(float dt, Game *game) {
|
|
ClearBackground(RAYWHITE);
|
|
BeginMode2D(game->camera);
|
|
|
|
bzTileMapDraw(&game->map);
|
|
bzTileMapDrawColliders(&game->map);
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
}
|
|
|