PixelDefense/game/map_init.c

#include "map_init.h"

#include <flecs.h>

#include "components.h"
#include "game_state.h"
#include "map_layers.h"

bool initGameObjectsLayer(BzTileMap *map, BzTileObjectGroup *objectGroup) {
    Game *game = ecs_singleton_get_mut(ECS, Game);
    for (i32 i = 0; i < objectGroup->objectCount; i++) {
        BzTileObject object = objectGroup->objects[i];
        if (bzStringDefaultHash("camera") == object.id) {
            game->camera.target.x = object.shape.x;
            game->camera.target.y = object.shape.y;
        }
    }
    return true;
}



bool initEntityObjectsLayer(BzTileMap *map, BzTileObjectGroup *objectGroup) {
    Game *game = ecs_singleton_get_mut(ECS, Game);
    BzTileset *objectTileset = bzTileObjectGroupGetTileset(&game->map, objectGroup);
    if (!objectTileset) return true;

    for (i32 i = 0; i < objectGroup->objectCount; i++) {
        if (i == 1) break;
        BzTileObject object = objectGroup->objects[i];
        ecs_entity_t e = createWorker((Position) {object.shape.x, object.shape.y},
                                      (Size) {object.shape.sizeX, object.shape.sizeY},
                                      game->entityGrid, objectTileset, object.gid);
        /*ecs_set(ECS, e, Animation, {
            .entityType=ENTITY_WORKER,
            .tileset = objectTileset,
            .curFrame=0,
            .frameDuration=0.6f + (i % 10) * 0.05f,
            .elapsed=i * 0.1f,
        });
         */
        bzLogInfo("%d %.2f %.2f", object.gid, object.shape.sizeX, object.shape.sizeY);
        //EntityArms arms = {
        //        .left=ecs_new_id(ECS),
        //        .right=ecs_new_id(ECS),
        //};
        //ecs_set_ptr(ECS, e, EntityArms, &arms);
    }
    return true;

}

bool initBuildingsLayer(BzTileMap *map, BzTileLayer *layer) {
    Game *game = ecs_singleton_get_mut(ECS, Game);

    BzTileLayer *ownershipLayer = layer;
    BzTileLayer *buildingLayer = bzTileMapGetLayer(map, LAYER_BUILDINGS);
    BzTileset *buildingTileset = bzTileLayerGetTileset(map, buildingLayer);
    BzTile *data = layer->data;
    BzTile *buildingData = buildingLayer->data;

    for (i32 y = 0; y < layer->height; y++) {
        for (i32 x = 0; x < layer->width; x++) {
            BzTile ownerTile = data[y * layer->width + x];
            BzTile buildingRawTile = buildingData[y * layer->width + x];
            BzTile buildingTile = bzTilesetGetTileID(buildingTileset, buildingRawTile);
            buildingTile = getTileBuilding(buildingTile);
            if (buildingTile == BUILDING_NONE || ownerTile == 0) continue;
            // We have a building
            TileSize size = {};
            getBuildingSize(buildingTile, &size.sizeX, &size.sizeY);
            bzTileLayerSetTile(ownershipLayer, 0, x, y, size.sizeX, size.sizeY);

            const i32 tileWidth  = map->tileWidth;
            const i32 tileHeight = map->tileHeight;
            ecs_entity_t e = ecs_new_id(ECS);
            ecs_set(ECS, e, Position, {.x = x * tileWidth, .y = y * tileHeight});
            ecs_set(ECS, e, TileSize, {.sizeX = size.sizeX * tileWidth, .sizeY = size.sizeY * tileHeight});
            ownerTile = bzTilesetGetTileID(buildingTileset, ownerTile);
            ownerTile = getTileBuilding(ownerTile);
            ecs_set(ECS, e, Owner, {.playerID=ownerTile});
            ecs_add_id(ECS, e, Selectable);
            //if (buildingTile == BUILDINGS_WAREHOUSE) {
            //    ecs_set(ECS, e, Storage, {});
            //}

            //bzTileMapUpdateCollider(&GAME.map, x, y);
        }
    }
    return true;

}

bool initTreesLayer(BzTileMap *map, BzTileLayer *layer) {
    Game *game = ecs_singleton_get_mut(ECS, Game);

    BzTileset *tileset = bzTileLayerGetTileset(map, layer);

    for (i32 y = 0; y < layer->height; y++) {
        for (i32 x = 0; x < layer->width; x++) {
            BzTile tile = layer->data[y * layer->width + x];
            BzTile layerTile = tile;
            tile = bzTilesetGetTileID(tileset, tile);
            if (tile == -1) continue; // Not a tree

            f32 sizeX = tileset->tileWidth;
            f32 sizeY = tileset->tileHeight;
            f32 posX = layer->offsetX + x * sizeX;
            f32 posY = layer->offsetY + y * sizeY;
            ecs_entity_t e = ecs_new_id(ECS);
            bzSpatialGridInsert(game->entityGrid, &e, posX, posY, sizeX, sizeY);
            posX += sizeX * 0.5f;
            posY += sizeY * 0.5f;
            ecs_add(ECS, e, TextureTerrain);
            ecs_set(ECS, e, Position, {posX, posY});
            ecs_set(ECS, e, Size, {sizeX, sizeY});
            ecs_set(ECS, e, Rotation, {0});
            BzTile tileID = bzTilesetGetTileID(tileset, layerTile);
            ecs_set(ECS, e, TextureRegion, {tileset->tiles, bzTilesetGetTileRegion(tileset, tileID)});
            ecs_set(ECS, e, Resource, {RES_WOOD, 20});
            ecs_add_id(ECS, e, Selectable);
            ecs_add_id(ECS, e, Harvestable);

        }
    }
    return true;
}

ecs_entity_t createWorker(Position position, Size size, BzSpatialGrid *grid, BzTileset *tileset, BzTile gid) {
    ecs_entity_t e = ecs_new_id(ECS);
    ecs_add(ECS, e, TextureEntities);
    ecs_set_ptr(ECS, e, Position, &position);
    ecs_set_ptr(ECS, e, Size, &size);
    BzSpatialGridID spatialID = bzSpatialGridInsert(grid, &e,
                                                    position.x, position.y,
                                                    size.x, size.y);
    ecs_set(ECS, e, SpatialGridID, {spatialID});
    ecs_set(ECS, e, Rotation, {0.0f});
    ecs_set(ECS, e, Velocity, {});
    ecs_set(ECS, e, Steering, {});
    ecs_set(ECS, e, TextureRegion, {tileset->tiles, bzTilesetGetTileRegion(tileset, gid)});
    /*
    ecs_set(ECS, e, Animation, {
        .entityType=ENTITY_WORKER,
        .tileset = tileset,
        .curFrame=0,
    });
    ecs_set(ECS, e, AnimationType, {ANIM_IDLE});
     */
    ecs_add_id(ECS, e, Selectable);
    ecs_add_id(ECS, e, Unit);
    ecs_add_id(ECS, e, Worker);
    return e;
}