Merge remote-tracking branch 'origin'

code/first.c

@@ -24,7 +24,6 @@
 #include "game/impl/world.c"
 #include "game/impl/npc.c"
 #include "game/impl/bandit.c"
-#include "game/testnavmesh.h"
 
 int main(int argc, char **argv)
 {
@@ -79,7 +78,7 @@ int main(int argc, char **argv)
 		game->draw.arena = arena;
 
 		G_ImagesLoad(game);
-		D_FontLoad(&game->draw, S("ubuntu"), 60);
+		//D_FontLoad(&game->draw, S("ubuntu"), 60);
 
 		G_PipelinesLoad(game);
 		G_AudioLoad(game);
@@ -97,21 +96,21 @@ int main(int argc, char **argv)
 		camera->farp = 1000.0f;
 
 		game->draw.camera = camera;
-		World *world = M_ArenaPush(arena, World);//LoadWorld(arena);
+		World *world = M_ArenaPush(arena, World);
+    LoadWorld(arena, world);
     game->world = world;
     world->arena = arena;
-    world->navMesh = &TestNavMesh;
     world->random = Random_Seed(29237489723847);
-    world->npcCount = 2;
+    world->npcCount = 127;
     for(U32 i = 0; i < world->npcCount; i++) {
-    NPC *npc1 = &world->npcs[i];
+      NPC *npc1 = &world->npcs[i];
-      npc1->collision.pos.x = 15;
+      npc1->collision.pos.x = 0;
-      npc1->collision.pos.y = 15;
+      npc1->collision.pos.y = 0;
       npc1->collision.size.x = 1;
       npc1->collision.size.y = 2;
       npc1->name = S("Matt");
       npc1->mode = NPC_ACTION_WAITING;
-      npc1->currentArea = i;
+      npc1->currentArea = WORLD_AREA_OUTSIDE;
       npc1->waitTime = 0;
       npc1->maxWaitTime = 5;
       npc1->currentNavNode = 0;
@@ -141,86 +140,87 @@ int main(int argc, char **argv)
 
 		PlayerInit(game, &world->player);
 
-    for(int i =0; i< 4200; i++) {
+    world->tileTypes = M_ArenaPush(arena, World_Tile, .count=WORLD_TILE_TYPE_MAX);
-      world->map[i] = map[i];
-    }
-
     world->tileTypes[0].rotation=0;
-    world->tileTypes[0].collision=false;
+    world->tileTypes[0].tag=S("tile_dirt_0");
-    world->tileTypes[0].tile=D_ImageHandle(&game->draw, S("tile_dirt_0"));
     world->tileTypes[1].rotation=0,
-    world->tileTypes[1].collision=false,
+    world->tileTypes[1].tag=S("path_middle");
-    world->tileTypes[1].tile=D_ImageHandle(&game->draw, S("path_middle"));
     world->tileTypes[2].rotation=0;
-    world->tileTypes[2].collision=false;
+    world->tileTypes[2].tag=S("path_middle_edge");
-    world->tileTypes[2].tile=D_ImageHandle(&game->draw, S("path_middle_edge"));
     world->tileTypes[3].rotation=PI_F32/2;
-    world->tileTypes[3].collision=false;
+    world->tileTypes[3].tag=S("path_middle_edge");
-    world->tileTypes[3].tile=D_ImageHandle(&game->draw, S("path_middle_edge"));
     world->tileTypes[4].rotation=PI_F32;
-    world->tileTypes[4].collision=false;
+    world->tileTypes[4].tag=S("path_middle_edge");
-    world->tileTypes[4].tile=D_ImageHandle(&game->draw, S("path_middle_edge"));
     world->tileTypes[5].rotation=-PI_F32/2;
-    world->tileTypes[5].collision=false;
+    world->tileTypes[5].tag=S("path_middle_edge");
-    world->tileTypes[5].tile=D_ImageHandle(&game->draw, S("path_middle_edge"));
     world->tileTypes[6].rotation=0;
-    world->tileTypes[6].collision=false;
+    world->tileTypes[6].tag=S("path_middle");
-    world->tileTypes[6].tile=D_ImageHandle(&game->draw, S("path_middle"));
     world->tileTypes[7].rotation=PI_F32/2;
-    world->tileTypes[7].collision=false;
+    world->tileTypes[7].tag=S("path_middle");
-    world->tileTypes[7].tile=D_ImageHandle(&game->draw, S("path_middle"));
     world->tileTypes[8].rotation=-PI_F32;
-    world->tileTypes[8].collision=false;
+    world->tileTypes[8].tag=S("path_middle");
-    world->tileTypes[8].tile=D_ImageHandle(&game->draw, S("path_middle"));
     world->tileTypes[9].rotation=-PI_F32/2;
-    world->tileTypes[9].collision=false;
+    world->tileTypes[9].tag=S("path_middle");
-    world->tileTypes[9].tile=D_ImageHandle(&game->draw, S("path_middle"));
     world->tileTypes[10].rotation=0;
-    world->tileTypes[10].collision=false;
+    world->tileTypes[10].tag=S("path_corner");
-    world->tileTypes[10].tile=D_ImageHandle(&game->draw, S("path_corner"));
     world->tileTypes[11].rotation=PI_F32/2;
-    world->tileTypes[11].collision=false;
+    world->tileTypes[11].tag=S("path_corner");
-    world->tileTypes[11].tile=D_ImageHandle(&game->draw, S("path_corner"));
     world->tileTypes[12].rotation=-PI_F32/2;
-    world->tileTypes[12].collision=false;
+    world->tileTypes[12].tag=S("path_corner");
-    world->tileTypes[12].tile=D_ImageHandle(&game->draw, S("path_corner"));
     world->tileTypes[13].rotation=PI_F32;
-    world->tileTypes[13].collision=false;
+    world->tileTypes[13].tag=S("path_corner");
-    world->tileTypes[13].tile=D_ImageHandle(&game->draw, S("path_corner"));
     world->tileTypes[14].rotation=0;
-    world->tileTypes[14].collision=false;
+    world->tileTypes[14].tag=S("tile_dirt_1");
-    world->tileTypes[14].tile=D_ImageHandle(&game->draw, S("tile_dirt_1"));
 
-    world->propTypes[0].assetHandle=D_ImageHandle(&game->draw, S("rug0"));
+    world->propTypes = M_ArenaPush(arena, World_PropType, .count=WORLD_PROP_TYPE_MAX);
+    world->propTypes[0].tag=S("rug0");
     world->propTypes[0].scale=1;
-    world->propTypes[1].assetHandle=D_ImageHandle(&game->draw, S("rug1"));
+    world->propTypes[1].tag=S("rug1");
     world->propTypes[1].scale=1;
-    world->propTypes[2].assetHandle=D_ImageHandle(&game->draw, S("skull"));
+    world->propTypes[2].tag=S("skull");
     world->propTypes[2].scale=1;
-    world->propTypes[3].assetHandle=D_ImageHandle(&game->draw, S("table"));
+    world->propTypes[3].tag = S("table");
-    world->propTypes[3].scale=1;
+    world->propTypes[3].scale=2;
-    world->propTypes[4].assetHandle=D_ImageHandle(&game->draw, S("barrel"));
+    world->propTypes[4].tag = S("barrel");
     world->propTypes[4].scale=1;
-    world->propTypes[5].assetHandle=D_ImageHandle(&game->draw, S("can"));
+    world->propTypes[5].tag = S("can");
     world->propTypes[5].scale=1;
-    world->propTypes[6].assetHandle=D_ImageHandle(&game->draw, S("candle"));
+    world->propTypes[6].tag = S("candle");
     world->propTypes[6].scale=1;
-    world->propTypes[7].assetHandle=D_ImageHandle(&game->draw, S("clock"));
+    world->propTypes[7].tag = S("clock");
     world->propTypes[7].scale=1;
-    world->propTypes[8].assetHandle=D_ImageHandle(&game->draw, S("log_pile"));
+    world->propTypes[8].tag = S("log_pile");
     world->propTypes[8].scale=1;
-    world->propTypes[9].assetHandle=D_ImageHandle(&game->draw, S("nightstand"));
+    world->propTypes[9].tag = S("nightstand");
     world->propTypes[9].scale=1;
-    world->propTypes[10].assetHandle=D_ImageHandle(&game->draw, S("pool_table"));
+    world->propTypes[10].tag = S("pool_table");
-    world->propTypes[10].scale=1;
+    world->propTypes[10].scale=2;
-    world->propTypes[11].assetHandle=D_ImageHandle(&game->draw, S("saloon_ext"));
+    world->propTypes[11].tag = S("saloon_ext");
     world->propTypes[11].scale=6.875f;
-    world->propTypes[12].assetHandle=D_ImageHandle(&game->draw, S("saloon_int"));
+    world->propTypes[12].tag = S("saloon_int");
-    world->propTypes[12].scale=6.875f;
+    world->propTypes[12].scale=2*6.875f;
-    world->propTypes[11].assetHandle=D_ImageHandle(&game->draw, S("house"));
+    world->propTypes[13].tag = S("house");
-    world->propTypes[11].scale=6.875f;
+    world->propTypes[13].scale=6.875f;
-    world->propTypes[12].assetHandle=D_ImageHandle(&game->draw, S("house_int"));
+    world->propTypes[14].tag = S("house_int");
-    world->propTypes[12].scale=6.875f;
+    world->propTypes[14].scale=6.875f;
+    world->propTypes[15].tag=S("tile_detail_0");
+    world->propTypes[15].scale=1;
+    world->propTypes[16].tag =  S("tile_detail_1");
+    world->propTypes[16].scale=1;
+    world->propTypes[17].tag = S("tile_detail_2");
+    world->propTypes[17].scale=1;
+    world->propTypes[18].tag= S("tile_detail_3");
+    world->propTypes[18].scale=1;
+    world->propTypes[19].tag= S("tile_detail_4");
+    world->propTypes[19].scale=1;
+    world->propTypes[20].tag=S("tile_detail_5");
+    world->propTypes[20].scale=1;
+    world->propTypes[21].tag=S("tile_detail_6");
+    world->propTypes[21].scale=1;
+    world->propCount = 0;
+    world->props = M_ArenaPush(arena, World_Prop, .count=WORLD_PROP_MAX);
+    world->hitboxes = M_ArenaPush(arena, AABB, .count=WORLD_HITBOX_MAX);
+    GenerateNavMesh(arena, world);
 	}
   game->editor.enabled = false;
   game->editor.mode = G_EDITOR_MODE_TILE;
@@ -287,6 +287,7 @@ int main(int argc, char **argv)
             Abs(game->editor.cursor.y-game->editor.dragStart.y)
           );
           game->world->hitboxCount++;
