diff --git a/core.h b/core.h
index feb19e1..8d14c35 100644
--- a/core.h
+++ b/core.h
@@ -34,7 +34,7 @@
 #undef ARCHITECTURE_ARM32
 #define ARCHITECTURE_ARM32 1
 #else
-#error Unknown not architecture . . .
+#error Unknown architecture . . .
 #endif
 
 /* OS */
@@ -61,7 +61,7 @@
 #undef OS_LINUX
 #define OS_LINUX 1
 #else
-#error Unknown Operating System . . .
+#error Unknown operating system . . .
 #endif
 
 /* Compiler */
diff --git a/handmade.c b/handmade.c
index aec1e27..3ed63cd 100644
--- a/handmade.c
+++ b/handmade.c
@@ -97,10 +97,17 @@ static void DrawBitmap(game_offscreen_buffer *Buffer, loaded_bitmap *Bitmap, F32
     S32 Width = Buffer->Width;
     S32 Height = Buffer->Height;
 
-    if(MinX < 0)
+    S32 SourceOffsetX = 0;
+    if(MinX < 0) {
+        SourceOffsetX = -MinX;
         MinX = 0;
-    if(MinY < 0)
+    }
+
+    S32 SourceOffsetY = 0;
+    if(MinY < 0) {
+        SourceOffsetY = -MinY;
         MinY = 0;
+    }
 
     if(MaxX > Width)
         MaxX = Width;
@@ -108,6 +115,7 @@ static void DrawBitmap(game_offscreen_buffer *Buffer, loaded_bitmap *Bitmap, F32
         MaxY = Height;
 
     U32 *SourceRow = Bitmap->Pixels + Bitmap->Width*(Bitmap->Height - 1);
+    SourceRow += -Bitmap->Width*SourceOffsetY + SourceOffsetX;
     U8 *DestRow = ((U8 *)Buffer->Memory + MinX*Buffer->BytesPerPixel + MinY*Buffer->Pitch);
     for(S32 Y = MinY; Y < MaxY; Y++) {
         U32 *Dest = (U32 *)DestRow;
@@ -461,6 +469,22 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory, game_input *In
                 }
                 GameState->PlayerP = NewPlayerP;
             }
+
+            GameState->CameraP.AbsTileZ = GameState->PlayerP.AbsTileZ;
+
+            tile_map_difference Diff = SubtractInF32(TileMap, &GameState->PlayerP, &GameState->CameraP);
+            if(Diff.dX > (9.0f*TileMap->TileSideInMeters)) {
+                GameState->CameraP.AbsTileX += 17;
+            }
+            if(Diff.dX < -(9.0f*TileMap->TileSideInMeters)) {
+                GameState->CameraP.AbsTileX -= 17;
+            }
+            if(Diff.dY > (5.0f*TileMap->TileSideInMeters)) {
+                GameState->CameraP.AbsTileY += 9;
+            }
+            if(Diff.dY < -(5.0f*TileMap->TileSideInMeters)) {
+                GameState->CameraP.AbsTileY -= 9;
+            }
         }
     }
 
