raycast fin

code/game/aabb.h

@@ -12,5 +12,6 @@ struct AABB
 
 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_

code/game/impl/aabb.c

@@ -1,5 +1,5 @@
 #include "game/aabb.h"
-#include "core/types.h"
+#include <math.h>
 
 bool AABB_Collide(AABB a, AABB b)
 {
@@ -19,17 +19,18 @@ 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 direction = {origin.x - point.x, origin.y - point.y};
+  V2f invdirection = {1 / (origin.x - point.x), 1 / (origin.y - point.y)};
   // x
-  F32 tLow = (start.x - origin.x) / direction.x;
-  F32 tHigh = (finish.x - origin.x) / direction.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.x - origin.x) / direction.x;
-  tHigh = (finish.x - origin.x) / direction.x;
+  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 >= max(0.0, tMin);
+
+  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,13 +15,16 @@ 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++) {
+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;
@@ -30,20 +34,25 @@ navSearchState initState(U32 start, U32 meshSize) {
   return state;
 }
 
-U32 getLowestState(U32 unfinishedIndexes[128], U32 unfinishedCount, navSearchState state, U32 *offset) {
+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) {
+    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++) {
+  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;}
+      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) {
+      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/world.c

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