From 3940d04a624980bfe4782ccd87adda1043778959 Mon Sep 17 00:00:00 2001
From: "Z. Cliffe Schreuders" <code.cliffe@schreuders.org>
Date: Sun, 31 Aug 2025 23:10:58 +0100
Subject: [PATCH] Update key-demo.html and lockpicking minigame: Enhance key
 mode functionality by introducing a random key selection feature, allowing
 players to choose from three random keys. Update UI instructions for clarity
 and improve feedback messages based on key selection outcomes. Adjust game
 parameters to streamline the key selection process and ensure a smoother
 gameplay experience.

WiP updates to the main game including improved doors, animations, and player depth. Locks currently disabled.
---
 README.md                                     |    2 +-
 assets/rooms/room_reception.json              |  669 +++++++-
 assets/tiles/door_sheet.png                   |  Bin 0 -> 6173 bytes
 assets/tiles/door_side_sheet.png              |  Bin 0 -> 1705 bytes
 index_new.html                                |    2 +-
 js/core/game.js                               |   53 +-
 js/core/player.js                             |   51 +-
 js/core/rooms.js                              | 1353 +++++++++++++++--
 js/main.js                                    |    3 +
 .../lockpicking/lockpicking-game-phaser.js    |  562 ++++++-
 js/systems/interactions.js                    |  423 ++++--
 key-demo.html                                 |  183 ++-
 locksmith-forge.html                          |   99 +-
 simple-phaser-test.html                       |  103 --
 14 files changed, 2901 insertions(+), 602 deletions(-)
 create mode 100644 assets/tiles/door_sheet.png
 create mode 100644 assets/tiles/door_side_sheet.png
 delete mode 100644 simple-phaser-test.html

diff --git a/README.md b/README.md
index 34e9963..3d190bf 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@ Break Escape is an escape room-inspired games-based learning framework that simu
 
 **Note: Break Escape is currently in development. Please report any issues or feedback via GitHub.**
 
-## Live Demo
+## Live Demo -- Early Beta Playtesting
 
 You can try Break Escape directly from your browser by visiting:
 https://hacktivity.co.uk/break-escape-beta/scenario_select.html
diff --git a/assets/rooms/room_reception.json b/assets/rooms/room_reception.json
index d8525ed..5ce6dc5 100644
--- a/assets/rooms/room_reception.json
+++ b/assets/rooms/room_reception.json
@@ -3,15 +3,15 @@
  "infinite":false,
  "layers":[
         {
-         "data":[3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-            13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
-            23, 0, 0, 26, 27, 28, 29, 0, 0, 32,
-            33, 0, 0, 0, 0, 0, 0, 0, 0, 42,
-            43, 0, 0, 0, 0, 0, 0, 0, 0, 52,
-            53, 0, 0, 0, 0, 0, 0, 0, 0, 62,
-            63, 0, 0, 0, 0, 0, 0, 0, 0, 72,
-            73, 0, 0, 0, 0, 0, 0, 0, 0, 82,
-            83, 84, 85, 86, 87, 88, 89, 90, 91, 92],
+         "data":[0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+            21, 0, 12, 24, 12, 12, 27, 28, 0, 30,
+            31, 0, 0, 0, 0, 0, 0, 0, 0, 40,
+            41, 0, 0, 0, 0, 0, 0, 0, 0, 50,
+            51, 0, 0, 0, 0, 0, 0, 0, 0, 60,
+            61, 0, 0, 0, 0, 0, 0, 0, 0, 70,
+            71, 0, 0, 0, 0, 0, 0, 0, 0, 80,
+            81, 82, 83, 84, 85, 86, 87, 88, 89, 90],
          "height":9,
          "id":8,
          "name":"walls",
@@ -23,15 +23,15 @@
          "y":0
         }, 
         {
-         "data":[3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-            13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
-            23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
-            33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
-            43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
-            53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
-            63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
-            73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
-            83, 84, 85, 86, 87, 88, 89, 90, 91, 92],
+         "data":[1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
+            11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+            21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
+            31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+            41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+            51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
+            61, 62, 63, 64, 65, 66, 67, 68, 69, 70,
+            71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+            81, 82, 83, 84, 85, 86, 87, 88, 89, 90],
          "height":9,
          "id":12,
          "name":"ROOM",
@@ -43,13 +43,13 @@
          "y":0
         }, 
         {
-         "data":[0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
-            0, 2, 0, 0, 0, 0, 0, 0, 2, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+         "data":[0, 101, 0, 0, 0, 0, 0, 0, 101, 0,
+            0, 103, 0, 0, 0, 0, 0, 0, 103, 0,
+            102, 0, 0, 0, 0, 0, 0, 0, 0, 104,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            102, 0, 0, 0, 0, 0, 0, 0, 0, 104,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
             0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
          "height":9,
@@ -149,44 +149,43 @@
                  "width":48,
                  "x":143.838518642089,
                  "y":191.623488197514
-                },
+                }, 
                 {
-                    "gid":12329,
-                    "height":48,
-                    "id":13,
-                    "name":"safe",
-                    "rotation":0,
-                    "type":"",
-                    "visible":true,
-                    "width":48,
-                    "x":192,
-                    "y":96
-                   },
-                   {
-                    "gid":12329,
-                    "height":48,
-                    "id":14,
-                    "name":"safe2",
-                    "rotation":0,
-                    "type":"",
-                    "visible":true,
-                    "width":48,
-                    "x":140,
-                    "y":300
-                   },
-                   {
-                    "gid":12329,
-                    "height":48,
-                    "id":15,
-                    "name":"safe3",
-                    "rotation":0,
-                    "type":"",
-                    "visible":true,
-                    "width":48,
-                    "x":350,
-                    "y":250
-                   }
-            ],
+                 "gid":12327,
+                 "height":48,
+                 "id":13,
+                 "name":"safe",
+                 "rotation":0,
+                 "type":"",
+                 "visible":true,
+                 "width":48,
+                 "x":192,
+                 "y":96
+                }, 
+                {
+                 "gid":12327,
+                 "height":48,
+                 "id":14,
+                 "name":"safe2",
+                 "rotation":0,
+                 "type":"",
+                 "visible":true,
+                 "width":48,
+                 "x":140,
+                 "y":300
+                }, 
+                {
+                 "gid":12327,
+                 "height":48,
+                 "id":15,
+                 "name":"safe3",
+                 "rotation":0,
+                 "type":"",
+                 "visible":true,
+                 "width":48,
+                 "x":350,
+                 "y":250
+                }],
          "opacity":1,
          "type":"objectgroup",
          "visible":true,
@@ -197,25 +196,12 @@
  "nextobjectid":13,
  "orientation":"orthogonal",
  "renderorder":"right-down",
- "tiledversion":"1.11.0",
+ "tiledversion":"1.11.2",
  "tileheight":48,
  "tilesets":[
-        {
-         "columns":1,
-         "firstgid":1,
-         "image":"..\/tiles\/door.png",
-         "imageheight":96,
-         "imagewidth":48,
-         "margin":0,
-         "name":"door",
-         "spacing":0,
-         "tilecount":2,
-         "tileheight":48,
-         "tilewidth":48
-        }, 
         {
          "columns":10,
-         "firstgid":3,
+         "firstgid":1,
          "image":"room_reception_l.png",
          "imageheight":480,
          "imagewidth":480,
@@ -224,10 +210,543 @@
          "spacing":0,
          "tilecount":100,
          "tileheight":48,
+         "tiles":[
+                {
+                 "id":11,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":2.75,
+                             "id":1,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":47.625,
+                             "x":0.25,
+                             "y":45.25
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":12,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":3,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":2.875,
+                             "id":5,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":47.75,
+                             "x":0.25,
+                             "y":45.125
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":13,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":2.875,
+                             "id":3,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":47.75,
+                             "x":0.125,
+                             "y":45.0625
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":14,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":1.5,
+                             "id":1,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":47.625,
+                             "x":0.25,
+                             "y":46.5
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":15,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":2.875,
+                             "id":2,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":47.75,
+                             "x":0.125,
+                             "y":44.8125
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":16,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":2.875,
+                             "id":1,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":47.75,
+                             "x":0.125,
+                             "y":39.0625
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":17,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":2.875,
+                             "id":1,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":47.875,
+                             "x":0.25,
+                             "y":45.25
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":18,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":3,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":2.875,
+                             "id":2,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":47.75,
+                             "x":0.25,
+                             "y":45.25
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":22,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":0,
+                             "id":3,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":28.6021787636173,
+                             "y":9.70206063787899
+                            }, 
+                            {
+                             "height":0,
+                             "id":6,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":28.7281795511222,
+                             "y":18.0181126132038
+                            }, 
+                            {
+                             "height":0,
+                             "id":7,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":30.7441921512009,
+                             "y":20.0341252132826
+                            }, 
+                            {
+                             "height":0,
+                             "id":8,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":33.2642079012994,
+                             "y":21.6721354508466
+                            }, 
+                            {
+                             "height":0,
+                             "id":9,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":34.7762173513584,
+                             "y":24.0661504134401
+                            }, 
+                            {
+                             "height":0,
+                             "id":10,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":38.0522378264864,
+                             "y":26.0821630135188
+                            }, 
+                            {
+                             "height":0,
+                             "id":11,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":42.8402677516735,
+                             "y":26.8381677385484
+                            }, 
+                            {
+                             "height":0,
+                             "id":12,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":46.9982937393359,
+                             "y":28.8541803386271
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":23,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":0,
+                             "id":1,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":0.882005512534453,
+                             "y":28.8541803386271
+                            }, 
+                            {
+                             "height":0,
+                             "id":2,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":20.6641291508072,
+                             "y":26.2081638010238
+                            }, 
+                            {
+                             "height":0,
+                             "id":3,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":40.320252001575,
+                             "y":26.0821630135188
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                },
+            
+                {
+                 "id":24,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":3,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":17.3881086756792,
+                             "id":3,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":48.7623047644048,
+                             "x":0.252001575009844,
+                             "y":18.3961149757186
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":25,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":17.2621078881743,
+                             "id":1,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":49.6443102769392,
+                             "x":0.126000787504922,
+                             "y":18.5221157632235
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":26,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":3,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":21.4201338758367,
+                             "id":3,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":17.2621078881743,
+                             "x":30.618191363696,
+                             "y":17.8921118256989
+                            }, 
+                            {
+                             "height":17.8921118256989,
+                             "id":4,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":40.4462527890799,
+                             "x":-9.82806142538391,
+                             "y":18.2701141882137
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }, 
+                {
+                 "id":27,
+                 "objectgroup":
+                    {
+                     "draworder":"index",
+                     "id":2,
+                     "name":"",
+                     "objects":[
+                            {
+                             "height":20.916130725817,
+                             "id":1,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":8.56805355033469,
+                             "x":0.126000787504922,
+                             "y":18.2701141882137
+                            }, 
+                            {
+                             "height":0,
+                             "id":2,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":6.3000393752461,
+                             "y":26.4601653760336
+                            }, 
+                            {
+                             "height":0,
+                             "id":3,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":10.7100669379184,
+                             "y":23.6881480509253
+                            }, 
+                            {
+                             "height":0,
+                             "id":4,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":14.7420921380759,
+                             "y":20.7901299383121
+                            }, 
+                            {
+                             "height":0,
+                             "id":5,
+                             "name":"",
+                             "rotation":0,
+                             "type":"",
+                             "visible":true,
+                             "width":0,
+                             "x":14.7420921380759,
+                             "y":6.55204095025594
+                            }],
+                     "opacity":1,
+                     "type":"objectgroup",
+                     "visible":true,
+                     "x":0,
+                     "y":0
+                    }
+                }],
+         "tilewidth":48
+        }, 
+        {
+         "columns":2,
+         "firstgid":101,
+         "image":"..\/tiles\/door_tiles.png",
+         "imageheight":96,
+         "imagewidth":96,
+         "margin":0,
+         "name":"door_tiles",
+         "spacing":0,
+         "tilecount":4,
+         "tileheight":48,
          "tilewidth":48
         }],
  "tilewidth":48,
  "type":"map",
  "version":"1.10",
  "width":10