@@ -510,7 +534,7 @@ void UpdateAndRender(thread_context *Thread, game_memory *Memory, game_input *In
     F32 PlayerG = 0.0f;
     F32 PlayerB = 0.0f;
     F32 PlayerGroundPointX = ScreenCenterX + MetersToPixels*Diff.dX;
-    F32 PlayerGroundPointY = ScreenCenterY + MetersToPixels*Diff.dY;
+    F32 PlayerGroundPointY = ScreenCenterY - MetersToPixels*Diff.dY;
     F32 PlayerLeft = PlayerGroundPointX - 0.5f * MetersToPixels*PlayerWidth;
     F32 PlayerTop = PlayerGroundPointY - MetersToPixels*PlayerHeight;
     DrawRectangle(Buffer, PlayerLeft, PlayerTop, PlayerLeft + MetersToPixels*PlayerWidth, PlayerTop + MetersToPixels*PlayerHeight, PlayerR, PlayerG, PlayerB);
diff --git a/handmade_tile.c b/handmade_tile.c
index d5f277e..fc7c250 100644
--- a/handmade_tile.c
+++ b/handmade_tile.c
@@ -140,9 +140,9 @@ static tile_map_difference SubtractInF32(tile_map *TileMap, tile_map_position *A
 {
     tile_map_difference Result;
 
-    F32 dTileX = (F32)A->AbsTileX - (F32)B->AbsTileY;
-    F32 dTileY = (F32)A->AbsTileX - (F32)B->AbsTileY;
-    F32 dTileZ = (F32)A->AbsTileX - (F32)B->AbsTileY;
+    F32 dTileX = (F32)A->AbsTileX - (F32)B->AbsTileX;
+    F32 dTileY = (F32)A->AbsTileY - (F32)B->AbsTileY;
+    F32 dTileZ = (F32)A->AbsTileZ - (F32)B->AbsTileZ;
 
     Result.dX = TileMap->TileSideInMeters*dTileX + (A->OffsetX - B->OffsetX);
     Result.dY = TileMap->TileSideInMeters*dTileY + (A->OffsetY - B->OffsetY);
diff --git a/sdl_handmade.c b/sdl_handmade.c
index df191f2..00355a3 100644
--- a/sdl_handmade.c
+++ b/sdl_handmade.c
@@ -402,6 +402,7 @@ static U32 GetLastWriteTime(const char *FileName)
 {
     struct stat file_info;
     memset(&file_info, 0, sizeof(file_info));
+
     if(stat(FileName, &file_info) != 0) {
         /* TODO: Diagnostic. perror("stat failed"); */
     }
@@ -550,16 +551,14 @@ S32 main(S32 argc, char *argv[])
     /* NOTE: Floating windows are not supported oficially by Wayland
      *       protocol. However, SDL_WINDOW_ALWAYS_ON_TOP does work on KDE
      *       under Wayland. I have not tested GNOME. */
-    SDL_Window *Window = SDL_CreateWindow("Handmade Hero", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, RESOLUTION_WIDTH+20, RESOLUTION_HEIGHT+20, SDL_WINDOW_RESIZABLE);
-                              /*SDL_WINDOW_RESIZABLE |
-                                                 SDL_WINDOW_ALWAYS_ON_TOP);*/
+    SDL_Window *Window = SDL_CreateWindow("Handmade Hero", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, RESOLUTION_WIDTH+20, RESOLUTION_HEIGHT+20, SDL_WINDOW_RESIZABLE/* | SDL_WINDOW_ALWAYS_ON_TOP*/);
 
     if(Window) {
         SDL_DisplayMode display_mode;
         SDL_GetCurrentDisplayMode(0, &display_mode);
 
         SDL_Renderer *Renderer = SDL_CreateRenderer(Window, -1, SDL_RENDERER_PRESENTVSYNC);
-        SDL_SetWindowPosition(Window, (display_mode.w - RESOLUTION_WIDTH-20), (display_mode.h - RESOLUTION_HEIGHT-20));
+        SDL_SetWindowPosition(Window, (display_mode.w - RESOLUTION_WIDTH-30), (display_mode.h - RESOLUTION_HEIGHT-30));
 
         /* NOTE: For future reference, the custom window bar should use
          * SDL_SetWindowHitTest to define areas that will be used to
@@ -793,16 +792,21 @@ S32 main(S32 argc, char *argv[])
                     SDLDisplayBufferInWindow(GlobalBackbuffer, Window, Renderer);
 
                     F64 MSPerFrame = 1000.0 * SDLGetSecondsElapsed(LastCounter, EndCounter);
-                    F64 FPS = 0.0;
+                    F64 FPS = 1000.0 / MSPerFrame;
 
                     LastCounter = EndCounter;
 
-#if 0
+#if 1
                     U64 EndCycleCount = __rdtsc();
                     U64 CyclesElapsed = EndCycleCount - LastCycleCount;
-                    F64 MCPF = ((double)CyclesElapsed / (1000.0 * 1000.0));
-                    fprintf(stderr, "%.02f ms/f, %.02f/s, %.02f mc/f\n",
-                            MSPerFrame, FPS, MCPF);
+                    F64 MCPF = ((F64)CyclesElapsed / (1000.0 * 1000.0));
+
+                    //fprintf(stderr, "%.02f ms/f, %.02f f/s, %.02f mc/f\n", MSPerFrame, FPS, MCPF);
+
+                    static char fps_buffer[128];
+                    snprintf(fps_buffer, sizeof(fps_buffer), "%.02f ms/f, %.02f f/s, %.02f mc/f", MSPerFrame, FPS, MCPF);
+                    SDL_SetWindowTitle(Window, (const char *)fps_buffer);
+
                     LastCycleCount = EndCycleCount;
 #endif