add ignore

code/core/impl/math.c

@@ -1,22 +1,8 @@
-#include <math.h>
 V2f V2F(F32 x, F32 y) {
 	V2f result = { x, y };
 	return result;
 }
 
-function V2f V2f_Scale(V2f x, F32 scale) {
-  return V2F(x.x * scale, x.y * scale);
-}
-
-V2f NormaliseV2F(V2f x) {
-  F32 magnitude = sqrtf((x.x * x.x) + (x.y * x.y)); 
-  if(magnitude > 0.0){
-    F32 inverse = 1.0f/magnitude;
-    return V2F(x.x*inverse, x.y*inverse);    
-  }
-  return x;
-}
-
 V3f V3F(F32 x, F32 y, F32 z) {
 	V3f result = { x, y, z };
 	return result;
@@ -174,46 +160,4 @@ Mat4x4FInv M4x4F_CameraView(V3f x, V3f y, V3f z, V3f p) {
 	return result;
 }
 
-// Random
 
-Random Random_Seed(U64 seed) {
-	Random result = { seed };
-	return result;
-}
-
-U64 Random_Next(Random *rnd) {
-	U64 result = rnd->state;
-
-	result ^= (result << 13);
-	result ^= (result >>  7);
-	result ^= (result << 17);
-
-	rnd->state = result;
-
-	return result;
-}
-
-F32 Random_F32(Random *rnd, F32 min, F32 max) {
-	F32 result = min + (Random_Unilateral(rnd) * (max - min));
-	return result;
-}
-
-F64 Random_F64(Random *rnd, F64 min, F64 max) {
-	F64 result = min + (Random_Unilateral(rnd) * (max - min));
-	return result;
-}
-
-U32 Random_U32(Random *rnd, U32 min, U32 max) {
-	U32 result = min + (U32) (Random_Unilateral(rnd) * (max - min));
-	return result;
-}
-
-F32 Random_Unilateral(Random *rnd) {
-	F32 result = Random_Next(rnd) / (F32) U64_MAX;
-	return result;
-}
-
-F32 Random_Bilateral(Random *rnd) {
-	F32 result = -1.0f + (2.0f * Random_Unilateral(rnd));
-	return result;
-}

code/core/math.h

@@ -4,13 +4,6 @@
 #define PI_F32  (3.14159265358979323846264338f)
 #define TAU_F32 (2.0f * PI_F32)
 
-#define Abs(x) (((x) < 0 ? -(x) : (x)))
-
-typedef struct Random Random;
-struct Random {
-	U64 state;
-};
-
 typedef union V2f V2f;
 union V2f {
 	struct {
@@ -121,21 +114,4 @@ function V3f M4x4F_VMul3(Mat4x4F m, V3f v);
 function Mat4x4FInv M4x4F_Perspective(F32 fov, F32 aspect, F32 nearp, F32 farp);
 function Mat4x4FInv M4x4F_CameraView(V3f x, V3f y, V3f z, V3f p);
 
-function V2f NormaliseV2F(V2f x);
-function V2f V2f_Scale(V2f x, F32 scale);
-
-// Random
-
-function Random Random_Seed(U64 seed);
-
-function U64 Random_Next(Random *rnd);
-
-function F32 Random_F32(Random *rnd, F32 min, F32 max);
-function F64 Random_F64(Random *rnd, F64 min, F64 max);
-
-function U32 Random_U32(Random *rnd, U32 min, U32 max);
-
-function F32 Random_Unilateral(Random *rnd);
-function F32 Random_Bilateral(Random *rnd);
-
 #endif  // LD_CORE_MATH_H_

code/draw/core.h

@@ -1,7 +1,7 @@
 #if !defined(LD_DRAW_CORE_H_)
 #define LD_DRAW_CORE_H_
 
-#define D_MAX_RECTS (262144)
+#define D_MAX_RECTS 1024
 
 typedef struct D_Image D_Image;
 struct D_Image {

code/first.c

@@ -1,7 +1,6 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <SDL3/SDL.h>
-#include <SDL3/SDL_keycode.h>
 
 #define STB_IMAGE_IMPLEMENTATION 1
 #include <stb_image.h>
@@ -18,7 +17,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)
@@ -64,49 +62,34 @@ int main(int argc, char **argv)
 		camera->farp = 1000.0f;
 
 		game->draw.camera = camera;
-		World *world = M_ArenaPush(arena, World);
-    game->world = world;
-    world->random = Random_Seed(29237489723847);
-    world->npcCount = 1;
-    for(int i = 0; i < world->npcCount; i++) {
-    NPC *npc1 = &world->npcs[i];
-      npc1->collision.pos.x = 15;
-      npc1->collision.pos.y = 15;
-      npc1->collision.size.x = 1;
-      npc1->collision.size.y = 1;
-      npc1->name = S("Matt");
-      npc1->mode = NPC_ACTION_WAITING;
-      npc1->waitTime = 0;
-      npc1->maxWaitTime = 5;
-      npc1->currentNavNode = 0;
-      npc1->collision.pos.x = 15;
-      npc1->collision.pos.y = 15;
-      npc1->collision.size.x = 10;
-      npc1->collision.size.y = 10;
 	}
 
-    Bandit *badman = &world->bandit;
+	Vk_Buffer rbo = {0};
-		badman->collision.pos.x = 15;
+	rbo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-		badman->collision.pos.y = 15;
+	rbo.size = KB(4);
-		badman->collision.size.x = 10;
+	rbo.host_visible = true;
-		badman->collision.size.y = 10;
-		badman->name = S("Leroy Brown");
-		badman->mode = BANDIT_WAITING;
-		badman->waitTime = 0;
-		badman->maxWaitTime = 2;
-		badman->poiCount = 2;
-    badman->pointsOfInterest[0] = 937;
-    badman->pointsOfInterest[1] = 12;
 
-		world->navMesh = &TestNavMesh;
+	Vk_BufferCreate(&rbo);
-		world->npcPOI[0] = 100;
-		world->player.pos.x = 0;
-		world->player.pos.y = 0;
-		world->player.bulletsLoaded = PLAYER_BULLET_COUNT;
-		world->player.reloadTimer = 0;
-	}
 
 	bool running = true;
+	World world = {
+		.npcCount = 2,
+		.npcs = {
+			{.collision = {{10, 10}, {10, 10}},
+			 .name = S("Matt"),
+			 .mode = NPC_ACTION_WAITING,
+			 .waitTime = 0,
+			 .maxWaitTime = 5,
+			 .currentNavNode = 87},
+			{.collision = {{15, 15}, {10, 10}},
+			 .name = S("James"),
+			 .mode = NPC_ACTION_WAITING,
+			 .waitTime = 0,
+			 .maxWaitTime = 10,
+			 .currentNavNode = 0}},
+		.navMesh = &TestNavMesh,
+		.npcPOI = {100},
+		.player = {.pos = {0, 0}}};
 
 	printf("%zu size in bytes\n", sizeof(TestNavMesh));
 
@@ -119,11 +102,9 @@ int main(int argc, char **argv)
 			{
 				running = false;
 			}
-      ProcessEvents(&e, game->world);
+			ProcessEvents(&e, &world);
 		}
-		UpdateWorld(1.0 / 60.0, game->world);
+		UpdateWorld(1.0 / 60.0, &world);
-    game->camera.p.x = game->world->player.pos.x;
-    game->camera.p.y = game->world->player.pos.y;
 
 		int w, h;
 		SDL_GetWindowSizeInPixels(window, &w, &h);
@@ -131,7 +112,7 @@ int main(int argc, char **argv)
 		game->draw.window_width = w;
 		game->draw.window_height = h;
 
-		G_CalculateCamera(&game->camera, (F32)w / (F32)h);
+		G_CalulateCamera(&game->camera, (F32)w / (F32)h);
 
 		Vk_Frame *frame = Vk_FrameBegin(window);
 		VkCommandBuffer cmd = frame->cmd;
@@ -161,7 +142,6 @@ int main(int argc, char **argv)
 
 		D_Begin(&game->draw, frame, D_MAX_RECTS);
 
-    RenderWorld(game->world, &game->draw);
 		D_Rect(&game->draw, 0.0f, 0.0f, .texture = 1);
 		D_Rect(&game->draw, -8.0f, 0.0f, .texture = 2, .scale = 2.0f);
 		D_Rect(&game->draw, 6.0f, 0.0f, .texture = 3);

code/game/bandit.h

@@ -6,7 +6,7 @@ enum BANDIT_ACTION {
   BANDIT_WAITING,
   BANDIT_WALKING,
   BANDIT_RUNNING,
-  BANDIT_SHOOTING,
+  BANDIT_SHOOTOUT,
 };
 
 typedef struct Bandit Bandit;
@@ -22,7 +22,6 @@ struct Bandit {
   // How long they will wait in this location.
   F32 maxWaitTime;
 
-  U32 poiCount;
   // Places the bandit walks to / from
   // E.g. hide outs, home, saloon
   U32 pointsOfInterest[12];

code/game/core.c

@@ -290,7 +290,7 @@ void G_PipelinesLoad(G_State *game) {
 	Vk_PipelineCreate(basic);
 }
 
-void G_CalculateCamera(G_Camera *camera, F32 aspect) {
+void G_CalulateCamera(G_Camera *camera, F32 aspect) {
 	Mat4x4FInv proj = M4x4F_Perspective(camera->fov, aspect, camera->nearp, camera->farp);
 	Mat4x4FInv view = M4x4F_CameraView(camera->x, camera->y, camera->z, camera->p);
 

code/game/core.h

@@ -1,6 +1,5 @@
 #if !defined(LD_GAME_CORE_H_)
 #define LD_GAME_CORE_H_
-#include "world.h"
 
 typedef struct G_Camera G_Camera;
 struct G_Camera {
@@ -19,18 +18,17 @@ struct G_State {
 
 	D_Context draw;
 	G_Camera camera;
-
-  World *world;
 };
 
 function void G_ImagesLoad(G_State *game);
 function void G_PipelinesLoad(G_State *game);
 
-function void G_CalculateCamera(G_Camera *camera, F32 aspect);
+function void G_CalulateCamera(G_Camera *camera, F32 aspect);
 
 #include "aabb.h"
 #include "player.h"
 #include "nav.h"
 #include "npc.h"
+#include "world.h"
 
 #endif  // LD_GAME_CORE_H_

code/game/impl/aabb.c

@@ -23,14 +23,14 @@ bool AABB_Slab(V2f origin, V2f point, AABB a)
   // x
   F32 tLow = (start.x - origin.x) * invdirection.x;
   F32 tHigh = (finish.x - origin.x) * invdirection.x;
-  F32 tMin = Min(tLow, tHigh);
+  F32 tMin = min(tLow, tHigh);
-  F32 tMax = Max(tLow, tHigh);
+  F32 tMax = max(tLow, tHigh);
   // y
   tLow = (start.y - origin.y) * invdirection.y;
   tHigh = (finish.y - origin.y) * invdirection.y;
 
-  tMin = Max(tMin, Min(tLow, tHigh));
+  tMin = max(tMin, min(tLow, tHigh));
-  tMax = Min(tMax, Max(tLow, tHigh));
+  tMax = min(tMax, max(tLow, tHigh));
 
   return tMax >= tMin;
 }

code/game/impl/bandit.c

@@ -1,41 +0,0 @@
-#include "game/world.h"
-#include "game/bandit.h"
-
-void UpdateBandit(F32 delta, Bandit *bandit, World *world) {
-  switch (bandit->mode) {
-    case BANDIT_WAITING:
-      bandit->waitTime+=delta;
-      if(bandit->waitTime > bandit->maxWaitTime) {
-        bandit->mode = BANDIT_WALKING;
-        do {
-          U32 randomChoice = Random_U32(&world->random, 0, bandit->poiCount);
-          bandit->targetNavNode = bandit->pointsOfInterest[randomChoice];
-        } while(bandit->targetNavNode == bandit->currentNavNode);
-        bandit->path = Nav_Path(world->navMesh, bandit->currentNavNode, bandit->targetNavNode);
-        bandit->walkTimer = 0;
-      }
-    break;
-    case BANDIT_WALKING:
-      bandit->walkTimer+=delta;
-      if(bandit->walkTimer >= NPC_SPEED){
-        bandit->walkTimer = 0;
-        if(bandit->path.nodeCount == bandit->pathIndex+1){
-          bandit->mode = BANDIT_WAITING;
-          bandit->maxWaitTime = Random_F32(&world->random, 20, 140);
-          bandit->waitTime = 0;
-          bandit->currentNavNode = bandit->targetNavNode;
-          bandit->pathIndex = 0;
-          return;
-        }
-        bandit->currentNavNode = bandit->path.indexes[bandit->pathIndex];
-        bandit->pathIndex+=1;
-      }
-      NavNode cNav = world->navMesh->nodes[bandit->currentNavNode];
-      NavNode tNav = world->navMesh->nodes[bandit->path.indexes[bandit->pathIndex]];
-      bandit->collision.pos.x = cNav.pos.x * (1 - bandit->walkTimer/NPC_SPEED) + tNav.pos.x * bandit->walkTimer/NPC_SPEED;
-      bandit->collision.pos.y = cNav.pos.y * (1 - bandit->walkTimer/NPC_SPEED) + tNav.pos.y * bandit->walkTimer/NPC_SPEED;
-    break;
-      // TODO Shooting
-      // TODO Running away
-  }
-}

code/game/impl/nav.c

@@ -9,7 +9,7 @@ typedef struct navSearchNodeState navSearchNodeState;
 struct navSearchNodeState
 {
   bool visited;
-  F64 distance;
+  U64 distance;
   U32 shortest;
   bool addedToUnvisited;
 };
@@ -61,13 +61,8 @@ U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchSta
 }
 
 // Generate a path to follow between the start and end node.
-NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
+NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end)
-  // This is a stupid fix, since it's easier to work backwards
+{
-  // to generate a path, I'm swapping the start / end, to generate
-  // it backwards
-  U32 tmp = end;
-  end = start;
-  start = tmp;
   navSearchState state = initState(start, mesh->nodeCount);
   U32 unfinishedCount = 1;
   U32 unfinishedIndexes[NAV_MAX_NODES] = {start};
@@ -78,15 +73,21 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
   U32 unfinishedOffset = 0;
   U32 lowestNodeIndex = start;
   bool found = false;
-  while(!found) {
+  while (!found)
-    for(int connectionI = 0 ; connectionI < mesh->nodes[lowestNodeIndex].connectionCount; connectionI++) {
+  {
+    for (int connectionI = 0; connectionI < mesh->nodes[lowestNodeIndex].connectionCount; connectionI++)
+    {
       NavConnection *connection = &mesh->nodes[lowestNodeIndex].connections[connectionI];
       navSearchNodeState *testNode = &state.nodeStates[connection->NodeIndex];
-      if(testNode->visited) {continue;}
+      if (testNode->visited)
-      F64 distance = cast(F64) (state.nodeStates[lowestNodeIndex].distance + connection->Cost);
+      {
-      distance += cast(F64) Abs((mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x));
+        continue;
-      distance += cast(F64) Abs((mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y));
+      }
-      if(testNode->distance > distance) {
+      U32 distance = cast(U32)(state.nodeStates[lowestNodeIndex].distance + connection->Cost);
+      distance += cast(U32)(mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x);
+      distance += cast(U32)(mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y);
+      if (testNode->distance > distance)
+      {
         testNode->distance = distance;
         testNode->shortest = lowestNodeIndex;
       }

code/game/impl/npc.c

@@ -1,22 +1,22 @@
 #include "game/npc.h"
 #include "game/world.h"
 #include "core/types.h"
-#include "core/math.h"
 
-void UpdateNPC(F32 delta, NPC *npc, World *world) {
+#include <stdio.h>
+
+void updateNPC(F32 delta, NPC *npc, World *world) {
   switch (npc->mode) {
     case NPC_ACTION_WAITING:
       npc->waitTime+=delta;
       if(npc->waitTime > npc->maxWaitTime) {
         npc->mode = NPC_ACTION_WALKING;
-        // TODO change targets to poi's rather than just random nodes
+        U32 next = npc->targetNavNode == 100 ? 20 : 100;
-        // TODO choose either global POI's or use NPC custom poi if
+        npc->targetNavNode = next; // TODO RANDOM
-        // customPOI is true
+        printf("Starting to nav path\n");
-        do {
-          npc->targetNavNode = Random_U32(&world->random, 0, world->navMesh->nodeCount);
-        } while(npc->targetNavNode == npc->currentNavNode);
         npc->path = Nav_Path(world->navMesh, npc->currentNavNode, npc->targetNavNode);
+        printf("done\n");
         npc->walkTimer = 0;
+        printf("%.*s started walking to %d\n", Sv(npc->name), npc->targetNavNode);
       }
     break;
     case NPC_ACTION_WALKING:
@@ -24,18 +24,18 @@ void UpdateNPC(F32 delta, NPC *npc, World *world) {
       if(npc->walkTimer >= NPC_SPEED){
         npc->walkTimer = 0;
         if(npc->path.nodeCount == npc->pathIndex+1){
+          printf("Finished! so I'm waiting\n");
           npc->mode = NPC_ACTION_WAITING;
-          npc->maxWaitTime = Random_F32(&world->random, 20, 140);
+          npc->maxWaitTime = 20; // TODO RANDOM
           npc->waitTime = 0;
-          npc->currentNavNode = npc->targetNavNode;
           npc->pathIndex = 0;
           return;
         }
-        npc->currentNavNode = npc->path.indexes[npc->pathIndex];
         npc->pathIndex+=1;
+        npc->currentNavNode = npc->path.indexes[npc->pathIndex];
       }
       NavNode cNav = world->navMesh->nodes[npc->currentNavNode];
-      NavNode tNav = world->navMesh->nodes[npc->path.indexes[npc->pathIndex]];
+      NavNode tNav = world->navMesh->nodes[npc->pathIndex];
       npc->collision.pos.x = cNav.pos.x * (1 - npc->walkTimer/NPC_SPEED) + tNav.pos.x * npc->walkTimer/NPC_SPEED;
       npc->collision.pos.y = cNav.pos.y * (1 - npc->walkTimer/NPC_SPEED) + tNav.pos.y * npc->walkTimer/NPC_SPEED;
     break;

code/game/impl/player.c

@@ -1,78 +1,37 @@
 #include "../player.h"
-#include <SDL3/SDL_events.h>
 #include <SDL3/SDL_keycode.h>
 #include <stdio.h>
 
-void PlayerInput(SDL_Event *event, Player *player)
+void PlayerUpdate(SDL_Event *event, Player *player)
 {
-  player->controls.shot = false;
   SDL_KeyboardEvent key = event->key;
   SDL_MouseButtonEvent mouseBtn = event->button;
-  if(event->type == SDL_EVENT_KEY_DOWN || event->type == SDL_EVENT_KEY_UP) {
-    bool val = event->type == SDL_EVENT_KEY_DOWN;
   switch (key.key)
   {
   case SDLK_W:
   {
-        player->controls.upDown = val;
+    player->pos.y += 10;
     break;
   }
   case SDLK_A:
   {
-        player->controls.leftDown = val;
+    player->pos.x -= 10;
     break;
   }
   case SDLK_D:
   {
-        player->controls.rightDown = val;
+    player->pos.x += 10;
     break;
   }
   case SDLK_S:
   {
-        player->controls.downDown = val;
+    player->pos.y -= 10;
     break;
   }
   }
-  }
+  if (mouseBtn.clicks == 1)
-  if (
+  {
-    event->type == SDL_EVENT_MOUSE_BUTTON_DOWN 
-    && mouseBtn.button == SDL_BUTTON_LEFT
-  ) {
-    if(player->bulletsLoaded > 0) {
     // shooting
     player->bulletsLoaded -= 1;
-      player->controls.shot = true;
-      player->shotPos = V2F(mouseBtn.x, mouseBtn.y);
-      printf("shot %f %f\n", mouseBtn.x, mouseBtn.y);
-    } else if(player->reloadTimer == 0) {
-      player->reloadTimer = PLAYER_RELOAD_TIME;
-      printf("reloading\n");
-  };
   }
 }
-
-void PlayerUpdate(F32 delta, Player *player) {
-  V2f dir = V2F(0, 0);
-  if(player->controls.upDown) {
-    dir.y -= 1;
-  }
-  if(player->controls.downDown) {
-    dir.y += 1;
-  }
-  if(player->controls.leftDown) {
-    dir.x -= 1;
-  }
-  if(player->controls.rightDown) {
-    dir.x += 1;
-  }
-  if(player->reloadTimer > 0) {
-    player->reloadTimer-=delta;
-    if(player->reloadTimer <= 0) {
-      player->bulletsLoaded = PLAYER_BULLET_COUNT;
-      player->reloadTimer = 0;
-    }
-  }
-  dir = V2f_Scale(NormaliseV2F(dir), PLAYER_SPEED*delta);
-  player->pos.x += dir.x;
-  player->pos.y += dir.y;
-}

code/game/impl/world.c

@@ -5,34 +5,18 @@
 
 void UpdateWorld(F32 delta, World *world)
 {
-  UpdateBandit(delta, &world->bandit, world);
+  // UpdateNPCs(delta, world);
-  UpdateNPCs(delta, world);
-  PlayerUpdate(delta, &world->player);
 }
 
 void UpdateNPCs(F32 delta, World *world)
 {
-  for (U32 i = 0; i < world->npcCount; i++)
+  for (int i = 0; i < world->npcCount; i++)
   {
-    UpdateNPC(delta, &world->npcs[i], world);
+    updateNPC(delta, &world->npcs[i], world);
-    if(world->player.controls.shot && AABB_Point(world->npcs[i].collision, world->player.shotPos)) {
-      // TODO we need to unproject the mouse location !!!
-      printf("You shot %.*s\n", Sv(world->npcs[i].name)); 
-    }
   }
 }
 
 void ProcessEvents(SDL_Event *event, World *world)
 {
-  PlayerInput(event, &world->player);
+  PlayerUpdate(event, &world->player);
-}
-
-void RenderWorld(World *world, D_Context *draw) {
-  for(int i = 0; i < world->npcCount; i++) {
-    NPC npc = world->npcs[i];
-    D_Rect(draw, npc.collision.pos.x, npc.collision.pos.y, .texture = 1); 
-    D_Rect(draw, npc.collision.pos.x, npc.collision.pos.y, .texture = 0, .dim = npc.collision.size); 
-  }
-  D_Rect(draw, world->bandit.collision.pos.x, world->bandit.collision.pos.y, .texture = 9); 
-  D_Rect(draw, world->player.pos.x, world->player.pos.y, .texture = 1); 
 }

code/game/npc.h

@@ -5,7 +5,7 @@
 #include "npc_look.h"
 #include "../core/types.h"
 
-#define NPC_SPEED 1.0f
+#define NPC_SPEED 0.2f
 
 typedef enum NPC_ACTION NPC_ACTION;
 enum NPC_ACTION {
@@ -23,10 +23,6 @@ struct NPC {
   Str8 name;
   NPC_LOOK look;
 
-  bool customPOI;
-  U32 customPOICount;
-  U32 npcPOI[16];
-
   //// Actions
   NPC_ACTION mode;
   // How long they've been waiting

code/game/player.h

@@ -6,31 +6,13 @@
 
 #include <SDL3/SDL_events.h>
 
-#define PLAYER_SPEED 10.0f
-#define PLAYER_RELOAD_TIME 1.5f
-#define PLAYER_BULLET_COUNT 6
-
-typedef struct ControlState ControlState;
-struct ControlState {
-  bool rightDown;
-  bool leftDown;
-  bool upDown;
-  bool downDown;
-  bool shot;
-};
-
 typedef struct Player Player;
 struct Player
 {
     V2f pos;
     U32 bulletsLoaded;
-    ControlState controls;
-    V2f shotPos;
-
-    F32 reloadTimer;
 };
 
-function void PlayerInput(SDL_Event *event, Player *player);
+function void PlayerUpdate(SDL_Event *event, Player *player);
-function void PlayerUpdate(F32 delta, Player *player);
 
 #endif  // LD_GAME_PLAYER_H_

code/game/world.h

@@ -4,7 +4,6 @@
 #include "player.h"
 #include "npc.h"
 #include "bandit.h"
-#include "../core/math.h"
 
 // Areas are which
 typedef U32 World_Area;
@@ -17,7 +16,6 @@ typedef struct World World;
 struct World {
   //// Static stuff
   NavMesh *navMesh;
-  Random random;
 
   //// Player
 	Player player;
@@ -35,10 +33,8 @@ struct World {
 };
 
 function void UpdateWorld(F32 delta, World *world);
-function void RenderWorld(World *world, D_Context *drawContext );
 function void ProcessEvents(SDL_Event *event, World *world);
 function void UpdateNPCs(F32 delta, World *world);
-function void UpdateNPC(F32 delta, NPC *npc, World *world);
+function void updateNPC(F32 delta, NPC *npc, World *world);
-function void UpdateBandit(F32 delta, Bandit *bandit, World *world);
 
 #endif  // LD_GAME_WORLD_H_