Separate engine and game

game/common.h

@@ -0,0 +1,8 @@
+#ifndef PIXELDEFENSE_COMMON_H
+#define PIXELDEFENSE_COMMON_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+
+#endif //PIXELDEFENSE_COMMON_H

game/main.c

@@ -0,0 +1,133 @@
+#include <stdio.h>
+#include <raylib.h>
+#include <cute_tiled.h>
+#include <flecs.h>
+#include <breeze.h>
+#include "world/tileset.h"
+
+static void drawTile(Texture2D texture, int tid, int tileSetWidth, int size, Vector2 pos) {
+    Rectangle rec = {(tid % tileSetWidth) * size, (tid / tileSetWidth) * size, size, size};
+
+    DrawTextureRec(texture, rec, pos, WHITE);
+}
+
+static void drawLayer(cute_tiled_layer_t *layer, Tileset *tileset) {
+    Vector2 pos = {layer->offsetx, layer->offsety};
+
+    for (int y = 0; y < layer->height; y++) {
+        for (int x = 0; x < layer->width; x++) {
+            int tile = layer->data[y * layer->width + x];
+            if (tile - tileset->startID != -1) {
+                Rectangle rec = tilesetGetTileRegion(tileset, tile);
+                DrawTextureRec(tileset->tiles, rec, pos, WHITE);
+            }
+            pos.x += tileset->tileWidth;
+        }
+        pos.x = layer->offsetx;
+        pos.y += tileset->tileHeight;
+    }
+}
+
+int main(void) {
+
+    const int screenWidth = 1280;
+    const int screenHeight = 720;
+
+    InitWindow(screenWidth, screenHeight, "PixelDefense");
+    SetTargetFPS(60);
+
+    cute_tiled_map_t* map = cute_tiled_load_map_from_file("assets/maps/test.tmj", NULL);
+
+    cute_tiled_tileset_t *terrainSource = cute_tiled_load_external_tileset("assets/terrain.tsj", NULL);
+    cute_tiled_tileset_t *buildingsSource = cute_tiled_load_external_tileset("assets/buildings.tsj", NULL);
+
+    Tileset terrainTileset = tilesetCreate( &(TilesetDesc) {
+        .source=terrainSource,
+        .assetDir="assets"
+    });
+    Tileset buildingsTileset = tilesetCreate(&(TilesetDesc) {
+        .source=buildingsSource,
+        .assetDir="assets"
+    });
+
+    cute_tiled_tileset_t *tileset = map->tilesets;
+    terrainTileset.startID = tileset->firstgid;
+    tileset = tileset->next;
+    buildingsTileset.startID = tileset->firstgid;
+
+    cute_tiled_free_external_tileset(terrainSource);
+    cute_tiled_free_external_tileset(buildingsSource);
+
+
+
+    cute_tiled_layer_t *terrain = NULL;
+    cute_tiled_layer_t *trees = NULL;
+    cute_tiled_layer_t *trees2 = NULL;
+    cute_tiled_layer_t *buildings = NULL;
+    // loop over the map's layers
+    cute_tiled_layer_t* layer = map->layers;
+    while (layer)
+    {
+        int* data = layer->data;
+        int data_count = layer->data_count;
+
+        if (strcmp("Terrain", layer->name.ptr) == 0) {
+            terrain = layer;
+        } else if (strcmp("Foliage", layer->name.ptr) == 0) {
+
+        } else if (strcmp("Trees", layer->name.ptr) == 0) {
+            trees = layer;
+        } else if (strcmp("TreesS", layer->name.ptr) == 0) {
+            trees2 = layer;
+        } else if (strcmp("Buildings", layer->name.ptr) == 0) {
+            buildings = layer;
+        }
+
+        layer = layer->next;
+    }
+
+    Camera2D camera = { 0 };
+    camera.target = (Vector2) {0, 0};
+    camera.offset = (Vector2) {screenWidth / 2.0f, screenHeight / 2.0f};
+    camera.rotation = 0.0f;
+    camera.zoom = 1.0f;
+
+
+
+    while (!WindowShouldClose()) {
+        if (IsKeyPressed(KEY_ESCAPE)) {
+            break;
+        }
+
+        if (IsKeyDown(KEY_W)) camera.target.y -= 20;
+        if (IsKeyDown(KEY_S)) camera.target.y += 20;
+        if (IsKeyDown(KEY_A)) camera.target.x -= 20;
+        if (IsKeyDown(KEY_D)) camera.target.x += 20;
+
+        if (IsKeyDown(KEY_Q)) camera.rotation--;
+        if (IsKeyDown(KEY_E)) camera.rotation++;
+
+        camera.zoom += ((float)GetMouseWheelMove()*0.05f);
+
+        BeginDrawing();
+        BeginMode2D(camera);
+        ClearBackground(RAYWHITE);
+
+        drawLayer(terrain, &terrainTileset);
+        drawLayer(trees, &terrainTileset);
+        drawLayer(trees2, &terrainTileset);
+        drawLayer(buildings, &buildingsTileset);
+
+        EndMode2D();
+        EndDrawing();
+
+    }
+
+    tilesetDestroy(&terrainTileset);
+    tilesetDestroy(&buildingsTileset);
+    cute_tiled_free_map(map);
+
+    CloseWindow();
+
+    return 0;
+}

