Improve unit recruiting

game/building_factory.c

@@ -94,6 +94,32 @@ ecs_entity_t placeBuilding(Game *game, BuildingType type,
         case BUILDING_KEEP:
             ecs_set(ECS, building, AddPopCapacity, {10});
             ecs_add_id(ECS, building, Storage);
+            ecs_set(ECS, building, BuildingRecruitInfo, {
+                .numSlots = 1,
+                .slots[0] = {
+                        .entityType = ENTITY_WORKER,
+                        .numRecruiting = 0,
+                        .recruitTime = 5.0f,
+                        .elapsed = 0.0f,
+                }
+            });
+            break;
+        case BUILDING_BARRACKS:
+            ecs_set(ECS, building, BuildingRecruitInfo, {
+                .numSlots = 2,
+                .slots[0] = {
+                        .entityType = ENTITY_SOLDIER,
+                        .numRecruiting = 0,
+                        .recruitTime = 6.0f,
+                        .elapsed = 0.0f,
+                },
+                .slots[1] = {
+                        .entityType = ENTITY_WARRIOR,
+                        .numRecruiting = 0,
+                        .recruitTime = 15.0f,
+                        .elapsed = 0.0f
+                }
+            });
             break;
         case BUILDING_HOUSE_01:
         case BUILDING_HOUSE_02:

game/components.c

@@ -40,6 +40,7 @@ ECS_COMPONENT_DECLARE(ConsumePopCapacity);
 ECS_COMPONENT_DECLARE(Worker);
 ECS_COMPONENT_DECLARE(Building);
 ECS_COMPONENT_DECLARE(Unit);
+ECS_COMPONENT_DECLARE(BuildingRecruitInfo);
 ECS_TAG_DECLARE(Storage);
 ECS_COMPONENT_DECLARE(Harvestable);
 ECS_TAG_DECLARE(Buildable);
@@ -85,6 +86,7 @@ void initComponentIDs(ecs_world_t *ecs) {
     ECS_COMPONENT_DEFINE(ecs, Worker);
     ECS_COMPONENT_DEFINE(ecs, Building);
     ECS_COMPONENT_DEFINE(ecs, Unit);
+    ECS_COMPONENT_DEFINE(ecs, BuildingRecruitInfo);
     ECS_TAG_DEFINE(ecs, Storage);
     ECS_COMPONENT_DEFINE(ecs, Harvestable);
     ECS_TAG_DEFINE(ecs, Buildable);

game/components.h

@@ -239,6 +239,18 @@ typedef struct Unit {
     EntityType unitType;
 } Unit;
 extern ECS_COMPONENT_DECLARE(Unit);
+#define BUILDING_MAX_RECRUIT_SLOTS 4
+typedef struct BuildingRecruitSlot {
+    EntityType entityType;
+    i32 numRecruiting;
+    f32 recruitTime;
+    f32 elapsed;
+} BuildingRecruitSlot;
+typedef struct BuildingRecruitInfo {
+    BuildingRecruitSlot slots[BUILDING_MAX_RECRUIT_SLOTS];
+    i32 numSlots;
+} BuildingRecruitInfo;
+extern ECS_COMPONENT_DECLARE(BuildingRecruitInfo);
 typedef struct Building {
     BuildingType type;
     Vec2i pos;

game/entity_factory.c

@@ -83,16 +83,10 @@ ecs_entity_t entityCreateWorker(const Position position, Player player, Game *ga
     return e;
 }
 
-ecs_entity_t entityHire(EntityType type, Position position, Player player, Game *game) {
+ecs_entity_t entityRecruit(EntityType type, Position position, Player player, Game *game) {
-    PlayerResources *playerRes = &game->playerResources[player];
-    i32 res[RES_COUNT] = {0, };
-    getEntityCost(type, res);
     switch (type) {
         case ENTITY_WORKER:
             entityCreateWorker(position, player, game);
-            playerRes->food -= res[RES_FOOD];
-            playerRes->wood -= res[RES_WOOD];
-            playerRes->gold -= res[RES_GOLD];
         default:
             return 0;
     }
@@ -114,6 +108,7 @@ void getEntityCost(EntityType type, i32 cost[RES_COUNT]) {
             cost[RES_FOOD] = 200;
             cost[RES_GOLD] = 100;
             break;
+        default:;
     }
 }
 bool canAffordEntity(EntityType type, PlayerResources res) {

game/entity_factory.h

@@ -11,7 +11,7 @@ ecs_entity_t entityCreateBaseUnit(const Position position, f32 size, Player play
 ecs_entity_t entityCreateSoldier(const Position position, Player player, Game *game);
 ecs_entity_t entityCreateWorker(const Position position, Player player, Game *game);
 
-ecs_entity_t entityHire(EntityType type, Position position, Player player, Game *game);
+ecs_entity_t entityRecruit(EntityType type, Position position, Player player, Game *game);
 
 void getEntityCost(EntityType type, i32 cost[RES_COUNT]);
 bool canAffordEntity(EntityType type, PlayerResources res);

game/main.c

@@ -705,6 +705,7 @@ void imguiRender(float dt, void *userData) {
 
     igSetNextWindowSize((ImVec2){300, 400}, ImGuiCond_FirstUseEver);
     igBegin("Debug Menu", NULL, 0);
+    igText("Frame time: %.5f s", GetFrameTime());
     igText("PathData    pool available: %lu", bzObjectPoolGetNumFree(game->pools.pathData));
     igText("BTNode      pool available: %lu", bzObjectPoolGetNumFree(game->pools.btNode));
     igText("BTNodeState pool available: %lu", bzObjectPoolGetNumFree(game->pools.btNodeState));

game/systems/s_entity.c

@@ -4,6 +4,7 @@
 #include "../game_state.h"
 #include "../input.h"
 #include "../pathfinding.h"
+#include "../entity_factory.h"
 
 #include <math.h>
 #include <raymath.h>
@@ -236,6 +237,38 @@ void entityFollowPath(ecs_iter_t *it) {
     }
 }
 
+void updateBuildingRecruitment(ecs_iter_t *it) {
+    Game *game = ecs_singleton_get_mut(ECS, Game);
+    Owner *owner = ecs_field(it, Owner, 1);
+    Building *building = ecs_field(it, Building, 2);
+    BuildingRecruitInfo *info = ecs_field(it, BuildingRecruitInfo, 3);
+
+    f32 dt = GetFrameTime();
+    for (i32 i = 0; i < it->count; i++) {
+        Player player = owner[i].player;
+        Vector2 placePos = {
+                (building[i].pos.x + building[i].size.x * 0.5f) * 16.0f,
+                (building[i].pos.y + building->size.y + 0.5f) * 16.0f
+        };
+        placePos.x += GetRandomValue(-building[i].size.x, building[i].size.x);
+        placePos.y += GetRandomValue(-4, 4);
+
+        for (i32 slotIdx = 0; slotIdx < info[i].numSlots; i++) {
+            BuildingRecruitSlot *slot = &info[i].slots[slotIdx];
+
+            if (slot->numRecruiting <= 0) continue;
+            slot->elapsed += dt;
+            if (slot->elapsed >= slot->recruitTime) {
+                slot->elapsed = 0;
+                bzLogInfo("spawned");
+                entityRecruit(slot->entityType, placePos, player, game);
+                slot->numRecruiting--;
+            }
+        }
+
+    }
+}
+
 void renderColliders(ecs_iter_t *it) {
     Position *pos = ecs_field(it, Position, 1);
     HitBox *hitbox = ecs_field(it, HitBox , 2);

game/systems/s_ui.c

@@ -191,29 +191,30 @@ void drawGameUI(Game *game, f32 dt) {
             };
             placePos.x += GetRandomValue(-16, 16);
             placePos.y += GetRandomValue(-4, 4);
-            PlayerResources playerRes = game->playerResources[game->player];
+            PlayerResources *playerRes = &game->playerResources[game->player];
-            switch (building.type) {
+
-                case BUILDING_KEEP: {
+            bool canRecruit = ecs_has(ECS, buildingEntity, BuildingRecruitInfo);
-                    Rectangle rec = getTextureRect(getEntityTile(ENTITY_WORKER));
+            if (canRecruit) {
+                BuildingRecruitInfo *info = ecs_get_mut(ECS, buildingEntity, BuildingRecruitInfo);
+                for (i32 i = 0; i < info->numSlots; i++) {
+                    BuildingRecruitSlot *slot = &info->slots[i];
+                    const char *label = getEntityStr(slot->entityType);
+                    Rectangle rec = getTextureRect(getEntityTile(slot->entityType));
                     bool selected = false;
-                    uiGameBuild("Worker", rec, tex, canAffordEntity(ENTITY_WORKER, playerRes), &selected);
+                    bool canAfford = canAffordEntity(slot->entityType, *playerRes);
-                    if (selected)
+                    canAfford &= playerRes->pop < playerRes->popCapacity;
-                        entityHire(ENTITY_WORKER, placePos, game->player, game);
+                    uiGameBuild(label, rec, tex, canAfford, &selected);
-                    break;
+                    if (selected) {
+                        i32 res[RES_COUNT] = {0,};
+                        getEntityCost(slot->entityType, res);
+                        playerRes->food -= res[RES_FOOD];
+                        playerRes->wood -= res[RES_WOOD];
+                        playerRes->gold -= res[RES_GOLD];
+
+                        slot->numRecruiting++;
+                    }
+
                 }
-                case BUILDING_BARRACKS: {
-                    Rectangle soldierRec = getTextureRect(getEntityTile(ENTITY_SOLDIER));
-                    Rectangle warriorRec = getTextureRect(getEntityTile(ENTITY_WARRIOR));
-                    bool selected = false;
-                    uiGameBuild("Soldier", soldierRec, tex, canAffordEntity(ENTITY_SOLDIER, playerRes), &selected);
-                    if (selected)
-                        entityHire(ENTITY_SOLDIER, placePos, game->player, game);
-                    selected = false;
-                    uiGameBuild("Warrior", warriorRec, tex, canAffordEntity(ENTITY_WARRIOR, playerRes), &selected);
-                    if (selected)
-                        entityHire(ENTITY_WARRIOR, placePos, game->player, game);
-                }
-                default:;
             }
             break;
         }

game/systems/systems.c

@@ -104,6 +104,8 @@ void setupSystems() {
     ECS_SYSTEM(ECS, entityMoveToTarget, EcsOnUpdate, Position, Velocity, TargetPosition, Steering);
     ECS_SYSTEM(ECS, entityFollowPath, EcsOnUpdate, Path);
 
+    ECS_SYSTEM(ECS, updateBuildingRecruitment, EcsOnUpdate, Owner, Building, BuildingRecruitInfo);
+
     ECS_SYSTEM(ECS, resetHarvestCount, EcsOnUpdate, Harvestable);
     ECS_SYSTEM(ECS, updateAISystem, EcsOnUpdate, BzBTState);
 

game/systems/systems.h

@@ -141,6 +141,14 @@ void entityMoveToTarget(ecs_iter_t *it);
  */
 void entityFollowPath(ecs_iter_t *it);
 
+/*
+ * 0: Game (singleton for spawning entities)
+ * 1: Owner
+ * 2: Building
+ * 3: BuildingRecruitInfo
+ */
+void updateBuildingRecruitment(ecs_iter_t *it);
+
 /*
  * 1: Position
  * 2: HitBox
@@ -158,6 +166,8 @@ void renderOrientationDirection(ecs_iter_t *it);
  */
 void renderDebugPath(ecs_iter_t *it);
 
+
+
 /**********************************
  * Event Systems
  **********************************/