-}
+}
\ No newline at end of file
diff --git a/assets/tiles/door_sheet.png b/assets/tiles/door_sheet.png
new file mode 100644
index 0000000000000000000000000000000000000000..9111c1062b3ebe59cb1cd0037be5e74de90c937a
GIT binary patch
literal 6173
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
ZnNQE{VoULHWA^<3)t8z|wF>V-{s$u3CGr3O

literal 0
HcmV?d00001

diff --git a/assets/tiles/door_side_sheet.png b/assets/tiles/door_side_sheet.png
new file mode 100644
index 0000000000000000000000000000000000000000..fa09ee66a8f6fe3a97a8417090d531deb7ba294f
GIT binary patch
literal 1705
zcmV;a23GlrP)<h;3K|Lk000e1NJLTq00AHX001xu1^@s6u_C9h0004gX+uL$Nkc;*
zaB^>EX>4Tx04R}tkvT{MQ4~ebOx%zJ3!{iwOrc_78aFIs6oQ}-VuU1GI7<=(nMs&Q
zu(1?u1q+wPt+27y*1}d01Q!r{!Aj9aWaKA-1TntmAMStm@!$O*ALew^X$pdA742v^
zq{I_RrS*jty6IwwaaDH;Q<2CV4eRp`Nu0L<F{^RkpXD=Bjt-In1oeVl1Zf4BSSuC;
z?*e{(RW(351BUH*A_>xi(6tJ`3eJ>S7Bl^JEIJLcA5b!Ntkto;YMUUB0sV$)86d|i
zYzST#Z01UO^_^lvZ^~L+5IWFDm|5nDprBDAOO7G|vREiML<tjW;O{N_Bb3m{kwr&g
zhCC)}*^l^x-`P6p(UHm|ZwQ*7UH5$eTDReQ%XPnwT=)AJJWp_G)%^KGnEU|GR!!?a
zfQ}6~zp8244qR+P&tpNg)w1LP<a8R|PQjOe&Kqc7s^nI^=j0w@>o9i>d;2h$fsW+{
zd$-l+_HR!$zaIkca^OZaqqzV81m;OZK~#90?VZ7H(?Af0XPuV5L|-VUzC+bEQtwEp
zaH&wag1A9SAESO15KjV5yc~klt-E%1x0&7fo%tjLNsawyGX6a?>!fBrpIcHCMe$JA
zwc*@<#kq4uQIs)`+y{@3k4ZaenugBK&bE*5?mp4VHe}k3dA39}vqWoJZ8m6~!~XZz
z$`V;>w%d2|j9oh$Zho>h6@9$DeW7Dt`b(klSN+oT*L9t=&rps6wu$EC%?Z7Kd&9Bo
zY&_h5XWjq##TDDW(c`cB%aT(+OABU5$4VtZkH6|KOHTbP70}V~@%G<bl>}!6fevT<
zbHsf}zk6)o>)Q2m-*z0h`niU<oQp@Uer|LKtw4}!K7F&%3zsZd45*sTICiT95)%LO
ziz~4wV_*Mk%xBDuxIoYUocgr_3PAG7nnL$lV%xLs|8d_N;yWho(R_01SH|I~fU3iJ
ze}~Me|9nmZOO3x2qxI?ESKF1te9-ehr+%$~4vZLskzhuYSow6%Y2_mure%2l`y5&=
z3_UO9gpkfq{9PosU#@<{wkst5lF6x`$AAp>8-Pwq{8Q&b9E|CgZay@D{LiVM#egjM
z6#$)~_{X+irOYTqzf|*~3FLoH{VWF5V#hxisV(8I_)BiTXh1)T`OpONKc{{jLKi@q
zaY<^wd?1;R5(m#RJoZOn;PJ&jwf!n#macw8^Fh!5oceVLJwe9epIYT)T}ATfM=>9o
zK>ouIp^X8*1b`D0e~Il^Uq6!h&;;^7r+%FQ9RM*VQ@Z`?gJwQT96ZbL_ONn6QuRO)
z@eeha+$XnBKa%;N=YLN9JVR*bOC^<IxK5nd_)DsI$fF<0d}spspHn~6jfmRWmBfvI
z?2Jc(8Ts`49!oSInn3>N)X(ybhy;EGz-M>-rM6!ip7bMCK2M<MKX?VC;NVs~(q>sM
zIOe0op!WeykbeB7fApeHUq71ppyxmQeL&cELEy71{!)g`L%90U%!ekB|2g$DwO|l=
zGGW5vFSq@AsUO9BHULTWf?fex^lLyI)>^XGim5Ez`2Sdbi+Vpww_oJRA1w31&;OkI
zbqKu&jM@B=NT;ha7KtCd7z53GlsK3S2>S{Uj}caOyYV-p<|wcIq6y@W>JNqKKA>qa
zbb@xzOaJWQ`Nbk|yYlUqa#*k!5c>C_#IkBvFP`h0R?aHJjelp35BJ|;+As9{QT-9e
z%6F*UNE_yca=Eys%f)qR8D3m->>H2F_DeY=SSlc!IFXe)$VJ1A|K;NPnaK<pj->W0
zHGia_`om$G0j1V(m~WiCDk3cY@^p8A_b{qI82u>51c{Bmw3Zh=e^h@sEESNc{Js{u
znpAR-EA6C=!Hs`R%p|m5G?G6ksQz$7EyMd(la$wiY^2Kc;i-TUOE@VjNz3JuPESuo
zR0An!3s4r-9}Z6iq~FI>7DvC7wknDV#UGN4`dJKUZPQ+XlvSBj{Zdf<Wl{a%U{A{w
zMS+H=1#=t}atI231#|V!=X1Q9QdECg&?}%8{P!ZM{<5h4vgFjyQUU#G8v642E77_k
zBBH-!sA?@)yLsIG;xlWXmfel1$ac=Vo^AfBTB^EWnDw(`yu10pA$_a=*U#S;SwDLG
zRlf}VbzQR^hlt2PmWYa?WPy7XRfo`uq7>sF9Rxvbt?be$00000NkvXXu0mjfJyBD^

literal 0
HcmV?d00001

diff --git a/index_new.html b/index_new.html
index 66a0662..27cee60 100644
--- a/index_new.html
+++ b/index_new.html
@@ -151,7 +151,7 @@
     <div class="popup-overlay"></div>
 
     <!-- Main Game JavaScript Module -->
-    <script type="module" src="js/main.js?v=32"></script>
+    <script type="module" src="js/main.js?v=33"></script>
     
     <!-- Mobile touch handling -->
     <script>
diff --git a/js/core/game.js b/js/core/game.js
index e3ccf6e..b9a378b 100644
--- a/js/core/game.js
+++ b/js/core/game.js
@@ -1,8 +1,8 @@
-import { initializeRooms, validateDoorsByRoomOverlap, calculateWorldBounds, calculateRoomPositions, createRoom, revealRoom, updatePlayerRoom, rooms } from './rooms.js?v=16';
+import { initializeRooms, calculateWorldBounds, calculateRoomPositions, createRoom, revealRoom, updatePlayerRoom, rooms } from './rooms.js?v=16';
 import { createPlayer, updatePlayerMovement, movePlayerToPoint, player } from './player.js?v=7';
 import { initializePathfinder } from './pathfinding.js?v=7';
 import { initializeInventory, processInitialInventoryItems } from '../systems/inventory.js?v=8';
-import { checkObjectInteractions, processAllDoorCollisions, setGameInstance, setupDoorOverlapChecks } from '../systems/interactions.js?v=23';
+import { checkObjectInteractions, setGameInstance } from '../systems/interactions.js?v=23';
 import { introduceScenario } from '../utils/helpers.js?v=19';
 import '../minigames/index.js?v=2';
 
@@ -28,6 +28,10 @@ export function preload() {
     this.load.image('room_ceo_l', 'assets/rooms/room_ceo_l.png');
     this.load.image('room_spooky_basement_l', 'assets/rooms/room_spooky_basement_l.png');
     this.load.image('door', 'assets/tiles/door.png');
+    this.load.spritesheet('door_sheet', 'assets/tiles/door_sheet.png', {
+        frameWidth: 48,
+        frameHeight: 96
+    });
 
     // Load object sprites
     this.load.image('pc', 'assets/objects/pc.png');
@@ -91,25 +95,36 @@ export function create() {
     // Store player globally for access from other modules
     window.player = player;
     
+    // Create door opening animation
+    this.anims.create({
+        key: 'door_open',
+        frames: this.anims.generateFrameNumbers('door_sheet', { start: 0, end: 4 }),
+        frameRate: 8,
+        repeat: 0
+    });
+    
+    // Create door top animation (6th frame)
+    this.anims.create({
+        key: 'door_top',
+        frames: [{ key: 'door_sheet', frame: 5 }],
+        frameRate: 1,
+        repeat: 0
+    });
+    
     // Initialize rooms system after player exists
     initializeRooms(this);
     
-    // Calculate room positions
+    // Create only the starting room initially
     const roomPositions = calculateRoomPositions(this);
+    const startingRoomData = gameScenario.rooms[gameScenario.startRoom];
+    const startingRoomPosition = roomPositions[gameScenario.startRoom];
     
-    // Create all rooms
-    Object.entries(gameScenario.rooms).forEach(([roomId, roomData]) => {
-        const position = roomPositions[roomId];
-        if (position) {
-            createRoom(roomId, roomData, position);
-        }
-    });
-    
-    // Validate doors by checking room overlaps
-    validateDoorsByRoomOverlap();
-    
-    // Reveal starting room early like in original  
-    revealRoom(gameScenario.startRoom);
+    if (startingRoomData && startingRoomPosition) {
+        createRoom(gameScenario.startRoom, startingRoomData, startingRoomPosition);
+        revealRoom(gameScenario.startRoom);
+    } else {
+        console.error('Failed to create starting room');
+    }
     
     // Position player in the starting room
     const startingRoom = rooms[gameScenario.startRoom];
@@ -124,11 +139,7 @@ export function create() {
     this.cameras.main.startFollow(player);
     this.cameras.main.setZoom(1);
     
-    // Process door collisions after rooms are revealed
-    processAllDoorCollisions();
-    
-    // Setup door overlap checks
-    setupDoorOverlapChecks();
+    // Door interactions are now handled by the door sprites themselves
     
     // Initialize pathfinder
     initializePathfinder(this);
diff --git a/js/core/player.js b/js/core/player.js
index 667396e..49407c6 100644
--- a/js/core/player.js
+++ b/js/core/player.js
@@ -43,8 +43,8 @@ export function createPlayer(gameInstance) {
     player.body.setDrag(0);
     player.body.setFriction(0);
     
-    // Set player depth to ensure it renders above most objects
-    player.setDepth(2000);
+    // Set initial player depth (will be updated dynamically during movement)
+    updatePlayerDepth(startRoomPosition.x, startRoomPosition.y);
     
     // Track player direction and movement state
     player.direction = 'down'; // Initial direction
@@ -149,6 +149,38 @@ export function movePlayerToPoint(x, y) {
     isMoving = true;
 }
 
+function updatePlayerDepth(x, y) {
+    // Calculate dynamic depth based on Y position
+    // This creates the effect where player appears behind objects when north of them
+    // and in front when south of them
+    
+    // Get the bottom of the player sprite (feet position)
+    // Since player origin is at center, bottom is y + half the scaled height
+    const playerBottomY = y + (player.height * player.scaleY) / 2;
+    
+    // Calculate room depth based on player position with finer granularity
+    // Use 50-pixel boundaries instead of 100 for smoother depth transitions
+    const roomDepth = Math.floor(playerBottomY / 50) * 50;
+    
+    // Player should use the same depth calculation as objects for proper layering
+    // This allows player and objects to layer relative to each other based on Y position
+    const playerDepth = roomDepth + 500; // Same as objects - above all room layers
+    
+    // Set the player depth (always update, no threshold)
+    if (player) {
+        player.setDepth(playerDepth);
+        
+        // Debug logging - only show when depth actually changes significantly
+        const lastDepth = player.lastDepth || 0;
+        if (Math.abs(playerDepth - lastDepth) > 25) { // Reduced threshold for finer granularity
+            console.log(`Player depth: ${playerDepth} (Y: ${y}, BottomY: ${playerBottomY}, RoomDepth: ${roomDepth})`);
+            console.log(`  Player uses same depth calculation as objects: roomDepth + 500`);
+            console.log(`  Room layer depths: floor=${roomDepth + 100}, collision=${roomDepth + 150}, walls=${roomDepth + 200}, props=${roomDepth + 300}, other=${roomDepth + 400}`);
+            player.lastDepth = playerDepth;
+        }
+    }
+}
+
 function createClickIndicator(x, y) {
     // Create a circle at the click position
     const indicator = gameRef.add.circle(x, y, CLICK_INDICATOR_SIZE, 0xffffff, 0.7);
@@ -188,6 +220,9 @@ export function updatePlayerMovement() {
     const px = player.x;
     const py = player.y + PLAYER_FEET_OFFSET_Y; // Add offset to target the feet
     
+    // Update player depth based on actual player position (not feet-adjusted)
+    updatePlayerDepth(px, player.y);
+    
     // Use squared distance for performance
     const dx = targetPoint.x - px;
     const dy = targetPoint.y - py; // Compare with feet position
@@ -204,15 +239,9 @@ export function updatePlayerMovement() {
         return;
     }
 
-    // Only check room transitions periodically
-    const movedX = Math.abs(px - lastPlayerPosition.x);
-    const movedY = Math.abs(py - lastPlayerPosition.y);
-    
-    if (movedX > ROOM_CHECK_THRESHOLD || movedY > ROOM_CHECK_THRESHOLD) {
-        // Room checking will be handled in game.js to avoid circular dependencies
-        lastPlayerPosition.x = px;
-        lastPlayerPosition.y = py - PLAYER_FEET_OFFSET_Y; // Store actual player position
-    }
+    // Update last player position for depth calculations
+    lastPlayerPosition.x = px;
+    lastPlayerPosition.y = py - PLAYER_FEET_OFFSET_Y; // Store actual player position
 
     // Normalize movement vector for consistent speed
     const distance = Math.sqrt(distanceSq);
diff --git a/js/core/rooms.js b/js/core/rooms.js
index 1d58f27..fb8768c 100644
--- a/js/core/rooms.js
+++ b/js/core/rooms.js
@@ -5,8 +5,18 @@ export let rooms = {};
 export let currentRoom = '';
 export let currentPlayerRoom = '';
 export let discoveredRooms = new Set();
+// Make discoveredRooms available globally
+window.discoveredRooms = discoveredRooms;
 let gameRef = null;
 
+// Helper function to check if two rectangles overlap
+function boundsOverlap(rect1, rect2) {
+    return rect1.x < rect2.x + rect2.width &&
+           rect1.x + rect1.width > rect2.x &&
+           rect1.y < rect2.y + rect2.height &&
+           rect1.y + rect1.height > rect2.y;
+}
+
 // Define scale factors for different object types
 const OBJECT_SCALES = {
     'notes': 0.75,
@@ -16,6 +26,1018 @@ const OBJECT_SCALES = {
     'bluetooth_scanner': 0.7
 };
 
+// Function to create door sprites based on gameScenario connections
+function createDoorSpritesForRoom(roomId, position) {
+    const gameScenario = window.gameScenario;
+    const roomData = gameScenario.rooms[roomId];
+    if (!roomData || !roomData.connections) {
+        console.log(`No connections found for room ${roomId}`);
+        return [];
+    }
+    
+    console.log(`Creating door sprites for room ${roomId}:`, roomData.connections);
+    
+    const doorSprites = [];
+    const connections = roomData.connections;
+    
+    // Get room dimensions for door positioning
+    const map = gameRef.cache.tilemap.get(roomData.type);
+    let roomWidth = 800, roomHeight = 600; // fallback
+    
+    if (map) {
+        if (map.json) {
+            roomWidth = map.json.width * 48;
+            roomHeight = map.json.height * 48;
+        } else if (map.data) {
+            roomWidth = map.data.width * 48;
+            roomHeight = map.data.height * 48;
+        }
+    }
+    
+    console.log(`Room ${roomId} dimensions: ${roomWidth}x${roomHeight}, position: (${position.x}, ${position.y})`);
+    
+    // Create door sprites for each connection direction
+    Object.entries(connections).forEach(([direction, connectedRooms]) => {
+        const roomList = Array.isArray(connectedRooms) ? connectedRooms : [connectedRooms];
+        
+        roomList.forEach((connectedRoom, index) => {
+            // Calculate door position based on direction
+            let doorX, doorY;
+            let doorWidth = TILE_SIZE, doorHeight = TILE_SIZE * 2;
+            
+            switch (direction) {
+                case 'north':
+                    // Door at top of room, 1.5 tiles in from sides
+                    if (roomList.length === 1) {
+                        // Single connection - check the connecting room's connections to determine position
+                        const connectingRoom = roomList[0];
+                        const connectingRoomConnections = window.gameScenario.rooms[connectingRoom]?.connections?.south;
+                        
+                        if (Array.isArray(connectingRoomConnections) && connectingRoomConnections.length > 1) {
+                            // The connecting room has multiple south doors, find which one connects to this room
+                            const doorIndex = connectingRoomConnections.indexOf(roomId);
+                            if (doorIndex >= 0) {
+                                // When the connecting room has multiple doors, position this door to match
+                                // If this room is at index 0 (left), position door on the right (southeast)
+                                // If this room is at index 1 (right), position door on the left (southwest)
+                                if (doorIndex === 0) {
+                                    // This room is on the left, so door should be on the right
+                                    doorX = position.x + roomWidth - TILE_SIZE * 1.5;
+                                    console.log(`North door positioning for ${roomId}: left room (index 0), door on right (southeast), doorX=${doorX}`);
+                                } else {
+                                    // This room is on the right, so door should be on the left
+                                    doorX = position.x + TILE_SIZE * 1.5;
+                                    console.log(`North door positioning for ${roomId}: right room (index ${doorIndex}), door on left (southwest), doorX=${doorX}`);
+                                }
+                            } else {
+                                // Fallback to left positioning
+                                doorX = position.x + TILE_SIZE * 1.5;
+                                console.log(`North door positioning for ${roomId}: fallback to left, doorX=${doorX}`);
+                            }
+                        } else {
+                            // Single door - use left positioning
+                            doorX = position.x + TILE_SIZE * 1.5;
+                            console.log(`North door positioning for ${roomId}: single connection to ${connectingRoom}, doorX=${doorX}`);
+                        }
+                    } else {
+                        // Multiple connections - use 1.5 tile spacing from edges
+                        const availableWidth = roomWidth - (TILE_SIZE * 1.5 * 2); // Subtract edge spacing
+                        const doorSpacing = availableWidth / (roomList.length - 1); // Space between doors
+                        doorX = position.x + TILE_SIZE * 1.5 + (doorSpacing * index); // Start at 1.5 tiles from edge
+                    }
+                    doorY = position.y + TILE_SIZE; // 1 tile from top
+                    console.log(`North door Y position: ${doorY} (position.y=${position.y}, TILE_SIZE=${TILE_SIZE})`);
+                    break;
+                case 'south':
+                    // Door at bottom of room, 1.5 tiles in from sides
+                    if (roomList.length === 1) {
+                        // Single connection - check if the connecting room has multiple doors
+                        const connectingRoom = roomList[0];
+                        const connectingRoomConnections = window.gameScenario.rooms[connectingRoom]?.connections?.north;
+                        if (Array.isArray(connectingRoomConnections) && connectingRoomConnections.length > 1) {
+                            // The connecting room has multiple north doors, find which one connects to this room
+                            const doorIndex = connectingRoomConnections.indexOf(roomId);
+                            if (doorIndex >= 0) {
+                                // When the connecting room has multiple doors, position this door to match
+                                // If this room is at index 0 (left), position door on the right (southeast)
+                                // If this room is at index 1 (right), position door on the left (southwest)
+                                if (doorIndex === 0) {
+                                    // This room is on the left, so door should be on the right
+                                    doorX = position.x + roomWidth - TILE_SIZE * 1.5;
+                                    console.log(`South door positioning for ${roomId}: left room (index 0), door on right (southeast), doorX=${doorX}`);
+                                } else {
+                                    // This room is on the right, so door should be on the left
+                                    doorX = position.x + TILE_SIZE * 1.5;
+                                    console.log(`South door positioning for ${roomId}: right room (index ${doorIndex}), door on left (southwest), doorX=${doorX}`);
+                                }
+                            } else {
+                                // Fallback to left positioning
+                                doorX = position.x + TILE_SIZE * 1.5;
+                                console.log(`South door positioning for ${roomId}: fallback to left, doorX=${doorX}`);
+                            }
+                        } else {
+                            // Single door - use left positioning
+                            doorX = position.x + TILE_SIZE * 1.5;
+                            console.log(`South door positioning for ${roomId}: single connection to ${connectingRoom}, doorX=${doorX}`);
+                        }
+                    } else {
+                        // Multiple connections - use 1.5 tile spacing from edges
+                        const availableWidth = roomWidth - (TILE_SIZE * 1.5 * 2); // Subtract edge spacing
+                        const doorSpacing = availableWidth / (roomList.length - 1); // Space between doors
+                        doorX = position.x + TILE_SIZE * 1.5 + (doorSpacing * index); // Start at 1.5 tiles from edge
+                    }
+                    doorY = position.y + roomHeight - TILE_SIZE; // 1 tile from bottom
+                    // replace the bottom most tile with a copy of the tile above
+                    
+                    
+                    break;
+                case 'east':
+                    // Door at right side of room, 1 tile in from top/bottom
+                    doorX = position.x + roomWidth - TILE_SIZE; // 1 tile from right
+                    doorY = position.y + roomHeight / 2; // Center of room
+                    doorWidth = TILE_SIZE * 2;
+                    doorHeight = TILE_SIZE;
+                    break;
+                case 'west':
+                    // Door at left side of room, 1 tile in from top/bottom
+                    doorX = position.x + TILE_SIZE; // 1 tile from left
+                    doorY = position.y + roomHeight / 2; // Center of room
+                    doorWidth = TILE_SIZE * 2;
+                    doorHeight = TILE_SIZE;
+                    break;
+                default:
+                    return; // Skip unknown directions
+            }
+            
+            // Create door sprite
+            console.log(`Creating door sprite at (${doorX}, ${doorY}) for ${roomId} -> ${connectedRoom}`);
+            
+            // Create a colored rectangle as a fallback if door texture fails
+            let doorSprite;
+            try {
+                doorSprite = gameRef.add.sprite(doorX, doorY, 'door');
+            } catch (error) {
+                console.warn(`Failed to create door sprite with 'door' texture, creating colored rectangle instead:`, error);
+                // Create a colored rectangle as fallback
+                const graphics = gameRef.add.graphics();
+                graphics.fillStyle(0xff0000, 1); // Red color
+                graphics.fillRect(-TILE_SIZE/2, -TILE_SIZE, TILE_SIZE, TILE_SIZE * 2);
+                graphics.setPosition(doorX, doorY);
+                doorSprite = graphics;
+            }
+            doorSprite.setOrigin(0.5, 0.5);
+            doorSprite.setDepth(position.y * 100 + 1000); // Much higher depth to render on top
+            doorSprite.setAlpha(1); // Visible by default
+            doorSprite.setVisible(true); // Ensure visibility
+            
+            console.log(`Door sprite created:`, {
+                x: doorSprite.x,
+                y: doorSprite.y,
+                visible: doorSprite.visible,
+                alpha: doorSprite.alpha,
+                depth: doorSprite.depth,
+                texture: doorSprite.texture?.key,
+                width: doorSprite.width,
+                height: doorSprite.height,
+                displayWidth: doorSprite.displayWidth,
+                displayHeight: doorSprite.displayHeight
+            });
+            console.log(`Door depth: ${doorSprite.depth} (roomDepth: ${position.y * 100}, should be above all layers)`);
+            
+            // Set up door properties
+            doorSprite.doorProperties = {
+                roomId: roomId,
+                connectedRoom: connectedRoom,
+                direction: direction,
+                worldX: doorX,
+                worldY: doorY,
+                open: false,
+                locked: roomData.locked || false,
+                lockType: roomData.lockType || null,
+                requires: roomData.requires || null
+            };
+            
+            // Set up collision
+            gameRef.physics.add.existing(doorSprite);
+            doorSprite.body.setSize(doorWidth, doorHeight);
+            doorSprite.body.setImmovable(true);
+            
+            // Add collision with player
+            if (window.player && window.player.body) {
+                gameRef.physics.add.collider(window.player, doorSprite);
+            }
+            
+            // Set up interaction zone
+            const zone = gameRef.add.zone(doorX, doorY, doorWidth, doorHeight);
+            zone.setInteractive({ useHandCursor: true });
+            zone.on('pointerdown', () => handleDoorInteraction(doorSprite));
+            
+            doorSprite.interactionZone = zone;
+            doorSprites.push(doorSprite);
+            
+            console.log(`Created door sprite for ${roomId} -> ${connectedRoom} (${direction}) at (${doorX}, ${doorY})`);
+        });
+    });
+    
+    console.log(`Created ${doorSprites.length} door sprites for room ${roomId}`);
+    
+    // Log camera position for debugging
+    if (gameRef.cameras && gameRef.cameras.main) {
+        console.log(`Camera position:`, {
+            x: gameRef.cameras.main.scrollX,
+            y: gameRef.cameras.main.scrollY,
+            width: gameRef.cameras.main.width,
+            height: gameRef.cameras.main.height
+        });
+    }
+    
+    return doorSprites;
+}
+
+// Function to handle door interactions
+function handleDoorInteraction(doorSprite) {
+    const player = window.player;
+    if (!player) return;
+    
+    const distance = Phaser.Math.Distance.Between(
+        player.x, player.y,
+        doorSprite.x, doorSprite.y
+    );
+    
+    const DOOR_INTERACTION_RANGE = 2 * TILE_SIZE;
+    
+    if (distance > DOOR_INTERACTION_RANGE) {
+        console.log('Door too far to interact');
+        return;
+    }
+    
+    const props = doorSprite.doorProperties;
+    console.log(`Interacting with door: ${props.roomId} -> ${props.connectedRoom}`);
+    
+    if (props.locked) {
+        console.log(`Door is locked. Type: ${props.lockType}, Requires: ${props.requires}`);
+        // TODO: Implement lock checking logic based on lockType
+        // For now, just unlock if we have the required item
+        if (window.checkDoorUnlock && window.checkDoorUnlock(props)) {
+            unlockDoor(doorSprite);
+        } else {
+            console.log('Door unlock check failed');
+        }
+    } else {
+        openDoor(doorSprite);
+    }
+}
+
+// Function to unlock a door
+function unlockDoor(doorSprite) {
+    const props = doorSprite.doorProperties;
+    console.log(`Unlocking door: ${props.roomId} -> ${props.connectedRoom}`);
+    
+    // TODO: Implement unlock animation/effect
+    props.locked = false;
+    openDoor(doorSprite);
+}
+
+// Function to open a door
+function openDoor(doorSprite) {
+    const props = doorSprite.doorProperties;
+    console.log(`Opening door: ${props.roomId} -> ${props.connectedRoom}`);
+    
+    // Load the connected room if it doesn't exist
+    if (!rooms[props.connectedRoom]) {
+        console.log(`Loading room: ${props.connectedRoom}`);
+        loadRoom(props.connectedRoom);
+    }
+    
+    // Remove wall tiles from the connected room under the door position
+    removeWallTilesForDoorInRoom(props.connectedRoom, props.roomId, props.direction, doorSprite.x, doorSprite.y);
+    
+    // Remove the matching door sprite from the connected room
+    removeMatchingDoorSprite(props.connectedRoom, props.roomId, props.direction, doorSprite.x, doorSprite.y);
+    
+    // Create animated door sprite on the opposite side
+    createAnimatedDoorOnOppositeSide(props.connectedRoom, props.roomId, props.direction, doorSprite.x, doorSprite.y);
+    
+    // Remove the door sprite
+    doorSprite.destroy();
+    if (doorSprite.interactionZone) {
+        doorSprite.interactionZone.destroy();
+    }
+    
+    props.open = true;
+}
+
+// Function to remove the matching door sprite from the connected room
+function removeMatchingDoorSprite(roomId, fromRoomId, direction, doorWorldX, doorWorldY) {
+    console.log(`Removing matching door sprite in room ${roomId} for door from ${fromRoomId} (${direction})`);
+    
+    const room = rooms[roomId];
+    if (!room || !room.doorSprites) {
+        console.log(`No door sprites found for room ${roomId}`);
+        return;
+    }
+    
+    // Find the door sprite that connects to the fromRoomId
+    const matchingDoorSprite = room.doorSprites.find(doorSprite => {
+        const props = doorSprite.doorProperties;
+        return props && props.connectedRoom === fromRoomId;
+    });
+    
+    if (matchingDoorSprite) {
+        console.log(`Found matching door sprite in room ${roomId}, removing it`);
+        matchingDoorSprite.destroy();
+        if (matchingDoorSprite.interactionZone) {
+            matchingDoorSprite.interactionZone.destroy();
+        }
+        
+        // Remove from the doorSprites array
+        const index = room.doorSprites.indexOf(matchingDoorSprite);
+        if (index > -1) {
+            room.doorSprites.splice(index, 1);
+        }
+    } else {
+        console.log(`No matching door sprite found in room ${roomId}`);
+    }
+}
+
+// Function to create animated door sprite on the opposite side
+function createAnimatedDoorOnOppositeSide(roomId, fromRoomId, direction, doorWorldX, doorWorldY) {
+    console.log(`Creating animated door on opposite side in room ${roomId} for door from ${fromRoomId} (${direction}) at world position (${doorWorldX}, ${doorWorldY})`);
+    
+    const room = rooms[roomId];
+    if (!room) {
+        console.log(`Room ${roomId} not found, cannot create animated door`);
+        return;
+    }
+    
+    // Calculate the door position in the connected room
+    const oppositeDirection = getOppositeDirection(direction);
+    const roomPosition = window.roomPositions[roomId];
+    const roomData = window.gameScenario.rooms[roomId];
+    
+    if (!roomPosition || !roomData) {
+        console.log(`Missing position or data for room ${roomId}`);
+        return;
+    }
+    
+    // Get room dimensions from tilemap (same as door sprite creation)
+    const map = gameRef.cache.tilemap.get(roomData.type);
+    let roomWidth = 480, roomHeight = 432; // fallback
+    
+    if (map) {
+        if (map.json) {
+            roomWidth = map.json.width * 48;
+            roomHeight = map.json.height * 48;
+        } else if (map.data) {
+            roomWidth = map.data.width * 48;
+            roomHeight = map.data.height * 48;
+        }
+    }
+    
+    // Calculate door position in the connected room based on the opposite direction
+    let doorX, doorY, doorWidth, doorHeight;
+    
+    // Calculate door position based on the room's door configuration
+    if (direction === 'north' || direction === 'south') {
+        // For north/south connections, calculate X position based on room configuration
+        const connections = roomData.connections?.[oppositeDirection];
+        
+        if (Array.isArray(connections)) {
+            // Multiple doors - find the one that connects to fromRoomId
+            const doorIndex = connections.indexOf(fromRoomId);
+            if (doorIndex >= 0) {
+                const totalDoors = connections.length;
+                const availableWidth = roomWidth - (TILE_SIZE * 3); // 1.5 tiles from each edge
+                const doorSpacing = totalDoors > 1 ? availableWidth / (totalDoors - 1) : 0;
+                doorX = roomPosition.x + TILE_SIZE * 1.5 + (doorIndex * doorSpacing);
+            } else {
+                doorX = roomPosition.x + roomWidth / 2; // Default to center
+            }
+        } else {
+            // Single door - check if the connecting room has multiple doors
+            const connectingRoomConnections = window.gameScenario.rooms[fromRoomId]?.connections?.[direction];
+            if (Array.isArray(connectingRoomConnections) && connectingRoomConnections.length > 1) {
+                // The connecting room has multiple doors, find which one connects to this room
+                const doorIndex = connectingRoomConnections.indexOf(roomId);
+                if (doorIndex >= 0) {
+                    // When the connecting room has multiple doors, position this door to match
+                    // If this room is at index 0 (left), position door on the right (southeast)
+                    // If this room is at index 1 (right), position door on the left (southwest)
+                    if (doorIndex === 0) {
+                        // This room is on the left, so door should be on the right
+                        doorX = roomPosition.x + roomWidth - TILE_SIZE * 1.5;
+                        console.log(`Animated door positioning for ${roomId}: left room (index 0), door on right (southeast), calculated doorX=${doorX}`);
+                    } else {
+                        // This room is on the right, so door should be on the left
+                        doorX = roomPosition.x + TILE_SIZE * 1.5;
+                        console.log(`Animated door positioning for ${roomId}: right room (index ${doorIndex}), door on left (southwest), calculated doorX=${doorX}`);
+                    }
+                } else {
+                    // Fallback to left positioning
+                    doorX = roomPosition.x + TILE_SIZE * 1.5;
+                    console.log(`Animated door positioning for ${roomId}: fallback to left, calculated doorX=${doorX}`);
+                }
+            } else {
+                // Single door - use left positioning
+                doorX = roomPosition.x + TILE_SIZE * 1.5;
+                console.log(`Animated door positioning for ${roomId}: single connection to ${fromRoomId}, calculated doorX=${doorX}`);
+            }
+        }
+        
+        if (direction === 'north') {
+            // Original door is north, so new door should be south
+            doorY = roomPosition.y + roomHeight - TILE_SIZE;
+        } else {
+            // Original door is south, so new door should be north
+            doorY = roomPosition.y + TILE_SIZE;
+        }
+        doorWidth = TILE_SIZE * 2;
+        doorHeight = TILE_SIZE;
+    } else if (direction === 'east' || direction === 'west') {
+        // For east/west connections, calculate Y position based on room configuration
+        doorY = roomPosition.y + roomHeight / 2; // Center of room
+        if (direction === 'east') {
+            // Original door is east, so new door should be west
+            doorX = roomPosition.x + TILE_SIZE;
+        } else {
+            // Original door is west, so new door should be east
+            doorX = roomPosition.x + roomWidth - TILE_SIZE;
+        }
+        doorWidth = TILE_SIZE * 2;
+        doorHeight = TILE_SIZE;
+    } else {
+        console.log(`Unknown direction: ${direction}`);
+        return;
+    }
+    
+    // Create the animated door sprite
+    let animatedDoorSprite;
+    let doorTopSprite;
+    try {
+        // Create main door sprite
+        animatedDoorSprite = gameRef.add.sprite(doorX, doorY, 'door_sheet');
+        
+        // Set sprite properties
+        animatedDoorSprite.setOrigin(0.5, 0.5);
+        animatedDoorSprite.setDepth(roomPosition.y * 100 + 1000);
+        animatedDoorSprite.setVisible(true);
+        
+        // Play the opening animation
+        animatedDoorSprite.play('door_open');
+        
+        // Create door top sprite (6th frame) at high z-index
+        doorTopSprite = gameRef.add.sprite(doorX, doorY, 'door_sheet');
+        doorTopSprite.setOrigin(0.5, 0.5);
+        doorTopSprite.setDepth(roomPosition.y * 100 + 2000); // Higher z-index than main door
+        doorTopSprite.setVisible(true);
+        doorTopSprite.play('door_top');
+        
+        // Store references to the animated doors in the room
+        if (!room.animatedDoors) {
+            room.animatedDoors = [];
+        }
+        room.animatedDoors.push(animatedDoorSprite);
+        room.animatedDoors.push(doorTopSprite);
+        
+        console.log(`Created animated door sprite at (${doorX}, ${doorY}) in room ${roomId} with door top`);
+        
+    } catch (error) {
+        console.warn(`Failed to create animated door sprite:`, error);
+        // Fallback to a simple colored rectangle
+        const graphics = gameRef.add.graphics();
+        graphics.fillStyle(0x00ff00, 1); // Green color for open door
+        graphics.fillRect(-doorWidth/2, -doorHeight/2, doorWidth, doorHeight);
+        graphics.setPosition(doorX, doorY);
+        graphics.setDepth(roomPosition.y * 100 + 1000);
+        
+        if (!room.animatedDoors) {
+            room.animatedDoors = [];
+        }
+        room.animatedDoors.push(graphics);
+        
+        console.log(`Created fallback animated door at (${doorX}, ${doorY}) in room ${roomId}`);
+    }
+}
+
+// Function to load a room lazily
+function loadRoom(roomId) {
+    const gameScenario = window.gameScenario;
+    const roomData = gameScenario.rooms[roomId];
+    const position = window.roomPositions[roomId];
+    
+    if (!roomData || !position) {
+        console.error(`Cannot load room ${roomId}: missing data or position`);
+        return;
+    }
+    
+    console.log(`Lazy loading room: ${roomId}`);
+    createRoom(roomId, roomData, position);
+    revealRoom(roomId);
+}
+
+// Function to remove wall tiles under doors
+function removeTilesUnderDoor(wallLayer, roomId, position) {
+    console.log(`Removing wall tiles under doors in room ${roomId}`);
+
+    // Remove wall tiles under doors using the same positioning logic as door sprites
+    const gameScenario = window.gameScenario;
+    const roomData = gameScenario.rooms[roomId];
+    if (!roomData || !roomData.connections) {
+        console.log(`No connections found for room ${roomId}, skipping wall tile removal`);
+        return;
+    }
+    
+    // Get room dimensions for door positioning (same as door sprite creation)
+    const map = gameRef.cache.tilemap.get(roomData.type);
+    let roomWidth = 800, roomHeight = 600; // fallback
+    
+    if (map) {
+        if (map.json) {
+            roomWidth = map.json.width * 48;
+            roomHeight = map.json.height * 48;
+        } else if (map.data) {
+            roomWidth = map.data.width * 48;
+            roomHeight = map.data.height * 48;
+        }
+    }
+    
+    const connections = roomData.connections;
+    
+    // Process each connection direction
+    Object.entries(connections).forEach(([direction, connectedRooms]) => {
+        const roomList = Array.isArray(connectedRooms) ? connectedRooms : [connectedRooms];
+        
+        roomList.forEach((connectedRoom, index) => {
+            // Calculate door position using the same logic as door sprite creation
+            let doorX, doorY;
+            let doorWidth = TILE_SIZE, doorHeight = TILE_SIZE * 2;
+            
+            switch (direction) {
+                case 'north':
+                    if (roomList.length === 1) {
+                        // Single connection - check the connecting room's connections to determine position
+                        const connectingRoom = roomList[0];
+                        const connectingRoomConnections = window.gameScenario.rooms[connectingRoom]?.connections?.south;
+                        
+                        if (Array.isArray(connectingRoomConnections) && connectingRoomConnections.length > 1) {
+                            // The connecting room has multiple south doors, find which one connects to this room
+                            const doorIndex = connectingRoomConnections.indexOf(roomId);
+                            if (doorIndex >= 0) {
+                                // When the connecting room has multiple doors, position this door to match
+                                // If this room is at index 0 (left), position door on the right (southeast)
+                                // If this room is at index 1 (right), position door on the left (southwest)
+                                if (doorIndex === 0) {
+                                    // This room is on the left, so door should be on the right
+                                    doorX = position.x + roomWidth - TILE_SIZE * 1.5;
+                                } else {
+                                    // This room is on the right, so door should be on the left
+                                    doorX = position.x + TILE_SIZE * 1.5;
+                                }
+                            } else {
+                                // Fallback to left positioning
+                                doorX = position.x + TILE_SIZE * 1.5;
+                            }
+                        } else {
+                            // Single door - use left positioning
+                            doorX = position.x + TILE_SIZE * 1.5;
+                        }
+                    } else {
+                        // Multiple connections - use 1.5 tile spacing from edges
+                        const availableWidth = roomWidth - (TILE_SIZE * 1.5 * 2); // Subtract edge spacing
+                        const doorSpacing = availableWidth / (roomList.length - 1); // Space between doors
+                        doorX = position.x + TILE_SIZE * 1.5 + (doorSpacing * index); // Start at 1.5 tiles from edge
+                    }
+                    doorY = position.y + TILE_SIZE;
+                    break;
+                case 'south':
+                    if (roomList.length === 1) {
+                        // Single connection - check if the connecting room has multiple doors
+                        const connectingRoom = roomList[0];
+                        const connectingRoomConnections = window.gameScenario.rooms[connectingRoom]?.connections?.north;
+                        if (Array.isArray(connectingRoomConnections) && connectingRoomConnections.length > 1) {
+                            // The connecting room has multiple north doors, find which one connects to this room
+                            const doorIndex = connectingRoomConnections.indexOf(roomId);
+                            if (doorIndex >= 0) {
+                                // When the connecting room has multiple doors, position this door to match
+                                // If this room is at index 0 (left), position door on the right (southeast)
+                                // If this room is at index 1 (right), position door on the left (southwest)
+                                if (doorIndex === 0) {
+                                    // This room is on the left, so door should be on the right
+                                    doorX = position.x + roomWidth - TILE_SIZE * 1.5;
+                                } else {
+                                    // This room is on the right, so door should be on the left
+                                    doorX = position.x + TILE_SIZE * 1.5;
+                                }
+                            } else {
+                                // Fallback to left positioning
+                                doorX = position.x + TILE_SIZE * 1.5;
+                            }
+                        } else {
+                            // Single door - use left positioning
+                            doorX = position.x + TILE_SIZE * 1.5;
+                        }
+                    } else {
+                        // Multiple connections - use 1.5 tile spacing from edges
+                        const availableWidth = roomWidth - (TILE_SIZE * 1.5 * 2); // Subtract edge spacing
+                        const doorSpacing = availableWidth / (roomList.length - 1); // Space between doors
+                        doorX = position.x + TILE_SIZE * 1.5 + (doorSpacing * index); // Start at 1.5 tiles from edge
+                    }
+                    doorY = position.y + roomHeight - TILE_SIZE;
+                    break;
+                case 'east':
+                    doorX = position.x + roomWidth - TILE_SIZE;
+                    doorY = position.y + roomHeight / 2;
+                    doorWidth = TILE_SIZE * 2;
+                    doorHeight = TILE_SIZE;
+                    break;
+                case 'west':
+                    doorX = position.x + TILE_SIZE;
+                    doorY = position.y + roomHeight / 2;
+                    doorWidth = TILE_SIZE * 2;
+                    doorHeight = TILE_SIZE;
+                    break;
+                default:
+                    return;
+            }
+            
+            // Use Phaser's getTilesWithin to get tiles that overlap with the door area
+            const doorBounds = {
+                x: doorX - (doorWidth / 2), // Door sprite origin is center, so adjust bounds
+                y: doorY - (doorHeight / 2),
+                width: doorWidth,
+                height: doorHeight
+            };
+            
+            // Convert door bounds to tilemap coordinates (relative to the layer)
+            const doorBoundsInTilemap = {
+                x: doorBounds.x - wallLayer.x,
+                y: doorBounds.y - wallLayer.y,
+                width: doorBounds.width,
+                height: doorBounds.height
+            };
+            
+            console.log(`Removing wall tiles for ${roomId} -> ${connectedRoom} (${direction}): door at (${doorX}, ${doorY}), world bounds:`, doorBounds, `tilemap bounds:`, doorBoundsInTilemap);
+            console.log(`Wall layer info: x=${wallLayer.x}, y=${wallLayer.y}, width=${wallLayer.width}, height=${wallLayer.height}`);
+            
+            // Try a different approach - convert to tile coordinates first
+            const doorTileX = Math.floor(doorBoundsInTilemap.x / TILE_SIZE);
+            const doorTileY = Math.floor(doorBoundsInTilemap.y / TILE_SIZE);
+            const doorTilesWide = Math.ceil(doorBoundsInTilemap.width / TILE_SIZE);
+            const doorTilesHigh = Math.ceil(doorBoundsInTilemap.height / TILE_SIZE);
+            
+            console.log(`Door tile coordinates: (${doorTileX}, ${doorTileY}) covering ${doorTilesWide}x${doorTilesHigh} tiles`);
+            
+            // Check what tiles exist in the door area manually
+            let foundTiles = [];
+            for (let x = 0; x < doorTilesWide; x++) {
+                for (let y = 0; y < doorTilesHigh; y++) {
+                    const tileX = doorTileX + x;
+                    const tileY = doorTileY + y;
+                    const tile = wallLayer.getTileAt(tileX, tileY);
+                    if (tile && tile.index !== -1) {
+                        foundTiles.push({x: tileX, y: tileY, tile: tile});
+                        console.log(`Found wall tile at (${tileX}, ${tileY}) with index ${tile.index}`);
+                    }
+                }
+            }
+            
+            console.log(`Manually found ${foundTiles.length} wall tiles in door area`);
+            
+            // Get all tiles within the door bounds (using tilemap coordinates)
+            const overlappingTiles = wallLayer.getTilesWithin(
+                doorBoundsInTilemap.x,
+                doorBoundsInTilemap.y,
+                doorBoundsInTilemap.width,
+                doorBoundsInTilemap.height
+            );
+            
+            console.log(`getTilesWithin found ${overlappingTiles.length} tiles overlapping with door area`);
+            
+            // Use the manually found tiles if getTilesWithin didn't work
+            const tilesToRemove = foundTiles.length > 0 ? foundTiles : overlappingTiles;
+            
+            // Remove wall tiles that overlap with the door
+            tilesToRemove.forEach(tileData => {
+                const tileX = tileData.x;
+                const tileY = tileData.y;
+                
+                // Remove the wall tile
+                const removedTile = wallLayer.tilemap.removeTileAt(
+                    tileX,
+                    tileY,
+                    true,  // replaceWithNull
+                    true,  // recalculateFaces
+                    wallLayer  // layer
+                );
+                
+                if (removedTile) {
+                    console.log(`Removed wall tile at (${tileX}, ${tileY}) under door ${roomId} -> ${connectedRoom}`);
+                }
+            });
+            
+            // Recalculate collision after removing tiles
+            if (tilesToRemove.length > 0) {
+                console.log(`Recalculating collision for wall layer in ${roomId} after removing ${tilesToRemove.length} tiles`);
+                wallLayer.setCollisionByExclusion([-1]);
+            }
+        });
+    });
+    
+    // // Convert door world position to tile coordinates
+    // const doorTileX = Math.floor((doorPos.x - wallLayer.x) / TILE_SIZE);
+    // const doorTileY = Math.floor((doorPos.y - wallLayer.y) / TILE_SIZE);
+    
+    // // Calculate how many tiles the door covers
+    // const doorTilesWide = Math.ceil(doorPos.width / TILE_SIZE);
+    // const doorTilesHigh = Math.ceil(doorPos.height / TILE_SIZE);
+    
+    // console.log(`Door covers ${doorTilesWide}x${doorTilesHigh} tiles at tile position (${doorTileX}, ${doorTileY})`);
+    
+    // // Remove wall tiles in the door area
+    // for (let x = 0; x < doorTilesWide; x++) {
+    //     for (let y = 0; y < doorTilesHigh; y++) {
+    //         const tileX = doorTileX + x;
+    //         const tileY = doorTileY + y;
+            
+    //         // Check if there's a wall tile at this position
+    //         const wallTile = wallLayer.getTileAt(tileX, tileY);
+    //         if (wallTile && wallTile.index !== -1) {
+    //             // Remove the wall tile
+    //             const removedTile = wallLayer.tilemap.removeTileAt(
+    //                 tileX,
+    //                 tileY,
+    //                 true,  // replaceWithNull
+    //                 true,  // recalculateFaces
+    //                 wallLayer  // layer
+    //             );
+                
+    //             if (removedTile) {
+    //                 console.log(`Removed wall tile at (${tileX}, ${tileY}) under door in room ${roomId}`);
+    //             }
+    //         }
+    //     }
+    // }
+}
+
+// Function to remove wall tiles from a specific room for a door connection
+function removeWallTilesForDoorInRoom(roomId, fromRoomId, direction, doorWorldX, doorWorldY) {
+    console.log(`Removing wall tiles in room ${roomId} for door from ${fromRoomId} (${direction}) at world position (${doorWorldX}, ${doorWorldY})`);
+    
+    const room = rooms[roomId];
+    if (!room || !room.wallsLayers || room.wallsLayers.length === 0) {
+        console.log(`No wall layers found for room ${roomId}`);
+        return;
+    }
+    
+    // Calculate the door position in the connected room
+    // The door should be on the opposite side of the connection
+    const oppositeDirection = getOppositeDirection(direction);
+    const roomPosition = window.roomPositions[roomId];
+    const roomData = window.gameScenario.rooms[roomId];
+    
+    if (!roomPosition || !roomData) {
+        console.log(`Missing position or data for room ${roomId}`);
+        return;
+    }
+    
+    // Get room dimensions
+    const roomWidth = roomData.width || 480;
+    const roomHeight = roomData.height || 432;
+    
+    // Calculate door position in the connected room based on the opposite direction
+    let doorX, doorY, doorWidth, doorHeight;
+    
+    // Calculate door position based on the room's door configuration
+    if (direction === 'north' || direction === 'south') {
+        // For north/south connections, calculate X position based on room configuration
+        const oppositeDirection = getOppositeDirection(direction);
+        const connections = roomData.connections?.[oppositeDirection];
+        
+        if (Array.isArray(connections)) {
+            // Multiple doors - find the one that connects to fromRoomId
+            const doorIndex = connections.indexOf(fromRoomId);
+            if (doorIndex >= 0) {
+                const totalDoors = connections.length;
+                const availableWidth = roomWidth - (TILE_SIZE * 3); // 1.5 tiles from each edge
+                const doorSpacing = totalDoors > 1 ? availableWidth / (totalDoors - 1) : 0;
+                doorX = roomPosition.x + TILE_SIZE * 1.5 + (doorIndex * doorSpacing);
+            } else {
+                doorX = roomPosition.x + roomWidth / 2; // Default to center
+            }
+        } else {
+            // Single door - check if the connecting room has multiple doors
+            const connectingRoomConnections = window.gameScenario.rooms[fromRoomId]?.connections?.[direction];
+            if (Array.isArray(connectingRoomConnections) && connectingRoomConnections.length > 1) {
+                // The connecting room has multiple doors, find which one connects to this room
+                const doorIndex = connectingRoomConnections.indexOf(roomId);
+                if (doorIndex >= 0) {
+                    // When the connecting room has multiple doors, position this door to match
+                    // If this room is at index 0 (left), position door on the right (southeast)
+                    // If this room is at index 1 (right), position door on the left (southwest)
+                    if (doorIndex === 0) {
+                        // This room is on the left, so door should be on the right
+                        doorX = roomPosition.x + roomWidth - TILE_SIZE * 1.5;
+                        console.log(`Wall tile removal door positioning for ${roomId}: left room (index 0), door on right (southeast), calculated doorX=${doorX}`);
+                    } else {
+                        // This room is on the right, so door should be on the left
+                        doorX = roomPosition.x + TILE_SIZE * 1.5;
+                        console.log(`Wall tile removal door positioning for ${roomId}: right room (index ${doorIndex}), door on left (southwest), calculated doorX=${doorX}`);
+                    }
+                } else {
+                    // Fallback to left positioning
+                    doorX = roomPosition.x + TILE_SIZE * 1.5;
+                    console.log(`Wall tile removal door positioning for ${roomId}: fallback to left, calculated doorX=${doorX}`);
+                }
+            } else {
+                // Single door - use left positioning
+                doorX = roomPosition.x + TILE_SIZE * 1.5;
+                console.log(`Wall tile removal door positioning for ${roomId}: single connection to ${fromRoomId}, calculated doorX=${doorX}`);
+            }
+        }
+        
+        if (direction === 'north') {
+            // Original door is north, so new door should be south
+            doorY = roomPosition.y + roomHeight - TILE_SIZE;
+        } else {
+            // Original door is south, so new door should be north
+            doorY = roomPosition.y + TILE_SIZE;
+        }
+        doorWidth = TILE_SIZE * 2;
+        doorHeight = TILE_SIZE;
+    } else if (direction === 'east' || direction === 'west') {
+        // For east/west connections, calculate Y position based on room configuration
+        doorY = roomPosition.y + roomHeight / 2; // Center of room
+        if (direction === 'east') {
+            // Original door is east, so new door should be west
+            doorX = roomPosition.x + TILE_SIZE;
+        } else {
+            // Original door is west, so new door should be east
+            doorX = roomPosition.x + roomWidth - TILE_SIZE;
+        }
+        doorWidth = TILE_SIZE;
+        doorHeight = TILE_SIZE * 2;
+    } else {
+        console.log(`Unknown direction: ${direction}`);
+        return;
+    }
+    
+    // For debugging: Calculate what the door position should be based on room dimensions
+    const expectedSouthDoorY = roomPosition.y + roomHeight - TILE_SIZE;
+    const expectedNorthDoorY = roomPosition.y + TILE_SIZE;
+    console.log(`Expected door positions for ${roomId}: north=${expectedNorthDoorY}, south=${expectedSouthDoorY}`);
+    
+    // Debug: Log the room position and calculated door position
+    console.log(`Room ${roomId} position: (${roomPosition.x}, ${roomPosition.y}), dimensions: ${roomWidth}x${roomHeight}`);
+    console.log(`Original door at (${doorWorldX}, ${doorWorldY}), calculated door at (${doorX}, ${doorY})`);
+    console.log(`Direction: ${direction}, oppositeDirection: ${getOppositeDirection(direction)}`);
+    console.log(`Room connections:`, roomData.connections);
+    
+
+    
+    console.log(`Calculated door position in ${roomId}: (${doorX}, ${doorY}) for ${oppositeDirection} connection`);
+    
+    // Remove wall tiles from all wall layers in this room
+    room.wallsLayers.forEach(wallLayer => {
+        // Calculate door bounds
+        // For north/south doors, the door sprite origin is at the center, but we need to adjust for the actual door position
+        let doorBounds;
+        if (oppositeDirection === 'north' || oppositeDirection === 'south') {
+            // For north/south doors, the door should cover the full width and be positioned at the edge
+            doorBounds = {
+                x: doorX - (doorWidth / 2),
+                y: doorY, // Don't subtract half height - the door is positioned at the edge
+                width: doorWidth,
+                height: doorHeight
+            };
+        } else {
+            // For east/west doors, use center positioning
+            doorBounds = {
+                x: doorX - (doorWidth / 2),
+                y: doorY - (doorHeight / 2),
+                width: doorWidth,
+                height: doorHeight
+            };
+        }
+        
+        // For debugging: Show the door sprite dimensions and bounds
+        console.log(`Door sprite at (${doorX}, ${doorY}) with dimensions ${doorWidth}x${doorHeight}`);
+        console.log(`Door bounds: x=${doorBounds.x}, y=${doorBounds.y}, width=${doorBounds.width}, height=${doorBounds.height}`);
+        
+        // Convert door bounds to tilemap coordinates
+        const doorBoundsInTilemap = {
+            x: doorBounds.x - wallLayer.x,
+            y: doorBounds.y - wallLayer.y,
+            width: doorBounds.width,
+            height: doorBounds.height
+        };
+        
+        console.log(`Removing wall tiles in ${roomId} for ${oppositeDirection} door: world bounds:`, doorBounds, `tilemap bounds:`, doorBoundsInTilemap);
+        console.log(`Wall layer position: (${wallLayer.x}, ${wallLayer.y}), size: ${wallLayer.width}x${wallLayer.height}`);
+        console.log(`Room position: (${roomPosition.x}, ${roomPosition.y}), door position: (${doorX}, ${doorY})`);
+        
+        // Convert to tile coordinates
+        const doorTileX = Math.floor(doorBoundsInTilemap.x / TILE_SIZE);
+        const doorTileY = Math.floor(doorBoundsInTilemap.y / TILE_SIZE);
+        const doorTilesWide = Math.ceil(doorBoundsInTilemap.width / TILE_SIZE);
+        const doorTilesHigh = Math.ceil(doorBoundsInTilemap.height / TILE_SIZE);
+        
+        console.log(`Expected tile Y: ${Math.floor((doorY - roomPosition.y) / TILE_SIZE)}, actual tile Y: ${doorTileY}`);
+        
+        console.log(`Door tile coordinates in ${roomId}: (${doorTileX}, ${doorTileY}) covering ${doorTilesWide}x${doorTilesHigh} tiles`);
+        
+        // Check what tiles exist in the door area manually
+        let foundTiles = [];
+        for (let x = 0; x < doorTilesWide; x++) {
+            for (let y = 0; y < doorTilesHigh; y++) {
+                const tileX = doorTileX + x;
+                const tileY = doorTileY + y;
+                const tile = wallLayer.getTileAt(tileX, tileY);
+                if (tile && tile.index !== -1) {
+                    foundTiles.push({x: tileX, y: tileY, tile: tile});
+                    console.log(`Found wall tile at (${tileX}, ${tileY}) with index ${tile.index} in ${roomId}`);
+                }
+            }
+        }
+        
+        console.log(`Manually found ${foundTiles.length} wall tiles in door area in ${roomId}`);
+        
+        // Remove wall tiles that overlap with the door
+        foundTiles.forEach(tileData => {
+            const tileX = tileData.x;
+            const tileY = tileData.y;
+            
+            // Remove the wall tile
+            const removedTile = wallLayer.tilemap.removeTileAt(
+                tileX,
+                tileY,
+                true,  // replaceWithNull
+                true,  // recalculateFaces
+                wallLayer  // layer
+            );
+            
+            if (removedTile) {
+                console.log(`Removed wall tile at (${tileX}, ${tileY}) under door in ${roomId}`);
+            }
+        });
+        
+        // Recalculate collision after removing tiles
+        if (foundTiles.length > 0) {
+            console.log(`Recalculating collision for wall layer in ${roomId} after removing ${foundTiles.length} tiles`);
+            wallLayer.setCollisionByExclusion([-1]);
+        }
+    });
+}
+
+// Helper function to get the opposite direction
+function getOppositeDirection(direction) {
+    switch (direction) {
+        case 'north': return 'south';
+        case 'south': return 'north';
+        case 'east': return 'west';
+        case 'west': return 'east';
+        default: return direction;
+    }
+}
+
+// Function to remove wall tiles from all overlapping room layers at a world position
+function removeWallTilesAtWorldPosition(worldX, worldY, debugInfo = '') {
+    console.log(`Removing wall tiles at world position (${worldX}, ${worldY}) - ${debugInfo}`);
+    
+    // Find all rooms and their wall layers that could contain this world position
+        Object.entries(rooms).forEach(([roomId, room]) => {
+        if (!room.wallsLayers || room.wallsLayers.length === 0) return;
+        
+        room.wallsLayers.forEach(wallLayer => {
+            try {
+                // Convert world coordinates to tile coordinates for this layer
+                const tileX = Math.floor((worldX - room.position.x) / 48);
+                const tileY = Math.floor((worldY - room.position.y) / 48);
+                
+                // Check if the tile coordinates are within the layer bounds
+                const wallTile = wallLayer.getTileAt(tileX, tileY);
+                if (wallTile && wallTile.index !== -1) {
+                    // Remove the wall tile using the map's removeTileAt method
+                    const removedTile = room.map.removeTileAt(
+                        tileX,
+                        tileY,
+                        true,  // replaceWithNull
+                        true,  // recalculateFaces
+                        wallLayer  // layer
+                    );
+                    
+                    if (removedTile) {
+                        console.log(`  Removed wall tile at (${tileX},${tileY}) from room ${roomId} layer ${wallLayer.name}`);
+                    }
+                } else {
+                    console.log(`  No wall tile found at (${tileX},${tileY}) in room ${roomId} layer ${wallLayer.name || 'unnamed'}`);
+                }
+            } catch (error) {
+                console.warn(`Error removing wall tile from room ${roomId}:`, error);
+            }
+        });
+    });
+}
+
 export function initializeRooms(gameInstance) {
     gameRef = gameInstance;
     console.log('Initializing rooms');
@@ -25,67 +1047,17 @@ export function initializeRooms(gameInstance) {
     currentPlayerRoom = '';
     window.currentPlayerRoom = '';
     discoveredRooms = new Set();
+    // Update global reference
+    window.discoveredRooms = discoveredRooms;
+    
+    // Calculate room positions for lazy loading
+    window.roomPositions = calculateRoomPositions(gameInstance);
+    console.log('Room positions calculated for lazy loading');
 }
 
-// Validate doors by room overlap
+// Door validation is now handled by the sprite-based door system
 export function validateDoorsByRoomOverlap() {
-    console.log('Validating doors by room overlap');
-    
-    const doorTiles = [];
-    
-    // Collect all door tiles from all rooms
-    Object.entries(rooms).forEach(([roomId, room]) => {
-        if (room.doorsLayer) {
-            const roomDoorTiles = room.doorsLayer.getTilesWithin()
-                .filter(tile => tile.index !== -1);
-            roomDoorTiles.forEach(doorTile => {
-                const worldX = room.doorsLayer.x + (doorTile.x * room.doorsLayer.tilemap.tileWidth);
-                const worldY = room.doorsLayer.y + (doorTile.y * room.doorsLayer.tilemap.tileHeight);
-                
-                doorTiles.push({
-                    tile: doorTile,
-                    worldX,
-                    worldY,
-                    roomId,
-                    layer: room.doorsLayer
-                });
-            });
-        }
-    });
-    
-    // Check each door against all rooms
-    doorTiles.forEach(doorInfo => {
-        const overlappingRooms = [];
-        
-        Object.entries(rooms).forEach(([roomId, room]) => {
-            const roomBounds = {
-                x: room.position.x,
-                y: room.position.y,
-                width: 800,  // Assuming standard room size
-                height: 600
-            };
-            
-            // Check if door overlaps with this room
-            if (doorInfo.worldX >= roomBounds.x && 
-                doorInfo.worldX < roomBounds.x + roomBounds.width &&
-                doorInfo.worldY >= roomBounds.y && 
-                doorInfo.worldY < roomBounds.y + roomBounds.height) {
-                overlappingRooms.push(roomId);
-            }
-        });
-        
-        console.log(`Door at (${doorInfo.worldX}, ${doorInfo.worldY}) overlaps with room ${overlappingRooms.join(', ')}`);
-        
-        if (overlappingRooms.length === 2) {
-            // Valid door - connects two rooms
-            const doorLocked = doorInfo.tile.properties?.locked;
-            console.log(`Door at (${doorInfo.worldX}, ${doorInfo.worldY}) marked as locked:`, doorLocked);
-        } else if (overlappingRooms.length === 1) {
-            // Invalid door - only overlaps one room, remove it
-            console.log(`Removing door at (${doorInfo.worldX}, ${doorInfo.worldY}) - overlaps ${overlappingRooms.length} rooms`);
-            doorInfo.tile.index = -1;
-        }
-    });
+    console.log('Door validation is now handled by the sprite-based door system');
 }
 
 // Calculate world bounds
@@ -331,43 +1303,26 @@ export function createRoom(roomId, roomData, position) {
         // Calculate base depth for this room's layers
         const roomDepth = position.y * 100;
         
-        // Create doors layer first with a specific depth
-        const doorsLayerIndex = map.layers.findIndex(layer => 
-            layer.name.toLowerCase().includes('doors'));
-        let doorsLayer = null;
-        if (doorsLayerIndex !== -1) {
-            window.globalLayerCounter++;
-            const uniqueDoorsId = `${roomId}_doors_${window.globalLayerCounter}`;
-            doorsLayer = map.createLayer(doorsLayerIndex, tilesets, position.x, position.y);
-            if (doorsLayer) {
-                doorsLayer.name = uniqueDoorsId;
-                // Set doors layer depth higher than other layers
-                doorsLayer.setDepth(roomDepth + 500);
-                layers[uniqueDoorsId] = doorsLayer;
-                rooms[roomId].doorsLayer = doorsLayer;
-                
-                // Apply room-level locking to door tiles
-                if (roomData.locked) {
-                    console.log(`Applying lock to doors in room ${roomId}`);
-                    const doorTiles = doorsLayer.getTilesWithin().filter(tile => tile.index !== -1);
-                    doorTiles.forEach(doorTile => {
-                        if (!doorTile.properties) {
-                            doorTile.properties = {};
-                        }
-                        doorTile.properties.locked = true;
-                        doorTile.properties.lockType = roomData.lockType || 'key';
-                        doorTile.properties.requires = roomData.requires || '';
-                        doorTile.properties.difficulty = roomData.difficulty || 'medium';
-                        console.log(`Door tile locked:`, doorTile.properties);
-                    });
-                }
-            }
-        }
+        // Create door sprites based on gameScenario connections
+        const doorSprites = createDoorSpritesForRoom(roomId, position);
+        rooms[roomId].doorSprites = doorSprites;
+        console.log(`Stored ${doorSprites.length} door sprites in room ${roomId}`);
+        
+        // Store door positions for wall tile removal
+        const doorPositions = doorSprites.map(doorSprite => ({
+            x: doorSprite.x,
+            y: doorSprite.y,
+            width: doorSprite.body ? doorSprite.body.width : TILE_SIZE,
+            height: doorSprite.body ? doorSprite.body.height : TILE_SIZE * 2
+        }));
 
         // Create other layers with appropriate depths
         map.layers.forEach((layerData, index) => {
-            // Skip the doors layer as we already created it
-            if (index === doorsLayerIndex) return;
+            // Skip the doors layer since we're using sprite-based doors
+            if (layerData.name.toLowerCase().includes('doors')) {
+                console.log(`Skipping doors layer: ${layerData.name} in room ${roomId}`);
+                return;
+            }
 
             window.globalLayerCounter++;
             const uniqueLayerId = `${roomId}_${layerData.name}_${window.globalLayerCounter}`;
@@ -375,33 +1330,25 @@ export function createRoom(roomId, roomData, position) {
             const layer = map.createLayer(index, tilesets, position.x, position.y);
             if (layer) {
                 layer.name = uniqueLayerId;
+                // remove tiles under doors
+                removeTilesUnderDoor(layer, roomId, position);
+
                 
                 // Set depth based on layer type and room position
                 if (layerData.name.toLowerCase().includes('floor')) {
                     layer.setDepth(roomDepth + 100);
+                    console.log(`Floor layer depth: ${roomDepth + 100}`);
                 } else if (layerData.name.toLowerCase().includes('walls')) {
                     layer.setDepth(roomDepth + 200);
-                    // Handle walls layer collision
+                    console.log(`Wall layer depth: ${roomDepth + 200}`);
+                    
+                    // Remove wall tiles under doors
+                    removeTilesUnderDoor(layer, roomId, position);
+                    
+                    // Set up wall layer collisions
                     try {
                         layer.setCollisionByExclusion([-1]);
-                        
-                        if (doorsLayer) {
-                            const doorTiles = doorsLayer.getTilesWithin()
-                                .filter(tile => tile.index !== -1);
-                            
-                            doorTiles.forEach(doorTile => {
-                                const wallTile = layer.getTileAt(doorTile.x, doorTile.y);
-                                if (wallTile) {
-                                    if (doorTile.properties?.locked) {
-                                        wallTile.setCollision(true);
-                                        console.log(`Door tile at (${doorTile.x},${doorTile.y}) set to collision: locked`);
-                                    } else {
-                                        wallTile.setCollision(false);
-                                        console.log(`Door tile at (${doorTile.x},${doorTile.y}) set to collision: false (unlocked)`);
-                                    }
-                                }
-                            });
-                        }
+                        console.log(`Wall layer ${uniqueLayerId} collision enabled for room ${roomId}`);
                         
                         wallsLayers.push(layer);
                         console.log(`Added collision to wall layer: ${uniqueLayerId}`);
@@ -415,10 +1362,30 @@ export function createRoom(roomId, roomData, position) {
                     } catch (e) {
                         console.warn(`Error setting up collisions for ${uniqueLayerId}:`, e);
                     }
+                } else if (layerData.name.toLowerCase().includes('collision')) {
+                    layer.setDepth(roomDepth + 150);
+                    console.log(`Collision layer depth: ${roomDepth + 150}`);
+                    
+                    // Set up collision layer
+                    try {
+                        layer.setCollisionByExclusion([-1]);
+                        console.log(`Collision layer ${uniqueLayerId} enabled for room ${roomId}`);
+                        
+                        // Add collision with player
+                        const player = window.player;
+                        if (player && player.body) {
+                            gameRef.physics.add.collider(player, layer);
+                            console.log(`Added collision between player and collision layer: ${uniqueLayerId}`);
+                        }
+                    } catch (e) {
+                        console.warn(`Error setting up collision layer ${uniqueLayerId}:`, e);
+                    }
                 } else if (layerData.name.toLowerCase().includes('props')) {
                     layer.setDepth(roomDepth + 300);
+                    console.log(`Props layer depth: ${roomDepth + 300}`);
                 } else {
                     layer.setDepth(roomDepth + 400);
+                    console.log(`Other layer depth: ${roomDepth + 400}`);
                 }
                 
                 layers[uniqueLayerId] = layer;
@@ -431,6 +1398,40 @@ export function createRoom(roomId, roomData, position) {
         const objectsLayer = map.getObjectLayer('Object Layer 1');
         console.log(`Object layer found for room ${roomId}:`, objectsLayer ? `${objectsLayer.objects.length} objects` : 'No objects layer');
         if (objectsLayer) {
+            
+            // Handle collision objects
+            objectsLayer.objects.forEach(obj => {
+                if (obj.name.toLowerCase().includes('collision') || obj.type === 'collision') {
+                    console.log(`Creating collision object: ${obj.name} at (${obj.x}, ${obj.y})`);
+                    
+                    // Create invisible collision body
+                    const collisionBody = gameRef.add.rectangle(
+                        position.x + obj.x + obj.width/2,
+                        position.y + obj.y + obj.height/2,
+                        obj.width,
+                        obj.height
+                    );
+                    
+                    // Make it invisible but with collision
+                    collisionBody.setVisible(false);
+                    collisionBody.setAlpha(0);
+                    gameRef.physics.add.existing(collisionBody, true);
+                    
+                    // Add collision with player
+                    const player = window.player;
+                    if (player && player.body) {
+                        gameRef.physics.add.collider(player, collisionBody);
+                        console.log(`Added collision object: ${obj.name}`);
+                    }
+                    
+                    // Store collision body in room for cleanup
+                    if (!room.collisionBodies) {
+                        room.collisionBodies = [];
+                    }
+                    room.collisionBodies.push(collisionBody);
+                }
+            });
+            
             // Create a map of room objects by type for easy lookup
             const roomObjectsByType = {};
             objectsLayer.objects.forEach(obj => {
@@ -503,7 +1504,18 @@ export function createRoom(roomId, roomData, position) {
                     sprite.name = objType;  // Keep name as the object type for texture loading
                     sprite.objectId = objectId;  // Use our simplified ID format
                     sprite.setInteractive({ useHandCursor: true });
-                    sprite.setDepth(1001);
+                    
+                    // Set dynamic depth based on the bottom of the object sprite for proper layering
+                    const objectBottomY = sprite.y + (sprite.height * sprite.scaleY); // Bottom of the sprite
+                    const roomDepth = Math.floor(objectBottomY / 100) * 100;
+                    const objectDepth = roomDepth + 500; // Objects above all room tiles (floor:100, collision:150, walls:200, props:300, other:400)
+                    sprite.setDepth(objectDepth);
+                    
+                    // Debug logging with more detail
+                    console.log(`Object ${objectId} depth: ${objectDepth} (Y: ${sprite.y}, BottomY: ${objectBottomY}, RoomDepth: ${roomDepth})`);
+                    console.log(`  Room position: (${position.x}, ${position.y}), Object world position: (${sprite.x}, ${sprite.y})`);
+                    console.log(`  Object should be above room tiles (max depth: ${roomDepth + 400})`);
+                    
                     sprite.originalAlpha = 1;
                     sprite.active = true;
                     
@@ -547,15 +1559,15 @@ export function revealRoom(roomId) {
             }
         });
         
-        // Explicitly reveal doors layer if it exists
-        if (room.doorsLayer) {
-            room.doorsLayer.setVisible(true);
-            room.doorsLayer.setAlpha(1);
+        // Show door sprites for this room
+        if (room.doorSprites) {
+            room.doorSprites.forEach(doorSprite => {
+                doorSprite.setVisible(true);
+                doorSprite.setAlpha(1);
+                console.log(`Made door sprite visible for room ${roomId}`);
+            });
         }
         
-        // Update visibility of doors from other rooms that overlap with this room
-        updateDoorsVisibility();
-        
         // Show all objects
         if (room.objects) {
             console.log(`Revealing ${Object.keys(room.objects).length} objects in room ${roomId}`);
@@ -571,6 +1583,8 @@ export function revealRoom(roomId) {
         }
         
         discoveredRooms.add(roomId);
+        // Update global reference
+        window.discoveredRooms = discoveredRooms;
     }
     currentRoom = roomId;
 }
@@ -616,11 +1630,32 @@ export function updatePlayerRoom() {
         console.log(`Player's main room changed to: ${overlappingRooms[0]}`);
         currentPlayerRoom = overlappingRooms[0];
         window.currentPlayerRoom = overlappingRooms[0];
+        
+        // Update player depth for the new room
+        updatePlayerDepthForRoom(overlappingRooms[0]);
     }
     
     return currentPlayerRoom;
 }
 
+// Function to update player depth when entering a room
+export function updatePlayerDepthForRoom(roomId) {
+    const player = window.player;
+    if (!player) return;
+    
+    // Use the same depth calculation as objects for consistent z-index behavior
+    const playerBottomY = player.y + (player.height * player.scaleY) / 2;
+    const roomDepth = Math.floor(playerBottomY / 50) * 50; // Use 50-pixel boundaries for finer granularity
+    const playerDepth = roomDepth + 500; // Same as objects - above all room layers
+    
+    // Update player depth
+    player.setDepth(playerDepth);
+    
+    console.log(`Updated player depth for room ${roomId}: ${playerDepth} (RoomDepth: ${roomDepth})`);
+    console.log(`  Player uses same depth calculation as objects: roomDepth + 500`);
+    console.log(`  Room layer depths: floor=${roomDepth + 100}, collision=${roomDepth + 150}, walls=${roomDepth + 200}, props=${roomDepth + 300}, other=${roomDepth + 400}`);
+}
+
 // Helper function to check if player properly overlaps with room bounds
 function isPlayerInBounds(player, bounds) {
     // Use the player's physics body bounds for more precise detection
@@ -654,26 +1689,27 @@ function isPlayerInBounds(player, bounds) {
 
 
 
-// Update doors visibility based on which rooms are revealed
-function updateDoorsVisibility() {
-    // Check all rooms for doors
+// Update door sprites visibility based on which rooms are revealed
+function updateDoorSpritesVisibility() {
+    const discoveredRooms = window.discoveredRooms || new Set();
+    console.log(`updateDoorSpritesVisibility called. Discovered rooms:`, Array.from(discoveredRooms));
+    
     Object.entries(rooms).forEach(([roomId, room]) => {
-        if (!room.doorsLayer) return;
+        if (!room.doorSprites) return;
         
-        const doorTiles = room.doorsLayer.getTilesWithin().filter(tile => tile.index !== -1);
-        
-        doorTiles.forEach(doorTile => {
-            const doorWorldX = room.doorsLayer.x + (doorTile.x * TILE_SIZE);
-            const doorWorldY = room.doorsLayer.y + (doorTile.y * TILE_SIZE);
-            
-            const doorCheckArea = {
-                x: doorWorldX - DOOR_ALIGN_OVERLAP,
-                y: doorWorldY - DOOR_ALIGN_OVERLAP,
-                width: DOOR_ALIGN_OVERLAP * 2,
-                height: DOOR_ALIGN_OVERLAP * 2
+        room.doorSprites.forEach(doorSprite => {
+            // Get the door sprite's bounds (it covers 2 tiles vertically)
+            const doorSpriteBounds = {
+                x: doorSprite.x - TILE_SIZE/2, // Left edge of door sprite (center origin)
+                y: doorSprite.y - TILE_SIZE,   // Top edge of door sprite (center origin)
+                width: TILE_SIZE,              // Door sprite width
+                height: TILE_SIZE * 2          // Door sprite height (2 tiles)
             };
             
-            // Check how many revealed rooms this door overlaps with
+            // Check if this room is revealed (doors should be visible if their room is visible)
+            const thisRoomRevealed = discoveredRooms.has(roomId);
+            
+            // Check how many other revealed rooms this door overlaps with
             let overlappingRevealedRooms = 0;
             
             Object.entries(rooms).forEach(([otherRoomId, otherRoom]) => {
@@ -686,30 +1722,49 @@ function updateDoorsVisibility() {
                     height: otherRoom.map.heightInPixels
                 };
                 
-                // Check if door overlaps with this revealed room
-                if (boundsOverlap(doorCheckArea, otherRoomBounds)) {
+                // Check if door sprite bounds overlap with this revealed room
+                if (boundsOverlap(doorSpriteBounds, otherRoomBounds)) {
                     overlappingRevealedRooms++;
                 }
             });
             
-            // Door should be visible if it overlaps with at least one revealed room
-            const shouldBeVisible = overlappingRevealedRooms > 0;
+            // Door should be visible if its room is revealed OR if it overlaps with any revealed room
+            const shouldBeVisible = thisRoomRevealed || overlappingRevealedRooms > 0;
             
-            if (shouldBeVisible && !room.doorsLayer.visible) {
-                room.doorsLayer.setVisible(true);
-                room.doorsLayer.setAlpha(1);
+            console.log(`Door sprite at (${doorSprite.x}, ${doorSprite.y}) in room ${roomId}:`);
+            console.log(`  This room revealed: ${thisRoomRevealed}`);
+            console.log(`  Overlapping revealed rooms: ${overlappingRevealedRooms}`);
+            console.log(`  Should be visible: ${shouldBeVisible}`);
+            
+            if (shouldBeVisible) {
+                doorSprite.setVisible(true);
+                doorSprite.setAlpha(1);
+            } else {
+                doorSprite.setVisible(false);
+                doorSprite.setAlpha(0);
             }
         });
     });
 }
 
-// Helper function for bounds overlap check
-function boundsOverlap(rect1, rect2) {
-    return rect1.x < rect2.x + rect2.width &&
-           rect1.x + rect1.width > rect2.x &&
-           rect1.y < rect2.y + rect2.height &&
-           rect1.y + rect1.height > rect2.y;
+// Door collisions are now handled by sprite-based system
+export function setupDoorCollisions() {
+    console.log('Door collisions are now handled by sprite-based system');
 }
 
+// Global function to check if a door can be unlocked
+window.checkDoorUnlock = function(doorProps) {
+    console.log(`Checking door unlock: ${doorProps.lockType}, requires: ${doorProps.requires}`);
+    
+    // TODO: Implement proper unlock checking based on lockType
+    // For now, just return true to allow all doors to be unlocked
+    return true;
+};
+
 // Export for global access
-window.initializeRooms = initializeRooms; 
\ No newline at end of file
+window.initializeRooms = initializeRooms;
+window.setupDoorCollisions = setupDoorCollisions;
+window.updateDoorSpritesVisibility = updateDoorSpritesVisibility;
+
+// Export functions for module imports
+export { updateDoorSpritesVisibility }; 
\ No newline at end of file
diff --git a/js/main.js b/js/main.js
index c9a1775..e77e66a 100644
--- a/js/main.js
+++ b/js/main.js
@@ -8,6 +8,9 @@ import { initializeDebugSystem } from './systems/debug.js?v=7';
 import { initializeUI } from './ui/panels.js?v=9';
 import { initializeModals } from './ui/modals.js?v=7';
 
+// Import minigame framework
+import './minigames/index.js';
+
 // Global game variables
 window.game = null;
 window.gameScenario = null;
diff --git a/js/minigames/lockpicking/lockpicking-game-phaser.js b/js/minigames/lockpicking/lockpicking-game-phaser.js
index cb29f03..a159c5f 100644
--- a/js/minigames/lockpicking/lockpicking-game-phaser.js
+++ b/js/minigames/lockpicking/lockpicking-game-phaser.js
@@ -9,10 +9,29 @@ export class LockpickingMinigamePhaser extends MinigameScene {
         params = params || {};
         
         this.lockable = params.lockable || 'default-lock';
+        this.lockId = params.lockId || 'default_lock';
         this.difficulty = params.difficulty || 'medium';
         // Use passed pinCount if provided, otherwise calculate based on difficulty
         this.pinCount = params.pinCount || (this.difficulty === 'easy' ? 3 : this.difficulty === 'medium' ? 4 : 5);
         
+        // Initialize global lock storage if it doesn't exist
+        if (!window.lockConfigurations) {
+            window.lockConfigurations = {};
+        }
+        
+        // Also try to load from localStorage for persistence across sessions
+        if (!window.lockConfigurations[this.lockId]) {
+            try {
+                const savedConfigs = localStorage.getItem('lockConfigurations');
+                if (savedConfigs) {
+                    const parsed = JSON.parse(savedConfigs);
+                    window.lockConfigurations = { ...window.lockConfigurations, ...parsed };
+                }
+            } catch (error) {
+                console.warn('Failed to load lock configurations from localStorage:', error);
+            }
+        }
+        
         // Threshold sensitivity for pin setting (1-10, higher = more sensitive)
         this.thresholdSensitivity = params.thresholdSensitivity || 5;
         
@@ -34,6 +53,8 @@ export class LockpickingMinigamePhaser extends MinigameScene {
         this.keyData = params.keyData || null; // Key data with cuts/ridges
         this.keyInsertionProgress = 0; // 0 = not inserted, 1 = fully inserted
         this.keyInserting = false;
+        this.skipStartingKey = params.skipStartingKey || false; // Skip creating initial key if true
+        this.keySelectionMode = false; // Track if we're in key selection mode
         
         // Sound effects
         this.sounds = {};
@@ -64,6 +85,97 @@ export class LockpickingMinigamePhaser extends MinigameScene {
         this.scene = null;
     }
     
+    saveLockConfiguration() {
+        // Save the current lock configuration to global storage and localStorage
+        if (this.pins && this.pins.length > 0) {
+            const pinHeights = this.pins.map(pin => pin.originalHeight);
+            const config = {
+                pinHeights: pinHeights,
+                pinCount: this.pinCount,
+                timestamp: Date.now()
+            };
+            
+            // Save to memory
+            window.lockConfigurations[this.lockId] = config;
+            
+            // Save to localStorage for persistence
+            try {
+                const savedConfigs = localStorage.getItem('lockConfigurations') || '{}';
+                const parsed = JSON.parse(savedConfigs);
+                parsed[this.lockId] = config;
+                localStorage.setItem('lockConfigurations', JSON.stringify(parsed));
+            } catch (error) {
+                console.warn('Failed to save lock configuration to localStorage:', error);
+            }
+            
+            console.log(`Saved lock configuration for ${this.lockId}:`, pinHeights);
+        }
+    }
+    
+    loadLockConfiguration() {
+        // Load lock configuration from global storage
+        const config = window.lockConfigurations[this.lockId];
+        if (config && config.pinHeights && config.pinHeights.length === this.pinCount) {
+            console.log(`Loaded lock configuration for ${this.lockId}:`, config.pinHeights);
+            return config.pinHeights;
+        }
+        return null;
+    }
+    
+    clearLockConfiguration() {
+        // Clear the lock configuration for this lock
+        if (window.lockConfigurations[this.lockId]) {
+            delete window.lockConfigurations[this.lockId];
+            
+            // Also remove from localStorage
+            try {
+                const savedConfigs = localStorage.getItem('lockConfigurations') || '{}';
+                const parsed = JSON.parse(savedConfigs);
+                delete parsed[this.lockId];
+                localStorage.setItem('lockConfigurations', JSON.stringify(parsed));
+            } catch (error) {
+                console.warn('Failed to clear lock configuration from localStorage:', error);
+            }
+            
+            console.log(`Cleared lock configuration for ${this.lockId}`);
+        }
+    }
+    
+    clearAllLockConfigurations() {
+        // Clear all lock configurations (useful for testing)
+        window.lockConfigurations = {};
+        
+        // Also clear from localStorage
+        try {
+            localStorage.removeItem('lockConfigurations');
+        } catch (error) {
+            console.warn('Failed to clear all lock configurations from localStorage:', error);
+        }
+        
+        console.log('Cleared all lock configurations');
+    }
+    
+    resetPinsToOriginalPositions() {
+        // Reset all pins to their original positions (before any key insertion)
+        this.pins.forEach(pin => {
+            pin.currentHeight = 0;
+            pin.isSet = false;
+            
+            // Clear any highlights
+            if (pin.shearHighlight) {
+                pin.shearHighlight.setVisible(false);
+            }
+            if (pin.setHighlight) {
+                pin.setHighlight.setVisible(false);
+            }
+            
+            // Update pin visuals
+            this.updatePinVisuals(pin);
+        });
+        
+        console.log('Reset all pins to original positions');
+    }
+    
     init() {
         super.init();
         
@@ -177,11 +289,19 @@ export class LockpickingMinigamePhaser extends MinigameScene {
                 self.createHookPick();
                 self.createShearLine();
                 
-                // Create key if in key mode
-                if (self.keyMode) {
+                // Create key if in key mode and not skipping starting key
+                if (self.keyMode && !self.skipStartingKey) {
                     self.createKey();
                     self.hideLockpickingTools();
                     self.updateFeedback("Click the key to insert it into the lock");
+                } else if (self.keyMode && self.skipStartingKey) {
+                    // Skip creating initial key, will show key selection instead
+                    // But we still need to initialize keyData for the correct key
+                    if (!self.keyData) {
+                        self.generateKeyDataFromPins();
+                    }
+                    self.hideLockpickingTools();
+                    self.updateFeedback("Select a key to begin");
                 } else {
                     self.updateFeedback("Apply tension first, then lift pins in binding order - only the binding pin can be set");
                 }
@@ -604,6 +724,359 @@ export class LockpickingMinigamePhaser extends MinigameScene {
         console.log('Generated key data from pins:', this.keyData);
     }
     
+    createKeyFromPinSizes(pinSizes) {
+        // Create a complete key object based on a set of pin sizes
+        // pinSizes: array of numbers representing the depth of each cut (0-100)
+        
+        const keyConfig = {
+            pinCount: pinSizes.length,
+            cuts: pinSizes,
+            // Standard key dimensions
+            circleRadius: 20,
+            shoulderWidth: 30,
+            shoulderHeight: 130,
+            bladeWidth: 420,
+            bladeHeight: 110,
+            keywayStartX: 100,
+            keywayStartY: 170,
+            keywayWidth: 400,
+            keywayHeight: 120
+        };
+        
+        return keyConfig;
+    }
+    
+    generateRandomKey(pinCount = 5) {
+        // Generate a random key with the specified number of pins
+        const cuts = [];
+        for (let i = 0; i < pinCount; i++) {
+            // Generate random cut depth between 20-80 (avoiding extremes)
+            cuts.push(Math.floor(Math.random() * 60) + 20);
+        }
+        return { 
+            id: `random_key_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            cuts,
+            name: `Random Key`,
+            pinCount: pinCount
+        };
+    }
+    
+    createKeysFromInventory(inventoryKeys, correctKeyId) {
+        // Create key selection from inventory keys
+        // inventoryKeys: array of key objects from player inventory
+        // correctKeyId: ID of the key that should work with this lock
+        
+        // Filter keys to only include those with cuts data
+        const validKeys = inventoryKeys.filter(key => key.cuts && Array.isArray(key.cuts));
+        
+        if (validKeys.length === 0) {
+            // No valid keys in inventory, generate random ones
+            const key1 = this.generateRandomKey(this.pinCount);
+            const key2 = this.generateRandomKey(this.pinCount);
+            const key3 = this.generateRandomKey(this.pinCount);
+            
+            // Make the first key correct
+            key1.cuts = this.keyData.cuts;
+            key1.id = correctKeyId || 'correct_key';
+            key1.name = 'Correct Key';
+            
+            // Randomize the order
+            const keys = [key1, key2, key3];
+            this.shuffleArray(keys);
+            
+            return this.createKeySelectionUI(keys, correctKeyId);
+        }
+        
+        // Use inventory keys and randomize their order
+        const shuffledKeys = [...validKeys];
+        this.shuffleArray(shuffledKeys);
+        
+        return this.createKeySelectionUI(shuffledKeys, correctKeyId);
+    }
+    
+    createKeysForChallenge(correctKeyId = 'challenge_key') {
+        // Create keys for challenge mode (like locksmith-forge.html)
+        // Generates 3 keys with one guaranteed correct key
+        
+        const key1 = this.generateRandomKey(this.pinCount);
+        const key2 = this.generateRandomKey(this.pinCount);
+        const key3 = this.generateRandomKey(this.pinCount);
+        
+        // Make the first key correct by copying the actual key cuts
+        key1.cuts = this.keyData.cuts;
+        key1.id = correctKeyId;
+        key1.name = 'Correct Key';
+        
+        // Give other keys descriptive names
+        key2.name = 'Wrong Key 1';
+        key3.name = 'Wrong Key 2';
+        
+        // Randomize the order of keys
+        const keys = [key1, key2, key3];
+        this.shuffleArray(keys);
+        
+        // Find the new index of the correct key after shuffling
+        const correctKeyIndex = keys.findIndex(key => key.id === correctKeyId);
+        
+        return this.createKeySelectionUI(keys, correctKeyId);
+    }
+    
+    startWithKeySelection(inventoryKeys = null, correctKeyId = null) {
+        // Start the minigame with key selection instead of a default key
+        // inventoryKeys: array of keys from inventory (optional)
+        // correctKeyId: ID of the correct key (optional)
+        
+        this.keySelectionMode = true; // Mark that we're in key selection mode
+        
+        if (inventoryKeys && inventoryKeys.length > 0) {
+            // Use provided inventory keys
+            this.createKeysFromInventory(inventoryKeys, correctKeyId);
+        } else {
+            // Generate random keys for challenge
+            this.createKeysForChallenge(correctKeyId || 'challenge_key');
+        }
+    }
+    
+    // Example usage:
+    // 
+    // 1. For BreakEscape main game with inventory keys:
+    // const playerKeys = [
+    //     { id: 'office_key', cuts: [45, 67, 23, 89, 34], name: 'Office Key' },
+    //     { id: 'basement_key', cuts: [12, 78, 56, 23, 90], name: 'Basement Key' },
+    //     { id: 'shed_key', cuts: [67, 34, 89, 12, 45], name: 'Shed Key' }
+    // ];
+    // this.startWithKeySelection(playerKeys, 'office_key');
+    //
+    // 2. For challenge mode (like locksmith-forge.html):
+    // this.startWithKeySelection(); // Generates 3 random keys, one correct
+    //
+    // 3. Skip starting key and go straight to selection:
+    // const minigame = new LockpickingMinigamePhaser(container, {
+    //     keyMode: true,
+    //     skipStartingKey: true, // Don't create initial key
+    //     lockId: 'office_door_lock'
+    // });
+    // minigame.startWithKeySelection(playerKeys, 'office_key');
+    
+    createKeySelectionUI(keys, correctKeyId = null) {
+        // Create a UI for selecting between multiple keys
+        // keys: array of key objects with id, cuts, and optional name properties
+        // correctKeyId: ID of the correct key (if null, uses index 0 as fallback)
+        
+        // Find the correct key index
+        let correctKeyIndex = 0;
+        if (correctKeyId) {
+            correctKeyIndex = keys.findIndex(key => key.id === correctKeyId);
+            if (correctKeyIndex === -1) {
+                correctKeyIndex = 0; // Fallback to first key if ID not found
+            }
+        }
+        
+        // Remove any existing key from the scene before showing selection UI
+        if (this.keyGroup) {
+            this.keyGroup.destroy();
+            this.keyGroup = null;
+        }
+        
+        // Remove any existing click zone
+        if (this.keyClickZone) {
+            this.keyClickZone.destroy();
+            this.keyClickZone = null;
+        }
+        
+        // Reset pins to their original positions before showing key selection
+        this.resetPinsToOriginalPositions();
+        
+        // Create container for key selection - positioned in the middle but below pins
+        const keySelectionContainer = this.scene.add.container(0, 230);
+        keySelectionContainer.setDepth(1000); // High z-index to appear above everything
+        
+        // Add background
+        const background = this.scene.add.graphics();
+        background.fillStyle(0x000000, 0.8);
+        background.fillRect(0, 0, 700, 180);
+        background.lineStyle(2, 0xffffff);
+        background.strokeRect(0, 0, 600, 170);
+        keySelectionContainer.add(background);
+        
+        // Add title
+        const title = this.scene.add.text(300, 15, 'Select the correct key', {
+            fontSize: '24px',
+            fill: '#ffffff',
+            fontFamily: 'VT323',
+        });
+        title.setOrigin(0.5, 0);
+        keySelectionContainer.add(title);
+        
+        // Create key options
+        const keyWidth = 140;
+        const keyHeight = 80;
+        const spacing = 20;
+        const startX = 50;
+        const startY = 50;
+        
+        keys.forEach((keyData, index) => {
+            const keyX = startX + index * (keyWidth + spacing);
+            const keyY = startY;
+            
+            // Create key visual representation
+            const keyVisual = this.createKeyVisual(keyData, keyWidth, keyHeight);
+            keyVisual.setPosition(keyX, keyY);
+            keySelectionContainer.add(keyVisual);
+            
+            // Make key clickable
+            keyVisual.setInteractive(new Phaser.Geom.Rectangle(0, 0, keyWidth, keyHeight), Phaser.Geom.Rectangle.Contains);
+            keyVisual.on('pointerdown', () => {
+                // Close the popup
+                keySelectionContainer.destroy();
+                // Trigger key selection and insertion
+                this.selectKey(index, correctKeyIndex, keyData);
+            });
+            
+            // Add key label (use name if available, otherwise use number)
+            const keyName = keyData.name || `Key ${index + 1}`;
+            const keyLabel = this.scene.add.text(keyX + keyWidth/2, keyY + keyHeight + 5, keyName, {
+                fontSize: '16px',
+                fill: '#ffffff',
+                fontFamily: 'VT323'
+            });
+            keyLabel.setOrigin(0.5, 0);
+            keySelectionContainer.add(keyLabel);
+        });
+        
+        this.keySelectionContainer = keySelectionContainer;
+    }
+    
+    createKeyVisual(keyData, width, height) {
+        // Create a visual representation of a key for the selection UI by building the actual key and scaling it down
+        const keyContainer = this.scene.add.container(0, 0);
+        
+        // Temporarily set the key data to create the key
+        const originalKeyData = this.keyData;
+        this.keyData = keyData;
+        
+        // Create the key using the same method as the main key
+        this.createKey();
+        
+        // Get the key group and scale it down
+        const keyGroup = this.keyGroup;
+        if (keyGroup) {
+            // Calculate scale to fit within the selection area
+            const maxWidth = width - 20; // Leave 10px margin on each side
+            const maxHeight = height - 20;
+            
+            // Get the key's current dimensions
+            const keyBounds = keyGroup.getBounds();
+            const keyWidth = keyBounds.width;
+            const keyHeight = keyBounds.height;
+            
+            // Calculate scale
+            const scaleX = maxWidth / keyWidth;
+            const scaleY = maxHeight / keyHeight;
+            const scale = Math.min(scaleX, scaleY) * 0.9; // Use 90% to leave some margin
+            
+            // Scale the key group
+            keyGroup.setScale(scale);
+            
+            // Center the key in the selection area
+            const scaledWidth = keyWidth * scale;
+            const scaledHeight = keyHeight * scale;
+            const offsetX = (width - scaledWidth) / 2;
+            const offsetY = (height - scaledHeight) / 2;
+            
+            // Position the key
+            keyGroup.setPosition(offsetX, offsetY);
+            
+            // Add the key group to the container
+            keyContainer.add(keyGroup);
+        }
+        
+        // Restore the original key data
+        this.keyData = originalKeyData;
+        
+        return keyContainer;
+    }
+    
+
+    
+    selectKey(selectedIndex, correctIndex, keyData) {
+        // Handle key selection from the UI
+        console.log(`Key ${selectedIndex + 1} selected (correct: ${correctIndex + 1})`);
+        
+        // Close the popup immediately
+        if (this.keySelectionContainer) {
+            this.keySelectionContainer.destroy();
+        }
+        
+        // Remove any existing key from the scene
+        if (this.keyGroup) {
+            this.keyGroup.destroy();
+            this.keyGroup = null;
+        }
+        
+        // Remove any existing click zone
+        if (this.keyClickZone) {
+            this.keyClickZone.destroy();
+            this.keyClickZone = null;
+        }
+        
+        // Reset pins to their original positions before creating the new key
+        this.resetPinsToOriginalPositions();
+        
+        // Store the original correct key data (this determines if the key is correct)
+        const originalKeyData = this.keyData;
+        
+        // Store the selected key data for visual purposes
+        this.selectedKeyData = keyData;
+        
+        // Create the visual key with the selected key data
+        this.keyData = keyData;
+        this.pinCount = keyData.pinCount;
+        this.createKey();
+        
+        // Restore the original key data for correctness checking
+        this.keyData = originalKeyData;
+        
+        // Update feedback - don't reveal if correct/wrong yet
+        this.updateFeedback("Key selected! Inserting into lock...");
+        
+        // Automatically trigger key insertion after a short delay
+        setTimeout(() => {
+            this.startKeyInsertion();
+        }, 300); // Small delay to let the key appear first
+        
+        // Update feedback if available
+        if (this.selectKeyCallback) {
+            this.selectKeyCallback(selectedIndex, correctIndex, keyData);
+        }
+    }
+    
+    showWrongKeyFeedback() {
+        // Show visual feedback for wrong key selection
+        const feedback = this.scene.add.graphics();
+        feedback.fillStyle(0xff0000, 0.3);
+        feedback.fillRect(0, 0, 800, 600);
+        feedback.setDepth(9999);
+        
+        // Remove feedback after a short delay
+        this.scene.time.delayedCall(500, () => {
+            feedback.destroy();
+        });
+    }
+    
+    flashLockRed() {
+        // Flash the entire lock area red to indicate wrong key
+        const flash = this.scene.add.graphics();
+        flash.fillStyle(0xff0000, 0.4); // Red with 40% opacity
+        flash.fillRect(100, 50, 400, 300); // Cover the entire lock area
+        flash.setDepth(9998); // High z-index but below other UI elements
+        
+        // Remove flash after a short delay
+        this.scene.time.delayedCall(800, () => {
+            flash.destroy();
+        });
+    }
+    
     createKey() {
         if (!this.keyMode) return;
         
@@ -773,7 +1246,7 @@ export class LockpickingMinigamePhaser extends MinigameScene {
         // |          |_|______________/
         //  \________/ 
         
-    
+        
         
         const cutWidth = 24; // Width of each cut (same as pin width)
         
@@ -1163,25 +1636,30 @@ export class LockpickingMinigamePhaser extends MinigameScene {
     checkKeyCorrectness() {
         if (!this.keyData || !this.keyData.cuts) return;
         
-        // Check if all pins are green (at the shear line)
-        let isCorrect = true;
+        // Check if the selected key matches the correct key
+        let isCorrect = false;
         
-        console.log('Checking key correctness based on pin highlights...');
-        
-        this.pins.forEach((pin, index) => {
-            if (index >= this.pinCount) return;
+        if (this.selectedKeyData && this.selectedKeyData.cuts) {
+            // Compare the selected key cuts with the original correct key cuts
+            const selectedCuts = this.selectedKeyData.cuts;
+            const correctCuts = this.keyData.cuts;
             
-            // Check if this pin has a green highlight (meaning it's at the shear line)
-            const isPinGreen = pin.shearHighlight && pin.shearHighlight.visible;
-            
-            console.log(`Pin ${index}: isGreen=${isPinGreen}, hasShearHighlight=${!!pin.shearHighlight}, highlightVisible=${pin.shearHighlight ? pin.shearHighlight.visible : false}`);
-            
-            if (!isPinGreen) {
+            if (selectedCuts.length === correctCuts.length) {
+                isCorrect = true;
+                for (let i = 0; i < selectedCuts.length; i++) {
+                    if (Math.abs(selectedCuts[i] - correctCuts[i]) > 5) { // Allow small tolerance
                 isCorrect = false;
+                        break;
+                    }
+                }
             }
-        });
+        }
         
-        console.log('Key correctness result:', isCorrect);
+        console.log('Key correctness check:', {
+            selectedKey: this.selectedKeyData ? this.selectedKeyData.cuts : 'none',
+            correctKey: this.keyData.cuts,
+            isCorrect: isCorrect
+        });
         
         if (isCorrect) {
             // Key is correct - all pins are aligned at the shear line
@@ -1197,28 +1675,37 @@ export class LockpickingMinigamePhaser extends MinigameScene {
                 this.complete(true);
             }, 3000); // Longer delay to allow rotation animation to complete
         } else {
-            // Key is wrong
-            this.updateFeedback("Wrong key! Try a different one.");
+            // Key is wrong - show red flash and then pop up key selection again
+            this.updateFeedback("Wrong key! The lock won't turn.");
             
             // Play wrong sound
             if (this.sounds.wrong) {
                 this.sounds.wrong.play();
             }
             
-            // Reset key position
+            // Flash the entire lock red
+            this.flashLockRed();
+            
+            // Reset key position and show key selection again after a delay
             setTimeout(() => {
                 this.updateKeyPosition(0);
-            }, 1000);
+                // Show key selection again
+                if (this.keySelectionMode) {
+                    this.createKeysForChallenge('correct_key');
+                }
+            }, 2000); // Longer delay to show the red flash
         }
     }
     
     snapPinsToExactPositions() {
-        if (!this.keyData || !this.keyData.cuts) return;
+        // Use selected key data for visual positioning, but original key data for correctness
+        const keyDataToUse = this.selectedKeyData || this.keyData;
+        if (!keyDataToUse || !keyDataToUse.cuts) return;
         
         console.log('Snapping pins to exact positions based on key cuts for shear line alignment');
         
         // Set each pin to the exact final position based on key cut dimensions
-        this.keyData.cuts.forEach((cutDepth, index) => {
+        keyDataToUse.cuts.forEach((cutDepth, index) => {
             if (index >= this.pinCount) return;
             
             const pin = this.pins[index];
@@ -1625,10 +2112,10 @@ export class LockpickingMinigamePhaser extends MinigameScene {
             let nextCutDepth = 0;
             
             if (i < this.pinCount) {
-                cutDepth = this.keyData.cuts[i] || 0;
+                cutDepth = (this.selectedKeyData || this.keyData).cuts[i] || 0;
             }
             if (i < this.pinCount - 1) {
-                nextCutDepth = this.keyData.cuts[i + 1] || 0;
+                nextCutDepth = (this.selectedKeyData || this.keyData).cuts[i + 1] || 0;
             }
             
             // Calculate pin position
@@ -1644,8 +2131,8 @@ export class LockpickingMinigamePhaser extends MinigameScene {
             
             if (i < this.pinCount) {
                 // Draw the cut
-                const cutStartX = cutX - cutWidth/2;
-                const cutEndX = cutX + cutWidth/2;
+            const cutStartX = cutX - cutWidth/2;
+            const cutEndX = cutX + cutWidth/2;
                 points.push({ x: cutStartX, y: keyBladeBaseY + cutDepth });
                 points.push({ x: cutEndX, y: keyBladeBaseY + cutDepth });
                 currentX = cutEndX;
@@ -2283,19 +2770,31 @@ export class LockpickingMinigamePhaser extends MinigameScene {
         const pinSpacing = 400 / (this.pinCount + 1);
         const margin = pinSpacing * 0.75; // 25% smaller margins
         
+        // Try to load saved pin heights for this lock
+        const savedPinHeights = this.loadLockConfiguration();
+        
         for (let i = 0; i < this.pinCount; i++) {
             const pinX = 100 + margin + i * pinSpacing;
             const pinY = 200;
             
-            // Random pin lengths that add up to 75 (total height - 25% increase from 60)
-            const keyPinLength = 25 + Math.random() * 37.5; // 25-62.5 (25% increase)
-            const driverPinLength = 75 - keyPinLength; // Remaining to make 75 total
+            // Use saved pin heights if available, otherwise generate random ones
+            let keyPinLength, driverPinLength;
+            if (savedPinHeights && savedPinHeights[i] !== undefined) {
+                // Use saved configuration
+                keyPinLength = savedPinHeights[i];
+                driverPinLength = 75 - keyPinLength; // Total height is 75
+            } else {
+                // Generate random pin lengths that add up to 75 (total height - 25% increase from 60)
+                keyPinLength = 25 + Math.random() * 37.5; // 25-62.5 (25% increase)
+                driverPinLength = 75 - keyPinLength; // Remaining to make 75 total
+            }
             
             const pin = {
                 index: i,
                 binding: bindingOrder[i],
                 isSet: false,
                 currentHeight: 0,
+                originalHeight: keyPinLength, // Store original height for consistency
                 keyPinHeight: 0, // Track key pin position separately
                 driverPinHeight: 0, // Track driver pin position separately
                 keyPinLength: keyPinLength,
@@ -2522,6 +3021,9 @@ export class LockpickingMinigamePhaser extends MinigameScene {
             
             this.pins.push(pin);
         }
+        
+        // Save the lock configuration after all pins are created
+        this.saveLockConfiguration();
     }
     
     createShearLine() {
diff --git a/js/systems/interactions.js b/js/systems/interactions.js
index 7b8f7d2..09a4f4c 100644
--- a/js/systems/interactions.js
+++ b/js/systems/interactions.js
@@ -419,21 +419,21 @@ function removeFromInventory(item) {
 function handleUnlock(lockable, type) {
     console.log('UNLOCK ATTEMPT');
     
-    const isLocked = type === 'door' ? 
-        lockable.properties?.locked : 
-        lockable.scenarioData?.locked;
-    
-    if (!isLocked) {
-        console.log('OBJECT NOT LOCKED');
-        return;
-    }
-    
     // Get lock requirements based on type
     const lockRequirements = type === 'door' 
         ? getLockRequirementsForDoor(lockable)
         : getLockRequirementsForItem(lockable);
     
     if (!lockRequirements) {
+        console.log('NO LOCK REQUIREMENTS FOUND');
+        return;
+    }
+    
+    // Check if object is locked based on lock requirements
+    const isLocked = lockRequirements.requires;
+    
+    if (!isLocked) {
+        console.log('OBJECT NOT LOCKED');
         return;
     }
     
@@ -441,22 +441,16 @@ function handleUnlock(lockable, type) {
         case 'key':
             const requiredKey = lockRequirements.requires;
             console.log('KEY REQUIRED', requiredKey);
-            const hasKey = window.inventory.items.some(item => 
+            
+            // Get all keys from player's inventory
+            const playerKeys = window.inventory.items.filter(item => 
                 item && item.scenarioData && 
-                item.scenarioData.key_id === requiredKey
+                item.scenarioData.type === 'key'
             );
-
-            if (hasKey) {
-                const keyItem = window.inventory.items.find(item => 
-                    item && item.scenarioData && 
-                    item.scenarioData.key_id === requiredKey
-                );
-                const keyName = keyItem?.scenarioData?.name || 'key';
-                const keyLocation = keyItem?.scenarioData?.foundIn || 'your inventory';
-                
-                console.log('KEY UNLOCK SUCCESS');
-                unlockTarget(lockable, type, lockable.layer);
-                window.gameAlert(`You used the ${keyName} that you found in ${keyLocation} to unlock the ${type}.`, 'success', 'Unlock Successful', 5000);
+            
+            if (playerKeys.length > 0) {
+                // Show key selection interface
+                startKeySelectionMinigame(lockable, type, playerKeys, requiredKey);
             } else {
                 // Check for lockpick kit
                 const hasLockpick = window.inventory.items.some(item => 
@@ -481,7 +475,7 @@ function handleUnlock(lockable, type) {
                         });
                     }
                 } else {
-                    console.log('KEY NOT FOUND - FAIL');
+                    console.log('NO KEYS OR LOCKPICK AVAILABLE');
                     window.gameAlert(`Requires key: ${requiredKey}`, 'error', 'Locked', 4000);
                 }
             }
@@ -636,13 +630,62 @@ function handleUnlock(lockable, type) {
     }
 }
 
-function getLockRequirementsForDoor(doorTile) {
-    if (!doorTile.properties) return null;
+function getLockRequirementsForDoor(doorSprite) {
+    const doorWorldX = doorSprite.x;
+    const doorWorldY = doorSprite.y;
     
-    return {
-        lockType: doorTile.properties.lockType || 'key',
-        requires: doorTile.properties.requires || ''
-    };
+    const overlappingRooms = [];
+    Object.entries(rooms).forEach(([roomId, otherRoom]) => {
+        const doorCheckArea = {
+            x: doorWorldX - DOOR_ALIGN_OVERLAP,
+            y: doorWorldY - DOOR_ALIGN_OVERLAP,
+            width: DOOR_ALIGN_OVERLAP * 2,
+            height: DOOR_ALIGN_OVERLAP * 2
+        };
+        
+        const roomBounds = {
+            x: otherRoom.position.x,
+            y: otherRoom.position.y,
+            width: otherRoom.map.widthInPixels,
+            height: otherRoom.map.heightInPixels
+        };
+        
+        if (boundsOverlap(doorCheckArea, roomBounds)) {
+            const roomCenterX = roomBounds.x + (roomBounds.width / 2);
+            const roomCenterY = roomBounds.y + (roomBounds.height / 2);
+            const player = window.player;
+            const distanceToPlayer = player ? Phaser.Math.Distance.Between(
+                player.x, player.y,
+                roomCenterX, roomCenterY
+            ) : 0;
+            
+            const gameScenario = window.gameScenario;
+            const roomData = gameScenario?.rooms?.[roomId];
+            
+            overlappingRooms.push({
+                id: roomId,
+                room: otherRoom,
+                distance: distanceToPlayer,
+                lockType: roomData?.lockType,
+                requires: roomData?.requires,
+                locked: roomData?.locked
+            });
+        }
+    });
+    
+    const lockedRooms = overlappingRooms
+        .filter(r => r.locked)
+        .sort((a, b) => b.distance - a.distance);
+
+    if (lockedRooms.length > 0) {
+        const targetRoom = lockedRooms[0];
+        return {
+            lockType: targetRoom.lockType,
+            requires: targetRoom.requires
+        };
+    }
+    
+    return null;
 }
 
 function getLockRequirementsForItem(item) {
@@ -656,11 +699,14 @@ function getLockRequirementsForItem(item) {
 
 function unlockTarget(lockable, type, layer) {
     if (type === 'door') {
-        if (!layer) {
-            console.error('Missing layer for door unlock');
-            return;
+        // After unlocking, open the door
+        // Find the room that contains this door sprite
+        const room = Object.values(rooms).find(r => 
+            r.doorSprites && r.doorSprites.includes(lockable)
+        );
+        if (room) {
+            openDoor(lockable, room);
         }
-        unlockDoor(lockable, layer);
     } else {
         // Handle item unlocking
         if (lockable.scenarioData) {
@@ -681,75 +727,17 @@ function unlockTarget(lockable, type, layer) {
     console.log(`${type} unlocked successfully`);
 }
 
+// This function is no longer needed - door unlocking is handled by the minigame system
+// and door opening is handled by openDoor()
 function unlockDoor(doorTile, doorsLayer) {
-    if (!doorsLayer) {
-        console.error('Missing doorsLayer in unlockDoor');
-        return;
-    }
-
-    // Remove lock properties from this door and adjacent door tiles
-    const doorTiles = [
-        doorsLayer.getTileAt(doorTile.x, doorTile.y - 1),
-        doorsLayer.getTileAt(doorTile.x, doorTile.y),
-        doorsLayer.getTileAt(doorTile.x, doorTile.y + 1),
-        doorsLayer.getTileAt(doorTile.x - 1, doorTile.y),
-        doorsLayer.getTileAt(doorTile.x + 1, doorTile.y)
-    ].filter(tile => tile && tile.index !== -1);
-
-    doorTiles.forEach(tile => {
-        if (tile.properties) {
-            tile.properties.locked = false;
-        }
-    });
-    
-    // Find the room that contains this doors layer
-    const room = Object.values(rooms).find(r => r.doorsLayer === doorsLayer);
-    if (!room) {
-        console.error('Could not find room for doors layer');
-        return;
-    }
-    
-    // Process each door tile's position to remove wall collisions
-    doorTiles.forEach(tile => {
-        const worldX = doorsLayer.x + (tile.x * TILE_SIZE);
-        const worldY = doorsLayer.y + (tile.y * TILE_SIZE);
-        
-        const doorCheckArea = {
-            x: worldX - DOOR_ALIGN_OVERLAP,
-            y: worldY - DOOR_ALIGN_OVERLAP,
-            width: DOOR_ALIGN_OVERLAP * 2,
-            height: DOOR_ALIGN_OVERLAP * 2
-        };
-        
-        // Remove collision for this door in ALL overlapping rooms' wall layers
-        Object.entries(rooms).forEach(([otherId, otherRoom]) => {
-            const otherBounds = {
-                x: otherRoom.position.x,
-                y: otherRoom.position.y,
-                width: otherRoom.map.widthInPixels,
-                height: otherRoom.map.heightInPixels
-            };
-            
-            if (boundsOverlap(doorCheckArea, otherBounds)) {
-                otherRoom.wallsLayers.forEach(wallLayer => {
-                    const wallX = Math.floor((worldX - wallLayer.x) / TILE_SIZE);
-                    const wallY = Math.floor((worldY - wallLayer.y) / TILE_SIZE);
-                    
-                    const wallTile = wallLayer.getTileAt(wallX, wallY);
-                    if (wallTile) {
-                        wallTile.setCollision(false);
-                    }
-                });
-            }
-        });
-    });
-    
-    // Update door visuals for all affected tiles
-    doorTiles.forEach(tile => {
-        colorDoorTiles(tile, room);
-    });
+    console.log('unlockDoor called - this should not happen');
+    // The unlock process is handled by the minigame system
+    // When unlock is successful, unlockTarget() calls openDoor()
 }
 
+// Store door zones globally so we can manage them
+window.doorZones = window.doorZones || new Map();
+
 export function setupDoorOverlapChecks() {
     if (!gameRef) {
         console.error('Game reference not set in interactions.js');
@@ -758,80 +746,148 @@ export function setupDoorOverlapChecks() {
     
     const DOOR_INTERACTION_RANGE = 2 * TILE_SIZE;
     
+    // Clear existing door zones
+    if (window.doorZones) {
+        window.doorZones.forEach(zone => {
+            if (zone && zone.destroy) {
+                zone.destroy();
+            }
+        });
+        window.doorZones.clear();
+    }
+    
     Object.entries(rooms).forEach(([roomId, room]) => {
-        if (!room.doorsLayer) return;
+        if (!room.doorSprites) return;
 
-        const doorTiles = room.doorsLayer.getTilesWithin().filter(tile => tile.index !== -1);
+        const doorSprites = room.doorSprites;
         
-        doorTiles.forEach(doorTile => {
-            const worldX = room.doorsLayer.x + (doorTile.x * TILE_SIZE);
-            const worldY = room.doorsLayer.y + (doorTile.y * TILE_SIZE);
-            
-            const zone = gameRef.add.zone(worldX + TILE_SIZE/2, worldY + TILE_SIZE/2, TILE_SIZE, TILE_SIZE);
+        // Get room data to check if this room should be locked
+        const gameScenario = window.gameScenario;
+        const roomData = gameScenario?.rooms?.[roomId];
+        
+        doorSprites.forEach(doorSprite => {
+            const zone = gameRef.add.zone(doorSprite.x, doorSprite.y, TILE_SIZE, TILE_SIZE * 2);
             zone.setInteractive({ useHandCursor: true });
             
+            // Store zone reference for later management
+            const zoneKey = `${roomId}_${doorSprite.doorProperties.topTile.x}_${doorSprite.doorProperties.topTile.y}`;
+            window.doorZones.set(zoneKey, zone);
+            
             zone.on('pointerdown', () => {
-                console.log('Door clicked:', { doorTile, room });
+                console.log('Door clicked:', { doorSprite, room });
+                console.log('Door properties:', doorSprite.doorProperties);
+                console.log('Door open state:', doorSprite.doorProperties?.open);
+                console.log('Door sprite position:', { x: doorSprite.x, y: doorSprite.y });
+                
                 const player = window.player;
                 if (!player) return;
                 
                 const distance = Phaser.Math.Distance.Between(
                     player.x, player.y,
-                    worldX + TILE_SIZE/2, worldY + TILE_SIZE/2
+                    doorSprite.x, doorSprite.y
                 );
                 
                 if (distance <= DOOR_INTERACTION_RANGE) {
-                    if (doorTile.properties?.locked) {
-                        console.log('DOOR LOCKED - ATTEMPTING UNLOCK');
-                        colorDoorTiles(doorTile, room);
-                        handleDoorUnlock(doorTile, room);
-                    } else {
-                        console.log('DOOR NOT LOCKED');
-                    }
+                    handleDoorInteraction(doorSprite, room);
                 } else {
                     console.log('DOOR TOO FAR TO INTERACT');
                 }
             });
 
             gameRef.physics.world.enable(zone);
-            const player = window.player;
-            if (player) {
-                gameRef.physics.add.overlap(player, zone, () => {
-                    colorDoorTiles(doorTile, room);
-                }, null, gameRef);
-            }
         });
     });
 }
 
-function colorDoorTiles(doorTile, room) {
-    // Visual feedback for door tiles
-    const doorTiles = [
-        room.doorsLayer.getTileAt(doorTile.x, doorTile.y - 1),
-        room.doorsLayer.getTileAt(doorTile.x, doorTile.y),
-        room.doorsLayer.getTileAt(doorTile.x, doorTile.y + 1)
-    ];
-    doorTiles.forEach(tile => {
-        if (tile) {
-            // Use red tint for locked doors, clear tint for unlocked doors
-            // Check each individual tile's lock status, not just the main doorTile
-            const isLocked = tile.properties?.locked !== false;
-            if (isLocked) {
-                tile.tint = 0xff0000; // Red tint for locked doors
-                tile.tintFill = false;
-            } else {
-                // Black tint for unlocked doors - tiles don't have clearTint() method
-                tile.tint = 0x000000;
-                tile.tintFill = false;
-            }
+// Function to update door zone visibility based on room visibility
+export function updateDoorZoneVisibility() {
+    if (!window.doorZones || !gameRef) return;
+    
+    const discoveredRooms = window.discoveredRooms || new Set();
+    
+    window.doorZones.forEach((zone, zoneKey) => {
+        const [roomId] = zoneKey.split('_');
+        
+        // Show zone if this room is discovered
+        if (discoveredRooms.has(roomId)) {
+            zone.setVisible(true);
+            zone.setInteractive({ useHandCursor: true });
+        } else {
+            zone.setVisible(false);
+            zone.setInteractive(false);
         }
     });
 }
 
-function handleDoorUnlock(doorTile, room) {
+function colorDoorSprite(doorSprite, isLocked = null) {
+    // Visual feedback for door sprites
+    if (doorSprite) {
+        const isOpen = doorSprite.doorProperties?.open;
+        
+        if (isOpen) {
+            doorSprite.setTint(0x000000); // Black tint for open doors
+        } else if (isLocked) {
+            doorSprite.setTint(0xff0000); // Red tint for locked doors
+        } else {
+            doorSprite.setTint(0xffffff); // White tint for closed but unlocked doors
+        }
+    }
+}
+
+function handleDoorInteraction(doorSprite, room) {
+    // Check if door is already open
+    if (doorSprite.doorProperties.open) {
+        console.log('DOOR ALREADY OPEN');
+        return;
+    }
+    
+    // Check if door is locked by looking up lock requirements
+    const lockRequirements = getLockRequirementsForDoor(doorSprite);
+    const isLocked = lockRequirements && lockRequirements.requires;
+    
+    if (isLocked) {
+        console.log('DOOR LOCKED - ATTEMPTING UNLOCK');
+        colorDoorSprite(doorSprite, true);
+        handleDoorUnlock(doorSprite, room);
+    } else {
+        console.log('DOOR UNLOCKED - OPENING DOOR');
+        openDoor(doorSprite, room);
+    }
+}
+
+function handleDoorUnlock(doorSprite, room) {
     console.log('DOOR UNLOCK ATTEMPT');
-    doorTile.layer = room.doorsLayer; // Ensure layer reference is set
-    handleUnlock(doorTile, 'door');
+    handleUnlock(doorSprite, 'door');
+}
+
+
+
+
+
+
+
+function openDoor(doorSprite, room) {
+    console.log('OPENING DOOR');
+    console.log('Door sprite before opening:', { x: doorSprite.x, y: doorSprite.y, open: doorSprite.doorProperties?.open });
+    
+    // Mark door sprite as open
+    doorSprite.doorProperties.open = true;
+    
+    // Remove the door sprite (this removes collision and visual)
+    doorSprite.destroy();
+    
+    // Remove from room's door sprites array
+    const spriteIndex = room.doorSprites.indexOf(doorSprite);
+    if (spriteIndex > -1) {
+        room.doorSprites.splice(spriteIndex, 1);
+    }
+    
+    console.log('Door sprite removed - door is now open');
+    
+    // Show success message
+    window.gameAlert('Door opened successfully!', 'success', 'Door Opened', 2000);
+    
+    console.log('DOOR OPENED SUCCESSFULLY');
 }
 
 function startLockpickingMinigame(lockable, scene, difficulty = 'medium', callback) {
@@ -879,6 +935,79 @@ function startLockpickingMinigame(lockable, scene, difficulty = 'medium', callba
     });
 }
 
+function startKeySelectionMinigame(lockable, type, playerKeys, requiredKeyId) {
+    console.log('Starting key selection minigame', { playerKeys, requiredKeyId });
+    
+    // Initialize the minigame framework if not already done
+    if (!window.MinigameFramework) {
+        console.error('MinigameFramework not available');
+        // Fallback to simple key selection
+        const correctKey = playerKeys.find(key => key.scenarioData.key_id === requiredKeyId);
+        if (correctKey) {
+            window.gameAlert(`You used the ${correctKey.scenarioData.name} to unlock the ${type}.`, 'success', 'Unlock Successful', 4000);
+            unlockTarget(lockable, type, lockable.layer);
+        } else {
+            window.gameAlert('None of your keys work with this lock.', 'error', 'Wrong Keys', 4000);
+        }
+        return;
+    }
+    
+    // Use the advanced minigame framework
+    if (!window.MinigameFramework.mainGameScene) {
+        window.MinigameFramework.init(window.game);
+    }
+    
+    // Convert inventory keys to the format expected by the minigame
+    const inventoryKeys = playerKeys.map(key => {
+        // Generate cuts data if not present
+        let cuts = key.scenarioData.cuts;
+        if (!cuts) {
+            // Generate random cuts based on the key_id for consistency
+            const seed = key.scenarioData.key_id.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0);
+            const random = (min, max) => {
+                const x = Math.sin(seed++) * 10000;
+                return Math.floor((x - Math.floor(x)) * (max - min + 1)) + min;
+            };
+            
+            cuts = [];
+            for (let i = 0; i < 5; i++) {
+                cuts.push(random(20, 80)); // Random cuts between 20-80
+            }
+        }
+        
+        return {
+            id: key.scenarioData.key_id,
+            name: key.scenarioData.name,
+            cuts: cuts,
+            pinCount: key.scenarioData.pinCount || 5
+        };
+    });
+    
+    // Start the key selection minigame
+    window.MinigameFramework.startMinigame('lockpicking', null, {
+        keyMode: true,
+        skipStartingKey: true,
+        lockable: lockable,
+        onComplete: (success, result) => {
+            if (success) {
+                console.log('KEY SELECTION SUCCESS');
+                window.gameAlert('Successfully unlocked with the correct key!', 'success', 'Unlock Successful', 4000);
+                unlockTarget(lockable, type, lockable.layer);
+            } else {
+                console.log('KEY SELECTION FAILED');
+                window.gameAlert('The selected key doesn\'t work with this lock.', 'error', 'Wrong Key', 4000);
+            }
+        }
+    });
+    
+    // Start with key selection using inventory keys
+    setTimeout(() => {
+        if (window.MinigameFramework.currentMinigame && window.MinigameFramework.currentMinigame.startWithKeySelection) {
+            window.MinigameFramework.currentMinigame.startWithKeySelection(inventoryKeys, requiredKeyId);
+        }
+    }, 500);
+}
+
 // Fingerprint collection function
 function collectFingerprint(item) {
     if (!item.scenarioData?.hasFingerprint) {
@@ -1035,4 +1164,6 @@ function generateFingerprintData(item) {
 window.checkObjectInteractions = checkObjectInteractions;
 window.setupDoorOverlapChecks = setupDoorOverlapChecks;
 window.handleObjectInteraction = handleObjectInteraction;
-window.processAllDoorCollisions = processAllDoorCollisions; 
\ No newline at end of file
+window.processAllDoorCollisions = processAllDoorCollisions;
+window.startKeySelectionMinigame = startKeySelectionMinigame;
+window.updateDoorZoneVisibility = updateDoorZoneVisibility; 
\ No newline at end of file
diff --git a/key-demo.html b/key-demo.html
index fa19e51..b778c17 100644
--- a/key-demo.html
+++ b/key-demo.html
@@ -228,7 +228,7 @@
         <div class="header">
             <div class="title">🔑 LOCKPICKING KEY MODE DEMO 🔑</div>
             <div class="description">
-                Test the new key mode functionality! Try different keys to see which ones work with the lock.
+                Test the new key mode functionality! Key mode now starts with a selection of 3 random keys to choose from.
             </div>
         </div>
         
@@ -254,22 +254,25 @@
             <div class="key-preset" data-key="key3">Key 3 (Partial)</div>
             <div class="key-preset" data-key="key4">Key 4 (Random)</div>
             <div class="key-preset" data-key="key5">Key 5 (Deep)</div>
+            <button class="key-preset" id="keySelectionToggle">🎲 Random Key Selection</button>
         </div>
         
         <div class="game-container">
             <div id="gameContainer"></div>
-            <div class="feedback" id="feedback">Select a key and try inserting it into the lock</div>
+            <div class="feedback" id="feedback">Select a key from the options above to begin</div>
         </div>
         
         <div class="demo-container">
             <div class="instructions">
                 <h3>How to Use</h3>
                 <ul>
-                    <li><strong>Key Mode:</strong> Click and drag the key from left to right to insert it into the lock</li>
+                    <li><strong>Key Mode:</strong> Automatically shows 3 random keys to choose from (one correct)</li>
+                    <li><strong>Key Selection:</strong> Click any key to select it and automatically insert it into the lock</li>
+                    <li><strong>Random Key Selection:</strong> Click "🎲 Random Key Selection" to generate new random keys</li>
                     <li><strong>Pick Mode:</strong> Use the tension wrench and hook pick to manually pick the lock</li>
                     <li><strong>Key Cuts:</strong> The numbers show the depth of each cut as a percentage (0-100%)</li>
                     <li><strong>Success:</strong> When the key cuts match the pin heights, the lock will unlock</li>
-                    <li><strong>Failure:</strong> Wrong keys will be rejected and the key will reset</li>
+                    <li><strong>Failure:</strong> Wrong keys will flash the lock red and show key selection again</li>
                 </ul>
             </div>
         </div>
@@ -284,6 +287,7 @@
                 this.currentGame = null;
                 this.currentMode = 'key';
                 this.currentKey = 'key1';
+                this.keySelectionMode = false;
                 
                 // Key presets with different cut patterns
                 this.keyPresets = {
@@ -329,11 +333,16 @@
                 });
                 
                 // Key preset buttons
-                document.querySelectorAll('.key-preset').forEach(button => {
+                document.querySelectorAll('.key-preset[data-key]').forEach(button => {
                     button.addEventListener('click', () => {
                         this.setKey(button.dataset.key);
                     });
                 });
+                
+                // Key selection toggle button
+                document.getElementById('keySelectionToggle').addEventListener('click', () => {
+                    this.toggleKeySelection();
+                });
             }
             
             setMode(mode) {
@@ -352,9 +361,10 @@
             
             setKey(keyId) {
                 this.currentKey = keyId;
+                this.keySelectionMode = false;
                 
                 // Update button states
-                document.querySelectorAll('.key-preset').forEach(button => {
+                document.querySelectorAll('.key-preset[data-key]').forEach(button => {
                     button.classList.toggle('active', button.dataset.key === keyId);
                 });
                 
@@ -367,6 +377,39 @@
                 }
             }
             
+            toggleKeySelection() {
+                try {
+                    this.keySelectionMode = !this.keySelectionMode;
+                    
+                    if (this.keySelectionMode) {
+                        if (!this.currentGame) {
+                            throw new Error('No game instance available. Please start the game first.');
+                        }
+                        
+                        // Generate new random keys for selection
+                        this.currentGame.keySelectionMode = true; // Mark that we're in key selection mode
+                        this.currentGame.createKeysForChallenge('correct_key');
+                        
+                        // Update feedback
+                        document.getElementById('feedback').textContent = 
+                            "Select the correct key from the 3 new options above";
+                    } else {
+                        // Hide key selection UI if it exists
+                        if (this.currentGame.keySelectionContainer) {
+                            this.currentGame.keySelectionContainer.destroy();
+                            this.currentGame.keySelectionContainer = null;
+                        }
+                        
+                        // Update feedback
+                        document.getElementById('feedback').textContent = 
+                            "Key selection mode disabled. Use preset keys or enable random selection.";
+                    }
+                } catch (error) {
+                    console.error('Error toggling key selection:', error);
+                    document.getElementById('feedback').textContent = 'Error: ' + error.message;
+                }
+            }
+            
             updateKeyDisplay() {
                 const keyData = this.keyPresets[this.currentKey];
                 const keyCutsContainer = document.getElementById('keyCuts');
@@ -394,48 +437,61 @@
             }
             
             startGame() {
-                if (this.currentGame) {
-                    this.currentGame.cleanup();
-                }
-                
-                const params = {
-                    pinCount: 5,
-                    difficulty: 'medium',
-                    thresholdSensitivity: 5,
-                    highlightBindingOrder: true,
-                    pinAlignmentHighlighting: true,
-                    liftSpeed: 1.0,
-                    lockable: { id: 'key-demo-lock' },
-                    closeButtonText: 'Reset',
-                    closeButtonAction: 'reset'
-                };
-                
-                // Add key mode parameters if in key mode
-                if (this.currentMode === 'key') {
-                    params.keyMode = true;
-                    
-                    // For the "correct" key, don't pass keyData so it generates from pins
-                    // For other keys, use the preset cuts
-                    if (this.currentKey === 'key1') {
-                        // Let the game generate the correct key from actual pin heights
-                        console.log('Using auto-generated correct key from pin heights');
-                    } else {
-                        params.keyData = {
-                            cuts: this.keyPresets[this.currentKey].cuts
-                        };
+                try {
+                    if (this.currentGame) {
+                        this.currentGame.cleanup();
                     }
+                    
+                    const params = {
+                        pinCount: 5,
+                        difficulty: 'medium',
+                        thresholdSensitivity: 5,
+                        highlightBindingOrder: true,
+                        pinAlignmentHighlighting: true,
+                        liftSpeed: 1.0,
+                        lockable: { id: 'key-demo-lock' },
+                        closeButtonText: 'Reset',
+                        closeButtonAction: 'reset'
+                    };
+                    
+                    // Add key mode parameters if in key mode
+                    if (this.currentMode === 'key') {
+                        params.keyMode = true;
+                        params.skipStartingKey = true; // Skip creating initial key, go straight to selection
+                        
+                        // For the "correct" key, don't pass keyData so it generates from pins
+                        // For other keys, use the preset cuts
+                        if (this.currentKey === 'key1') {
+                            // Let the game generate the correct key from actual pin heights
+                            console.log('Using auto-generated correct key from pin heights');
+                        } else {
+                            params.keyData = {
+                                cuts: this.keyPresets[this.currentKey].cuts
+                            };
+                        }
+                    }
+                    
+                    console.log('Starting game with params:', params);
+                    
+                    this.currentGame = new LockpickingMinigamePhaser(
+                        document.getElementById('gameContainer'),
+                        params
+                    );
+                    
+                    this.currentGame.init();
+                    this.currentGame.start();
+                    
+                    // If in key mode, automatically show key selection
+                    if (this.currentMode === 'key') {
+                        setTimeout(() => {
+                            this.currentGame.startWithKeySelection();
+                        }, 500); // Small delay to ensure game is fully initialized
+                    }
+                } catch (error) {
+                    console.error('Error starting game:', error);
+                    document.getElementById('feedback').textContent = 'Error starting game: ' + error.message;
                 }
                 
-                console.log('Starting game with params:', params);
-                
-                this.currentGame = new LockpickingMinigamePhaser(
-                    document.getElementById('gameContainer'),
-                    params
-                );
-                
-                this.currentGame.init();
-                this.currentGame.start();
-                
                 // Update key display after game starts (for auto-generated correct key)
                 if (this.currentMode === 'key' && this.currentKey === 'key1') {
                     setTimeout(() => {
@@ -449,11 +505,21 @@
                     console.log('Game completed with success:', success);
                     
                     if (success) {
-                        document.getElementById('feedback').textContent = 
-                            `🎉 Success! ${this.keyPresets[this.currentKey].name} worked!`;
+                        if (this.keySelectionMode) {
+                            document.getElementById('feedback').textContent = 
+                                "🎉 Success! You selected the correct key!";
+                        } else {
+                            document.getElementById('feedback').textContent = 
+                                `🎉 Success! ${this.keyPresets[this.currentKey].name} worked!`;
+                        }
                     } else {
-                        document.getElementById('feedback').textContent = 
-                            `❌ Failed! ${this.keyPresets[this.currentKey].name} didn't work.`;
+                        if (this.keySelectionMode) {
+                            document.getElementById('feedback').textContent = 
+                                "❌ Failed! Wrong key selected. Try again!";
+                        } else {
+                            document.getElementById('feedback').textContent = 
+                                `❌ Failed! ${this.keyPresets[this.currentKey].name} didn't work.`;
+                        }
                     }
                     
                     // Restart after a delay
@@ -464,10 +530,25 @@
                     originalComplete(success);
                 };
                 
+                // Override the selectKey method to handle key selection feedback
+                const originalSelectKey = this.currentGame.selectKey.bind(this.currentGame);
+                this.currentGame.selectKey = (selectedIndex, correctIndex, keyData) => {
+                    // Don't reveal if correct/wrong yet - keep it suspenseful
+                    document.getElementById('feedback').textContent = 
+                        "🔑 Key selected! Inserting into lock...";
+                    
+                    originalSelectKey(selectedIndex, correctIndex, keyData);
+                };
+                
                 // Update feedback message
                 if (this.currentMode === 'key') {
-                    document.getElementById('feedback').textContent = 
-                        `Try inserting ${this.keyPresets[this.currentKey].name} into the lock (drag from left to right)`;
+                    if (this.keySelectionMode) {
+                        document.getElementById('feedback').textContent = 
+                            "Select the correct key from the 3 options above";
+                    } else {
+                        document.getElementById('feedback').textContent = 
+                            "Select a key from the options above to begin";
+                    }
                 } else {
                     document.getElementById('feedback').textContent = 
                         "Use the tension wrench and hook pick to manually pick the lock";
diff --git a/locksmith-forge.html b/locksmith-forge.html
index 8ad38ff..d537319 100644
--- a/locksmith-forge.html
+++ b/locksmith-forge.html
@@ -310,10 +310,11 @@
         <div class="level-display">LEVEL <span id="currentLevel">1</span></div>
         <div class="stats">
             <div class="stat">Pins: <span id="pinCount">3</span></div>
-            <div class="stat">Sensitivity: <span id="sensitivity">5</span></div>
-            <div class="stat">Lift Speed: <span id="liftSpeed">1.0</span></div>
-            <div class="stat">Binding Order: <span id="bindingHints">Enabled</span></div>
-            <div class="stat">Pin Alignment: <span id="alignmentHints">Enabled</span></div>
+            <div class="stat" id="sensitivityStat">Sensitivity: <span id="sensitivity">5</span></div>
+            <div class="stat" id="liftSpeedStat">Lift Speed: <span id="liftSpeed">1.0</span></div>
+            <div class="stat" id="bindingHintsStat">Binding Order: <span id="bindingHints">Enabled</span></div>
+            <div class="stat" id="alignmentHintsStat">Pin Alignment: <span id="alignmentHints">Enabled</span></div>
+            <div class="stat" id="gameModeStat">Mode: <span id="gameMode">Lockpicking</span></div>
         </div>
     </div>
     
@@ -438,11 +439,11 @@
                     let sensitivity = 1;
                     let liftSpeed = 0.6;
                     
-                    if (positionInBlock <= 5) {
-                        // First 5 levels: increase sensitivity
+                    if (positionInBlock % 2 === 1) {
+                        // odd numbers: increase sensitivity
                         sensitivity = 1 + Math.floor((positionInBlock - 1) / 2);
                     } else {
-                        // Last 5 levels: increase speed
+                        // even numbers: increase speed
                         const speedLevel = positionInBlock - 5;
                         liftSpeed = 0.6 + (speedLevel * 0.1);
                     }
@@ -465,6 +466,12 @@
                     // Hint settings based on position in 10-level block
                     let highlightBindingOrder = 'enabled';
                     let pinAlignmentHighlighting = 'enabled';
+                    let keyMode = false; // Default to lockpicking mode
+                    
+                    // Level 6 of each 10-level block: Key selection challenge
+                    if (positionInBlock === 6) {
+                        keyMode = true;
+                    }
                     
                     // Last 3 levels of each 10-level block remove hints progressively
                     if (positionInBlock === 8) {
@@ -485,7 +492,8 @@
                         sensitivity,
                         liftSpeed: parseFloat(liftSpeed.toFixed(2)),
                         highlightBindingOrder,
-                        pinAlignmentHighlighting
+                        pinAlignmentHighlighting,
+                        keyMode
                     };
                 }
                 
@@ -571,6 +579,12 @@
                     closeButtonAction: 'reset'
                 };
                 
+                // Add key mode parameters if this is a key selection level
+                if (config.keyMode) {
+                    params.keyMode = true;
+                    params.skipStartingKey = true; // Skip creating initial key, go straight to selection
+                }
+                
                 this.updateStatus(`Starting Level ${this.currentLevel}...`);
                 
                 console.log('Creating minigame with params:', params);
@@ -591,6 +605,42 @@
                 // Start the minigame
                 this.currentGame.start();
                 
+                // If this is a key mode level, automatically show key selection
+                if (config.keyMode) {
+                    setTimeout(() => {
+                        // Override the createKeysForChallenge method to use generic names
+                        const originalCreateKeysForChallenge = this.currentGame.createKeysForChallenge.bind(this.currentGame);
+                        this.currentGame.createKeysForChallenge = (correctKeyId = 'challenge_key') => {
+                            // Create keys for challenge mode (like locksmith-forge.html)
+                            // Generates 3 keys with one guaranteed correct key
+                            
+                            const key1 = this.currentGame.generateRandomKey(this.currentGame.pinCount);
+                            const key2 = this.currentGame.generateRandomKey(this.currentGame.pinCount);
+                            const key3 = this.currentGame.generateRandomKey(this.currentGame.pinCount);
+                            
+                            // Make the first key correct by copying the actual key cuts
+                            key1.cuts = this.currentGame.keyData.cuts;
+                            key1.id = correctKeyId;
+                            key1.name = `Key ${Math.floor(Math.random() * 1000)}`; // Generic name
+                            
+                            // Give other keys generic names too
+                            key2.name = `Key ${Math.floor(Math.random() * 1000)}`;
+                            key3.name = `Key ${Math.floor(Math.random() * 1000)}`;
+                            
+                            // Randomize the order of keys
+                            const keys = [key1, key2, key3];
+                            this.currentGame.shuffleArray(keys);
+                            
+                            // Find the new index of the correct key after shuffling
+                            const correctKeyIndex = keys.findIndex(key => key.id === correctKeyId);
+                            
+                            return this.currentGame.createKeySelectionUI(keys, correctKeyId);
+                        };
+                        
+                        this.currentGame.startWithKeySelection();
+                    }, 500); // Small delay to ensure game is fully initialized
+                }
+                
                 console.log('Minigame started');
                 
                 // Listen for completion by overriding the complete method
@@ -641,8 +691,14 @@
                             this.updateStatus(milestone.status);
                             this.showAchievement(milestone.achievement);
                         } else {
-                            this.updateStatus(`Level ${this.currentLevel} completed successfully!`);
-                            this.showAchievement(`Level ${this.currentLevel} Complete!`);
+                            const config = this.levelConfig[this.currentLevel];
+                            if (config && config.keyMode) {
+                                this.updateStatus(`Key selection challenge completed!`);
+                                this.showAchievement(`🔑 Key Master - Level ${this.currentLevel} Complete! 🔑`);
+                            } else {
+                                this.updateStatus(`Level ${this.currentLevel} completed successfully!`);
+                                this.showAchievement(`Level ${this.currentLevel} Complete!`);
+                            }
                         }
                     }
                     
@@ -710,6 +766,16 @@
                     document.getElementById('alignmentHints').textContent = config.pinAlignmentHighlighting === 'enabled' ? 'Visible' : 'Hidden';
                     document.getElementById('sensitivity').textContent = config.sensitivity;
                     document.getElementById('liftSpeed').textContent = config.liftSpeed;
+                    document.getElementById('gameMode').textContent = config.keyMode ? 'Key Selection' : 'Lockpicking';
+                    
+                    // Show/hide stats based on game mode
+                    const lockpickingStats = ['sensitivityStat', 'liftSpeedStat', 'bindingHintsStat', 'alignmentHintsStat'];
+                    lockpickingStats.forEach(statId => {
+                        const statElement = document.getElementById(statId);
+                        if (statElement) {
+                            statElement.style.display = config.keyMode ? 'none' : 'block';
+                        }
+                    });
                     
                     // Apply highlighting based on level position
                     this.highlightBasedOnLevel(config);
@@ -742,13 +808,13 @@
                             break;
                             
                         case 'sensitivity':
-                            // Highlight on levels 1-5 (sensitivity focus phase)
-                            shouldHighlight = (positionInBlock <= 5);
+                            // odd numbers: increase sensitivity
+                            shouldHighlight = (positionInBlock % 2 === 1);
                             break;
                             
                         case 'liftSpeed':
-                            // Highlight on levels 6-10 (speed focus phase)
-                            shouldHighlight = (positionInBlock >= 6);
+                            // even numbers: increase speed
+                            shouldHighlight = (positionInBlock % 2 === 0);
                             break;
                             
                         case 'bindingHints':
@@ -761,6 +827,11 @@
                             shouldHighlight = (config.pinAlignmentHighlighting === 'disabled');
                             break;
                             
+                        case 'gameMode':
+                            // Highlight when in key selection mode
+                            shouldHighlight = config.keyMode;
+                            break;
+                            
                         default:
                             shouldHighlight = false;
                     }
diff --git a/simple-phaser-test.html b/simple-phaser-test.html
deleted file mode 100644
index 5180cc7..0000000
--- a/simple-phaser-test.html
+++ /dev/null
@@ -1,103 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Simple Phaser Test</title>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            background: #1a1a1a;
-            color: #ffffff;
-            margin: 0;
-            padding: 20px;
-        }
-        
-        .test-container {
-            max-width: 800px;
-            margin: 0 auto;
-            background: #2a2a2a;
-            border-radius: 10px;
-            padding: 20px;
-        }
-        
-        .test-container h1 {
-            text-align: center;
-            color: #00ff00;
-        }
-        
-        #phaser-container {
-            width: 600px;
-            height: 400px;
-            background: #333;
-            border-radius: 5px;
-            margin: 20px auto;
-            border: 2px solid #444;
-        }
-        
-        .status {
-            text-align: center;
-            margin: 20px 0;
-            padding: 10px;
-            background: #444;
-            border-radius: 5px;
-        }
-    </style>
-</head>
-<body>
-    <div class="test-container">
-        <h1>Simple Phaser Test</h1>
-        <div class="status" id="status">Loading...</div>
-        <div id="phaser-container"></div>
-    </div>
-
-    <!-- Load Phaser.js -->
-    <script src="https://cdn.jsdelivr.net/npm/phaser@3.60.0/dist/phaser.min.js"></script>
-    
-    <script>
-        document.getElementById('status').textContent = 'Phaser loaded, creating game...';
-        
-        // Simple test scene
-        class TestScene extends Phaser.Scene {
-            constructor() {
-                super({ key: 'TestScene' });
-            }
-            
-            create() {
-                document.getElementById('status').textContent = 'Phaser scene created successfully!';
-                
-                // Create a simple rectangle
-                const graphics = this.add.graphics();
-                graphics.fillStyle(0x00ff00);
-                graphics.fillRect(100, 100, 200, 100);
-                
-                // Add some text
-                this.add.text(200, 150, 'Phaser Works!', {
-                    fontSize: '24px',
-                    fill: '#ffffff'
-                }).setOrigin(0.5);
-                
-                console.log('Test scene created successfully');
-            }
-        }
-        
-        // Game config
-        const config = {
-            type: Phaser.AUTO,
-            parent: 'phaser-container',
-            width: 600,
-            height: 400,
-            backgroundColor: '#1a1a1a',
-            scene: TestScene
-        };
-        
-        try {
-            const game = new Phaser.Game(config);
-            console.log('Phaser game created:', game);
-        } catch (error) {
-            console.error('Error creating Phaser game:', error);
-            document.getElementById('status').textContent = 'Error: ' + error.message;
-        }
-    </script>
-</body>
-</html> 
\ No newline at end of file