game/world/layer.c

@@ -0,0 +1 @@
+#include "layer.h"

game/world/layer.h

@@ -0,0 +1,4 @@
+#ifndef PIXELDEFENSE_LAYER_H
+#define PIXELDEFENSE_LAYER_H
+
+#endif //PIXELDEFENSE_LAYER_H

game/world/map.c

@@ -0,0 +1 @@
+#include "map.h"

game/world/map.h

@@ -0,0 +1,4 @@
+#ifndef PIXELDEFENSE_MAP_H
+#define PIXELDEFENSE_MAP_H
+
+#endif //PIXELDEFENSE_MAP_H

game/world/tileset.c

@@ -0,0 +1,52 @@
+#include <assert.h>
+#include <stdio.h>
+
+#include "tileset.h"
+
+Tileset TILESET_INVALID = {.isValid = false};
+
+Tileset tilesetCreate(const TilesetDesc *desc) {
+    Tileset tileset = {};
+    cute_tiled_tileset_t *source = desc->source;
+
+    char pathBuffer[256];
+    // auto terminates
+    snprintf(pathBuffer, sizeof(pathBuffer), "%s%s%s",
+             desc->assetDir ? desc->assetDir : "",
+             desc->assetDir ? "/" : "",
+             source->image.ptr);
+
+    tileset.tiles = LoadTexture(pathBuffer);
+    tileset.startID = source->firstgid;
+    tileset.tileWidth = source->tilewidth;
+    tileset.tileHeight = source->tileheight;
+
+    tileset.offsetX = source->tileoffset_x;
+    tileset.offsetY = source->tileoffset_y;
+
+    tileset.width = tileset.tiles.width / tileset.tileWidth;
+    tileset.height = tileset.tiles.height / tileset.tileHeight;
+
+    if (tileset.tiles.width != source->imagewidth ||
+        tileset.tiles.height != source->imageheight) {
+        tilesetDestroy(&tileset);
+        return TILESET_INVALID;
+    }
+
+    tileset.isValid = true;
+    return tileset;
+}
+
+Rectangle tilesetGetTileRegion(Tileset *tileset, int tileID) {
+    tileID = tileID - tileset->startID;
+    int posX = tileID % tileset->width;
+    int posY = tileID / tileset->width;
+    return (Rectangle) {posX * tileset->tileWidth, posY * tileset->tileHeight,
+                        tileset->tileWidth, tileset->tileHeight};
+}
+
+void tilesetDestroy(Tileset *tileset) {
+    UnloadTexture(tileset->tiles);
+    *tileset = TILESET_INVALID;
+}
+

game/world/tileset.h

@@ -0,0 +1,36 @@
+#ifndef PIXELDEFENSE_TILESET_H
+#define PIXELDEFENSE_TILESET_H
+
+#include <raylib.h>
+#include <cute_tiled.h>
+
+#include "../common.h"
+
+typedef struct TilesetDesc {
+    cute_tiled_tileset_t *source;
+    const char *assetDir;
+} TilesetDesc;
+
+typedef struct Tileset {
+    Texture2D tiles;
+    int startID;
+    int tileWidth;
+    int tileHeight;
+    int width;
+    int height;
+    int offsetX;
+    int offsetY;
+    bool isValid;
+} Tileset;
+
+extern Tileset TILESET_INVALID;
+
+Tileset tilesetCreate(const TilesetDesc *desc);
+
+Rectangle tilesetGetTileRegion(Tileset *tileset, int tileID);
+
+void tilesetDestroy(Tileset *tileset);
+
+
+
+#endif //PIXELDEFENSE_TILESET_H