add ignore

.gitignore

@@ -1,3 +1,4 @@
 build/
 code/compile_commands.json
 code/.cache
+.vscode

code/first.c

@@ -15,13 +15,14 @@
 
 #include "game/core.h"
 
-#include "game/world.h"
+#include "game/impl/world.c"
 #include "game/impl/npc.c"
 #include "game/testnavmesh.h"
 
-int main(int argc, char **argv) {
-	(void) argc;
-	(void) argv;
+int main(int argc, char **argv)
+{
+	(void)argc;
+	(void)argv;
 
 	if (!SDL_Init(SDL_INIT_VIDEO))
 	{
@@ -58,44 +59,37 @@ int main(int argc, char **argv) {
 		camera->fov = 60.0f;
 
 		camera->nearp = 0.01f;
-		camera->farp  = 1000.0f;
+		camera->farp = 1000.0f;
 
 		game->draw.camera = camera;
 	}
 
-	Vk_Buffer rbo = { 0 };
-	rbo.usage        = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-	rbo.size         = KB(4);
+	Vk_Buffer rbo = {0};
+	rbo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+	rbo.size = KB(4);
 	rbo.host_visible = true;
 
 	Vk_BufferCreate(&rbo);
 
 	bool running = true;
-	Player player;
-	player.pos.x = 0;
-	player.pos.y = 0;
-  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}
-  };
+	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));
 
