Merge remote-tracking branch 'origin'

code/core/math.h

@@ -4,6 +4,8 @@
 #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;

code/first.c

@@ -1,6 +1,7 @@
 #include <stdio.h>
 #include <stdbool.h>
 #include <SDL3/SDL.h>
+#include <SDL3/SDL_keycode.h>
 
 #define STB_IMAGE_IMPLEMENTATION 1
 #include <stb_image.h>
@@ -62,11 +63,13 @@ int main(int argc, char **argv)
 		camera->farp = 1000.0f;
 
 		game->draw.camera = camera;
+    game->camera.p.z = 200;
 		World *world = M_ArenaPush(arena, World);
     game->world = world;
     world->random = Random_Seed(29237489723847);
-		world->npcCount = 2;
+    world->npcCount = 100;
-		NPC *npc1 = &world->npcs[0];
+    for(int i = 0; i < 100; i++) {
+    NPC *npc1 = &world->npcs[i];
       npc1->collision.pos.x = 15;
       npc1->collision.pos.y = 15;
       npc1->collision.size.x = 10;
@@ -75,11 +78,12 @@ int main(int argc, char **argv)
       npc1->mode = NPC_ACTION_WAITING;
       npc1->waitTime = 0;
       npc1->maxWaitTime = 5;
-		npc1->currentNavNode = 87;
+      npc1->currentNavNode = 0;
       npc1->collision.pos.x = 15;
       npc1->collision.pos.y = 15;
       npc1->collision.size.x = 10;
       npc1->collision.size.y = 10;
+    }
 
 		NPC *npc2 = &world->npcs[1];
 		npc2->collision.pos.x = 15;
@@ -111,6 +115,20 @@ int main(int argc, char **argv)
 			{
 				running = false;
 			}
+      if (e.type == SDL_EVENT_KEY_DOWN) {
+        if(e.key.key == SDLK_DOWN) {
+          game->camera.p.y += 5;
+        }
+        if(e.key.key == SDLK_UP) {
+          game->camera.p.y -= 5;
+        }
+        if(e.key.key == SDLK_RIGHT) {
+          game->camera.p.x += 5;
+        }
+        if(e.key.key == SDLK_LEFT) {
+          game->camera.p.x -= 5;
+        }
+      }
       ProcessEvents(&e, game->world);
 		}
 		UpdateWorld(1.0 / 60.0, game->world);
@@ -151,6 +169,7 @@ 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/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/nav.c

@@ -9,7 +9,7 @@ typedef struct navSearchNodeState navSearchNodeState;
 struct navSearchNodeState
 {
   bool visited;
-  U64 distance;
+  F64 distance;
   U32 shortest;
   bool addedToUnvisited;
 };
@@ -61,8 +61,13 @@ 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};
@@ -73,21 +78,15 @@ 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)
+      if(testNode->visited) {continue;}
-      {
+      F64 distance = cast(F64) (state.nodeStates[lowestNodeIndex].distance + connection->Cost);
-        continue;
+      distance += cast(F64) Abs((mesh->nodes[end].pos.x - mesh->nodes[connection->NodeIndex].pos.x));
-      }
+      distance += cast(F64) Abs((mesh->nodes[end].pos.y - mesh->nodes[connection->NodeIndex].pos.y));
-      U32 distance = cast(U32)(state.nodeStates[lowestNodeIndex].distance + connection->Cost);
+      if(testNode->distance > distance) {
-      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

@@ -13,7 +13,7 @@ void updateNPC(F32 delta, NPC *npc, World *world) {
         npc->mode = NPC_ACTION_WALKING;
         // TODO change targets to poi's rather than just random nodes
         npc->targetNavNode = Random_U32(&world->random, 0, world->navMesh->nodeCount);
-        printf("Starting to nav path\n");
+        printf("Starting to nav path from %d to %d\n", npc->currentNavNode, npc->targetNavNode);
         npc->path = Nav_Path(world->navMesh, npc->currentNavNode, npc->targetNavNode);
         printf("done\n");
         npc->walkTimer = 0;
@@ -29,14 +29,15 @@ void updateNPC(F32 delta, NPC *npc, World *world) {
           npc->mode = NPC_ACTION_WAITING;
           npc->maxWaitTime = Random_F32(&world->random, 10, 40);
           npc->waitTime = 0;
+          npc->currentNavNode = npc->targetNavNode;
           npc->pathIndex = 0;
           return;
         }
-        npc->pathIndex+=1;
         npc->currentNavNode = npc->path.indexes[npc->pathIndex];
+        npc->pathIndex+=1;
       }
       NavNode cNav = world->navMesh->nodes[npc->currentNavNode];
-      NavNode tNav = world->navMesh->nodes[npc->pathIndex];
+      NavNode tNav = world->navMesh->nodes[npc->path.indexes[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/world.c

@@ -20,3 +20,9 @@ void ProcessEvents(SDL_Event *event, World *world)
 {
   PlayerUpdate(event, &world->player);
 }
+
+void RenderWorld(World *world, D_Context *draw) {
+  for(int i = 0; i < world->npcCount; i++) {
+    D_Rect(draw, world->npcs[i].collision.pos.x, world->npcs[i].collision.pos.y, .texture = 1); 
+  }
+}

code/game/npc.h

@@ -5,7 +5,7 @@
 #include "npc_look.h"
 #include "../core/types.h"
 
-#define NPC_SPEED 0.2f
+#define NPC_SPEED 1.0f
 
 typedef enum NPC_ACTION NPC_ACTION;
 enum NPC_ACTION {

code/game/world.h

@@ -35,6 +35,7 @@ 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);