Day 45 is complete.

handmade.c

@@ -420,6 +420,7 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory, game_input *In
     S32 TileSideInPixels = 60;
     F32 MetersToPixels = (F32)TileSideInPixels / TileMap->TileSideInMeters;
 
+    tile_map_position OldPlayerP = GameState->PlayerP;
     for(U32 ControllerIndex = 0; ControllerIndex < ARRAY_SIZE(Input->Controllers); ControllerIndex++) {
         game_controller_input *Controller = GetController(Input, ControllerIndex);
         if(Controller->IsAnalog) {
@@ -454,12 +455,13 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory, game_input *In
 
             ddPlayer = V2Add(ddPlayer, V2Unary(V2Multiply(1.5f, GameState->dPlayerP)));
 
-            tile_map_position NewPlayerP;
+            tile_map_position NewPlayerP = GameState->PlayerP;
-            NewPlayerP = GameState->PlayerP;
+            v2 PlayerDelta = V2Add(V2Multiply(0.5f, V2Multiply(Square(Input->dtForFrame), ddPlayer)), V2Multiply(Input->dtForFrame, GameState->dPlayerP));
-            NewPlayerP.Offset = V2Add(V2Add(V2Multiply(0.5f, V2Multiply(Square(Input->dtForFrame), ddPlayer)), V2Multiply(Input->dtForFrame, GameState->dPlayerP)), NewPlayerP.Offset);
+            NewPlayerP.Offset = V2Add(PlayerDelta, NewPlayerP.Offset);
             GameState->dPlayerP = V2Add(V2Multiply(Input->dtForFrame, ddPlayer), GameState->dPlayerP);
             NewPlayerP = RecannonicalizePosition(TileMap, NewPlayerP);
 
+#if 1
             tile_map_position PlayerLeft;
             PlayerLeft = NewPlayerP;
             PlayerLeft.Offset.X -= 0.5f*PlayerWidth;
@@ -503,36 +505,62 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory, game_input *In
 
                 GameState->dPlayerP = V2Subtract(GameState->dPlayerP, V2Multiply(1*InnerProduct(GameState->dPlayerP, r), r));
             } else {
-                if(!AreOnSameTile(&GameState->PlayerP, &NewPlayerP)) {
-                    U32 NewTileValue = GetTileValueByPos(TileMap, NewPlayerP);
-
-                    if(NewTileValue == 3) {
-                        NewPlayerP.AbsTileZ++;
-                    } else if(NewTileValue == 4) {
-                        NewPlayerP.AbsTileZ--;
-                    }
-                }
                 GameState->PlayerP = NewPlayerP;
             }
+#else
+            U32 MinTileX = 0;
+            U32 MinTileY = 0;
+            U32 OnePastMaxTileX = 0;
+            U32 OnePastMaxTileY = 0;
+            U32 AbsTileZ = GameState->PlayerP.AbsTileZ;
+            tile_map_position BestPlayerP = GameState->PlayerP;
+            F32 BestDistance = LengthSq(PlayerDelta);
+            for(U32 AbsTileY = MinTileY; AbsTileY != OnePastMaxTileY; AbsTileY++) {
+                for(U32 AbsTileX = MinTileX; AbsTileX != OnePastMaxTileX; AbsTileX++) {
+                    tile_map_position TestTileP = CenteredTilePoint(AbsTileX, AbsTileY, AbsTileZ);
+                    U32 TileValue = GetTileValueByPos(TileMap, TestTileP);
+                    if(IsTileValueEmpty(TileValue)) {
+                        v2 MinCorner = V2Multiply(-0.5f, (v2){ TileMap->TileSideInMeters, TileMap->TileSideInMeters });
+                        v2 MaxCorner = V2Multiply(-0.5f, (v2){ TileMap->TileSideInMeters, TileMap->TileSideInMeters });
 
-            GameState->CameraP.AbsTileZ = GameState->PlayerP.AbsTileZ;
+                        tile_map_difference RelNewPlayerP = SubtractInF32(TileMap, &TestTileP, &NewPlayerP);
-
+                        v2 TestP = ClosestPointInRectangle(MinCorner, MaxCorner, RelNewPlayerP);
-            tile_map_difference Diff = SubtractInF32(TileMap, &GameState->PlayerP, &GameState->CameraP);
+                        if(...) {
-            if(Diff.dXY.X > (9.0f*TileMap->TileSideInMeters)) {
+                        }
-                GameState->CameraP.AbsTileX += 17;
+                    }
-            }
+                }
-            if(Diff.dXY.X < -(9.0f*TileMap->TileSideInMeters)) {
-                GameState->CameraP.AbsTileX -= 17;
-            }
-            if(Diff.dXY.Y > (5.0f*TileMap->TileSideInMeters)) {
-                GameState->CameraP.AbsTileY += 9;
-            }
-            if(Diff.dXY.Y < -(5.0f*TileMap->TileSideInMeters)) {
-                GameState->CameraP.AbsTileY -= 9;
             }
+#endif
         }
     }
 