+          GenerateNavMesh(game->arena, game->world);
         }
       }
 
@@ -332,6 +333,7 @@ int main(int argc, char **argv)
           }
           case SDLK_SPACE: {
             game->editor.mode = (game->editor.mode + 1) % 4;
+            printf("EDITOR MODE %d\n", game->editor.mode);
             break;
           }
           case SDLK_U: {
@@ -390,7 +392,7 @@ int main(int argc, char **argv)
 
     RenderWorld(game->world, &game->draw);
 
-		D_Text(&game->draw, game->draw.fonts, S("Small Test"), 0, 0);
+		//D_Text(&game->draw, game->draw.fonts, S("Small Test"), 0, 0);
 
     if(game->editor.enabled) {
       G_Editor editor = game->editor;
@@ -399,18 +401,26 @@ int main(int argc, char **argv)
       switch(game->editor.mode) {
         case G_EDITOR_MODE_TILE: {
           World_Tile asset = game->world->tileTypes[editor.currentAsset];
-		      D_Rect(&game->draw, tilex, tiley, .texture=asset.tile, .angle=(F32) asset.rotation);
+		      D_Rect(&game->draw, tilex, tiley, .texture=D_ImageHandle(&game->draw, asset.tag), .angle=asset.rotation);
           break;
         }
         case G_EDITOR_MODE_PROP: {
           World_PropType prop = game->world->propTypes[editor.currentAsset];
-		      D_Rect(&game->draw, editor.cursor.x, editor.cursor.y, .texture=prop.assetHandle, .scale=prop.scale);
+		      D_Rect(&game->draw, editor.cursor.x, editor.cursor.y, .texture=D_ImageHandle(&game->draw, prop.tag), .scale=prop.scale);
           break;
         }
         case G_EDITOR_MODE_HITBOX: {
           for(U32 i = 0; i < game->world->hitboxCount; i++) {
             V2f centre = AABB_Centre(game->world->hitboxes[i]);
-		        D_Rect(&game->draw, centre.x, centre.y, .texture=0, .dim=game->world->hitboxes[i].size, .flags=D_RECT_IGNORE_ASPECT);
+		        D_Rect(
+              &game->draw,
+              centre.x,
+              centre.y,
+              .texture=0,
+              .dim=game->world->hitboxes[i].size,
+              .flags=D_RECT_IGNORE_ASPECT,
+              .c=V4F(100,0,0,0.7),
+            );
           }
           break;
         }

code/game/impl/world.c

@@ -37,6 +37,9 @@ void ProcessEvents(SDL_Event *event, World *world)
   if(event->type == SDL_EVENT_KEY_DOWN && event->key.key == SDLK_F5){
     SaveWorld(world->arena, world);
   }
+  if(event->type == SDL_EVENT_KEY_DOWN && event->key.key == SDLK_F6){
+    LoadWorld(world->arena, world);
+  }
 }
 
 void RenderWorld(World *world, D_Context *draw) {
@@ -45,7 +48,7 @@ void RenderWorld(World *world, D_Context *draw) {
       D_Rect(
         draw,
         (F32) (i % 96), (F32) (i / 96),
-        .texture = world->tileTypes[world->map[i]].tile,
+        .texture = D_ImageHandle(draw,world->tileTypes[world->map[i]].tag),
         .angle = (F32) world->tileTypes[world->map[i]].rotation,
       );
     }
@@ -56,11 +59,21 @@ void RenderWorld(World *world, D_Context *draw) {
         draw,
         world->props[i].pos.x,
         world->props[i].pos.y,
-        .texture = world->propTypes[world->props[i].propType].assetHandle,
+        .texture = D_ImageHandle(draw,world->propTypes[world->props[i].propType].tag),
         .scale = world->propTypes[world->props[i].propType].scale,
       );
     }
   }
+  for (int i = 0; i < world->navMesh->nodeCount; i++) {
+    NavNode n = world->navMesh->nodes[i];
+    D_Rect(
+      draw,
+      n.pos.x,
+      n.pos.y,
+      .texture = 0,
+      .scale = 0.2f,
+    );
+  }
   for(U32 i = 0; i < world->npcCount; i++) {
     NPC npc = world->npcs[i];
     if(npc.currentArea == world->player.currentArea) {
@@ -81,23 +94,136 @@ void SaveWorld(M_Arena *arena, World *world) {
 
   printf("Saving world\n");
   OS_Handle file = FS_FileOpen(S("world.sgdat"), FS_ACCESS_WRITE);
-  FS_FileWrite(file, world, sizeof(World)+sizeof(NavMesh), 0);
+  U32 offset = 0;
-  FS_FileWrite(file, world->navMesh, sizeof(World)+sizeof(NavMesh), sizeof(World));
+  for(int i = 0; i < WORLD_TILE_TYPE_MAX; i++) {
+    FS_FileWrite(file, &world->tileTypes[i].tag.count, sizeof(S64), offset);
+    offset += sizeof(S64);
+    FS_FileWrite(file, world->tileTypes[i].tag.data, world->tileTypes[i].tag.count, offset);
+    offset += sizeof(U8) * world->tileTypes[i].tag.count;
+    FS_FileWrite(file, &world->tileTypes[i].rotation, sizeof(F32), offset);
+    offset += sizeof(F32);
+  }
+  for(int i = 0; i < WORLD_PROP_TYPE_MAX; i++) {
+    FS_FileWrite(file, &world->propTypes[i].tag.count, sizeof(S64), offset);
+    offset += sizeof(S64);
+    FS_FileWrite(file, world->propTypes[i].tag.data, world->propTypes[i].tag.count, offset);
+    offset += sizeof(U8) * world->propTypes[i].tag.count;
+    FS_FileWrite(file, &world->propTypes[i].scale, sizeof(F32), offset);
+    offset += sizeof(F32);
+  }
+
+  FS_FileWrite(file, &world->propCount, sizeof(U32), offset);
+  offset += sizeof(U32);
+
+  FS_FileWrite(file, world->props, sizeof(World_Prop)*WORLD_PROP_MAX, offset);
+  offset += sizeof(World_Prop)*WORLD_PROP_MAX;
+
+  FS_FileWrite(file, &world->hitboxCount, sizeof(U32), offset);
+  offset += sizeof(U32);
+
+  FS_FileWrite(file, world->hitboxes, sizeof(AABB)*WORLD_HITBOX_MAX, offset);
+  offset += sizeof(AABB)*WORLD_HITBOX_MAX;
+
+  FS_FileWrite(file, world->map, sizeof(U32)*WORLD_MAP_MAX, offset);
+  offset += sizeof(U32)*WORLD_MAP_MAX;
+
   FS_FileClose(file);
   printf("Saved world :)\n");
 }
 
-World *LoadWorld(M_Arena *arena) {
+void LoadWorld(M_Arena *arena, World *world) {
   printf("loading world\n");
   OS_Handle file = FS_FileOpen(S("world.sgdat"), FS_ACCESS_READ);
-  World *world = M_ArenaPush(arena, World);
+  U32 offset = 0;
-  NavMesh *navMesh = M_ArenaPush(arena, NavMesh);
+
-  FS_FileRead(file, world, sizeof(World), 0);
+  world->tileTypes = M_ArenaPush(arena, World_Tile, .count=WORLD_TILE_TYPE_MAX);
-  FS_FileRead(file, navMesh, sizeof(NavMesh), sizeof(World));
+  for(int i = 0; i < WORLD_TILE_TYPE_MAX; i++) {
+    FS_FileRead(file, &world->tileTypes[i].tag.count, sizeof(S64), offset);
+    offset += sizeof(S64);
+    world->tileTypes[i].tag.data = M_ArenaPush(arena, U8, .count=world->tileTypes[i].tag.count);
+    FS_FileRead(file, world->tileTypes[i].tag.data, world->tileTypes[i].tag.count, offset);
+    offset += sizeof(U8) * world->tileTypes[i].tag.count;
+    FS_FileRead(file, &world->tileTypes[i].rotation, sizeof(F32), offset);
+    offset += sizeof(F32);
+  }
+  world->propTypes = M_ArenaPush(arena, World_PropType, .count=WORLD_PROP_TYPE_MAX);
+  for(int i = 0; i < WORLD_PROP_TYPE_MAX; i++) {
+    FS_FileRead(file, &world->propTypes[i].tag.count, sizeof(S64), offset);
+    offset += sizeof(S64);
+    world->propTypes[i].tag.data = M_ArenaPush(arena, U8, .count=world->propTypes[i].tag.count);
+    FS_FileRead(file, world->propTypes[i].tag.data, world->propTypes[i].tag.count, offset);
+    offset += sizeof(U8) * world->propTypes[i].tag.count;
+    FS_FileRead(file, &world->propTypes[i].scale, sizeof(F32), offset);
+    offset += sizeof(F32);
+  }
+
+  FS_FileRead(file, &world->propCount, sizeof(U32), offset);
+  offset += sizeof(U32);
+
+  world->props = M_ArenaPush(arena, World_Prop, .count=WORLD_PROP_MAX);
+  FS_FileRead(file, world->props, sizeof(World_Prop)*WORLD_PROP_MAX, offset);
+  offset += sizeof(World_Prop)*WORLD_PROP_MAX;
+
+  FS_FileRead(file, &world->hitboxCount, sizeof(U32), offset);
+  offset += sizeof(U32);
+
+  world->hitboxes = M_ArenaPush(arena, AABB, .count=WORLD_HITBOX_MAX);
+  FS_FileRead(file, world->hitboxes, sizeof(AABB)*WORLD_HITBOX_MAX, offset);
+  offset += sizeof(AABB)*WORLD_HITBOX_MAX;
+
+  world->map = M_ArenaPush(arena, U32, .count=WORLD_MAP_MAX);
+  FS_FileRead(file, world->map, sizeof(U32)*WORLD_MAP_MAX, offset);
+  offset += sizeof(U32)*WORLD_MAP_MAX;
+
   FS_FileClose(file);
-  world->navMesh = navMesh;
-  world->arena = arena;
-  world->player.world = world;
   printf("loaded world\n");
-  return world;
+}
+
+void GenerateNavMesh(M_Arena *arena, World *world) {
+  world->navMesh = M_ArenaPush(arena, NavMesh);
+  world->navMesh->nodeCount = 0;
+  for(int i = 0; i < WORLD_MAP_MAX; i++) {
+    U32 x = (i % 96);
+    U32 y = (i / 96);
+    bool skip = false;
+    for(int hi = 0; hi < world->hitboxCount; hi++) {
+      if(AABB_Point(world->hitboxes[hi], V2F(x, y))) {
+        skip = true;
+        break;
+      }
+    }
+    if(skip) {continue;}
+    world->navMesh->nodes[world->navMesh->nodeCount].pos.x = x;
+    world->navMesh->nodes[world->navMesh->nodeCount].pos.y = y;
+    U32 cost = 20;
+    if(Str8_Equal(world->tileTypes[world->map[i]].tag, S("path_middle"), STR8_EQUAL_IGNORE_CASE)) {
+      cost = 10;
+    }
+    world->navMesh->nodes[world->navMesh->nodeCount].connectionCount = 0;
+    for(int nx = -1; nx < 2; nx++){
+      for(int ny = -1; ny < 2; ny++){
+        if((nx==ny) && nx==0) {continue;}
+        if(x+nx < 0 || x+nx > 95) {
+          continue;
+        }
+        if(y+ny < 0 || y+ny > 49) {
+          continue;
+        }
+        // It's quad for loop time :D
+        for(int hi = 0; hi < world->hitboxCount; hi++) {
+          if(AABB_Point(world->hitboxes[hi], V2F(x+nx, y+ny))) {
+            skip = true;
+            break;
+          }
+        }
+        if(skip) {continue;}
+        U32 index = x+nx + (y+ny)*96;
+        U32 nCount = world->navMesh->nodeCount;
+        world->navMesh->nodes[nCount].connections[world->navMesh->nodes[nCount].connectionCount].NodeIndex = index;
+        world->navMesh->nodes[nCount].connections[world->navMesh->nodes[nCount].connectionCount].Cost = cost;
+        world->navMesh->nodes[nCount].connectionCount++;
+      }
+    }
+    world->navMesh->nodeCount++;
+  }
 }

code/game/nav.h

@@ -6,7 +6,7 @@
 
 #define NAV_MAX_PATH 1024
 #define NAV_MAX_CONNECTIONS 8
-#define NAV_MAX_NODES 4096
+#define NAV_MAX_NODES 4800
 
 typedef struct NavNode NavNode;
 

code/game/world.h

@@ -3,6 +3,12 @@
 
 #include "../core/math.h"
 
+#define WORLD_HITBOX_MAX 4096
+#define WORLD_PROP_MAX 2048
+#define WORLD_PROP_TYPE_MAX 64
+#define WORLD_TILE_TYPE_MAX 64
+#define WORLD_MAP_MAX 4800
+
 // Areas are which
 typedef U32 World_Area;
 enum World_Area
@@ -13,14 +19,13 @@ enum World_Area
 
 typedef struct World_Tile World_Tile;
 struct World_Tile {
-  U32 tile;
+  Str8 tag;
-  double rotation;
+  F32 rotation;
-  bool collision;
 };
 
 typedef struct World_PropType World_PropType;
 struct World_PropType {
-  U32 assetHandle;
+  Str8 tag;
   F32 scale;
 };
 
@@ -44,14 +49,15 @@ struct World {
   NavMesh *navMesh;
   Random random;
   V2f mouseProjected;
-  World_Tile tileTypes[64];
+  //// Loaded from world file
-  U32 map[4800];
+  World_Tile *tileTypes;
+  World_PropType *propTypes;
+  World_Prop *props; 
+  AABB *hitboxes; 
+  U32 *map;
 
-  World_PropType propTypes[64];
   U32 propCount;
-  World_Prop props[256]; 
   U32 hitboxCount;
-  AABB hitboxes[4096]; 
 
   //// Player
   Player player;
@@ -75,7 +81,8 @@ function void UpdateNPCs(F32 delta, World *world);
 function void UpdateNPC(F32 delta, NPC *npc, World *world);
 function void UpdateBandit(F32 delta, Bandit *bandit, World *world);
 
-function World *LoadWorld(M_Arena *arena);
+function void LoadWorld(M_Arena *arena, World *world);
 function void SaveWorld(M_Arena *arena, World *world);
+function void GenerateNavMesh(M_Arena *arena, World *world);
 
 #endif  // LD_GAME_WORLD_H_