@@ -104,22 +98,21 @@ int main(int argc, char **argv) {
 		SDL_Event e;
 		while (SDL_PollEvent(&e))
 		{
-			PlayerUpdate(&e, &player);
 			if (e.type == SDL_EVENT_QUIT)
 			{
 				running = false;
 			}
+			ProcessEvents(&e, &world);
 		}
-
-    updateNPCs(1.0f / 60.0f, &world);
+		UpdateWorld(1.0 / 60.0, &world);
 
 		int w, h;
 		SDL_GetWindowSizeInPixels(window, &w, &h);
 
-		game->draw.window_width  = w;
+		game->draw.window_width = w;
 		game->draw.window_height = h;
 
-		G_CalulateCamera(&game->camera, (F32) w / (F32) h);
+		G_CalulateCamera(&game->camera, (F32)w / (F32)h);
 
 		Vk_Frame *frame = Vk_FrameBegin(window);
 		VkCommandBuffer cmd = frame->cmd;
@@ -131,27 +124,27 @@ int main(int argc, char **argv) {
 		clear_colour.color.float32[3] = 1.0f;
 
 		VkRenderingAttachmentInfo colour_attachment = {0};
-		colour_attachment.sType       = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
-		colour_attachment.imageView   = vk.swapchain.views[frame->image];
+		colour_attachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
+		colour_attachment.imageView = vk.swapchain.views[frame->image];
 		colour_attachment.imageLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-		colour_attachment.loadOp      = VK_ATTACHMENT_LOAD_OP_CLEAR;
-		colour_attachment.storeOp     = VK_ATTACHMENT_STORE_OP_STORE;
-		colour_attachment.clearValue  = clear_colour;
+		colour_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
+		colour_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
+		colour_attachment.clearValue = clear_colour;
 
 		VkRenderingInfo rendering_info = {0};
-		rendering_info.sType                = VK_STRUCTURE_TYPE_RENDERING_INFO;
-		rendering_info.renderArea           = (VkRect2D) { 0, 0, w, h };
-		rendering_info.layerCount           = 1;
+		rendering_info.sType = VK_STRUCTURE_TYPE_RENDERING_INFO;
+		rendering_info.renderArea = (VkRect2D){0, 0, w, h};
+		rendering_info.layerCount = 1;
 		rendering_info.colorAttachmentCount = 1;
-		rendering_info.pColorAttachments    = &colour_attachment;
+		rendering_info.pColorAttachments = &colour_attachment;
 
 		vk.CmdBeginRendering(cmd, &rendering_info);
 
 		D_Begin(&game->draw, frame, D_MAX_RECTS);
 
-		D_Rect(&game->draw,  0.0f, 0.0f, .texture = 1);
+		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);
+		D_Rect(&game->draw, 6.0f, 0.0f, .texture = 3);
 
 		D_End(&game->draw, frame);
 

code/game/aabb.h

@@ -3,15 +3,15 @@
 #include "../core/types.h"
 #include "../core/macros.h"
 
-
 typedef struct AABB AABB;
-struct AABB {
+struct AABB
+{
   V2f pos;
   V2f size;
 };
 
-
 function bool AABB_Collide(AABB a, AABB b);
 function bool AABB_Point(AABB a, V2f v);
+function bool AABB_Slab(V2f origin, V2f point, AABB a);
 
-#endif  // LD_GAME_AABB_H_
+#endif // LD_GAME_AABB_H_

code/game/bandit.h

@@ -0,0 +1,59 @@
+#if !defined(LD_GAME_BANDIT_H_)
+#define LD_GAME_BANDIT_H_
+
+typedef enum BANDIT_ACTION BANDIT_ACTION;
+enum BANDIT_ACTION {
+  BANDIT_WAITING,
+  BANDIT_WALKING,
+  BANDIT_RUNNING,
+  BANDIT_SHOOTOUT,
+};
+
+typedef struct Bandit Bandit;
+struct Bandit {
+  //// Personal
+  AABB collision;
+  Str8 name;
+
+  //// Actions
+  BANDIT_ACTION mode;
+  // How long they've been waiting.
+  F32 waitTime;
+  // How long they will wait in this location.
+  F32 maxWaitTime;
+
+  // Places the bandit walks to / from
+  // E.g. hide outs, home, saloon
+  U32 pointsOfInterest[12];
+  //// Navigation
+  // The bandits's current path
+  NavPath path;
+  // Which node the bandit is on in the path
+  U32 currentNavNode;
+  // The current index of the bandit's current node
+  U32 pathIndex;
+  // Target navNode index the bandit is walking to
+  U32 targetNavNode;
+  // How long the bandit has been walking to the next index
+  F32 walkTimer;
+
+  // How many shots they can take.
+  U32 health;
+  // How paranoid they are about being hunted,
+  // this will make them more trigger happy.
+  F32 paranoidLevel;
+  // Max 6?
+  U8 bullets;
+  // How long it its between shots.
+  F32 shootDelay;
+  // After each shot this is set to shootDelay;
+  F32 shootCooldownTimer;
+  // How long it takes them to reload.
+  F32 reloadTime;
+  // Accuracy, their shots can vary between this angle either side (rads)
+  F32 accuracyRange;
+  // A the circle around the bandit where they will trigger the quicktime reaction scene
+  F32 agroRadius;
+};
+
+#endif  // LD_GAME_BANDIT_H_

code/game/impl/aabb.c

@@ -1,15 +1,36 @@
 #include "game/aabb.h"
-#include "core/types.h"
+#include <math.h>
 
-bool AABB_Collide(AABB a, AABB b) {
+bool AABB_Collide(AABB a, AABB b)
+{
   bool collision_x = a.pos.x + a.size.x >= b.pos.x && b.pos.x + b.size.x >= a.pos.x;
   bool collision_y = a.pos.y + a.size.x >= b.pos.y && b.pos.y + b.size.y >= a.pos.y;
   return collision_x && collision_y;
 }
 
-bool AABB_Point(AABB a, V2f v) {
+bool AABB_Point(AABB a, V2f v)
+{
   bool collision_x = a.pos.x + a.size.x >= v.x && a.pos.x <= v.x;
   bool collision_y = a.pos.x + a.size.y >= v.y && a.pos.y <= v.y;
   return collision_x && collision_y;
 }
 
+bool AABB_Slab(V2f origin, V2f point, AABB a)
+{
+  V2f start = a.pos;
+  V2f finish = {a.pos.x + a.size.x, a.pos.y + a.size.y};
+  V2f invdirection = {1 / (origin.x - point.x), 1 / (origin.y - point.y)};
+  // x
+  F32 tLow = (start.x - origin.x) * invdirection.x;
+  F32 tHigh = (finish.x - origin.x) * invdirection.x;
+  F32 tMin = min(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));
+  tMax = min(tMax, max(tLow, tHigh));
+
+  return tMax >= tMin;
+}

code/game/impl/nav.c

@@ -6,7 +6,8 @@
 #define MAX_UNFINISHED 128
 
 typedef struct navSearchNodeState navSearchNodeState;
-struct navSearchNodeState{
+struct navSearchNodeState
+{
   bool visited;
   U64 distance;
   U32 shortest;
@@ -14,37 +15,45 @@ struct navSearchNodeState{
 };
 
 typedef struct navSearchState navSearchState;
-struct navSearchState{
+struct navSearchState
+{
   navSearchNodeState nodeStates[NAV_MAX_NODES];
 };
 
-navSearchState initState(U32 start, U32 meshSize) {
-  navSearchState state = {};
-  for(U32 i = 0; i < meshSize; i++) {
-    state.nodeStates[i].visited          = false;
+navSearchState initState(U32 start, U32 meshSize)
+{
+  navSearchState state;
+  for (U32 i = 0; i < meshSize; i++)
+  {
+    state.nodeStates[i].visited = false;
     state.nodeStates[i].addedToUnvisited = false;
-    state.nodeStates[i].distance         = U64_MAX;
-    state.nodeStates[i].shortest         = 0;
+    state.nodeStates[i].distance = U64_MAX;
+    state.nodeStates[i].shortest = 0;
   }
   state.nodeStates[start].distance = 0;
   return state;
 }
 
-U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchState state, U32 *offset) {
-  U32 lowest  = U32_MAX;
+U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchState state, U32 *offset)
+{
+  U32 lowest = U32_MAX;
   U32 lowestI = U32_MAX;
   bool startFound = false;
-  for(U32 i = *offset; i < unfinishedCount; i++) {
+  for (U32 i = *offset; i < unfinishedCount; i++)
+  {
     navSearchNodeState checkNode = state.nodeStates[unfinishedIndexes[i]];
-    if(checkNode.visited) {
-      if(!startFound) {
+    if (checkNode.visited)
+    {
+      if (!startFound)
+      {
         *offset = i;
       }
       continue;
     }
     startFound = true;
-    if (lowest > checkNode.distance) {
-      lowest  = cast(U32) checkNode.distance;
+    if (lowest > checkNode.distance)
+    {
+      lowest = cast(U32) checkNode.distance;
       lowestI = unfinishedIndexes[i];
     }
   }
@@ -52,7 +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)
+{
   navSearchState state = initState(start, mesh->nodeCount);
   U32 unfinishedCount = 1;
   U32 unfinishedIndexes[NAV_MAX_NODES] = {start};
@@ -63,19 +73,26 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
   U32 unfinishedOffset = 0;
   U32 lowestNodeIndex = start;
   bool found = false;
-  while(!found) {
-    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;}
-      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) {
+  while (!found)
+  {
+    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;
+      }
+      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;
       }
-      if(!testNode->addedToUnvisited) {
+      if (!testNode->addedToUnvisited)
+      {
         unfinishedIndexes[unfinishedCount] = connection->NodeIndex;
         unfinishedCount++;
         testNode->addedToUnvisited = true;
@@ -83,13 +100,15 @@ NavPath Nav_Path(NavMesh *mesh, U32 start, U32 end) {
     }
     state.nodeStates[lowestNodeIndex].visited = true;
     lowestNodeIndex = getLowestState(unfinishedIndexes, unfinishedCount, state, &unfinishedOffset);
-    if(lowestNodeIndex == end) {
+    if (lowestNodeIndex == end)
+    {
       found = true;
     }
   }
   NavPath res_path = {0};
   U32 index = end;
-  while(index!=start) {
+  while (index != start)
+  {
     res_path.indexes[res_path.nodeCount] = index;
     res_path.nodeCount++;
     index = state.nodeStates[index].shortest;

code/game/impl/npc.c

@@ -41,10 +41,3 @@ void updateNPC(F32 delta, NPC *npc, World *world) {
     break;
   }
 }
-
-void updateNPCs(F32 delta, World *world) {
-  for(U32 i = 0; i < world->npcCount; i++) {
-    updateNPC(delta, &world->npcs[i], world);
-  }
-}
-

code/game/impl/player.c

@@ -1,22 +1,37 @@
 #include "../player.h"
+#include <SDL3/SDL_keycode.h>
+#include <stdio.h>
 
 void PlayerUpdate(SDL_Event *event, Player *player)
 {
-    SDL_KeyboardEvent key = event->key;
-    if (key.key == SDLK_W)
-    {
-        player->pos.y += 10;
-    }
-    if (key.key == SDLK_A)
-    {
-        player->pos.x -= 10;
-    }
-    if (key.key == SDLK_D)
-    {
-        player->pos.x += 10;
-    }
-    if (key.key == SDLK_S)
-    {
-        player->pos.y -= 10;
-    }
+  SDL_KeyboardEvent key = event->key;
+  SDL_MouseButtonEvent mouseBtn = event->button;
+  switch (key.key)
+  {
+  case SDLK_W:
+  {
+    player->pos.y += 10;
+    break;
+  }
+  case SDLK_A:
+  {
+    player->pos.x -= 10;
+    break;
+  }
+  case SDLK_D:
+  {
+    player->pos.x += 10;
+    break;
+  }
+  case SDLK_S:
+  {
+    player->pos.y -= 10;
+    break;
+  }
+  }
+  if (mouseBtn.clicks == 1)
+  {
+    // shooting
+    player->bulletsLoaded -= 1;
+  }
 }

code/game/impl/world.c

@@ -0,0 +1,22 @@
+#include "../world.h"
+#include "../npc.h"
+#include "../player.h"
+#include <SDL3/SDL_events.h>
+
+void UpdateWorld(F32 delta, World *world)
+{
+  // UpdateNPCs(delta, world);
+}
+
+void UpdateNPCs(F32 delta, World *world)
+{
+  for (int i = 0; i < world->npcCount; i++)
+  {
+    updateNPC(delta, &world->npcs[i], world);
+  }
+}
+
+void ProcessEvents(SDL_Event *event, World *world)
+{
+  PlayerUpdate(event, &world->player);
+}

code/game/npc.h

@@ -2,6 +2,7 @@
 #define LD_GAME_NPC_H_
 #include "aabb.h"
 #include "nav.h"
+#include "npc_look.h"
 #include "../core/types.h"
 
 #define NPC_SPEED 0.2f
@@ -14,18 +15,36 @@ enum NPC_ACTION {
   NPC_ACTION_WALKING,
 };
 
+
 typedef struct NPC NPC;
 struct NPC {
+  //// Personal
   AABB collision;
   Str8 name;
+  NPC_LOOK look;
+
+  //// Actions
   NPC_ACTION mode;
+  // How long they've been waiting
   F32 waitTime;
+  // How long they will wait until changing action
   F32 maxWaitTime;
+
+  //// Navigation
+  // The NPC's current path
   NavPath path;
+  // Which node the NPC is on in the path
   U32 currentNavNode;
+  // The current index of the NPC's current node
   U32 pathIndex;
+  // Target navNode index the npc is walking to
   U32 targetNavNode;
+  // How long the npc has been walking to the next index
   F32 walkTimer;
+
+  //// Knowledge
+  // What the NPC knows about the bandit.
+  NPC_LOOK banditKnowledge;
 };
 
 #endif  // LD_GAME_NPC_H_

code/game/npc_look.h

@@ -0,0 +1,82 @@
+#if !defined(LD_GAME_NPC_LOOK_H_)
+#define LD_GAME_NPC_LOOK_H_
+
+typedef struct NPC_LOOK NPC_LOOK;
+typedef enum NPC_HAIR_COLOUR NPC_HAIR_COLOUR;
+typedef enum NPC_JACKET_COLOUR NPC_JACKET_COLOUR;
+typedef enum NPC_JEANS_COLOUR NPC_JEANS_COLOUR;
+typedef enum NPC_EYE_COLOUR NPC_EYE_COLOUR;
+typedef enum NPC_SKIN_TONE NPC_SKIN_TONE;
+typedef enum NPC_HAT NPC_HAT;
+typedef enum NPC_FACIAL_FEATURE NPC_FACIAL_FEATURE;
+
+enum NPC_HAIR_COLOUR {
+  NPC_HAIR_COLOUR_UNKNOWN,
+  NPC_HAIR_COLOUR_BLONDE,
+  NPC_HAIR_COLOUR_BLACK,
+  NPC_HAIR_COLOUR_BRUNETTE,
+  NPC_HAIR_COLOUR_GIGNER,
+};
+
+enum NPC_JACKET_COLOUR {
+  NPC_JACKET_COLOUR_UNKNOWN,
+  NPC_JACKET_COLOUR_TAN,
+  NPC_JACKET_COLOUR_BLUE,
+  NPC_JACKET_COLOUR_WHITE,
+};
+
+enum NPC_JEANS_COLOUR {
+  NPC_JEANS_COLOUR_UNKNOWN,
+  NPC_JEANS_COLOUR_TAN,
+  NPC_JEANS_COLOUR_BLACK,
+  NPC_JEANS_COLOUR_BLUE,
+  NPC_JEANS_COLOUR_WHITE,
+};
+
+enum NPC_EYE_COLOUR {
+  NPC_EYE_COLOUR_UNKNOWN,
+  NPC_EYE_COLOUR_GREEN,
+  NPC_EYE_COLOUR_BLUE,
+  NPC_EYE_COLOUR_BROWN,
+};
+
+enum NPC_SHOE_COLOUR {
+  NPC_SHOE_COLOUR_UNKNOWN,
+  NPC_SHOE_COLOUR_BLACK,
+  NPC_SHOE_COLOUR_BROWN,
+  NPC_SHOE_COLOUR_WHITE,
+  NPC_SHOE_COLOUR_NAVY,
+};
+
+enum NPC_SKIN_TONE {
+  NPC_SKIN_TONE_UNKNOWN,
+  NPC_SKIN_TONE_WHITE,
+  NPC_SKIN_TONE_BLACK,
+};
+
+enum NPC_FACIAL_FEATURE {
+  NPC_FACIAL_FEATURE_UNKNOWN,
+  NPC_FACIAL_FEATURE_BEARD,
+  NPC_FACIAL_FEATURE_MUSTACHE,
+  NPC_FACIAL_FEATURE_GLASSES,
+};
+
+enum NPC_HAT {
+  NPC_HAT_UNKNOWN,
+  NPC_HAT_TEN_GALLON,
+  NPC_TOP_HAT,
+  NPC_FLAT_CAP,
+  NPC_NONE,
+};
+
+struct NPC_LOOK {
+  NPC_HAIR_COLOUR hair;
+  NPC_JACKET_COLOUR jacket;
+  NPC_JEANS_COLOUR jeans;
+  NPC_EYE_COLOUR eyes;
+  NPC_SKIN_TONE skinTone;
+  NPC_HAT hat;
+  NPC_FACIAL_FEATURE facialFeature;
+};
+
+#endif  // LD_GAME_NPC_LOOK_H_

code/game/player.h

@@ -10,6 +10,7 @@ typedef struct Player Player;
 struct Player
 {
     V2f pos;
+    U32 bulletsLoaded;
 };
 
 function void PlayerUpdate(SDL_Event *event, Player *player);

code/game/world.h

@@ -3,6 +3,7 @@
 
 #include "player.h"
 #include "npc.h"
+#include "bandit.h"
 
 // Areas are which
 typedef U32 World_Area;
@@ -13,16 +14,27 @@ enum World_Area {
 
 typedef struct World World;
 struct World {
+  //// Static stuff
+  NavMesh *navMesh;
+
+  //// Player
+	Player player;
+
+  //// NPCs
   U32 npcCount;
   NPC npcs[128];
 
-  NavMesh *navMesh;
+  ////Bandit
+  // The bandit the player is after. 
+  Bandit bandit;
 
   // NPC points of interest, places to walk to.
   U32 npcPOI[256];
 };
 
-function void updateWorld(F32 delta, World *world);
-function void updateNPCs(F32 delta, World *world);
+function void UpdateWorld(F32 delta, World *world);
+function void ProcessEvents(SDL_Event *event, World *world);
+function void UpdateNPCs(F32 delta, World *world);
+function void updateNPC(F32 delta, NPC *npc, World *world);
 
 #endif  // LD_GAME_WORLD_H_