KlemenPl/PixelDefense
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rename buildings to building_factory, randomize unit place position

Browse Source
This commit is contained in:
Klemen Plestenjak
2024-02-05 10:13:22 +01:00
parent 18dd3e2226
commit c8d3b6952d
8 changed files with 13 additions and 12 deletions
Download Patch File Download Diff File Expand all files Collapse all files

208
game/building_factory.c Normal file
View File

@@ -0,0 +1,208 @@
#include "building_factory.h"
#include "components.h"
#include "entity_factory.h"
#include "game_state.h"
#include "map_layers.h"
#include "systems/systems.h"
#include <raymath.h>
bool canPlaceBuilding(Game *game, BuildingType type, BzTile tileX, BzTile tileY) {
i32 sizeX, sizeY;
getBuildingSize(type, &sizeX, &sizeY);
if (sizeX == 0 || sizeY == 0) return false;
if (!canAffordBuilding(type, game->playerResources[game->player]))
return false;
BzTileMap *map = &game->map;
// 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};
BzSpatialGridIter it = bzSpatialGridIter(game->entityGrid, buildArea.x, buildArea.y, buildArea.width, buildArea.height);
while (bzSpatialGridQueryNext(&it)) { ecs_entity_t entity = *(ecs_entity_t *) it.data;
Rectangle bounds;
if (!entityGetHitBox(entity, NULL, &bounds)) continue;
if (CheckCollisionRecs(buildArea, bounds))
return false;
}
return true;
}
ecs_entity_t placeBuilding(Game *game, BuildingType type,
BzTile posX, BzTile posY, Player player) {
if (type <= BUILDING_NONE || type >= BUILDING_COUNT)
return 0;
i32 sizeX, sizeY;
getBuildingSize(type, &sizeX, &sizeY);
const i32 tileWidth = game->map.tileWidth;
const i32 tileHeight = game->map.tileHeight;
// Create entity
ecs_entity_t building = entityCreateEmpty();
ecs_add_id(ECS, building, Selectable);
ecs_set(ECS, building, Building, {
.type = type,
.pos = (Vec2i) { posX, posY },
.size = (Vec2i) { sizeX, sizeY }
});
Position pos = {
.x = posX * tileWidth,
.y = posY * tileHeight
};
Size size = {
.x = sizeX * tileWidth,
.y = sizeY * tileHeight,
};
pos.y += size.y;
HitBox hitbox = {
.x = 0.0f, .y = 0.0f,
.width = size.x,
.height = size.y
};
ecs_set_ptr(ECS, building, Position, &pos);
ecs_set_ptr(ECS, building, Size, &size);
ecs_set_ptr(ECS, building, HitBox, &hitbox);
ecs_set(ECS, building, Rotation, {0});
HitBox tHitBox = entityTransformHitBox(pos, hitbox);
SpatialGridID gridID = bzSpatialGridInsert(game->entityGrid, &building,
tHitBox.x, tHitBox.y, tHitBox.width, tHitBox.height);
ecs_set_ptr(ECS, building, SpatialGridID, &gridID);
ecs_set(ECS, building, Owner, {player});
BzTileset *tileset = &game->tileset;
TextureRegion region = {
tileset->tiles,
bzTilesetGetTileRegion(tileset, getBuildingTile(type))
};
region.rec.width *= sizeX;
region.rec.height *= sizeY;
ecs_set_ptr(ECS, building, TextureRegion, &region);
bool hasCollision = true;
switch (type) {
case BUILDING_KEEP:
ecs_set(ECS, building, AddPopCapacity, {10});
ecs_add_id(ECS, building, Storage);
break;
case BUILDING_HOUSE_01:
case BUILDING_HOUSE_02:
case BUILDING_HOUSE_03:
case BUILDING_HOUSE_04:
case BUILDING_HOUSE_05:
case BUILDING_HOUSE_06:
ecs_set(ECS, building, AddPopCapacity, {5});
ecs_add_id(ECS, building, Storage);
break;
case BUILDING_WHEAT_0:
case BUILDING_WHEAT_1:
hasCollision = false;
ecs_set(ECS, building, Harvestable, {
.harvestLimit = 1
});
ecs_set(ECS, building, Resource, {RES_FOOD, INT32_MAX});
break;
default:
break;
}
if (hasCollision)
bzTileMapSetCollisions(&game->map, true, COLL_LAYER_BUILDINGS, posX, posY, sizeX, sizeY);
return building;
}
void getBuildingCost(BuildingType type, i32 cost[RES_COUNT]) {
for (i32 i = 0; i < RES_COUNT; i++) {
cost[i] = 0;
}
switch (type) {
case BUILDING_ARCHERY_RANGE:
cost[RES_WOOD] = 400;
cost[RES_FOOD] = 400;
cost[RES_GOLD] = 200;
break;
case BUILDING_BARRACKS:
cost[RES_WOOD] = 200;
cost[RES_FOOD] = 400;
cost[RES_GOLD] = 500;
break;
case BUILDING_GRANARY:
cost[RES_WOOD] = 80;
break;
case BUILDING_HOUSE_01:
case BUILDING_HOUSE_02:
case BUILDING_HOUSE_03:
case BUILDING_HOUSE_04:
case BUILDING_HOUSE_05:
case BUILDING_HOUSE_06:
case BUILDING_HOUSE_07:
case BUILDING_HOUSE_08:
case BUILDING_HOUSE_09:
cost[RES_WOOD] = 50;
break;
case BUILDING_MARKET:
cost[RES_WOOD] = 200;
cost[RES_FOOD] = 200;
cost[RES_GOLD] = 200;
break;
case BUILDING_MILL:
cost[RES_WOOD] = 200;
cost[RES_GOLD] = 50;
break;
case BUILDING_WAREHOUSE:
cost[RES_WOOD] = 100;
break;
case BUILDING_TOWER:
cost[RES_WOOD] = 400;
cost[RES_FOOD] = 100;
cost[RES_GOLD] = 500;
break;
case BUILDING_NONE:
case BUILDING_KEEP:
case BUILDING_COUNT:
// NA
break;
default:;
}
}
bool canAffordBuilding(BuildingType type, PlayerResources res) {
i32 needed[RES_COUNT] = {0, };
getBuildingCost(type, needed);
if (needed[RES_WOOD] > res.wood) return false;
if (needed[RES_FOOD] > res.food) return false;
if (needed[RES_GOLD] > res.gold) return false;
return true;
}
Vector2 getPositionNearBuilding(ecs_entity_t building, Vector2 fromPos) {
BZ_ASSERT(ecs_is_alive(ECS, building));
BZ_ASSERT(ecs_has(ECS, building, Position));
BZ_ASSERT(ecs_has(ECS, building, HitBox));
Vector2 pos = *ecs_get(ECS, building, Position);
HitBox hitbox = *ecs_get(ECS, building, HitBox);
Vector2 center = entityGetCenter(pos, hitbox);
Vector2 size = {hitbox.width, hitbox.height};
size = Vector2SubtractValue(size, 5.0f);
Vector2 dir = Vector2Normalize(Vector2Subtract(fromPos, center));
dir = Vector2Multiply(dir, size);
center = Vector2Add(center, dir);
return center;
}