+    if(!AreOnSameTile(&OldPlayerP, &GameState->PlayerP)) {
+        U32 NewTileValue = GetTileValueByPos(TileMap, GameState->PlayerP);
+
+        if(NewTileValue == 3) {
+            GameState->PlayerP.AbsTileZ++;
+        } else if(NewTileValue == 4) {
+            GameState->PlayerP.AbsTileZ--;
+        }
+    }
+
+    GameState->CameraP.AbsTileZ = GameState->PlayerP.AbsTileZ;
+
+    tile_map_difference Diff = SubtractInF32(TileMap, &GameState->PlayerP, &GameState->CameraP);
+    if(Diff.dXY.X > (9.0f*TileMap->TileSideInMeters)) {
+        GameState->CameraP.AbsTileX += 17;
+    }
+    if(Diff.dXY.X < -(9.0f*TileMap->TileSideInMeters)) {
+        GameState->CameraP.AbsTileX -= 17;
+    }
+    if(Diff.dXY.Y > (5.0f*TileMap->TileSideInMeters)) {
+        GameState->CameraP.AbsTileY += 9;
+    }
+    if(Diff.dXY.Y < -(5.0f*TileMap->TileSideInMeters)) {
+        GameState->CameraP.AbsTileY -= 9;
+    }
+    Diff = SubtractInF32(TileMap, &GameState->PlayerP, &GameState->CameraP);
+
     //DrawRectangle(Buffer, 0.0f, 0.0f, (F32)Buffer->Width, (F32)Buffer->Height, 0.0f, 1.0f, 0.0f);
 
     DrawBitmap(Buffer, &GameState->Backdrop, 0.0f, 0.0f, 0, 0);
@@ -571,8 +599,6 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory, game_input *In
         }
     }
 
-    tile_map_difference Diff = SubtractInF32(TileMap, &GameState->PlayerP, &GameState->CameraP);
-
     F32 PlayerR = 1.0f;
     F32 PlayerG = 0.0f;
     F32 PlayerB = 0.0f;

handmade_math.h

@@ -1,6 +1,7 @@
 #ifndef HANDMADE_MATH_H
 #define HANDMADE_MATH_H
 
+// TODO: Make these static.
 typedef struct v2 {
     F32 X, Y;
     F32 E[2];
@@ -71,4 +72,10 @@ F32 InnerProduct(v2 A, v2 B)
     return Result;
 }
 
+F32 LengthSq(v2 A)
+{
+    F32 Result = InnerProduct(A, A);
+    return Result;
+}
+
 #endif

handmade_tile.c

@@ -56,6 +56,12 @@ static U32 GetTileValue(tile_map *TileMap, U32 AbsTileX, U32 AbsTileY, U32 AbsTi
     return TileChunkValue;
 }
 
+static B32 IsTileValueEmpty(U32 TileValue)
+{
+    B32 Empty = ((TileValue == 1) || (TileValue == 3) || (TileValue == 4));
+    return Empty;
+}
+
 static U32 GetTileValueByPos(tile_map *TileMap, tile_map_position Pos)
 {
     U32 TileChunkValue = GetTileValue(TileMap, Pos.AbsTileX, Pos.AbsTileY, Pos.AbsTileZ);
@@ -81,7 +87,7 @@ static void SetTileChunkValue(tile_map *TileMap, tile_chunk *TileChunk, U32 Test
 static B32 IsTileMapPointEmpty(tile_map *TileMap, tile_map_position Pos)
 {
     U32 TileChunkValue = GetTileValueByPos(TileMap, Pos);
-    B32 Empty = ((TileChunkValue == 1) || (TileChunkValue == 3) || (TileChunkValue == 4));
+    B32 Empty = IsTileValueEmpty(TileChunkValue);
     return Empty;
 }
 
@@ -150,3 +156,15 @@ static tile_map_difference SubtractInF32(tile_map *TileMap, tile_map_position *A
 
     return Result;
 }
+
+static tile_map_position CenteredTilePoint(U32 AbsTileX, U32 AbsTileY, U32 AbsTileZ)
+{
+    tile_map_position Result;
+    memset(&Result, 0, sizeof(Result));
+
+    Result.AbsTileX = AbsTileX;
+    Result.AbsTileY = AbsTileY;
+    Result.AbsTileZ = AbsTileZ;
+
+    return Result;
+}