From 8bc296f1bc3a5ac8260ca24383de270e1ea9260c Mon Sep 17 00:00:00 2001
From: Nirav Ramdhanie <nirav@Vincents-MacBook-Pro.local>
Date: Wed, 7 May 2025 21:51:48 -0700
Subject: [PATCH 1/8] fixes movement and renames package

---
 app/build.gradle                              |  2 +-
 .../twod/game/Main.java                       |  5 +-
 .../twod/game/core/Game.java                  |  8 +-
 .../twod/game/core/GamePanel.java             | 11 ++-
 .../twod/game/core/GameStateManager.java      | 16 ++--
 .../twod/game/entity/BallPlayer.java          | 96 +++++++++----------
 .../twod/game/entity/Block.java               |  7 +-
 .../twod/game/entity/Entity.java              |  6 +-
 .../twod/game/graphics/Animation.java         |  2 +-
 .../twod/game/graphics/SpriteSheet.java       |  2 +-
 .../twod/game/input/KeyHandler.java           |  6 +-
 .../twod/game/input/MouseHandler.java         |  6 +-
 .../twod/game/state/GameState.java            |  6 +-
 .../twod/game/state/MenuState.java            | 10 +-
 .../twod/game/state/PauseState.java           |  8 +-
 .../twod/game/state/PlayState.java            | 12 +--
 .../twod/game/ui/Button.java                  |  3 +-
 .../twod/game/ui/HUD.java                     |  4 +-
 .../twod/game/ui/UIComponent.java             |  4 +-
 .../twod/game/utils/ResourceLoader.java       |  5 +-
 .../twod/game/utils/Vector2D.java             |  2 +-
 21 files changed, 106 insertions(+), 115 deletions(-)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/Main.java (90%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/core/Game.java (97%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/core/GamePanel.java (99%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/core/GameStateManager.java (94%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/entity/BallPlayer.java (84%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/entity/Block.java (93%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/entity/Entity.java (93%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/graphics/Animation.java (97%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/graphics/SpriteSheet.java (98%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/input/KeyHandler.java (90%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/input/MouseHandler.java (94%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/state/GameState.java (83%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/state/MenuState.java (97%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/state/PauseState.java (95%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/state/PlayState.java (96%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/ui/Button.java (98%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/ui/HUD.java (96%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/ui/UIComponent.java (94%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/utils/ResourceLoader.java (98%)
 rename app/src/main/java/com/{vincentramdhanie => niravramdhanie}/twod/game/utils/Vector2D.java (93%)

diff --git a/app/build.gradle b/app/build.gradle
index 75d9dc6..2866ff8 100644
--- a/app/build.gradle
+++ b/app/build.gradle
@@ -40,5 +40,5 @@ java {
 
 application {
     // Define the main class for the application.
-    mainClass = 'com.vincentramdhanie.twod.game.Main'
+    mainClass = 'com.niravramdhanie.twod.game.Main'
 }
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/Main.java b/app/src/main/java/com/niravramdhanie/twod/game/Main.java
similarity index 90%
rename from app/src/main/java/com/vincentramdhanie/twod/game/Main.java
rename to app/src/main/java/com/niravramdhanie/twod/game/Main.java
index 9019ee5..30d25ad 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/Main.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/Main.java
@@ -1,8 +1,9 @@
-package com.vincentramdhanie.twod.game;
+package com.niravramdhanie.twod.game;
 
-import com.vincentramdhanie.twod.game.core.Game;    
 import javax.swing.SwingUtilities;
 
+import com.niravramdhanie.twod.game.core.Game;
+
 public class Main {
     public static void main(String[] args) {
         System.out.println("Starting the game application...");
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/core/Game.java b/app/src/main/java/com/niravramdhanie/twod/game/core/Game.java
similarity index 97%
rename from app/src/main/java/com/vincentramdhanie/twod/game/core/Game.java
rename to app/src/main/java/com/niravramdhanie/twod/game/core/Game.java
index 8df1146..9e32cb7 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/core/Game.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/core/Game.java
@@ -1,12 +1,12 @@
-package com.vincentramdhanie.twod.game.core;
-
-import com.vincentramdhanie.twod.game.input.KeyHandler;
-import com.vincentramdhanie.twod.game.input.MouseHandler;
+package com.niravramdhanie.twod.game.core;
 
 import javax.swing.JFrame;
 import javax.swing.SwingUtilities;
 import javax.swing.Timer;
 
+import com.niravramdhanie.twod.game.input.KeyHandler;
+import com.niravramdhanie.twod.game.input.MouseHandler;
+
 public class Game implements Runnable {
     private JFrame window;
     private GamePanel gamePanel;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/core/GamePanel.java b/app/src/main/java/com/niravramdhanie/twod/game/core/GamePanel.java
similarity index 99%
rename from app/src/main/java/com/vincentramdhanie/twod/game/core/GamePanel.java
rename to app/src/main/java/com/niravramdhanie/twod/game/core/GamePanel.java
index 8100acc..9b30bbd 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/core/GamePanel.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/core/GamePanel.java
@@ -1,16 +1,17 @@
-package com.vincentramdhanie.twod.game.core;
+package com.niravramdhanie.twod.game.core;
 
-import javax.swing.JPanel;
+import java.awt.Color;
 import java.awt.Dimension;
+import java.awt.Font;
 import java.awt.Graphics;
 import java.awt.Graphics2D;
-import java.awt.Color;
-import java.awt.Font;
-import java.awt.RenderingHints;
 import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsEnvironment;
+import java.awt.RenderingHints;
 import java.awt.image.BufferedImage;
 
+import javax.swing.JPanel;
+
 public class GamePanel extends JPanel {
     private BufferedImage image;
     private Graphics2D g2d;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/core/GameStateManager.java b/app/src/main/java/com/niravramdhanie/twod/game/core/GameStateManager.java
similarity index 94%
rename from app/src/main/java/com/vincentramdhanie/twod/game/core/GameStateManager.java
rename to app/src/main/java/com/niravramdhanie/twod/game/core/GameStateManager.java
index 1bcd43b..c8c6f29 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/core/GameStateManager.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/core/GameStateManager.java
@@ -1,16 +1,16 @@
-package com.vincentramdhanie.twod.game.core;
-
-import com.vincentramdhanie.twod.game.state.GameState;
-import com.vincentramdhanie.twod.game.state.MenuState;
-import com.vincentramdhanie.twod.game.state.PlayState;
-import com.vincentramdhanie.twod.game.state.PauseState;
-import com.vincentramdhanie.twod.game.input.KeyHandler;
-import com.vincentramdhanie.twod.game.input.MouseHandler;
+package com.niravramdhanie.twod.game.core;
 
 import java.awt.Graphics2D;
 import java.util.ArrayList;
 import java.util.List;
 
+import com.niravramdhanie.twod.game.input.KeyHandler;
+import com.niravramdhanie.twod.game.input.MouseHandler;
+import com.niravramdhanie.twod.game.state.GameState;
+import com.niravramdhanie.twod.game.state.MenuState;
+import com.niravramdhanie.twod.game.state.PauseState;
+import com.niravramdhanie.twod.game.state.PlayState;
+
 public class GameStateManager {
     private List<GameState> gameStates;
     private int currentState;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/entity/BallPlayer.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/BallPlayer.java
similarity index 84%
rename from app/src/main/java/com/vincentramdhanie/twod/game/entity/BallPlayer.java
rename to app/src/main/java/com/niravramdhanie/twod/game/entity/BallPlayer.java
index 1228ba8..9430538 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/entity/BallPlayer.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/BallPlayer.java
@@ -1,14 +1,14 @@
-package com.vincentramdhanie.twod.game.entity;
+package com.niravramdhanie.twod.game.entity;
 
-import com.vincentramdhanie.twod.game.graphics.Animation;
-import com.vincentramdhanie.twod.game.graphics.SpriteSheet;
-import com.vincentramdhanie.twod.game.utils.ResourceLoader;
-
-import java.awt.Graphics2D;
 import java.awt.Color;
+import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
 import java.util.List;
 
+import com.niravramdhanie.twod.game.graphics.Animation;
+import com.niravramdhanie.twod.game.graphics.SpriteSheet;
+import com.niravramdhanie.twod.game.utils.ResourceLoader;
+
 public class BallPlayer extends Entity {
     // Movement flags
     private boolean left;
@@ -19,7 +19,6 @@ public class BallPlayer extends Entity {
     // Movement properties
     private float moveSpeed;
     private float maxSpeed;
-    private float friction;
     
     // Health properties
     private int health;
@@ -46,10 +45,9 @@ public BallPlayer(float x, float y, int width, int height, int screenWidth, int
         this.screenWidth = screenWidth;
         this.screenHeight = screenHeight;
         
-        // Set movement properties
-        moveSpeed = 0.5f;
-        maxSpeed = 5.0f;
-        friction = 0.1f;
+        // Set movement properties - instant movement with no friction
+        moveSpeed = 0.84f;   // 1.2f * 0.7 = 0.84f
+        maxSpeed = 2.8f;     // 4.0f * 0.7 = 2.8f
         
         // Set health properties
         this.maxHealth = 100;
@@ -129,31 +127,44 @@ public void update() {
         // Track previous animation for transition checks
         Animation previousAnim = currentAnim;
         
-        // Handle movement
-        // Apply acceleration based on input
-        if (left) {
-            velocity.x -= moveSpeed;
-            if (velocity.x < -maxSpeed) velocity.x = -maxSpeed;
-            if (spritesLoaded) currentAnim = leftAnim;
-        }
-        if (right) {
-            velocity.x += moveSpeed;
-            if (velocity.x > maxSpeed) velocity.x = maxSpeed;
-            if (spritesLoaded) currentAnim = rightAnim;
+        // Reset velocity immediately when no keys are pressed for instant stopping
+        if (!left && !right) velocity.x = 0;
+        if (!up && !down) velocity.y = 0;
+        
+        // Calculate input direction vector
+        float dirX = 0, dirY = 0;
+        if (left) dirX -= 1;
+        if (right) dirX += 1;
+        if (up) dirY -= 1;
+        if (down) dirY += 1;
+        
+        // Normalize diagonal movement
+        if (dirX != 0 && dirY != 0) {
+            // Calculate the normalized direction
+            float length = (float)Math.sqrt(dirX * dirX + dirY * dirY);
+            dirX /= length;
+            dirY /= length;
         }
-        if (up) {
-            velocity.y -= moveSpeed;
-            if (velocity.y < -maxSpeed) velocity.y = -maxSpeed;
-            if (spritesLoaded) currentAnim = upAnim;
+        
+        // Apply movement only if keys are pressed (no acceleration buildup)
+        if (dirX != 0) {
+            velocity.x = dirX * maxSpeed;
         }
-        if (down) {
-            velocity.y += moveSpeed;
-            if (velocity.y > maxSpeed) velocity.y = maxSpeed;
-            if (spritesLoaded) currentAnim = downAnim;
+        
+        if (dirY != 0) {
+            velocity.y = dirY * maxSpeed;
         }
         
-        // If no movement keys are pressed, use idle animation
-        if (!left && !right && !up && !down) {
+        // Set appropriate animation based on movement direction
+        if (velocity.x < 0 && Math.abs(velocity.x) > Math.abs(velocity.y)) {
+            if (spritesLoaded) currentAnim = leftAnim;
+        } else if (velocity.x > 0 && Math.abs(velocity.x) > Math.abs(velocity.y)) {
+            if (spritesLoaded) currentAnim = rightAnim;
+        } else if (velocity.y < 0 && Math.abs(velocity.y) > Math.abs(velocity.x)) {
+            if (spritesLoaded) currentAnim = upAnim;
+        } else if (velocity.y > 0 && Math.abs(velocity.y) > Math.abs(velocity.x)) {
+            if (spritesLoaded) currentAnim = downAnim;
+        } else if (velocity.x == 0 && velocity.y == 0) {
             if (spritesLoaded) currentAnim = idleAnim;
         }
         
@@ -162,27 +173,6 @@ public void update() {
             currentAnim.reset();
         }
         
-        // Apply friction
-        if (!left && !right) {
-            if (velocity.x > 0) {
-                velocity.x -= friction;
-                if (velocity.x < 0) velocity.x = 0;
-            } else if (velocity.x < 0) {
-                velocity.x += friction;
-                if (velocity.x > 0) velocity.x = 0;
-            }
-        }
-        
-        if (!up && !down) {
-            if (velocity.y > 0) {
-                velocity.y -= friction;
-                if (velocity.y < 0) velocity.y = 0;
-            } else if (velocity.y < 0) {
-                velocity.y += friction;
-                if (velocity.y > 0) velocity.y = 0;
-            }
-        }
-        
         // Calculate new position
         float newX = position.x + velocity.x;
         float newY = position.y + velocity.y;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/entity/Block.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Block.java
similarity index 93%
rename from app/src/main/java/com/vincentramdhanie/twod/game/entity/Block.java
rename to app/src/main/java/com/niravramdhanie/twod/game/entity/Block.java
index eb04e99..3cfb651 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/entity/Block.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Block.java
@@ -1,9 +1,10 @@
-package com.vincentramdhanie.twod.game.entity;
+package com.niravramdhanie.twod.game.entity;
 
-import java.awt.Graphics2D;
 import java.awt.Color;
+import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
-import com.vincentramdhanie.twod.game.utils.ResourceLoader;
+
+import com.niravramdhanie.twod.game.utils.ResourceLoader;
 
 public class Block extends Entity {
     private BufferedImage blockImage;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/entity/Entity.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Entity.java
similarity index 93%
rename from app/src/main/java/com/vincentramdhanie/twod/game/entity/Entity.java
rename to app/src/main/java/com/niravramdhanie/twod/game/entity/Entity.java
index 1593a12..3e35514 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/entity/Entity.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Entity.java
@@ -1,10 +1,10 @@
-package com.vincentramdhanie.twod.game.entity;
-
-import com.vincentramdhanie.twod.game.utils.Vector2D;
+package com.niravramdhanie.twod.game.entity;
 
 import java.awt.Graphics2D;
 import java.awt.Rectangle;
 
+import com.niravramdhanie.twod.game.utils.Vector2D;
+
 public abstract class Entity {
     protected Vector2D position;
     protected Vector2D velocity;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/graphics/Animation.java b/app/src/main/java/com/niravramdhanie/twod/game/graphics/Animation.java
similarity index 97%
rename from app/src/main/java/com/vincentramdhanie/twod/game/graphics/Animation.java
rename to app/src/main/java/com/niravramdhanie/twod/game/graphics/Animation.java
index 5fada75..958d641 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/graphics/Animation.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/graphics/Animation.java
@@ -1,4 +1,4 @@
-package com.vincentramdhanie.twod.game.graphics;
+package com.niravramdhanie.twod.game.graphics;
 
 import java.awt.image.BufferedImage;
 import java.util.ArrayList;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/graphics/SpriteSheet.java b/app/src/main/java/com/niravramdhanie/twod/game/graphics/SpriteSheet.java
similarity index 98%
rename from app/src/main/java/com/vincentramdhanie/twod/game/graphics/SpriteSheet.java
rename to app/src/main/java/com/niravramdhanie/twod/game/graphics/SpriteSheet.java
index be5eb13..a7f9228 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/graphics/SpriteSheet.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/graphics/SpriteSheet.java
@@ -1,4 +1,4 @@
-package com.vincentramdhanie.twod.game.graphics;
+package com.niravramdhanie.twod.game.graphics;
 
 import java.awt.image.BufferedImage;
 
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/input/KeyHandler.java b/app/src/main/java/com/niravramdhanie/twod/game/input/KeyHandler.java
similarity index 90%
rename from app/src/main/java/com/vincentramdhanie/twod/game/input/KeyHandler.java
rename to app/src/main/java/com/niravramdhanie/twod/game/input/KeyHandler.java
index 4922eb0..a68bd3f 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/input/KeyHandler.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/input/KeyHandler.java
@@ -1,10 +1,10 @@
-package com.vincentramdhanie.twod.game.input;
-
-import com.vincentramdhanie.twod.game.core.GameStateManager;
+package com.niravramdhanie.twod.game.input;
 
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 
+import com.niravramdhanie.twod.game.core.GameStateManager;
+
 public class KeyHandler implements KeyListener {
     private boolean[] keys;
     private GameStateManager gsm;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/input/MouseHandler.java b/app/src/main/java/com/niravramdhanie/twod/game/input/MouseHandler.java
similarity index 94%
rename from app/src/main/java/com/vincentramdhanie/twod/game/input/MouseHandler.java
rename to app/src/main/java/com/niravramdhanie/twod/game/input/MouseHandler.java
index 77545bc..c33f848 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/input/MouseHandler.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/input/MouseHandler.java
@@ -1,11 +1,11 @@
-package com.vincentramdhanie.twod.game.input;
-
-import com.vincentramdhanie.twod.game.core.GameStateManager;
+package com.niravramdhanie.twod.game.input;
 
 import java.awt.event.MouseEvent;
 import java.awt.event.MouseListener;
 import java.awt.event.MouseMotionListener;
 
+import com.niravramdhanie.twod.game.core.GameStateManager;
+
 public class MouseHandler implements MouseListener, MouseMotionListener {
     private int mouseX;
     private int mouseY;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/state/GameState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/GameState.java
similarity index 83%
rename from app/src/main/java/com/vincentramdhanie/twod/game/state/GameState.java
rename to app/src/main/java/com/niravramdhanie/twod/game/state/GameState.java
index 20f52bd..bc7a632 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/state/GameState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/GameState.java
@@ -1,9 +1,9 @@
-package com.vincentramdhanie.twod.game.state;
-
-import com.vincentramdhanie.twod.game.core.GameStateManager;
+package com.niravramdhanie.twod.game.state;
 
 import java.awt.Graphics2D;
 
+import com.niravramdhanie.twod.game.core.GameStateManager;
+
 public abstract class GameState {
     protected GameStateManager gsm;
     
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/state/MenuState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/MenuState.java
similarity index 97%
rename from app/src/main/java/com/vincentramdhanie/twod/game/state/MenuState.java
rename to app/src/main/java/com/niravramdhanie/twod/game/state/MenuState.java
index 74cf48b..aa0ff18 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/state/MenuState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/MenuState.java
@@ -1,8 +1,4 @@
-package com.vincentramdhanie.twod.game.state;
-
-import com.vincentramdhanie.twod.game.core.GameStateManager;
-import com.vincentramdhanie.twod.game.ui.Button;
-import com.vincentramdhanie.twod.game.utils.ResourceLoader;
+package com.niravramdhanie.twod.game.state;
 
 import java.awt.Color;
 import java.awt.Font;
@@ -11,6 +7,10 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import com.niravramdhanie.twod.game.core.GameStateManager;
+import com.niravramdhanie.twod.game.ui.Button;
+import com.niravramdhanie.twod.game.utils.ResourceLoader;
+
 public class MenuState extends GameState {
     private BufferedImage background;
     private List<Button> buttons;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/state/PauseState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PauseState.java
similarity index 95%
rename from app/src/main/java/com/vincentramdhanie/twod/game/state/PauseState.java
rename to app/src/main/java/com/niravramdhanie/twod/game/state/PauseState.java
index 81ecdef..d9a7be6 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/state/PauseState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PauseState.java
@@ -1,7 +1,4 @@
-package com.vincentramdhanie.twod.game.state;
-
-import com.vincentramdhanie.twod.game.core.GameStateManager;
-import com.vincentramdhanie.twod.game.ui.Button;
+package com.niravramdhanie.twod.game.state;
 
 import java.awt.Color;
 import java.awt.Font;
@@ -9,6 +6,9 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import com.niravramdhanie.twod.game.core.GameStateManager;
+import com.niravramdhanie.twod.game.ui.Button;
+
 public class PauseState extends GameState {
     private List<Button> buttons;
     private Font titleFont;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/state/PlayState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
similarity index 96%
rename from app/src/main/java/com/vincentramdhanie/twod/game/state/PlayState.java
rename to app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
index a444a52..143ff7a 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/state/PlayState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
@@ -1,16 +1,16 @@
-package com.vincentramdhanie.twod.game.state;
+package com.niravramdhanie.twod.game.state;
 
-import com.vincentramdhanie.twod.game.core.GameStateManager;
-import com.vincentramdhanie.twod.game.entity.BallPlayer;
-import com.vincentramdhanie.twod.game.entity.Block;
-
-import java.awt.Graphics2D;
 import java.awt.Color;
+import java.awt.Graphics2D;
 import java.awt.event.KeyEvent;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 
+import com.niravramdhanie.twod.game.core.GameStateManager;
+import com.niravramdhanie.twod.game.entity.BallPlayer;
+import com.niravramdhanie.twod.game.entity.Block;
+
 public class PlayState extends GameState {
     private BallPlayer player;
     private List<Block> blocks;
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/ui/Button.java b/app/src/main/java/com/niravramdhanie/twod/game/ui/Button.java
similarity index 98%
rename from app/src/main/java/com/vincentramdhanie/twod/game/ui/Button.java
rename to app/src/main/java/com/niravramdhanie/twod/game/ui/Button.java
index 7a0a537..ead558e 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/ui/Button.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/ui/Button.java
@@ -1,9 +1,8 @@
-package com.vincentramdhanie.twod.game.ui;
+package com.niravramdhanie.twod.game.ui;
 
 import java.awt.Color;
 import java.awt.Font;
 import java.awt.Graphics2D;
-import java.awt.event.MouseEvent;
 
 /**
  * Interactive button component for menus and UI
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/ui/HUD.java b/app/src/main/java/com/niravramdhanie/twod/game/ui/HUD.java
similarity index 96%
rename from app/src/main/java/com/vincentramdhanie/twod/game/ui/HUD.java
rename to app/src/main/java/com/niravramdhanie/twod/game/ui/HUD.java
index f18e963..4ea78a2 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/ui/HUD.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/ui/HUD.java
@@ -1,4 +1,4 @@
-package com.vincentramdhanie.twod.game.ui;
+package com.niravramdhanie.twod.game.ui;
 
 import java.awt.Color;
 import java.awt.Font;
@@ -6,7 +6,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import com.vincentramdhanie.twod.game.entity.BallPlayer;
+import com.niravramdhanie.twod.game.entity.BallPlayer;
 
 /**
  * Heads-Up Display for game information like health, score, etc.
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/ui/UIComponent.java b/app/src/main/java/com/niravramdhanie/twod/game/ui/UIComponent.java
similarity index 94%
rename from app/src/main/java/com/vincentramdhanie/twod/game/ui/UIComponent.java
rename to app/src/main/java/com/niravramdhanie/twod/game/ui/UIComponent.java
index 5aa05e5..d60adfe 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/ui/UIComponent.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/ui/UIComponent.java
@@ -1,7 +1,5 @@
-package com.vincentramdhanie.twod.game.ui;
+package com.niravramdhanie.twod.game.ui;
 
-import java.awt.Color;
-import java.awt.Font;
 import java.awt.Graphics2D;
 import java.awt.Rectangle;
 
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/utils/ResourceLoader.java b/app/src/main/java/com/niravramdhanie/twod/game/utils/ResourceLoader.java
similarity index 98%
rename from app/src/main/java/com/vincentramdhanie/twod/game/utils/ResourceLoader.java
rename to app/src/main/java/com/niravramdhanie/twod/game/utils/ResourceLoader.java
index 816fc24..5ece3b6 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/utils/ResourceLoader.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/utils/ResourceLoader.java
@@ -1,6 +1,5 @@
-package com.vincentramdhanie.twod.game.utils;
+package com.niravramdhanie.twod.game.utils;
 
-import javax.imageio.ImageIO;
 import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
@@ -10,6 +9,8 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import javax.imageio.ImageIO;
+
 public class ResourceLoader {
     // Cache loaded resources to avoid reloading the same resource multiple times
     private static final Map<String, BufferedImage> imageCache = new HashMap<>();
diff --git a/app/src/main/java/com/vincentramdhanie/twod/game/utils/Vector2D.java b/app/src/main/java/com/niravramdhanie/twod/game/utils/Vector2D.java
similarity index 93%
rename from app/src/main/java/com/vincentramdhanie/twod/game/utils/Vector2D.java
rename to app/src/main/java/com/niravramdhanie/twod/game/utils/Vector2D.java
index 2b3ac93..fd393e0 100644
--- a/app/src/main/java/com/vincentramdhanie/twod/game/utils/Vector2D.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/utils/Vector2D.java
@@ -1,4 +1,4 @@
-package com.vincentramdhanie.twod.game.utils;
+package com.niravramdhanie.twod.game.utils;
 
 public class Vector2D {
     public float x;

From 3eb9b5adaec07be6fa78f5e6b863c56ab5603590 Mon Sep 17 00:00:00 2001
From: Nirav Ramdhanie <nirav@Vincents-MacBook-Pro.local>
Date: Wed, 7 May 2025 22:29:43 -0700
Subject: [PATCH 2/8] Adds a grid system and makes a level system

---
 .../com/niravramdhanie/twod/game/Main.java    |   2 +-
 .../twod/game/entity/Entity.java              |   2 +
 .../niravramdhanie/twod/game/level/Level.java | 281 ++++++++++++++++++
 .../twod/game/state/PlayState.java            | 157 ++++++----
 .../twod/game/utils/GridSystem.java           | 222 ++++++++++++++
 5 files changed, 598 insertions(+), 66 deletions(-)
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/utils/GridSystem.java

diff --git a/app/src/main/java/com/niravramdhanie/twod/game/Main.java b/app/src/main/java/com/niravramdhanie/twod/game/Main.java
index 30d25ad..ddaf64a 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/Main.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/Main.java
@@ -16,7 +16,7 @@ public static void main(String[] args) {
             try {
                 // Create the game
                 System.out.println("Creating game instance");
-                Game game = new Game("My 2D Game", 800, 600);
+                Game game = new Game("My 2D Game", 1000, 750);
                 
                 // Game will start itself when initialization is complete
                 System.out.println("Game instance created");
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Entity.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Entity.java
index 3e35514..5eec890 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/entity/Entity.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Entity.java
@@ -42,6 +42,8 @@ public boolean checkCollision(Entity other) {
     public void setVelY(float vy) { velocity.y = vy; }
     public int getWidth() { return width; }
     public int getHeight() { return height; }
+    public void setWidth(int width) { this.width = width; }
+    public void setHeight(int height) { this.height = height; }
     public boolean isActive() { return active; }
     public void setActive(boolean active) { this.active = active; }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java b/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
new file mode 100644
index 0000000..87657ab
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
@@ -0,0 +1,281 @@
+package com.niravramdhanie.twod.game.level;
+
+import java.awt.Graphics2D;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import com.niravramdhanie.twod.game.entity.Block;
+import com.niravramdhanie.twod.game.entity.Entity;
+import com.niravramdhanie.twod.game.utils.GridSystem;
+
+/**
+ * Represents a game level with entities placed on a grid.
+ */
+public class Level {
+    private GridSystem grid;
+    private List<Entity> entities;
+    private Random random;
+    private int screenWidth;
+    private int screenHeight;
+    
+    /**
+     * Creates a new level with the specified dimensions.
+     * 
+     * @param screenWidth The width of the screen in pixels
+     * @param screenHeight The height of the screen in pixels
+     * @param gridCellSize The size of each grid cell in pixels
+     */
+    public Level(int screenWidth, int screenHeight, int gridCellSize) {
+        this.screenWidth = screenWidth;
+        this.screenHeight = screenHeight;
+        this.grid = new GridSystem(gridCellSize, gridCellSize, screenWidth, screenHeight);
+        this.entities = new ArrayList<>();
+        this.random = new Random();
+    }
+    
+    /**
+     * Adds a block at the specified grid position.
+     * 
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return True if the block was added successfully, false if the position was already occupied
+     */
+    public boolean addBlock(int gridX, int gridY) {
+        int cellSize = grid.getCellSize();
+        Block block = new Block(0, 0, cellSize, cellSize);
+        
+        if (grid.placeEntity(block, gridX, gridY)) {
+            entities.add(block);
+            return true;
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Adds any entity at the specified grid position.
+     * 
+     * @param entity The entity to add
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return True if the entity was added successfully, false if the position was already occupied
+     */
+    public boolean addEntity(Entity entity, int gridX, int gridY) {
+        int cellSize = grid.getCellSize();
+        entity.setWidth(cellSize);
+        entity.setHeight(cellSize);
+        
+        if (grid.placeEntity(entity, gridX, gridY)) {
+            entities.add(entity);
+            return true;
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Removes an entity at the specified grid position.
+     * 
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return True if an entity was removed, false otherwise
+     */
+    public boolean removeEntityAt(int gridX, int gridY) {
+        Entity entity = grid.removeEntity(gridX, gridY);
+        if (entity != null) {
+            entities.remove(entity);
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Gets the entity at the specified grid position.
+     * 
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return The entity at the specified position, or null if no entity is there
+     */
+    public Entity getEntityAt(int gridX, int gridY) {
+        return grid.getEntity(gridX, gridY);
+    }
+    
+    /**
+     * Adds blocks at random positions on the grid.
+     * 
+     * @param count The number of blocks to add
+     */
+    public void addRandomBlocks(int count) {
+        int horizontalCells = grid.getHorizontalCells();
+        int verticalCells = grid.getVerticalCells();
+        
+        // Reserve space for player at bottom center
+        int playerGridX = horizontalCells / 2;
+        int playerGridY = verticalCells - 3;
+        int reserveRadius = 2;
+        
+        for (int i = 0; i < count; i++) {
+            int attempts = 0;
+            boolean placed = false;
+            
+            while (!placed && attempts < 100) {
+                int gridX = random.nextInt(horizontalCells);
+                int gridY = random.nextInt(verticalCells);
+                
+                // Avoid the player spawn area
+                if (Math.abs(gridX - playerGridX) <= reserveRadius && 
+                    Math.abs(gridY - playerGridY) <= reserveRadius) {
+                    attempts++;
+                    continue;
+                }
+                
+                if (addBlock(gridX, gridY)) {
+                    placed = true;
+                } else {
+                    attempts++;
+                }
+            }
+        }
+    }
+    
+    /**
+     * Creates a border of blocks around the level.
+     */
+    public void addBorderBlocks() {
+        int horizontalCells = grid.getHorizontalCells();
+        int verticalCells = grid.getVerticalCells();
+        
+        // Add top and bottom borders
+        for (int x = 0; x < horizontalCells; x++) {
+            addBlock(x, 0);
+            addBlock(x, verticalCells - 1);
+        }
+        
+        // Add left and right borders (skip corners as they're already added)
+        for (int y = 1; y < verticalCells - 1; y++) {
+            addBlock(0, y);
+            addBlock(horizontalCells - 1, y);
+        }
+    }
+    
+    /**
+     * Updates all entities in the level.
+     */
+    public void update() {
+        for (Entity entity : entities) {
+            entity.update();
+        }
+    }
+    
+    /**
+     * Renders all entities in the level.
+     * 
+     * @param g The Graphics2D object to render to
+     */
+    public void render(Graphics2D g) {
+        for (Entity entity : entities) {
+            entity.render(g);
+        }
+    }
+    
+    /**
+     * Gets all entities in the level.
+     * 
+     * @return A list of all entities
+     */
+    public List<Entity> getEntities() {
+        return entities;
+    }
+    
+    /**
+     * Gets all blocks in the level.
+     * 
+     * @return A list of all blocks
+     */
+    public List<Block> getBlocks() {
+        List<Block> blocks = new ArrayList<>();
+        for (Entity entity : entities) {
+            if (entity instanceof Block) {
+                blocks.add((Block) entity);
+            }
+        }
+        return blocks;
+    }
+    
+    /**
+     * Gets the grid system.
+     * 
+     * @return The grid system
+     */
+    public GridSystem getGrid() {
+        return grid;
+    }
+    
+    /**
+     * Creates a predefined level layout.
+     * 
+     * @param layoutType The type of layout to create (1, 2, 3, etc.)
+     */
+    public void createLayout(int layoutType) {
+        clearLevel();
+        
+        switch (layoutType) {
+            case 1:
+                // Border with some blocks in the middle
+                addBorderBlocks();
+                addBlock(5, 5);
+                addBlock(5, 6);
+                addBlock(6, 5);
+                addBlock(10, 8);
+                addBlock(11, 8);
+                addBlock(12, 8);
+                break;
+                
+            case 2:
+                // Maze-like pattern
+                addBorderBlocks();
+                // Horizontal walls
+                for (int x = 5; x < 10; x++) {
+                    addBlock(x, 5);
+                    addBlock(x + 5, 10);
+                }
+                // Vertical walls
+                for (int y = 6; y < 10; y++) {
+                    addBlock(5, y);
+                    addBlock(15, y);
+                }
+                break;
+                
+            case 3:
+                // Random scattered blocks
+                addRandomBlocks(20);
+                break;
+                
+            default:
+                // Default: just add 10 random blocks
+                addRandomBlocks(10);
+                break;
+        }
+    }
+    
+    /**
+     * Clears all entities from the level.
+     */
+    public void clearLevel() {
+        entities.clear();
+        grid.clearGrid();
+    }
+    
+    /**
+     * Resizes the level to fit a new screen size.
+     * 
+     * @param newScreenWidth The new screen width in pixels
+     * @param newScreenHeight The new screen height in pixels
+     */
+    public void resize(int newScreenWidth, int newScreenHeight) {
+        this.screenWidth = newScreenWidth;
+        this.screenHeight = newScreenHeight;
+        grid.resize(newScreenWidth, newScreenHeight);
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
index 143ff7a..60a99d8 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
@@ -3,22 +3,23 @@
 import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.event.KeyEvent;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.Random;
 
 import com.niravramdhanie.twod.game.core.GameStateManager;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
-import com.niravramdhanie.twod.game.entity.Block;
+import com.niravramdhanie.twod.game.level.Level;
 
 public class PlayState extends GameState {
     private BallPlayer player;
-    private List<Block> blocks;
+    private Level level;
     private int screenWidth;
     private int screenHeight;
     private Random random;
     private boolean initialized = false;
     
+    // Grid cell size (can be easily changed)
+    private static final int GRID_CELL_SIZE = 32;
+    
     public PlayState(GameStateManager gsm, int screenWidth, int screenHeight) {
         super(gsm);
         this.screenWidth = screenWidth;
@@ -40,18 +41,28 @@ public PlayState(GameStateManager gsm) {
     public void init() {
         System.out.println("PlayState.init() called");
         
-        // Create blocks
-        blocks = new ArrayList<>();
-        createBlocks(10); // Create 10 random blocks
+        // Create the level with a grid
+        level = new Level(screenWidth, screenHeight, GRID_CELL_SIZE);
+        
+        // Create a level layout with random blocks
+        level.addRandomBlocks(10);
         
         try {
             // Create player in the lower middle of the screen
-            int playerSize = 32;
-            int playerX = screenWidth / 2 - playerSize / 2;
-            int playerY = screenHeight - playerSize - 50; // 50 pixels from bottom
+            int gridCellSize = level.getGrid().getCellSize();
+            int playerSize = gridCellSize; // Make player the same size as grid cells
+            
+            // Position player at the bottom middle of the grid
+            int gridX = level.getGrid().getHorizontalCells() / 2;
+            int gridY = level.getGrid().getVerticalCells() - 3;
+            int playerX = level.getGrid().gridToScreenX(gridX);
+            int playerY = level.getGrid().gridToScreenY(gridY);
+            
             System.out.println("Creating player at: " + playerX + "," + playerY);
             player = new BallPlayer(playerX, playerY, playerSize, playerSize, screenWidth, screenHeight);
-            player.setBlocks(blocks);
+            
+            // Pass the blocks to the player for collision detection
+            player.setBlocks(level.getBlocks());
             
             initialized = true;
             System.out.println("PlayState initialization complete");
@@ -61,59 +72,22 @@ public void init() {
         }
     }
     
-    private void createBlocks(int numBlocks) {
-        int blockWidth = 64;
-        int blockHeight = 64;
-        
-        for (int i = 0; i < numBlocks; i++) {
-            // Generate random positions, but don't spawn in the bottom center
-            // where the player will start
-            int x, y;
-            boolean validPosition;
-            
-            do {
-                validPosition = true;
-                x = random.nextInt(screenWidth - blockWidth);
-                y = random.nextInt(screenHeight - blockHeight);
-                
-                // Avoid spawning in the bottom center (player spawn area)
-                int playerSpawnX = screenWidth / 2 - 50; // 50 is half player spawn width
-                int playerSpawnY = screenHeight - 150; // 150 is approximate player spawn height
-                int playerSpawnWidth = 100; // Width of the spawn area
-                int playerSpawnHeight = 150; // Height of the spawn area
-                
-                // Check if block overlaps with player spawn area
-                if (x < playerSpawnX + playerSpawnWidth &&
-                    x + blockWidth > playerSpawnX &&
-                    y < playerSpawnY + playerSpawnHeight &&
-                    y + blockHeight > playerSpawnY) {
-                    validPosition = false;
-                }
-                
-                // Check if block overlaps with other blocks
-                for (Block block : blocks) {
-                    if (x < block.getX() + block.getWidth() + 10 &&
-                        x + blockWidth + 10 > block.getX() &&
-                        y < block.getY() + block.getHeight() + 10 &&
-                        y + blockHeight + 10 > block.getY()) {
-                        validPosition = false;
-                        break;
-                    }
-                }
-            } while (!validPosition);
-            
-            blocks.add(new Block(x, y, blockWidth, blockHeight));
-        }
+    /**
+     * Changes the current level layout
+     * @param layoutType The type of layout to create
+     */
+    public void setLevelLayout(int layoutType) {
+        level.createLayout(layoutType);
+        player.setBlocks(level.getBlocks());
     }
     
     @Override
     public void update() {
-        player.update();
+        // Update the level entities
+        level.update();
         
-        // Update blocks (if they had dynamic behavior)
-        for (Block block : blocks) {
-            block.update();
-        }
+        // Update the player
+        player.update();
     }
     
     @Override
@@ -122,12 +96,11 @@ public void render(Graphics2D g) {
         g.setColor(Color.BLACK);
         g.fillRect(0, 0, screenWidth, screenHeight);
         
-        // Draw blocks
-        if (blocks != null) {
-            for (Block block : blocks) {
-                block.render(g);
-            }
-        }
+        // Draw level (blocks and other entities)
+        level.render(g);
+        
+        // Draw grid lines for debugging (optional)
+        drawGridLines(g);
         
         // Draw player
         if (player != null) {
@@ -147,6 +120,54 @@ public void render(Graphics2D g) {
                 init();
             }
         }
+        
+        // Draw grid info
+        drawGridInfo(g);
+    }
+    
+    /**
+     * Draws debug grid lines
+     */
+    private void drawGridLines(Graphics2D g) {
+        if (level == null || level.getGrid() == null) return;
+        
+        g.setColor(new Color(50, 50, 50, 100)); // Semi-transparent gray
+        
+        int cellSize = level.getGrid().getCellSize();
+        int horizontalCells = level.getGrid().getHorizontalCells();
+        int verticalCells = level.getGrid().getVerticalCells();
+        
+        // Draw vertical lines
+        for (int x = 0; x <= horizontalCells; x++) {
+            int screenX = level.getGrid().gridToScreenX(x);
+            g.drawLine(screenX, 0, screenX, screenHeight);
+        }
+        
+        // Draw horizontal lines
+        for (int y = 0; y <= verticalCells; y++) {
+            int screenY = level.getGrid().gridToScreenY(y);
+            g.drawLine(0, screenY, screenWidth, screenY);
+        }
+    }
+    
+    /**
+     * Draws grid information for debugging
+     */
+    private void drawGridInfo(Graphics2D g) {
+        if (level == null || level.getGrid() == null) return;
+        
+        g.setColor(Color.WHITE);
+        g.drawString("Grid: " + level.getGrid().getHorizontalCells() + "x" + 
+                     level.getGrid().getVerticalCells() + " cells", 10, 20);
+        g.drawString("Cell size: " + level.getGrid().getCellSize() + "px", 10, 40);
+        g.drawString("Blocks: " + level.getBlocks().size(), 10, 60);
+        
+        // Show player grid position
+        if (player != null) {
+            int playerGridX = level.getGrid().screenToGridX((int)player.getX());
+            int playerGridY = level.getGrid().screenToGridY((int)player.getY());
+            g.drawString("Player grid pos: " + playerGridX + "," + playerGridY, 10, 80);
+        }
     }
     
     @Override
@@ -161,6 +182,12 @@ public void keyPressed(int k) {
         if (k == KeyEvent.VK_D) player.setRight(true);
         if (k == KeyEvent.VK_W) player.setUp(true);
         if (k == KeyEvent.VK_S) player.setDown(true);
+        
+        // Level layout switching for testing
+        if (k == KeyEvent.VK_1) setLevelLayout(1);
+        if (k == KeyEvent.VK_2) setLevelLayout(2);
+        if (k == KeyEvent.VK_3) setLevelLayout(3);
+        if (k == KeyEvent.VK_R) setLevelLayout(0); // Random blocks
     }
     
     @Override
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/utils/GridSystem.java b/app/src/main/java/com/niravramdhanie/twod/game/utils/GridSystem.java
new file mode 100644
index 0000000..e821761
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/utils/GridSystem.java
@@ -0,0 +1,222 @@
+package com.niravramdhanie.twod.game.utils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.niravramdhanie.twod.game.entity.Entity;
+
+/**
+ * A grid system for organizing and placing game entities.
+ * The grid spans the entire screen and scales to fit screens of any size.
+ */
+public class GridSystem {
+    private int gridWidth;
+    private int gridHeight;
+    private int cellSize;
+    private int screenWidth;
+    private int screenHeight;
+    private int horizontalCells;
+    private int verticalCells;
+    private Map<String, Entity> gridEntities;
+    
+    /**
+     * Creates a new grid system with the specified dimensions.
+     * 
+     * @param gridWidth The width of each grid cell in pixels (before scaling)
+     * @param gridHeight The height of each grid cell in pixels (before scaling)
+     * @param screenWidth The width of the screen in pixels
+     * @param screenHeight The height of the screen in pixels
+     */
+    public GridSystem(int gridWidth, int gridHeight, int screenWidth, int screenHeight) {
+        this.gridWidth = gridWidth;
+        this.gridHeight = gridHeight;
+        this.screenWidth = screenWidth;
+        this.screenHeight = screenHeight;
+        this.gridEntities = new HashMap<>();
+        
+        // Calculate the number of cells that fit horizontally and vertically
+        this.horizontalCells = screenWidth / gridWidth;
+        this.verticalCells = screenHeight / gridHeight;
+        
+        // Calculate the actual cell size after scaling to fit the screen
+        this.cellSize = Math.min(screenWidth / horizontalCells, screenHeight / verticalCells);
+        
+        System.out.println("Grid created: " + horizontalCells + "x" + verticalCells + 
+                           " cells, cell size: " + cellSize + "px");
+    }
+    
+    /**
+     * Returns the real-world X position for a grid X coordinate.
+     * 
+     * @param gridX The X position on the grid
+     * @return The actual X position in pixels
+     */
+    public int gridToScreenX(int gridX) {
+        return gridX * cellSize;
+    }
+    
+    /**
+     * Returns the real-world Y position for a grid Y coordinate.
+     * 
+     * @param gridY The Y position on the grid
+     * @return The actual Y position in pixels
+     */
+    public int gridToScreenY(int gridY) {
+        return gridY * cellSize;
+    }
+    
+    /**
+     * Converts a screen X coordinate to a grid X coordinate.
+     * 
+     * @param screenX The X position in pixels
+     * @return The X position on the grid
+     */
+    public int screenToGridX(int screenX) {
+        return screenX / cellSize;
+    }
+    
+    /**
+     * Converts a screen Y coordinate to a grid Y coordinate.
+     * 
+     * @param screenY The Y position in pixels
+     * @return The Y position on the grid
+     */
+    public int screenToGridY(int screenY) {
+        return screenY / cellSize;
+    }
+    
+    /**
+     * Places an entity at the specified grid position.
+     * 
+     * @param entity The entity to place
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return True if the entity was placed successfully, false if the cell was already occupied
+     */
+    public boolean placeEntity(Entity entity, int gridX, int gridY) {
+        String key = gridX + "," + gridY;
+        
+        // Check if the cell is already occupied
+        if (gridEntities.containsKey(key)) {
+            System.out.println("Cell " + gridX + "," + gridY + " is already occupied");
+            return false;
+        }
+        
+        // Calculate the actual position in pixels
+        float x = gridToScreenX(gridX);
+        float y = gridToScreenY(gridY);
+        
+        // Set the entity's position
+        entity.setX(x);
+        entity.setY(y);
+        
+        // Store the entity in the grid
+        gridEntities.put(key, entity);
+        
+        System.out.println("Placed entity at grid " + gridX + "," + gridY + " (pixel: " + x + "," + y + ")");
+        return true;
+    }
+    
+    /**
+     * Removes an entity from the specified grid position.
+     * 
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return The entity that was removed, or null if no entity was at that position
+     */
+    public Entity removeEntity(int gridX, int gridY) {
+        String key = gridX + "," + gridY;
+        return gridEntities.remove(key);
+    }
+    
+    /**
+     * Gets the entity at the specified grid position.
+     * 
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return The entity at the specified position, or null if no entity is there
+     */
+    public Entity getEntity(int gridX, int gridY) {
+        String key = gridX + "," + gridY;
+        return gridEntities.get(key);
+    }
+    
+    /**
+     * Checks if a grid position is occupied by an entity.
+     * 
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return True if the position is occupied, false otherwise
+     */
+    public boolean isOccupied(int gridX, int gridY) {
+        String key = gridX + "," + gridY;
+        return gridEntities.containsKey(key);
+    }
+    
+    /**
+     * Clears all entities from the grid.
+     */
+    public void clearGrid() {
+        gridEntities.clear();
+    }
+    
+    /**
+     * Gets the width of a grid cell in pixels.
+     * 
+     * @return The cell size
+     */
+    public int getCellSize() {
+        return cellSize;
+    }
+    
+    /**
+     * Gets the number of horizontal cells in the grid.
+     * 
+     * @return The number of horizontal cells
+     */
+    public int getHorizontalCells() {
+        return horizontalCells;
+    }
+    
+    /**
+     * Gets the number of vertical cells in the grid.
+     * 
+     * @return The number of vertical cells
+     */
+    public int getVerticalCells() {
+        return verticalCells;
+    }
+    
+    /**
+     * Resizes the grid to fit a new screen size.
+     * 
+     * @param newScreenWidth The new screen width in pixels
+     * @param newScreenHeight The new screen height in pixels
+     */
+    public void resize(int newScreenWidth, int newScreenHeight) {
+        this.screenWidth = newScreenWidth;
+        this.screenHeight = newScreenHeight;
+        
+        // Recalculate the grid dimensions
+        this.horizontalCells = screenWidth / gridWidth;
+        this.verticalCells = screenHeight / gridHeight;
+        this.cellSize = Math.min(screenWidth / horizontalCells, screenHeight / verticalCells);
+        
+        // Reposition all entities based on the new grid size
+        Map<String, Entity> newPositions = new HashMap<>();
+        for (Map.Entry<String, Entity> entry : gridEntities.entrySet()) {
+            String[] coords = entry.getKey().split(",");
+            int gridX = Integer.parseInt(coords[0]);
+            int gridY = Integer.parseInt(coords[1]);
+            
+            Entity entity = entry.getValue();
+            entity.setX(gridToScreenX(gridX));
+            entity.setY(gridToScreenY(gridY));
+            
+            newPositions.put(gridX + "," + gridY, entity);
+        }
+        
+        // Replace the grid entities with the repositioned ones
+        this.gridEntities = newPositions;
+    }
+} 
\ No newline at end of file

From b5454c64ae1a8a9f98a3375d7eba7cbef127b239 Mon Sep 17 00:00:00 2001
From: Nirav Ramdhanie <nirav@Vincents-MacBook-Pro.local>
Date: Thu, 8 May 2025 11:16:11 -0700
Subject: [PATCH 3/8] Added Button and action list for button

---
 .../twod/game/actions/Action.java             |  18 +
 .../twod/game/actions/ActionFactory.java      | 159 +++++++++
 .../twod/game/actions/DoorAction.java         | 104 ++++++
 .../twod/game/actions/MessageAction.java      | 128 +++++++
 .../twod/game/actions/MultiAction.java        | 104 ++++++
 .../twod/game/actions/PrintAction.java        |  52 +++
 .../twod/game/actions/TimedAction.java        | 154 +++++++++
 .../twod/game/actions/ToggleAction.java       | 113 +++++++
 .../twod/game/entity/Button.java              | 315 ++++++++++++++++++
 .../niravramdhanie/twod/game/level/Level.java |  55 +++
 .../twod/game/state/PlayState.java            | 146 ++++++++
 11 files changed, 1348 insertions(+)
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/Action.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/ActionFactory.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/DoorAction.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/MessageAction.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/MultiAction.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/PrintAction.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/TimedAction.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/ToggleAction.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java

diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/Action.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/Action.java
new file mode 100644
index 0000000..da853e2
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/Action.java
@@ -0,0 +1,18 @@
+package com.niravramdhanie.twod.game.actions;
+
+/**
+ * Interface for actions that can be executed when a button is pressed.
+ */
+public interface Action {
+    /**
+     * Executes the action.
+     */
+    void execute();
+    
+    /**
+     * Gets a description of the action.
+     * 
+     * @return A description of what the action does
+     */
+    String getDescription();
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/ActionFactory.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/ActionFactory.java
new file mode 100644
index 0000000..363671d
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/ActionFactory.java
@@ -0,0 +1,159 @@
+package com.niravramdhanie.twod.game.actions;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
+import com.niravramdhanie.twod.game.entity.Button;
+
+/**
+ * Factory class for creating different types of actions for buttons.
+ */
+public class ActionFactory {
+    private static final Random random = new Random();
+    
+    /**
+     * Action types enum
+     */
+    public enum ActionType {
+        MESSAGE,
+        TIMED,
+        TOGGLE,
+        DOOR,
+        MULTI,
+        CYCLING_MESSAGE,
+        TIMED_TOGGLE,     // A timed action that toggles
+        COMBINED         // Multiple actions combined
+    }
+    
+    /**
+     * Creates an action of the specified type.
+     * 
+     * @param type The type of action to create
+     * @param button The button that will use this action (needed for timed actions)
+     * @return The created action
+     */
+    public static Action createAction(ActionType type, Button button) {
+        switch (type) {
+            case MESSAGE:
+                return new MessageAction("Button pressed: " + type.name());
+                
+            case CYCLING_MESSAGE:
+                return new MessageAction(true, 
+                    "This is message 1", 
+                    "This is message 2", 
+                    "This is message 3",
+                    "Press again to cycle to the next message");
+                
+            case TIMED:
+                MessageAction msgAction = new MessageAction("Timed button pressed! Will deactivate in 3 seconds.");
+                TimedAction timedAction = new TimedAction(msgAction, 3000);
+                timedAction.setTargetButton(button);
+                return timedAction;
+                
+            case TOGGLE:
+                DoorAction doorAction = new DoorAction("toggle_door_" + random.nextInt(1000));
+                doorAction.setDoorStateChangeListener((doorId, isOpen) -> {
+                    System.out.println("Door listener: Door " + doorId + " is now " + (isOpen ? "open" : "closed"));
+                });
+                return new ToggleAction(doorAction, doorAction);
+                
+            case DOOR:
+                DoorAction simpleDoor = new DoorAction("simple_door_" + random.nextInt(1000));
+                return simpleDoor;
+                
+            case MULTI:
+                // Create a multi-action with several different actions
+                MessageAction firstAction = new MessageAction("First action executed!");
+                MessageAction secondAction = new MessageAction("Second action executed!");
+                DoorAction thirdAction = new DoorAction("multi_door_" + random.nextInt(1000));
+                thirdAction.setDoorStateChangeListener((doorId, isOpen) -> {
+                    System.out.println("MultiAction door: " + doorId + " is now " + (isOpen ? "open" : "closed"));
+                });
+                
+                return new MultiAction(firstAction, secondAction, thirdAction);
+                
+            case TIMED_TOGGLE:
+                // Create a timed action that wraps a toggle action
+                ToggleAction toggleAction = new ToggleAction(
+                    new MessageAction("Toggled OFF"),
+                    new MessageAction("Toggled ON")
+                );
+                TimedAction timedToggle = new TimedAction(toggleAction, 5000);
+                timedToggle.setTargetButton(button);
+                return timedToggle;
+                
+            case COMBINED:
+                // Create a combination of different action types
+                // This example creates a multi-action with cycling messages and a door action
+                MessageAction cyclingMsg = new MessageAction(true, 
+                    "Combined action - Message 1",
+                    "Combined action - Message 2",
+                    "Combined action - Message 3");
+                
+                DoorAction combinedDoor = new DoorAction("combined_door_" + random.nextInt(1000));
+                combinedDoor.setDoorStateChangeListener((doorId, isOpen) -> {
+                    System.out.println("Combined door: " + doorId + " is now " + (isOpen ? "open" : "closed"));
+                });
+                
+                return new MultiAction(cyclingMsg, combinedDoor);
+                
+            default:
+                return new MessageAction("Default action");
+        }
+    }
+    
+    /**
+     * Creates a random action.
+     * 
+     * @param button The button that will use this action
+     * @return A randomly selected action
+     */
+    public static Action createRandomAction(Button button) {
+        ActionType[] types = ActionType.values();
+        ActionType randomType = types[random.nextInt(types.length)];
+        
+        return createAction(randomType, button);
+    }
+    
+    /**
+     * Creates one of each action type.
+     * 
+     * @param button The button that will use these actions (for timed actions)
+     * @return A list containing one of each action type
+     */
+    public static List<Action> createAllActionTypes(Button button) {
+        List<Action> actions = new ArrayList<>();
+        
+        for (ActionType type : ActionType.values()) {
+            actions.add(createAction(type, button));
+        }
+        
+        return actions;
+    }
+    
+    /**
+     * Creates a timed message action.
+     * 
+     * @param message The message to display
+     * @param durationMillis The duration in milliseconds
+     * @param button The button to deactivate
+     * @return A timed message action
+     */
+    public static TimedAction createTimedMessage(String message, int durationMillis, Button button) {
+        MessageAction msgAction = new MessageAction(message);
+        TimedAction timedAction = new TimedAction(msgAction, durationMillis);
+        timedAction.setTargetButton(button);
+        return timedAction;
+    }
+    
+    /**
+     * Creates a cycling message action.
+     * 
+     * @param messages The messages to cycle through
+     * @return A cycling message action
+     */
+    public static MessageAction createCyclingMessage(String... messages) {
+        return new MessageAction(true, messages);
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/DoorAction.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/DoorAction.java
new file mode 100644
index 0000000..e51b032
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/DoorAction.java
@@ -0,0 +1,104 @@
+package com.niravramdhanie.twod.game.actions;
+
+/**
+ * An action that simulates opening or closing a door.
+ */
+public class DoorAction implements Action {
+    private String doorId;
+    private boolean doorOpen;
+    private DoorStateChangeListener listener;
+    
+    /**
+     * Creates a new door action.
+     * 
+     * @param doorId The ID of the door
+     */
+    public DoorAction(String doorId) {
+        this.doorId = doorId;
+        this.doorOpen = false;
+        this.listener = null;
+    }
+    
+    @Override
+    public void execute() {
+        // Toggle the door state
+        doorOpen = !doorOpen;
+        
+        // Notify the listener if present
+        if (listener != null) {
+            listener.onDoorStateChanged(doorId, doorOpen);
+        }
+        
+        // Print a message to the console
+        System.out.println("Door " + doorId + " is now " + (doorOpen ? "open" : "closed"));
+    }
+    
+    @Override
+    public String getDescription() {
+        return "Door '" + doorId + "' - " + (doorOpen ? "OPEN" : "CLOSED");
+    }
+    
+    /**
+     * Interface for components that need to be notified of door state changes.
+     */
+    public interface DoorStateChangeListener {
+        /**
+         * Called when a door's state changes.
+         * 
+         * @param doorId The ID of the door
+         * @param isOpen True if the door is now open, false if closed
+         */
+        void onDoorStateChanged(String doorId, boolean isOpen);
+    }
+    
+    /**
+     * Sets the listener for door state changes.
+     * 
+     * @param listener The listener to notify when the door state changes
+     */
+    public void setDoorStateChangeListener(DoorStateChangeListener listener) {
+        this.listener = listener;
+    }
+    
+    /**
+     * Gets the door ID.
+     * 
+     * @return The door ID
+     */
+    public String getDoorId() {
+        return doorId;
+    }
+    
+    /**
+     * Sets the door ID.
+     * 
+     * @param doorId The door ID
+     */
+    public void setDoorId(String doorId) {
+        this.doorId = doorId;
+    }
+    
+    /**
+     * Checks if the door is open.
+     * 
+     * @return True if the door is open, false if closed
+     */
+    public boolean isDoorOpen() {
+        return doorOpen;
+    }
+    
+    /**
+     * Sets the door state.
+     * 
+     * @param doorOpen True to set as open, false for closed
+     */
+    public void setDoorOpen(boolean doorOpen) {
+        boolean oldState = this.doorOpen;
+        this.doorOpen = doorOpen;
+        
+        // If the state changed and we have a listener, notify it
+        if (oldState != doorOpen && listener != null) {
+            listener.onDoorStateChanged(doorId, doorOpen);
+        }
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/MessageAction.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/MessageAction.java
new file mode 100644
index 0000000..33d21a7
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/MessageAction.java
@@ -0,0 +1,128 @@
+package com.niravramdhanie.twod.game.actions;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * An enhanced version of PrintAction that can cycle through multiple messages.
+ */
+public class MessageAction implements Action {
+    private List<String> messages;
+    private int currentMessageIndex;
+    private boolean cycling;
+    
+    /**
+     * Creates a new message action with a single message.
+     * 
+     * @param message The message to display
+     */
+    public MessageAction(String message) {
+        this.messages = new ArrayList<>();
+        this.messages.add(message);
+        this.currentMessageIndex = 0;
+        this.cycling = false;
+    }
+    
+    /**
+     * Creates a new message action with multiple messages that will cycle when executed.
+     * 
+     * @param cycling Whether to cycle through messages
+     * @param messages The messages to cycle through
+     */
+    public MessageAction(boolean cycling, String... messages) {
+        this.messages = new ArrayList<>(Arrays.asList(messages));
+        this.currentMessageIndex = 0;
+        this.cycling = cycling;
+    }
+    
+    @Override
+    public void execute() {
+        // Print the current message
+        if (!messages.isEmpty()) {
+            System.out.println(getCurrentMessage());
+            
+            // Move to the next message if cycling is enabled
+            if (cycling) {
+                currentMessageIndex = (currentMessageIndex + 1) % messages.size();
+            }
+        }
+    }
+    
+    @Override
+    public String getDescription() {
+        if (cycling) {
+            return "Cycling message (" + (currentMessageIndex + 1) + "/" + messages.size() + ")";
+        } else {
+            return "Message: " + getCurrentMessage();
+        }
+    }
+    
+    /**
+     * Gets the current message.
+     * 
+     * @return The current message
+     */
+    public String getCurrentMessage() {
+        if (messages.isEmpty()) {
+            return "No message";
+        }
+        return messages.get(currentMessageIndex);
+    }
+    
+    /**
+     * Gets all messages.
+     * 
+     * @return The list of messages
+     */
+    public List<String> getMessages() {
+        return messages;
+    }
+    
+    /**
+     * Adds a message to the list.
+     * 
+     * @param message The message to add
+     */
+    public void addMessage(String message) {
+        messages.add(message);
+    }
+    
+    /**
+     * Sets whether the action should cycle through messages.
+     * 
+     * @param cycling True to cycle, false to stay on the current message
+     */
+    public void setCycling(boolean cycling) {
+        this.cycling = cycling;
+    }
+    
+    /**
+     * Checks if the action is cycling through messages.
+     * 
+     * @return True if cycling, false otherwise
+     */
+    public boolean isCycling() {
+        return cycling;
+    }
+    
+    /**
+     * Gets the current message index.
+     * 
+     * @return The current message index
+     */
+    public int getCurrentMessageIndex() {
+        return currentMessageIndex;
+    }
+    
+    /**
+     * Sets the current message index.
+     * 
+     * @param index The index to set
+     */
+    public void setCurrentMessageIndex(int index) {
+        if (index >= 0 && index < messages.size()) {
+            currentMessageIndex = index;
+        }
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/MultiAction.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/MultiAction.java
new file mode 100644
index 0000000..b4713e2
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/MultiAction.java
@@ -0,0 +1,104 @@
+package com.niravramdhanie.twod.game.actions;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * An action that executes multiple actions in sequence.
+ */
+public class MultiAction implements Action {
+    private List<Action> actions;
+    
+    /**
+     * Creates a new multi-action with the given actions.
+     * 
+     * @param actions The actions to execute in sequence
+     */
+    public MultiAction(Action... actions) {
+        this.actions = new ArrayList<>(Arrays.asList(actions));
+    }
+    
+    /**
+     * Creates a new multi-action with a list of actions.
+     * 
+     * @param actions The list of actions to execute
+     */
+    public MultiAction(List<Action> actions) {
+        this.actions = new ArrayList<>(actions);
+    }
+    
+    @Override
+    public void execute() {
+        // Execute each action in sequence
+        for (Action action : actions) {
+            if (action != null) {
+                action.execute();
+            }
+        }
+    }
+    
+    @Override
+    public String getDescription() {
+        StringBuilder description = new StringBuilder("Multi-action (");
+        description.append(actions.size()).append(" actions)");
+        
+        // Add descriptions of individual actions if there aren't too many
+        if (actions.size() <= 3) {
+            description.append(": ");
+            for (int i = 0; i < actions.size(); i++) {
+                if (i > 0) {
+                    description.append(" → ");
+                }
+                Action action = actions.get(i);
+                description.append(action != null ? action.getDescription() : "null");
+            }
+        }
+        
+        return description.toString();
+    }
+    
+    /**
+     * Adds an action to the sequence.
+     * 
+     * @param action The action to add
+     */
+    public void addAction(Action action) {
+        actions.add(action);
+    }
+    
+    /**
+     * Removes an action from the sequence.
+     * 
+     * @param action The action to remove
+     * @return True if the action was found and removed, false otherwise
+     */
+    public boolean removeAction(Action action) {
+        return actions.remove(action);
+    }
+    
+    /**
+     * Gets all actions in the sequence.
+     * 
+     * @return The list of actions
+     */
+    public List<Action> getActions() {
+        return actions;
+    }
+    
+    /**
+     * Clears all actions.
+     */
+    public void clearActions() {
+        actions.clear();
+    }
+    
+    /**
+     * Gets the number of actions.
+     * 
+     * @return The number of actions
+     */
+    public int getActionCount() {
+        return actions.size();
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/PrintAction.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/PrintAction.java
new file mode 100644
index 0000000..217d120
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/PrintAction.java
@@ -0,0 +1,52 @@
+package com.niravramdhanie.twod.game.actions;
+
+/**
+ * A simple action that prints a message to the console.
+ */
+public class PrintAction implements Action {
+    private String message;
+    
+    /**
+     * Creates a new print action with the given message.
+     * 
+     * @param message The message to print
+     */
+    public PrintAction(String message) {
+        this.message = message;
+    }
+    
+    /**
+     * Creates a new print action with the default message.
+     */
+    public PrintAction() {
+        this("Button pressed");
+    }
+    
+    @Override
+    public void execute() {
+        System.out.println(message);
+    }
+    
+    @Override
+    public String getDescription() {
+        return "Prints: " + message;
+    }
+    
+    /**
+     * Sets the message to print.
+     * 
+     * @param message The new message
+     */
+    public void setMessage(String message) {
+        this.message = message;
+    }
+    
+    /**
+     * Gets the message that will be printed.
+     * 
+     * @return The message
+     */
+    public String getMessage() {
+        return message;
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/TimedAction.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/TimedAction.java
new file mode 100644
index 0000000..f0e0908
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/TimedAction.java
@@ -0,0 +1,154 @@
+package com.niravramdhanie.twod.game.actions;
+
+import com.niravramdhanie.twod.game.entity.Button;
+
+/**
+ * An action that executes another action and then automatically deactivates the button after a specified duration.
+ */
+public class TimedAction implements Action {
+    private Action wrappedAction;
+    private int duration; // in milliseconds
+    private Button targetButton;
+    private long activationTime;
+    
+    /**
+     * Creates a new timed action.
+     * 
+     * @param wrappedAction The action to execute
+     * @param duration The duration in milliseconds before the button deactivates
+     */
+    public TimedAction(Action wrappedAction, int duration) {
+        this.wrappedAction = wrappedAction;
+        this.duration = duration;
+        this.activationTime = 0;
+    }
+    
+    /**
+     * Creates a timed action with a default duration of 3 seconds.
+     * 
+     * @param wrappedAction The action to execute
+     */
+    public TimedAction(Action wrappedAction) {
+        this(wrappedAction, 3000); // Default 3 seconds
+    }
+    
+    /**
+     * Creates a timed message action with the specified message and duration.
+     * 
+     * @param message The message to display
+     * @param durationMillis The duration in milliseconds before deactivation
+     */
+    public static TimedAction createTimedMessage(String message, int durationMillis) {
+        MessageAction msgAction = new MessageAction(message);
+        TimedAction timedAction = new TimedAction(msgAction, durationMillis);
+        return timedAction;
+    }
+    
+    @Override
+    public void execute() {
+        // Execute the wrapped action
+        if (wrappedAction != null) {
+            wrappedAction.execute();
+        }
+        
+        // Record the activation time
+        activationTime = System.currentTimeMillis();
+        
+        // Start a thread to deactivate the button after the duration
+        if (targetButton != null) {
+            new Thread(() -> {
+                try {
+                    Thread.sleep(duration);
+                    targetButton.deactivate();
+                } catch (InterruptedException e) {
+                    System.err.println("TimedAction interrupted: " + e.getMessage());
+                }
+            }).start();
+        }
+    }
+    
+    @Override
+    public String getDescription() {
+        String baseDesc = wrappedAction != null ? wrappedAction.getDescription() : "No action";
+        return baseDesc + " (Timed: " + duration / 1000.0 + "s)";
+    }
+    
+    /**
+     * Sets the button that this timed action will deactivate.
+     * 
+     * @param button The button to deactivate
+     */
+    public void setTargetButton(Button button) {
+        this.targetButton = button;
+    }
+    
+    /**
+     * Gets the button that this action will deactivate.
+     * 
+     * @return The target button
+     */
+    public Button getTargetButton() {
+        return targetButton;
+    }
+    
+    /**
+     * Sets the duration before the button deactivates.
+     * 
+     * @param duration The duration in milliseconds
+     */
+    public void setDuration(int duration) {
+        this.duration = duration;
+    }
+    
+    /**
+     * Gets the duration before the button deactivates.
+     * 
+     * @return The duration in milliseconds
+     */
+    public int getDuration() {
+        return duration;
+    }
+    
+    /**
+     * Sets the wrapped action.
+     * 
+     * @param wrappedAction The action to execute
+     */
+    public void setWrappedAction(Action wrappedAction) {
+        this.wrappedAction = wrappedAction;
+    }
+    
+    /**
+     * Gets the wrapped action.
+     * 
+     * @return The wrapped action
+     */
+    public Action getWrappedAction() {
+        return wrappedAction;
+    }
+    
+    /**
+     * Gets the time when this action was activated.
+     * 
+     * @return The activation time as milliseconds since epoch, or 0 if not activated
+     */
+    public long getActivationTime() {
+        return activationTime;
+    }
+    
+    /**
+     * Calculates the remaining time before deactivation.
+     * 
+     * @return The remaining time in milliseconds, or 0 if not activated or time expired
+     */
+    public long getRemainingTime() {
+        if (activationTime == 0) {
+            return 0;
+        }
+        
+        long elapsed = System.currentTimeMillis() - activationTime;
+        long remaining = duration - elapsed;
+        
+        return Math.max(0, remaining);
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/ToggleAction.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/ToggleAction.java
new file mode 100644
index 0000000..4d56910
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/ToggleAction.java
@@ -0,0 +1,113 @@
+package com.niravramdhanie.twod.game.actions;
+
+/**
+ * An action that toggles between two different actions.
+ */
+public class ToggleAction implements Action {
+    private Action offAction;
+    private Action onAction;
+    private boolean toggled;
+    
+    /**
+     * Creates a new toggle action with actions for on and off states.
+     * 
+     * @param offAction The action to execute when toggled off
+     * @param onAction The action to execute when toggled on
+     */
+    public ToggleAction(Action offAction, Action onAction) {
+        this.offAction = offAction;
+        this.onAction = onAction;
+        this.toggled = false;
+    }
+    
+    /**
+     * Creates a toggle action with the same action for both states.
+     * 
+     * @param action The action to execute on every toggle
+     */
+    public ToggleAction(Action action) {
+        this(action, action);
+    }
+    
+    @Override
+    public void execute() {
+        // Toggle the state
+        toggled = !toggled;
+        
+        // Execute the appropriate action based on the toggled state
+        if (toggled) {
+            if (onAction != null) {
+                onAction.execute();
+            }
+        } else {
+            if (offAction != null) {
+                offAction.execute();
+            }
+        }
+    }
+    
+    @Override
+    public String getDescription() {
+        if (toggled) {
+            String onDesc = onAction != null ? onAction.getDescription() : "No action";
+            return "Toggle ON: " + onDesc;
+        } else {
+            String offDesc = offAction != null ? offAction.getDescription() : "No action";
+            return "Toggle OFF: " + offDesc;
+        }
+    }
+    
+    /**
+     * Checks if this action is toggled on.
+     * 
+     * @return True if toggled on, false if toggled off
+     */
+    public boolean isToggled() {
+        return toggled;
+    }
+    
+    /**
+     * Sets the toggled state.
+     * 
+     * @param toggled The new toggled state
+     */
+    public void setToggled(boolean toggled) {
+        this.toggled = toggled;
+    }
+    
+    /**
+     * Gets the action executed when toggled off.
+     * 
+     * @return The off action
+     */
+    public Action getOffAction() {
+        return offAction;
+    }
+    
+    /**
+     * Sets the action to execute when toggled off.
+     * 
+     * @param offAction The new off action
+     */
+    public void setOffAction(Action offAction) {
+        this.offAction = offAction;
+    }
+    
+    /**
+     * Gets the action executed when toggled on.
+     * 
+     * @return The on action
+     */
+    public Action getOnAction() {
+        return onAction;
+    }
+    
+    /**
+     * Sets the action to execute when toggled on.
+     * 
+     * @param onAction The new on action
+     */
+    public void setOnAction(Action onAction) {
+        this.onAction = onAction;
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
new file mode 100644
index 0000000..184094d
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
@@ -0,0 +1,315 @@
+package com.niravramdhanie.twod.game.entity;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+import com.niravramdhanie.twod.game.actions.Action;
+import com.niravramdhanie.twod.game.actions.MessageAction;
+import com.niravramdhanie.twod.game.actions.TimedAction;
+import com.niravramdhanie.twod.game.actions.ToggleAction;
+import com.niravramdhanie.twod.game.utils.ResourceLoader;
+
+/**
+ * A button entity that can be placed on the grid and activated by the player.
+ * The button is activated when the player is one grid space away and presses 'E'.
+ */
+public class Button extends Entity {
+    private BufferedImage buttonImage;
+    private BufferedImage buttonActiveImage;
+    private Color color;
+    private Color activeColor;
+    private boolean activated;
+    private Action action;
+    
+    /**
+     * Creates a new button entity with the specified action.
+     * 
+     * @param x The x position
+     * @param y The y position
+     * @param width The width
+     * @param height The height
+     * @param action The action to execute when the button is activated
+     */
+    public Button(float x, float y, int width, int height, Action action) {
+        super(x, y, width, height);
+        this.action = action;
+        this.activated = false;
+        
+        // Default colors
+        this.color = new Color(200, 50, 50); // Red when inactive
+        this.activeColor = new Color(50, 200, 50); // Green when active
+        
+        try {
+            // Load button images
+            buttonImage = ResourceLoader.loadImage("/sprites/button.png");
+            buttonActiveImage = ResourceLoader.loadImage("/sprites/button_active.png");
+        } catch (Exception e) {
+            System.err.println("Error loading button images: " + e.getMessage());
+            buttonImage = null;
+            buttonActiveImage = null;
+        }
+        
+        // If this is a timed action, set the target button
+        if (action instanceof TimedAction) {
+            ((TimedAction) action).setTargetButton(this);
+        }
+    }
+    
+    /**
+     * Creates a new button entity with no action.
+     * 
+     * @param x The x position
+     * @param y The y position
+     * @param width The width
+     * @param height The height
+     */
+    public Button(float x, float y, int width, int height) {
+        this(x, y, width, height, null);
+    }
+    
+    @Override
+    public void update() {
+        // For toggle actions, update button appearance based on toggle state
+        if (action instanceof ToggleAction) {
+            ToggleAction toggleAction = (ToggleAction) action;
+            if (toggleAction.isToggled()) {
+                this.color = new Color(70, 70, 200); // Blue when toggled on
+                this.activeColor = new Color(70, 200, 70); // Green when active and toggled on
+            } else {
+                this.color = new Color(200, 50, 50); // Red when toggled off
+                this.activeColor = new Color(50, 200, 50); // Green when active and toggled off
+            }
+        }
+    }
+    
+    @Override
+    public void render(Graphics2D g) {
+        try {
+            // Determine colors based on action type
+            Color currentColor = activated ? activeColor : color;
+            
+            // For toggle actions, use different colors
+            if (action instanceof ToggleAction) {
+                ToggleAction toggleAction = (ToggleAction) action;
+                if (toggleAction.isToggled()) {
+                    currentColor = new Color(70, 200, 70); // Green when toggled on
+                }
+            }
+            
+            // For message actions, use a different color
+            if (action instanceof MessageAction) {
+                MessageAction messageAction = (MessageAction) action;
+                if (messageAction.isCycling()) {
+                    // Purple for cycling messages
+                    currentColor = activated ? new Color(180, 100, 200) : new Color(120, 60, 140);
+                } else {
+                    // Yellow for regular messages
+                    currentColor = activated ? new Color(220, 220, 50) : new Color(180, 180, 40);
+                }
+            }
+            
+            if (activated && buttonActiveImage != null) {
+                g.drawImage(buttonActiveImage, (int)position.x, (int)position.y, width, height, null);
+            } else if (!activated && buttonImage != null) {
+                g.drawImage(buttonImage, (int)position.x, (int)position.y, width, height, null);
+            } else {
+                // Fallback if images aren't loaded
+                g.setColor(currentColor);
+                g.fillRect((int)position.x, (int)position.y, width, height);
+                
+                // Draw a button-like appearance
+                g.setColor(activated ? color : Color.DARK_GRAY);
+                g.fillRect((int)position.x + width/4, (int)position.y + height/4, width/2, height/2);
+            }
+            
+            // Draw a small indicator if the button has an action
+            if (action != null) {
+                g.setColor(Color.WHITE);
+                g.drawString("E", (int)position.x + 5, (int)position.y + 15);
+                
+                // For timed actions, draw a timer when activated
+                if (action instanceof TimedAction && activated) {
+                    drawTimerBar(g);
+                }
+                
+                // For toggle actions, draw a toggle indicator
+                if (action instanceof ToggleAction) {
+                    drawToggleIndicator(g, ((ToggleAction) action).isToggled());
+                }
+                
+                // For message actions, draw a message indicator
+                if (action instanceof MessageAction) {
+                    drawMessageIndicator(g, (MessageAction) action);
+                }
+            }
+        } catch (Exception e) {
+            // Ultimate fallback
+            System.err.println("Error rendering button: " + e.getMessage());
+            g.setColor(Color.MAGENTA);
+            g.fillRect((int)position.x, (int)position.y, width, height);
+        }
+    }
+    
+    /**
+     * Draws a timer bar for timed actions.
+     * 
+     * @param g The graphics context
+     */
+    private void drawTimerBar(Graphics2D g) {
+        TimedAction timedAction = (TimedAction) action;
+        long currentTime = System.currentTimeMillis();
+        long activationTime = timedAction.getActivationTime();
+        int durationMillis = timedAction.getDuration();
+        
+        if (activationTime == 0) {
+            // Fallback if activation time is not available
+            activationTime = currentTime - 100;
+        }
+        
+        float progress = Math.min(1.0f, (float)(currentTime - activationTime) / durationMillis);
+        
+        // Draw timer bar underneath the button
+        int barHeight = 5;
+        int barWidth = (int)((1.0f - progress) * width);
+        
+        g.setColor(Color.GREEN);
+        g.fillRect((int)position.x, (int)position.y + height + 2, barWidth, barHeight);
+        
+        g.setColor(Color.WHITE);
+        g.drawRect((int)position.x, (int)position.y + height + 2, width, barHeight);
+    }
+    
+    /**
+     * Draws a toggle indicator for toggle actions.
+     * 
+     * @param g The graphics context
+     * @param toggled Whether the action is toggled on
+     */
+    private void drawToggleIndicator(Graphics2D g, boolean toggled) {
+        g.setColor(Color.WHITE);
+        int circleSize = Math.min(width, height) / 3;
+        int circleX = (int)position.x + width - circleSize - 5;
+        int circleY = (int)position.y + 5;
+        
+        g.drawOval(circleX, circleY, circleSize, circleSize);
+        
+        if (toggled) {
+            g.fillOval(circleX, circleY, circleSize, circleSize);
+        }
+    }
+    
+    /**
+     * Draws a message indicator for message actions.
+     * 
+     * @param g The graphics context
+     * @param messageAction The message action to draw the indicator for
+     */
+    private void drawMessageIndicator(Graphics2D g, MessageAction messageAction) {
+        if (messageAction.isCycling()) {
+            // Draw cycling indicator (showing current message number)
+            g.setColor(Color.WHITE);
+            g.drawString("" + (messageAction.getCurrentMessageIndex() + 1) + "/" + messageAction.getMessages().size(), 
+                         (int)position.x + width - 20, (int)position.y + height - 5);
+        } else {
+            // Draw message icon
+            g.setColor(Color.WHITE);
+            int iconSize = Math.min(width, height) / 4;
+            int iconX = (int)position.x + width - iconSize - 5;
+            int iconY = (int)position.y + height - iconSize - 5;
+            
+            // Draw a simple message bubble icon
+            g.drawRoundRect(iconX, iconY, iconSize, iconSize, 3, 3);
+            g.drawLine(iconX + 2, iconY + 2, iconX + iconSize - 2, iconY + 2);
+            g.drawLine(iconX + 2, iconY + iconSize / 2, iconX + iconSize - 2, iconY + iconSize / 2);
+        }
+    }
+    
+    /**
+     * Activates the button and executes its action.
+     * 
+     * @return True if the button was activated, false if it was already activated
+     */
+    public boolean activate() {
+        if (action == null) return false;
+        
+        // For toggle actions, always activate
+        if (action instanceof ToggleAction) {
+            action.execute();
+            return true;
+        }
+        
+        // For MessageAction with cycling, always activate
+        if (action instanceof MessageAction && ((MessageAction) action).isCycling()) {
+            activated = true;
+            action.execute();
+            return true;
+        }
+        
+        // For other actions, only activate if not already activated
+        if (!activated) {
+            activated = true;
+            action.execute();
+            return true;
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Deactivates the button.
+     */
+    public void deactivate() {
+        activated = false;
+    }
+    
+    /**
+     * Checks if the button is activated.
+     * 
+     * @return True if the button is activated, false otherwise
+     */
+    public boolean isActivated() {
+        return activated;
+    }
+    
+    /**
+     * Sets the action for this button.
+     * 
+     * @param action The action to execute when the button is activated
+     */
+    public void setAction(Action action) {
+        this.action = action;
+        
+        // If this is a timed action, set the target button
+        if (action instanceof TimedAction) {
+            ((TimedAction) action).setTargetButton(this);
+        }
+    }
+    
+    /**
+     * Gets the action for this button.
+     * 
+     * @return The action
+     */
+    public Action getAction() {
+        return action;
+    }
+    
+    /**
+     * Sets the color of the button when inactive.
+     * 
+     * @param color The color
+     */
+    public void setColor(Color color) {
+        this.color = color;
+    }
+    
+    /**
+     * Sets the color of the button when active.
+     * 
+     * @param activeColor The active color
+     */
+    public void setActiveColor(Color activeColor) {
+        this.activeColor = activeColor;
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java b/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
index 87657ab..6abbdd3 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
@@ -6,6 +6,7 @@
 import java.util.Random;
 
 import com.niravramdhanie.twod.game.entity.Block;
+import com.niravramdhanie.twod.game.entity.Button;
 import com.niravramdhanie.twod.game.entity.Entity;
 import com.niravramdhanie.twod.game.utils.GridSystem;
 
@@ -203,6 +204,60 @@ public List<Block> getBlocks() {
         return blocks;
     }
     
+    /**
+     * Gets all buttons in the level.
+     * 
+     * @return A list of all buttons
+     */
+    public List<Button> getButtons() {
+        List<Button> buttons = new ArrayList<>();
+        for (Entity entity : entities) {
+            if (entity instanceof Button) {
+                buttons.add((Button) entity);
+            }
+        }
+        return buttons;
+    }
+    
+    /**
+     * Adds a button at the specified grid position.
+     * 
+     * @param button The button to add
+     * @param gridX The X position on the grid
+     * @param gridY The Y position on the grid
+     * @return True if the button was added successfully, false if the position was already occupied
+     */
+    public boolean addButton(Button button, int gridX, int gridY) {
+        return addEntity(button, gridX, gridY);
+    }
+    
+    /**
+     * Finds a suitable position for a button where it won't overlap with blocks.
+     * 
+     * @return An array containing the grid X and Y coordinates, or null if no position was found
+     */
+    public int[] findSuitableButtonPosition() {
+        int horizontalCells = grid.getHorizontalCells();
+        int verticalCells = grid.getVerticalCells();
+        int attempts = 0;
+        int maxAttempts = 100;
+        
+        while (attempts < maxAttempts) {
+            int gridX = random.nextInt(horizontalCells);
+            int gridY = random.nextInt(verticalCells);
+            
+            // Check if the position is unoccupied
+            if (!grid.isOccupied(gridX, gridY)) {
+                return new int[] {gridX, gridY};
+            }
+            
+            attempts++;
+        }
+        
+        // Couldn't find a suitable position
+        return null;
+    }
+    
     /**
      * Gets the grid system.
      * 
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
index 60a99d8..9377ad1 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
@@ -3,10 +3,16 @@
 import java.awt.Color;
 import java.awt.Graphics2D;
 import java.awt.event.KeyEvent;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 
+import com.niravramdhanie.twod.game.actions.Action;
+import com.niravramdhanie.twod.game.actions.ActionFactory;
 import com.niravramdhanie.twod.game.core.GameStateManager;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
+import com.niravramdhanie.twod.game.entity.Button;
+import com.niravramdhanie.twod.game.entity.Entity;
 import com.niravramdhanie.twod.game.level.Level;
 
 public class PlayState extends GameState {
@@ -47,6 +53,9 @@ public void init() {
         // Create a level layout with random blocks
         level.addRandomBlocks(10);
         
+        // Add some buttons to the level
+        addTestButtons();
+        
         try {
             // Create player in the lower middle of the screen
             int gridCellSize = level.getGrid().getCellSize();
@@ -167,9 +176,141 @@ private void drawGridInfo(Graphics2D g) {
             int playerGridX = level.getGrid().screenToGridX((int)player.getX());
             int playerGridY = level.getGrid().screenToGridY((int)player.getY());
             g.drawString("Player grid pos: " + playerGridX + "," + playerGridY, 10, 80);
+            
+            // Show nearby buttons info
+            List<Button> nearButtons = getButtonsNearPlayer();
+            g.drawString("Nearby buttons: " + nearButtons.size(), 10, 100);
+            if (nearButtons.size() > 0) {
+                g.drawString("Press 'E' to activate", 10, 120);
+            }
         }
     }
     
+    /**
+     * Adds test buttons to the level
+     */
+    private void addTestButtons() {
+        int cellSize = level.getGrid().getCellSize();
+        
+        // Create one button for each action type at different positions
+        List<ActionFactory.ActionType> actionTypes = List.of(
+            ActionFactory.ActionType.MESSAGE,
+            ActionFactory.ActionType.TIMED,
+            ActionFactory.ActionType.TOGGLE,
+            ActionFactory.ActionType.DOOR,
+            ActionFactory.ActionType.MULTI,
+            ActionFactory.ActionType.CYCLING_MESSAGE
+        );
+        
+        int horizontalCells = level.getGrid().getHorizontalCells();
+        int verticalCells = level.getGrid().getVerticalCells();
+        
+        // Calculate positions based on the number of action types
+        List<int[]> positions = new ArrayList<>();
+        
+        // Place buttons in the four corners and center
+        positions.add(new int[]{3, 3});  // Top-left
+        positions.add(new int[]{horizontalCells - 4, 3});  // Top-right
+        positions.add(new int[]{3, verticalCells - 4});  // Bottom-left
+        positions.add(new int[]{horizontalCells - 4, verticalCells - 4});  // Bottom-right
+        positions.add(new int[]{horizontalCells / 2, verticalCells / 2});  // Center
+        
+        // Add extra position if needed
+        if (actionTypes.size() > positions.size()) {
+            positions.add(new int[]{horizontalCells / 3, verticalCells / 3});
+        }
+        
+        // Create buttons for each action type
+        for (int i = 0; i < actionTypes.size() && i < positions.size(); i++) {
+            Button button = new Button(0, 0, cellSize, cellSize);
+            Action action = ActionFactory.createAction(actionTypes.get(i), button);
+            button.setAction(action);
+            
+            int[] pos = positions.get(i);
+            level.addEntity(button, pos[0], pos[1]);
+            
+            System.out.println("Added button with action: " + actionTypes.get(i) + " at " + pos[0] + "," + pos[1]);
+        }
+        
+        // Additionally, add a random button somewhere
+        int attempts = 0;
+        boolean placed = false;
+        
+        while (!placed && attempts < 10) {
+            // Try to find a random unoccupied position
+            int[] pos = level.findSuitableButtonPosition();
+            
+            if (pos != null) {
+                Button randomButton = new Button(0, 0, cellSize, cellSize);
+                Action randomAction = ActionFactory.createRandomAction(randomButton);
+                randomButton.setAction(randomAction);
+                
+                level.addEntity(randomButton, pos[0], pos[1]);
+                System.out.println("Added random button at " + pos[0] + "," + pos[1]);
+                placed = true;
+            }
+            
+            attempts++;
+        }
+        
+        System.out.println("Added test buttons to the level");
+    }
+    
+    /**
+     * Gets all buttons that are within one grid cell distance of the player
+     * 
+     * @return A list of buttons that are near the player
+     */
+    private List<Button> getButtonsNearPlayer() {
+        List<Button> nearButtons = new ArrayList<>();
+        
+        if (player == null || level == null) return nearButtons;
+        
+        // Get player's grid position
+        int playerGridX = level.getGrid().screenToGridX((int)player.getX());
+        int playerGridY = level.getGrid().screenToGridY((int)player.getY());
+        
+        // Check all adjacent cells (including diagonals)
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dy = -1; dy <= 1; dy++) {
+                // Skip the player's own cell
+                if (dx == 0 && dy == 0) continue;
+                
+                int checkX = playerGridX + dx;
+                int checkY = playerGridY + dy;
+                
+                // Get entity at this position
+                Entity entity = level.getEntityAt(checkX, checkY);
+                
+                // If it's a button, add it to the list
+                if (entity instanceof Button) {
+                    nearButtons.add((Button) entity);
+                }
+            }
+        }
+        
+        return nearButtons;
+    }
+    
+    /**
+     * Activates buttons that are near the player
+     * 
+     * @return True if any button was activated, false otherwise
+     */
+    private boolean activateNearbyButtons() {
+        List<Button> nearButtons = getButtonsNearPlayer();
+        boolean anyActivated = false;
+        
+        for (Button button : nearButtons) {
+            if (button.activate()) {
+                anyActivated = true;
+                System.out.println("Button activated!");
+            }
+        }
+        
+        return anyActivated;
+    }
+    
     @Override
     public void keyPressed(int k) {
         if (k == KeyEvent.VK_LEFT) player.setLeft(true);
@@ -183,6 +324,11 @@ public void keyPressed(int k) {
         if (k == KeyEvent.VK_W) player.setUp(true);
         if (k == KeyEvent.VK_S) player.setDown(true);
         
+        // Button activation with E key
+        if (k == KeyEvent.VK_E) {
+            activateNearbyButtons();
+        }
+        
         // Level layout switching for testing
         if (k == KeyEvent.VK_1) setLevelLayout(1);
         if (k == KeyEvent.VK_2) setLevelLayout(2);

From 3affbaf28b18ec6f146888a54647a761c87e8d95 Mon Sep 17 00:00:00 2001
From: Nirav Ramdhanie <nirav@Vincents-MacBook-Pro.local>
Date: Thu, 8 May 2025 11:44:09 -0700
Subject: [PATCH 4/8] Added a timer on top of the screen and gave a highlight
 to any button that you are able to get near to

---
 .../twod/game/state/PlayState.java            | 109 +++++++++++++++++-
 1 file changed, 108 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
index 9377ad1..1ab1053 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
@@ -1,6 +1,8 @@
 package com.niravramdhanie.twod.game.state;
 
+import java.awt.BasicStroke;
 import java.awt.Color;
+import java.awt.Font;
 import java.awt.Graphics2D;
 import java.awt.event.KeyEvent;
 import java.util.ArrayList;
@@ -26,11 +28,17 @@ public class PlayState extends GameState {
     // Grid cell size (can be easily changed)
     private static final int GRID_CELL_SIZE = 32;
     
+    // Timer variables
+    private long startTime;
+    private int timerDuration = 60; // Duration in seconds
+    private Font timerFont;
+    
     public PlayState(GameStateManager gsm, int screenWidth, int screenHeight) {
         super(gsm);
         this.screenWidth = screenWidth;
         this.screenHeight = screenHeight;
         this.random = new Random();
+        this.timerFont = new Font("Arial", Font.BOLD, 24);
         System.out.println("PlayState created with dimensions: " + screenWidth + "x" + screenHeight);
     }
     
@@ -40,6 +48,7 @@ public PlayState(GameStateManager gsm) {
         this.screenWidth = gsm.getWidth();
         this.screenHeight = gsm.getHeight();
         this.random = new Random();
+        this.timerFont = new Font("Arial", Font.BOLD, 24);
         System.out.println("PlayState created with dimensions from GSM: " + screenWidth + "x" + screenHeight);
     }
     
@@ -73,6 +82,9 @@ public void init() {
             // Pass the blocks to the player for collision detection
             player.setBlocks(level.getBlocks());
             
+            // Initialize the timer
+            startTime = System.currentTimeMillis();
+            
             initialized = true;
             System.out.println("PlayState initialization complete");
         } catch (Exception e) {
@@ -81,6 +93,20 @@ public void init() {
         }
     }
     
+    /**
+     * Get the remaining time in seconds
+     * @return Remaining time in seconds (0 if timer has expired)
+     */
+    private int getRemainingTime() {
+        long currentTime = System.currentTimeMillis();
+        long elapsedTime = currentTime - startTime;
+        int elapsedSeconds = (int)(elapsedTime / 1000);
+        int remainingSeconds = timerDuration - elapsedSeconds;
+        
+        // Don't allow negative time
+        return Math.max(0, remainingSeconds);
+    }
+    
     /**
      * Changes the current level layout
      * @param layoutType The type of layout to create
@@ -108,6 +134,9 @@ public void render(Graphics2D g) {
         // Draw level (blocks and other entities)
         level.render(g);
         
+        // Draw interaction indicators for nearby buttons
+        drawButtonHighlights(g);
+        
         // Draw grid lines for debugging (optional)
         drawGridLines(g);
         
@@ -132,6 +161,84 @@ public void render(Graphics2D g) {
         
         // Draw grid info
         drawGridInfo(g);
+        
+        // Draw timer
+        drawTimer(g);
+    }
+    
+    /**
+     * Draws highlights around buttons that can be interacted with
+     */
+    private void drawButtonHighlights(Graphics2D g) {
+        if (player == null || level == null) return;
+        
+        List<Button> nearButtons = getButtonsNearPlayer();
+        if (nearButtons.isEmpty()) return;
+        
+        // Save the original stroke
+        java.awt.Stroke originalStroke = g.getStroke();
+        
+        // Set a thicker stroke for highlighting
+        g.setStroke(new BasicStroke(3));
+        g.setColor(Color.WHITE);
+        
+        // Draw highlight around each nearby button's grid cell
+        for (Button button : nearButtons) {
+            // Calculate the grid position for the button
+            int gridX = level.getGrid().screenToGridX((int)button.getX());
+            int gridY = level.getGrid().screenToGridY((int)button.getY());
+            
+            // Convert grid position to screen coordinates
+            int screenX = level.getGrid().gridToScreenX(gridX);
+            int screenY = level.getGrid().gridToScreenY(gridY);
+            
+            // Draw the cell outline with a pulsating effect
+            long currentTime = System.currentTimeMillis();
+            float pulseIntensity = (float)Math.abs(Math.sin(currentTime * 0.003)) * 0.5f + 0.5f;
+            
+            // Create a partially transparent white based on pulse
+            Color highlightColor = new Color(
+                1.0f, 1.0f, 1.0f, 0.5f + pulseIntensity * 0.5f
+            );
+            g.setColor(highlightColor);
+            
+            // Draw the rectangle around the grid cell
+            g.drawRect(screenX, screenY, level.getGrid().getCellSize(), level.getGrid().getCellSize());
+        }
+        
+        // Restore the original stroke
+        g.setStroke(originalStroke);
+    }
+    
+    /**
+     * Draws the timer at the top center of the screen
+     */
+    private void drawTimer(Graphics2D g) {
+        int remainingTime = getRemainingTime();
+        
+        // Format the time as MM:SS
+        String minutes = String.format("%02d", remainingTime / 60);
+        String seconds = String.format("%02d", remainingTime % 60);
+        String timeText = minutes + ":" + seconds;
+        
+        // Set font and determine text width for centering
+        g.setFont(timerFont);
+        int textWidth = g.getFontMetrics().stringWidth(timeText);
+        
+        // Draw background for better visibility
+        g.setColor(new Color(0, 0, 0, 180)); // Semi-transparent black
+        int padding = 8;
+        g.fillRoundRect((screenWidth - textWidth) / 2 - padding, 10 - padding, 
+                        textWidth + padding * 2, timerFont.getSize() + padding * 2, 10, 10);
+        
+        // Draw timer text - white for normal, yellow when < 10 seconds
+        if (remainingTime > 10) {
+            g.setColor(Color.WHITE);
+        } else {
+            g.setColor(Color.YELLOW);
+        }
+        
+        g.drawString(timeText, (screenWidth - textWidth) / 2, 10 + timerFont.getSize());
     }
     
     /**
@@ -180,7 +287,7 @@ private void drawGridInfo(Graphics2D g) {
             // Show nearby buttons info
             List<Button> nearButtons = getButtonsNearPlayer();
             g.drawString("Nearby buttons: " + nearButtons.size(), 10, 100);
-            if (nearButtons.size() > 0) {
+            if (!nearButtons.isEmpty()) {
                 g.drawString("Press 'E' to activate", 10, 120);
             }
         }

From 4a1241d95b7cd432603b000e37215a0724d1ef13 Mon Sep 17 00:00:00 2001
From: Nirav Ramdhanie <nirav@Vincents-MacBook-Pro.local>
Date: Thu, 8 May 2025 12:23:28 -0700
Subject: [PATCH 5/8] Adds rewind function to the game

---
 .../twod/game/actions/DoorController.java     | 167 +++++++++
 .../twod/game/entity/Button.java              | 342 ++++++++++++-----
 .../niravramdhanie/twod/game/entity/Door.java | 191 ++++++++++
 .../twod/game/state/PlayState.java            | 351 +++++++++++-------
 .../twod/game/utils/RewindManager.java        | 277 ++++++++++++++
 .../twod/game/utils/TimerManager.java         | 163 ++++++++
 6 files changed, 1251 insertions(+), 240 deletions(-)
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/DoorController.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/utils/TimerManager.java

diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/DoorController.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/DoorController.java
new file mode 100644
index 0000000..1003458
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/DoorController.java
@@ -0,0 +1,167 @@
+package com.niravramdhanie.twod.game.actions;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import com.niravramdhanie.twod.game.entity.Door;
+
+/**
+ * Controls and manages doors in the game.
+ * Tracks door states and provides methods to open/close doors by ID.
+ */
+public class DoorController implements DoorAction.DoorStateChangeListener {
+    private List<Door> doors;
+    private Map<String, Door> doorMap;
+    
+    /**
+     * Creates a new door controller.
+     */
+    public DoorController() {
+        doors = new ArrayList<>();
+        doorMap = new HashMap<>();
+    }
+    
+    /**
+     * Registers a door with the controller.
+     * 
+     * @param door The door to register
+     */
+    public void registerDoor(Door door) {
+        doors.add(door);
+        doorMap.put(door.getId(), door);
+        
+        // Add this controller as a listener to the door
+        for (DoorAction action : findDoorActions(door.getId())) {
+            action.setDoorStateChangeListener(this);
+        }
+    }
+    
+    /**
+     * Finds all door actions for a specific door ID.
+     * 
+     * @param doorId The door ID
+     * @return List of door actions
+     */
+    private List<DoorAction> findDoorActions(String doorId) {
+        // This would typically be connected to a button registry or similar,
+        // but for now, we'll return an empty list and register actions manually
+        return new ArrayList<>();
+    }
+    
+    /**
+     * Opens a door by ID.
+     * 
+     * @param doorId The ID of the door to open
+     * @return True if the door was found and opened, false otherwise
+     */
+    public boolean openDoor(String doorId) {
+        Door door = doorMap.get(doorId);
+        if (door != null) {
+            door.open();
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Closes a door by ID.
+     * 
+     * @param doorId The ID of the door to close
+     * @return True if the door was found and closed, false otherwise
+     */
+    public boolean closeDoor(String doorId) {
+        Door door = doorMap.get(doorId);
+        if (door != null) {
+            door.close();
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Toggles a door's state by ID.
+     * 
+     * @param doorId The ID of the door to toggle
+     * @return True if the door was found and toggled, false otherwise
+     */
+    public boolean toggleDoor(String doorId) {
+        Door door = doorMap.get(doorId);
+        if (door != null) {
+            door.toggle();
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Closes all doors managed by this controller.
+     */
+    public void closeAllDoors() {
+        for (Door door : doors) {
+            door.close();
+        }
+    }
+    
+    /**
+     * Opens all doors managed by this controller.
+     */
+    public void openAllDoors() {
+        for (Door door : doors) {
+            door.open();
+        }
+    }
+    
+    /**
+     * Gets all doors managed by this controller.
+     * 
+     * @return The list of doors
+     */
+    public List<Door> getDoors() {
+        return doors;
+    }
+    
+    /**
+     * Gets a door by ID.
+     * 
+     * @param doorId The door ID
+     * @return The door, or null if not found
+     */
+    public Door getDoor(String doorId) {
+        return doorMap.get(doorId);
+    }
+    
+    /**
+     * Removes a door from the controller.
+     * 
+     * @param doorId The ID of the door to remove
+     * @return True if the door was found and removed, false otherwise
+     */
+    public boolean removeDoor(String doorId) {
+        Door door = doorMap.remove(doorId);
+        if (door != null) {
+            doors.remove(door);
+            return true;
+        }
+        return false;
+    }
+    
+    @Override
+    public void onDoorStateChanged(String doorId, boolean isOpen) {
+        // Propagate the door state change to the actual door
+        Door door = doorMap.get(doorId);
+        if (door != null) {
+            if (isOpen) {
+                door.open();
+            } else {
+                door.close();
+            }
+            System.out.println("DoorController: Door " + doorId + " is now " + 
+                              (isOpen ? "open" : "closed"));
+        } else {
+            System.out.println("DoorController: Warning - Door " + doorId + 
+                              " not found when trying to change state");
+        }
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
index 184094d..ebcab9f 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
@@ -1,14 +1,21 @@
 package com.niravramdhanie.twod.game.entity;
 
 import java.awt.Color;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.GradientPaint;
 import java.awt.Graphics2D;
+import java.awt.geom.Rectangle2D;
 import java.awt.image.BufferedImage;
 
 import com.niravramdhanie.twod.game.actions.Action;
+import com.niravramdhanie.twod.game.actions.DoorAction;
 import com.niravramdhanie.twod.game.actions.MessageAction;
+import com.niravramdhanie.twod.game.actions.MultiAction;
 import com.niravramdhanie.twod.game.actions.TimedAction;
 import com.niravramdhanie.twod.game.actions.ToggleAction;
 import com.niravramdhanie.twod.game.utils.ResourceLoader;
+import com.niravramdhanie.twod.game.utils.RewindManager;
 
 /**
  * A button entity that can be placed on the grid and activated by the player.
@@ -22,6 +29,17 @@ public class Button extends Entity {
     private boolean activated;
     private Action action;
     
+    // Fonts for button icons
+    private static Font iconFont;
+    
+    // Reference to the rewind manager
+    private static RewindManager rewindManager;
+    
+    static {
+        // Initialize the icon font
+        iconFont = new Font("Arial", Font.BOLD, 14);
+    }
+    
     /**
      * Creates a new button entity with the specified action.
      * 
@@ -70,78 +88,24 @@ public Button(float x, float y, int width, int height) {
     
     @Override
     public void update() {
-        // For toggle actions, update button appearance based on toggle state
-        if (action instanceof ToggleAction) {
-            ToggleAction toggleAction = (ToggleAction) action;
-            if (toggleAction.isToggled()) {
-                this.color = new Color(70, 70, 200); // Blue when toggled on
-                this.activeColor = new Color(70, 200, 70); // Green when active and toggled on
-            } else {
-                this.color = new Color(200, 50, 50); // Red when toggled off
-                this.activeColor = new Color(50, 200, 50); // Green when active and toggled off
-            }
-        }
+        // Button behavior updates handled in activation methods
     }
     
     @Override
     public void render(Graphics2D g) {
         try {
-            // Determine colors based on action type
-            Color currentColor = activated ? activeColor : color;
+            // Draw the base button
+            drawButtonBase(g);
             
-            // For toggle actions, use different colors
-            if (action instanceof ToggleAction) {
-                ToggleAction toggleAction = (ToggleAction) action;
-                if (toggleAction.isToggled()) {
-                    currentColor = new Color(70, 200, 70); // Green when toggled on
-                }
-            }
+            // Draw action-specific icon
+            drawButtonIcon(g);
             
-            // For message actions, use a different color
-            if (action instanceof MessageAction) {
-                MessageAction messageAction = (MessageAction) action;
-                if (messageAction.isCycling()) {
-                    // Purple for cycling messages
-                    currentColor = activated ? new Color(180, 100, 200) : new Color(120, 60, 140);
-                } else {
-                    // Yellow for regular messages
-                    currentColor = activated ? new Color(220, 220, 50) : new Color(180, 180, 40);
-                }
-            }
-            
-            if (activated && buttonActiveImage != null) {
-                g.drawImage(buttonActiveImage, (int)position.x, (int)position.y, width, height, null);
-            } else if (!activated && buttonImage != null) {
-                g.drawImage(buttonImage, (int)position.x, (int)position.y, width, height, null);
-            } else {
-                // Fallback if images aren't loaded
-                g.setColor(currentColor);
-                g.fillRect((int)position.x, (int)position.y, width, height);
-                
-                // Draw a button-like appearance
-                g.setColor(activated ? color : Color.DARK_GRAY);
-                g.fillRect((int)position.x + width/4, (int)position.y + height/4, width/2, height/2);
-            }
-            
-            // Draw a small indicator if the button has an action
+            // Draw additional indicators based on action type
             if (action != null) {
-                g.setColor(Color.WHITE);
-                g.drawString("E", (int)position.x + 5, (int)position.y + 15);
-                
                 // For timed actions, draw a timer when activated
                 if (action instanceof TimedAction && activated) {
                     drawTimerBar(g);
                 }
-                
-                // For toggle actions, draw a toggle indicator
-                if (action instanceof ToggleAction) {
-                    drawToggleIndicator(g, ((ToggleAction) action).isToggled());
-                }
-                
-                // For message actions, draw a message indicator
-                if (action instanceof MessageAction) {
-                    drawMessageIndicator(g, (MessageAction) action);
-                }
             }
         } catch (Exception e) {
             // Ultimate fallback
@@ -151,6 +115,152 @@ public void render(Graphics2D g) {
         }
     }
     
+    /**
+     * Draws the base button shape with appropriate colors
+     */
+    private void drawButtonBase(Graphics2D g) {
+        // Determine colors based on action type and state
+        Color baseColor = determineButtonColor();
+        Color topColor = baseColor.brighter();
+        Color bottomColor = baseColor.darker();
+        
+        // Create gradient for 3D effect
+        GradientPaint gradient = new GradientPaint(
+            (int)position.x, (int)position.y, topColor,
+            (int)position.x, (int)position.y + height, bottomColor
+        );
+        
+        // Store original paint and set gradient
+        java.awt.Paint originalPaint = g.getPaint();
+        g.setPaint(gradient);
+        
+        // Draw button body with rounded corners
+        g.fillRoundRect((int)position.x, (int)position.y, width, height, 5, 5);
+        
+        // Draw button border
+        g.setColor(activated ? Color.WHITE : Color.DARK_GRAY);
+        g.drawRoundRect((int)position.x, (int)position.y, width, height, 5, 5);
+        
+        // Draw button top (lighter) for 3D effect
+        g.setColor(new Color(255, 255, 255, 70));
+        g.fillRoundRect((int)position.x + 2, (int)position.y + 2, width - 4, height / 3, 3, 3);
+        
+        // Reset original paint
+        g.setPaint(originalPaint);
+    }
+    
+    /**
+     * Determines the appropriate color for the button based on its action type and state
+     */
+    private Color determineButtonColor() {
+        if (action == null) {
+            return activated ? activeColor : color;
+        }
+        
+        // Colors for different action types
+        if (action instanceof TimedAction) {
+            return activated ? new Color(255, 140, 0) : new Color(200, 110, 0); // Orange for timed
+        } else if (action instanceof ToggleAction) {
+            ToggleAction toggleAction = (ToggleAction) action;
+            if (toggleAction.isToggled()) {
+                return new Color(0, 170, 220); // Blue when toggled on
+            } else {
+                return new Color(60, 60, 180); // Dark blue when toggled off
+            }
+        } else if (action instanceof MessageAction) {
+            MessageAction messageAction = (MessageAction) action;
+            if (messageAction.isCycling()) {
+                return activated ? new Color(180, 100, 200) : new Color(120, 60, 140); // Purple for cycling
+            } else {
+                return activated ? new Color(220, 220, 50) : new Color(180, 180, 40); // Yellow for regular
+            }
+        } else if (action instanceof DoorAction) {
+            return activated ? new Color(50, 200, 50) : new Color(40, 130, 40); // Green for door
+        } else if (action instanceof MultiAction) {
+            return activated ? new Color(200, 50, 200) : new Color(150, 30, 150); // Magenta for multi
+        }
+        
+        return activated ? activeColor : color;
+    }
+    
+    /**
+     * Draws an appropriate icon based on the button's action type
+     */
+    private void drawButtonIcon(Graphics2D g) {
+        if (action == null) {
+            return;
+        }
+        
+        // Save original font and color
+        Font originalFont = g.getFont();
+        Color originalColor = g.getColor();
+        
+        // Set icon font
+        g.setFont(iconFont);
+        
+        // Get icon and color based on action type
+        String icon = "";
+        Color iconColor = Color.WHITE;
+        
+        if (action instanceof TimedAction) {
+            icon = "⏱"; // Clock icon for timed actions
+            iconColor = Color.WHITE;
+        } else if (action instanceof ToggleAction) {
+            icon = "⇆"; // Toggle icon
+            iconColor = Color.WHITE;
+            
+            ToggleAction toggleAction = (ToggleAction) action;
+            if (toggleAction.isToggled()) {
+                icon = "ON";
+            } else {
+                icon = "OFF";
+            }
+            
+        } else if (action instanceof MessageAction) {
+            MessageAction messageAction = (MessageAction) action;
+            if (messageAction.isCycling()) {
+                icon = "♻"; // Recycling symbol for cycling messages
+            } else {
+                icon = "!"; // Exclamation for regular messages
+            }
+            iconColor = Color.WHITE;
+        } else if (action instanceof DoorAction) {
+            icon = "🚪"; // Door symbol
+            iconColor = Color.WHITE;
+        } else if (action instanceof MultiAction) {
+            icon = "✦"; // Star for multi-actions
+            iconColor = Color.WHITE;
+        }
+        
+        // Center the icon in the button
+        FontMetrics metrics = g.getFontMetrics();
+        Rectangle2D bounds = metrics.getStringBounds(icon, g);
+        int x = (int)(position.x + (width - bounds.getWidth()) / 2);
+        int y = (int)(position.y + (height - bounds.getHeight()) / 2 + metrics.getAscent());
+        
+        // Draw icon with a subtle shadow for better visibility
+        g.setColor(Color.BLACK);
+        g.drawString(icon, x + 1, y + 1);
+        g.setColor(iconColor);
+        g.drawString(icon, x, y);
+        
+        // Draw interaction hint
+        drawInteractionHint(g);
+        
+        // Restore original font and color
+        g.setFont(originalFont);
+        g.setColor(originalColor);
+    }
+    
+    /**
+     * Draws a small "E" hint to show the button can be activated
+     */
+    private void drawInteractionHint(Graphics2D g) {
+        g.setFont(new Font("Arial", Font.BOLD, 10));
+        g.setColor(new Color(255, 255, 255, 200));
+        g.drawString("E", (int)position.x + width - 10, (int)position.y + 12);
+    }
+    
     /**
      * Draws a timer bar for timed actions.
      * 
@@ -173,7 +283,18 @@ private void drawTimerBar(Graphics2D g) {
         int barHeight = 5;
         int barWidth = (int)((1.0f - progress) * width);
         
-        g.setColor(Color.GREEN);
+        // Calculate color based on remaining time (green->yellow->red)
+        float remainingRatio = 1.0f - progress;
+        Color timerColor;
+        if (remainingRatio > 0.6f) {
+            timerColor = Color.GREEN;
+        } else if (remainingRatio > 0.3f) {
+            timerColor = Color.YELLOW;
+        } else {
+            timerColor = Color.RED;
+        }
+        
+        g.setColor(timerColor);
         g.fillRect((int)position.x, (int)position.y + height + 2, barWidth, barHeight);
         
         g.setColor(Color.WHITE);
@@ -200,82 +321,111 @@ private void drawToggleIndicator(Graphics2D g, boolean toggled) {
     }
     
     /**
-     * Draws a message indicator for message actions.
+     * Draws an indicator for message actions.
      * 
      * @param g The graphics context
-     * @param messageAction The message action to draw the indicator for
+     * @param messageAction The message action
      */
     private void drawMessageIndicator(Graphics2D g, MessageAction messageAction) {
+        int indicatorSize = Math.min(width, height) / 4;
+        int indicatorX = (int)position.x + width - indicatorSize - 5;
+        int indicatorY = (int)position.y + height - indicatorSize - 5;
+        
         if (messageAction.isCycling()) {
-            // Draw cycling indicator (showing current message number)
+            // Draw cycling indicator (circular arrow)
             g.setColor(Color.WHITE);
-            g.drawString("" + (messageAction.getCurrentMessageIndex() + 1) + "/" + messageAction.getMessages().size(), 
-                         (int)position.x + width - 20, (int)position.y + height - 5);
+            g.drawOval(indicatorX, indicatorY, indicatorSize, indicatorSize);
+            
+            // Draw arrow inside the circle
+            int centerX = indicatorX + indicatorSize / 2;
+            int centerY = indicatorY + indicatorSize / 2;
+            int arrowSize = indicatorSize / 3;
+            
+            g.drawLine(centerX, centerY - arrowSize, centerX + arrowSize, centerY);
+            g.drawLine(centerX, centerY - arrowSize, centerX - arrowSize, centerY);
         } else {
-            // Draw message icon
+            // Draw speech bubble for regular messages
             g.setColor(Color.WHITE);
-            int iconSize = Math.min(width, height) / 4;
-            int iconX = (int)position.x + width - iconSize - 5;
-            int iconY = (int)position.y + height - iconSize - 5;
-            
-            // Draw a simple message bubble icon
-            g.drawRoundRect(iconX, iconY, iconSize, iconSize, 3, 3);
-            g.drawLine(iconX + 2, iconY + 2, iconX + iconSize - 2, iconY + 2);
-            g.drawLine(iconX + 2, iconY + iconSize / 2, iconX + iconSize - 2, iconY + iconSize / 2);
+            g.fillRoundRect(indicatorX, indicatorY, indicatorSize, indicatorSize, 3, 3);
+            g.setColor(Color.BLACK);
+            g.drawString("!", indicatorX + indicatorSize/3, indicatorY + 2*indicatorSize/3);
         }
     }
     
+    /**
+     * Sets the rewind manager for all buttons.
+     * 
+     * @param rewindManager The rewind manager
+     */
+    public static void setRewindManager(RewindManager rewindManager) {
+        Button.rewindManager = rewindManager;
+    }
+    
     /**
      * Activates the button and executes its action.
      * 
      * @return True if the button was activated, false if it was already activated
      */
     public boolean activate() {
-        if (action == null) return false;
+        boolean wasActivated = activated;
         
-        // For toggle actions, always activate
-        if (action instanceof ToggleAction) {
-            action.execute();
-            return true;
+        if (activated) {
+            // If already activated, only perform action if it's a toggle or cycling action
+            if (action instanceof ToggleAction || 
+                (action instanceof MessageAction && ((MessageAction)action).isCycling())) {
+                if (action != null) {
+                    action.execute();
+                }
+                
+                // Record the button activation if we're recording
+                if (rewindManager != null) {
+                    rewindManager.recordButtonActivation(this, true);
+                }
+                
+                return true;
+            }
+            return false;
         }
         
-        // For MessageAction with cycling, always activate
-        if (action instanceof MessageAction && ((MessageAction) action).isCycling()) {
-            activated = true;
+        activated = true;
+        if (action != null) {
             action.execute();
-            return true;
         }
         
-        // For other actions, only activate if not already activated
-        if (!activated) {
-            activated = true;
-            action.execute();
-            return true;
+        // Record the button activation if we're recording
+        if (rewindManager != null && !wasActivated) {
+            rewindManager.recordButtonActivation(this, true);
         }
         
-        return false;
+        return true;
     }
     
     /**
      * Deactivates the button.
      */
     public void deactivate() {
+        boolean wasActivated = activated;
         activated = false;
+        
+        // Record the button deactivation if we're recording
+        if (rewindManager != null && wasActivated) {
+            rewindManager.recordButtonActivation(this, false);
+        }
     }
     
     /**
      * Checks if the button is activated.
      * 
-     * @return True if the button is activated, false otherwise
+     * @return True if activated, false otherwise
      */
     public boolean isActivated() {
         return activated;
     }
     
     /**
-     * Sets the action for this button.
+     * Sets the action to execute when the button is activated.
      * 
-     * @param action The action to execute when the button is activated
+     * @param action The action
      */
     public void setAction(Action action) {
         this.action = action;
@@ -287,7 +437,7 @@ public void setAction(Action action) {
     }
     
     /**
-     * Gets the action for this button.
+     * Gets the button's action.
      * 
      * @return The action
      */
@@ -296,7 +446,7 @@ public Action getAction() {
     }
     
     /**
-     * Sets the color of the button when inactive.
+     * Sets the button's inactive color.
      * 
      * @param color The color
      */
@@ -305,7 +455,7 @@ public void setColor(Color color) {
     }
     
     /**
-     * Sets the color of the button when active.
+     * Sets the button's active color.
      * 
      * @param activeColor The active color
      */
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
new file mode 100644
index 0000000..fb96873
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
@@ -0,0 +1,191 @@
+package com.niravramdhanie.twod.game.entity;
+
+import java.awt.Color;
+import java.awt.GradientPaint;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+import com.niravramdhanie.twod.game.actions.DoorAction;
+import com.niravramdhanie.twod.game.utils.ResourceLoader;
+
+/**
+ * A door entity that can be opened or closed.
+ * When closed, it blocks player movement.
+ * When open, it allows the player to pass through.
+ */
+public class Door extends Entity implements DoorAction.DoorStateChangeListener {
+    private String id;
+    private boolean isOpen;
+    private BufferedImage doorImage;
+    private BufferedImage doorOpenImage;
+    private Color doorColor = new Color(139, 69, 19); // Brown door color
+    private Color frameColor = new Color(101, 67, 33); // Darker frame color
+    
+    /**
+     * Creates a new door entity.
+     * 
+     * @param x The x position
+     * @param y The y position
+     * @param width The width
+     * @param height The height
+     * @param id The unique ID of the door
+     */
+    public Door(float x, float y, int width, int height, String id) {
+        super(x, y, width, height);
+        this.id = id;
+        this.isOpen = false;
+        
+        try {
+            // Load door images
+            doorImage = ResourceLoader.loadImage("/sprites/door_closed.png");
+            doorOpenImage = ResourceLoader.loadImage("/sprites/door_open.png");
+        } catch (Exception e) {
+            System.err.println("Error loading door images: " + e.getMessage());
+            doorImage = null;
+            doorOpenImage = null;
+        }
+    }
+    
+    @Override
+    public void update() {
+        // Currently nothing to update for the door
+    }
+    
+    @Override
+    public void render(Graphics2D g) {
+        if (doorImage != null && doorOpenImage != null) {
+            // Render using images
+            if (isOpen) {
+                g.drawImage(doorOpenImage, (int)position.x, (int)position.y, width, height, null);
+            } else {
+                g.drawImage(doorImage, (int)position.x, (int)position.y, width, height, null);
+            }
+        } else {
+            // Fallback rendering with rectangles
+            if (isOpen) {
+                // Draw frame but no door
+                drawDoorFrame(g);
+            } else {
+                // Draw both frame and door
+                drawDoorFrame(g);
+                drawDoorBody(g);
+            }
+        }
+    }
+    
+    /**
+     * Draws the door frame.
+     * 
+     * @param g The graphics context
+     */
+    private void drawDoorFrame(Graphics2D g) {
+        // Draw the door frame
+        g.setColor(frameColor);
+        
+        // Left side
+        g.fillRect((int)position.x, (int)position.y, width / 8, height);
+        
+        // Right side
+        g.fillRect((int)position.x + width - width / 8, (int)position.y, width / 8, height);
+        
+        // Top
+        g.fillRect((int)position.x, (int)position.y, width, height / 8);
+        
+        // Bottom
+        g.fillRect((int)position.x, (int)position.y + height - height / 8, width, height / 8);
+    }
+    
+    /**
+     * Draws the door body.
+     * 
+     * @param g The graphics context
+     */
+    private void drawDoorBody(Graphics2D g) {
+        // Door body fill
+        int doorBodyX = (int)position.x + width / 8;
+        int doorBodyY = (int)position.y + height / 8;
+        int doorBodyWidth = width - width / 4;
+        int doorBodyHeight = height - height / 4;
+        
+        // Create a gradient for 3D effect
+        GradientPaint gradient = new GradientPaint(
+            doorBodyX, doorBodyY, doorColor.brighter(),
+            doorBodyX + doorBodyWidth, doorBodyY, doorColor.darker()
+        );
+        
+        // Save original paint
+        java.awt.Paint originalPaint = g.getPaint();
+        
+        // Apply gradient and draw door
+        g.setPaint(gradient);
+        g.fillRect(doorBodyX, doorBodyY, doorBodyWidth, doorBodyHeight);
+        
+        // Add a door handle
+        g.setColor(Color.BLACK);
+        g.fillOval(doorBodyX + doorBodyWidth - doorBodyWidth / 6, 
+                  doorBodyY + doorBodyHeight / 2, 
+                  doorBodyWidth / 10, 
+                  doorBodyWidth / 10);
+        
+        // Restore original paint
+        g.setPaint(originalPaint);
+    }
+    
+    /**
+     * Opens the door.
+     */
+    public void open() {
+        isOpen = true;
+    }
+    
+    /**
+     * Closes the door.
+     */
+    public void close() {
+        isOpen = false;
+    }
+    
+    /**
+     * Checks if the door is open.
+     * 
+     * @return True if open, false if closed
+     */
+    public boolean isOpen() {
+        return isOpen;
+    }
+    
+    /**
+     * Gets the door ID.
+     * 
+     * @return The door ID
+     */
+    public String getId() {
+        return id;
+    }
+    
+    /**
+     * Sets the door ID.
+     * 
+     * @param id The door ID
+     */
+    public void setId(String id) {
+        this.id = id;
+    }
+    
+    /**
+     * Toggles the door state.
+     * 
+     * @return The new door state
+     */
+    public boolean toggle() {
+        isOpen = !isOpen;
+        return isOpen;
+    }
+    
+    @Override
+    public void onDoorStateChanged(String doorId, boolean isOpen) {
+        if (this.id.equals(doorId)) {
+            this.isOpen = isOpen;
+        }
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
index 1ab1053..8da4f92 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
@@ -14,8 +14,9 @@
 import com.niravramdhanie.twod.game.core.GameStateManager;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
 import com.niravramdhanie.twod.game.entity.Button;
-import com.niravramdhanie.twod.game.entity.Entity;
 import com.niravramdhanie.twod.game.level.Level;
+import com.niravramdhanie.twod.game.utils.RewindManager;
+import com.niravramdhanie.twod.game.utils.TimerManager;
 
 public class PlayState extends GameState {
     private BallPlayer player;
@@ -33,6 +34,16 @@ public class PlayState extends GameState {
     private int timerDuration = 60; // Duration in seconds
     private Font timerFont;
     
+    // Timer manager
+    private TimerManager timerManager;
+    
+    // Rewind feature
+    private RewindManager rewindManager;
+    private boolean rewindEnabled = true;
+    
+    // New variables for button highlighting
+    private List<Button> nearButtons = new ArrayList<>();
+    
     public PlayState(GameStateManager gsm, int screenWidth, int screenHeight) {
         super(gsm);
         this.screenWidth = screenWidth;
@@ -82,8 +93,15 @@ public void init() {
             // Pass the blocks to the player for collision detection
             player.setBlocks(level.getBlocks());
             
-            // Initialize the timer
-            startTime = System.currentTimeMillis();
+            // Initialize the timer manager
+            timerManager = new TimerManager(timerDuration);
+            timerManager.start();
+            
+            // Initialize the rewind manager
+            rewindManager = new RewindManager(player, level.getButtons(), timerManager);
+            
+            // Set the rewind manager for buttons
+            Button.setRewindManager(rewindManager);
             
             initialized = true;
             System.out.println("PlayState initialization complete");
@@ -98,13 +116,8 @@ public void init() {
      * @return Remaining time in seconds (0 if timer has expired)
      */
     private int getRemainingTime() {
-        long currentTime = System.currentTimeMillis();
-        long elapsedTime = currentTime - startTime;
-        int elapsedSeconds = (int)(elapsedTime / 1000);
-        int remainingSeconds = timerDuration - elapsedSeconds;
-        
-        // Don't allow negative time
-        return Math.max(0, remainingSeconds);
+        // Use the timer manager instead of calculating directly
+        return timerManager.getTime();
     }
     
     /**
@@ -118,64 +131,172 @@ public void setLevelLayout(int layoutType) {
     
     @Override
     public void update() {
-        // Update the level entities
-        level.update();
+        if (!initialized) return;
         
-        // Update the player
-        player.update();
+        try {
+            // Update timer
+            timerManager.update();
+            
+            // Update rewind manager
+            if (rewindManager != null) {
+                rewindManager.update();
+            }
+            
+            // Update level (includes buttons, etc.)
+            level.update();
+            
+            // Update player position
+            if (player != null) {
+                player.update();
+            }
+            
+            // Check for interaction with buttons
+            checkButtonHighlights();
+            
+        } catch (Exception e) {
+            System.err.println("Error in PlayState.update(): " + e.getMessage());
+            e.printStackTrace();
+        }
     }
     
     @Override
     public void render(Graphics2D g) {
-        // Clear screen with background color
-        g.setColor(Color.BLACK);
-        g.fillRect(0, 0, screenWidth, screenHeight);
-        
-        // Draw level (blocks and other entities)
-        level.render(g);
+        if (!initialized) return;
         
-        // Draw interaction indicators for nearby buttons
-        drawButtonHighlights(g);
-        
-        // Draw grid lines for debugging (optional)
-        drawGridLines(g);
-        
-        // Draw player
-        if (player != null) {
-            player.render(g);
-        } else {
-            // Fallback if player is null
-            g.setColor(Color.RED);
-            g.fillOval(screenWidth / 2 - 16, screenHeight - 16 - 50, 32, 32);
+        try {
+            // Clear the screen
+            g.setColor(Color.BLACK);
+            g.fillRect(0, 0, screenWidth, screenHeight);
+            
+            // Draw the grid (if needed for debugging)
+            // level.getGrid().render(g);
             
-            // Debug message
-            g.setColor(Color.WHITE);
-            g.drawString("Player object is null!", 10, 20);
+            // Draw the level blocks
+            level.render(g);
             
-            // If not initialized, try to initialize
-            if (!initialized) {
-                System.out.println("Player was null, attempting to initialize again");
-                init();
+            // Draw player
+            if (player != null) {
+                player.render(g);
             }
+            
+            // Draw remaining time
+            renderTimer(g);
+            
+            // Draw interaction indicator for buttons
+            drawButtonHighlights(g);
+            
+            // Draw rewind status indicator
+            drawRewindStatusIndicator(g);
+            
+        } catch (Exception e) {
+            System.err.println("Error in PlayState.render(): " + e.getMessage());
+            e.printStackTrace();
+            
+            // Display error information
+            g.setColor(Color.RED);
+            g.drawString("Render Error: " + e.getMessage(), 10, 20);
+        }
+    }
+    
+    /**
+     * Renders the timer at the top center of the screen
+     */
+    private void renderTimer(Graphics2D g) {
+        // Use the timer manager to render the timer
+        if (timerManager != null) {
+            timerManager.render(g, screenWidth);
+        }
+    }
+    
+    /**
+     * Draws an indicator showing the current rewind state
+     */
+    private void drawRewindStatusIndicator(Graphics2D g) {
+        if (rewindManager == null) return;
+        
+        // Save original color and font
+        Color originalColor = g.getColor();
+        Font originalFont = g.getFont();
+        
+        // Set font and position for rewind indicator
+        g.setFont(new Font("Arial", Font.BOLD, 16));
+        int y = screenHeight - 40;
+        
+        // Draw different indicators based on rewind state
+        switch (rewindManager.getCurrentState()) {
+            case RECORDING:
+                // Red recording indicator
+                g.setColor(Color.RED);
+                g.fillOval(10, y, 15, 15);
+                g.drawString("Recording", 30, y + 12);
+                break;
+                
+            case REWINDING:
+                // Flashing blue rewind indicator
+                if ((System.currentTimeMillis() / 250) % 2 == 0) {
+                    g.setColor(Color.BLUE);
+                } else {
+                    g.setColor(Color.CYAN);
+                }
+                
+                int[] xPoints = {20, 5, 5};
+                int[] yPoints = {y + 7, y, y + 15};
+                g.fillPolygon(xPoints, yPoints, 3);
+                
+                g.drawString("Rewinding", 30, y + 12);
+                break;
+                
+            case IDLE:
+                // Gray idle indicator
+                g.setColor(Color.GRAY);
+                g.drawOval(10, y, 15, 15);
+                g.drawString("Press 'R' to Record", 30, y + 12);
+                break;
         }
         
-        // Draw grid info
-        drawGridInfo(g);
-        
-        // Draw timer
-        drawTimer(g);
+        // Restore original color and font
+        g.setColor(originalColor);
+        g.setFont(originalFont);
+    }
+    
+    /**
+     * Checks for buttons near the player and highlights them
+     */
+    private void checkButtonHighlights() {
+        if (player == null) return;
+        
+        // Get all buttons from the level
+        List<Button> buttons = level.getButtons();
+        
+        // Clear the list of nearby buttons
+        nearButtons.clear();
+        
+        // Check each button to see if it's near the player
+        for (Button button : buttons) {
+            // Calculate distance between player center and button center
+            float playerCenterX = player.getX() + player.getWidth() / 2;
+            float playerCenterY = player.getY() + player.getHeight() / 2;
+            float buttonCenterX = button.getX() + button.getWidth() / 2;
+            float buttonCenterY = button.getY() + button.getHeight() / 2;
+            
+            // Calculate the distance in grid cells (not pixels)
+            float dx = Math.abs(playerCenterX - buttonCenterX) / GRID_CELL_SIZE;
+            float dy = Math.abs(playerCenterY - buttonCenterY) / GRID_CELL_SIZE;
+            
+            // Button is within 1 cell of player (Manhattan distance)
+            if (dx <= 1 && dy <= 1) {
+                nearButtons.add(button);
+            }
+        }
     }
     
     /**
-     * Draws highlights around buttons that can be interacted with
+     * Draws highlights around buttons that are near the player
      */
     private void drawButtonHighlights(Graphics2D g) {
-        if (player == null || level == null) return;
-        
-        List<Button> nearButtons = getButtonsNearPlayer();
         if (nearButtons.isEmpty()) return;
         
-        // Save the original stroke
+        // Save original stroke
         java.awt.Stroke originalStroke = g.getStroke();
         
         // Set a thicker stroke for highlighting
@@ -206,39 +327,22 @@ private void drawButtonHighlights(Graphics2D g) {
             g.drawRect(screenX, screenY, level.getGrid().getCellSize(), level.getGrid().getCellSize());
         }
         
-        // Restore the original stroke
+        // Restore original stroke
         g.setStroke(originalStroke);
     }
     
     /**
-     * Draws the timer at the top center of the screen
+     * Activates buttons near the player
      */
-    private void drawTimer(Graphics2D g) {
-        int remainingTime = getRemainingTime();
-        
-        // Format the time as MM:SS
-        String minutes = String.format("%02d", remainingTime / 60);
-        String seconds = String.format("%02d", remainingTime % 60);
-        String timeText = minutes + ":" + seconds;
-        
-        // Set font and determine text width for centering
-        g.setFont(timerFont);
-        int textWidth = g.getFontMetrics().stringWidth(timeText);
-        
-        // Draw background for better visibility
-        g.setColor(new Color(0, 0, 0, 180)); // Semi-transparent black
-        int padding = 8;
-        g.fillRoundRect((screenWidth - textWidth) / 2 - padding, 10 - padding, 
-                        textWidth + padding * 2, timerFont.getSize() + padding * 2, 10, 10);
-        
-        // Draw timer text - white for normal, yellow when < 10 seconds
-        if (remainingTime > 10) {
-            g.setColor(Color.WHITE);
-        } else {
-            g.setColor(Color.YELLOW);
+    private void activateNearbyButtons() {
+        // Process each nearby button
+        for (Button button : nearButtons) {
+            boolean activated = button.activate();
+            
+            if (activated) {
+                System.out.println("Button activated at " + button.getX() + "," + button.getY());
+            }
         }
-        
-        g.drawString(timeText, (screenWidth - textWidth) / 2, 10 + timerFont.getSize());
     }
     
     /**
@@ -285,7 +389,6 @@ private void drawGridInfo(Graphics2D g) {
             g.drawString("Player grid pos: " + playerGridX + "," + playerGridY, 10, 80);
             
             // Show nearby buttons info
-            List<Button> nearButtons = getButtonsNearPlayer();
             g.drawString("Nearby buttons: " + nearButtons.size(), 10, 100);
             if (!nearButtons.isEmpty()) {
                 g.drawString("Press 'E' to activate", 10, 120);
@@ -363,84 +466,44 @@ private void addTestButtons() {
         System.out.println("Added test buttons to the level");
     }
     
-    /**
-     * Gets all buttons that are within one grid cell distance of the player
-     * 
-     * @return A list of buttons that are near the player
-     */
-    private List<Button> getButtonsNearPlayer() {
-        List<Button> nearButtons = new ArrayList<>();
-        
-        if (player == null || level == null) return nearButtons;
-        
-        // Get player's grid position
-        int playerGridX = level.getGrid().screenToGridX((int)player.getX());
-        int playerGridY = level.getGrid().screenToGridY((int)player.getY());
-        
-        // Check all adjacent cells (including diagonals)
-        for (int dx = -1; dx <= 1; dx++) {
-            for (int dy = -1; dy <= 1; dy++) {
-                // Skip the player's own cell
-                if (dx == 0 && dy == 0) continue;
-                
-                int checkX = playerGridX + dx;
-                int checkY = playerGridY + dy;
-                
-                // Get entity at this position
-                Entity entity = level.getEntityAt(checkX, checkY);
-                
-                // If it's a button, add it to the list
-                if (entity instanceof Button) {
-                    nearButtons.add((Button) entity);
-                }
+    @Override
+    public void keyPressed(int k) {
+        // Handle player movement
+        if (player != null) {
+            if (k == KeyEvent.VK_LEFT || k == KeyEvent.VK_A) {
+                player.setLeft(true);
             }
-        }
-        
-        return nearButtons;
-    }
-    
-    /**
-     * Activates buttons that are near the player
-     * 
-     * @return True if any button was activated, false otherwise
-     */
-    private boolean activateNearbyButtons() {
-        List<Button> nearButtons = getButtonsNearPlayer();
-        boolean anyActivated = false;
-        
-        for (Button button : nearButtons) {
-            if (button.activate()) {
-                anyActivated = true;
-                System.out.println("Button activated!");
+            if (k == KeyEvent.VK_RIGHT || k == KeyEvent.VK_D) {
+                player.setRight(true);
+            }
+            if (k == KeyEvent.VK_UP || k == KeyEvent.VK_W) {
+                player.setUp(true);
+            }
+            if (k == KeyEvent.VK_DOWN || k == KeyEvent.VK_S) {
+                player.setDown(true);
             }
         }
         
-        return anyActivated;
-    }
-    
-    @Override
-    public void keyPressed(int k) {
-        if (k == KeyEvent.VK_LEFT) player.setLeft(true);
-        if (k == KeyEvent.VK_RIGHT) player.setRight(true);
-        if (k == KeyEvent.VK_UP) player.setUp(true);
-        if (k == KeyEvent.VK_DOWN) player.setDown(true);
-        
-        // Alternative WASD controls
-        if (k == KeyEvent.VK_A) player.setLeft(true);
-        if (k == KeyEvent.VK_D) player.setRight(true);
-        if (k == KeyEvent.VK_W) player.setUp(true);
-        if (k == KeyEvent.VK_S) player.setDown(true);
-        
-        // Button activation with E key
+        // Handle interaction with 'E' key
         if (k == KeyEvent.VK_E) {
             activateNearbyButtons();
         }
         
+        // Handle pause with Escape key
+        if (k == KeyEvent.VK_ESCAPE) {
+            gsm.setState(GameStateManager.PAUSE_STATE);
+        }
+        
+        // Handle rewind feature with 'R' key
+        if (k == KeyEvent.VK_R && rewindEnabled && rewindManager != null) {
+            rewindManager.toggleRewind();
+        }
+        
         // Level layout switching for testing
         if (k == KeyEvent.VK_1) setLevelLayout(1);
         if (k == KeyEvent.VK_2) setLevelLayout(2);
         if (k == KeyEvent.VK_3) setLevelLayout(3);
-        if (k == KeyEvent.VK_R) setLevelLayout(0); // Random blocks
+        if (k == KeyEvent.VK_0) setLevelLayout(0); // Random blocks (changed from R to 0)
     }
     
     @Override
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java b/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
new file mode 100644
index 0000000..2b1bcba
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
@@ -0,0 +1,277 @@
+package com.niravramdhanie.twod.game.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.niravramdhanie.twod.game.entity.Button;
+import com.niravramdhanie.twod.game.entity.BallPlayer;
+
+/**
+ * Manages the rewind feature for the game.
+ * Records player position, timer value, and button states.
+ * Replays recorded actions when rewinding.
+ */
+public class RewindManager {
+    // Enum to track rewind state
+    public enum RewindState {
+        IDLE,       // Not recording or rewinding
+        RECORDING,  // Currently recording actions
+        REWINDING   // Currently rewinding and replaying actions
+    }
+    
+    // Current state of the rewind system
+    private RewindState currentState = RewindState.IDLE;
+    
+    // Timestamp relative to the start of recording
+    private long recordingStartTime;
+    private long rewindStartTime;
+    
+    // Recorded initial state
+    private float playerStartX;
+    private float playerStartY;
+    private int timerStartValue;
+    private List<ButtonState> initialButtonStates = new ArrayList<>();
+    
+    // Recorded actions
+    private List<RecordedAction> recordedActions = new ArrayList<>();
+    
+    // Reference to game objects
+    private BallPlayer player;
+    private List<Button> buttons;
+    private TimerManager timer;
+    
+    /**
+     * Creates a new RewindManager.
+     * 
+     * @param player The player to record/restore
+     * @param buttons The list of buttons to record/restore
+     * @param timer The timer to record/restore
+     */
+    public RewindManager(BallPlayer player, List<Button> buttons, TimerManager timer) {
+        this.player = player;
+        this.buttons = buttons;
+        this.timer = timer;
+    }
+    
+    /**
+     * Starts recording player actions and game state.
+     */
+    public void startRecording() {
+        // Clear previous recordings
+        recordedActions.clear();
+        initialButtonStates.clear();
+        
+        // Record initial state
+        playerStartX = player.getX();
+        playerStartY = player.getY();
+        timerStartValue = timer.getTime();
+        
+        // Record initial button states
+        for (Button button : buttons) {
+            String buttonId = getButtonId(button);
+            initialButtonStates.add(new ButtonState(buttonId, button.isActivated()));
+        }
+        
+        // Set recording state
+        currentState = RewindState.RECORDING;
+        recordingStartTime = System.currentTimeMillis();
+        
+        System.out.println("Rewind: Started recording at position (" + playerStartX + ", " + playerStartY + 
+                          "), time: " + timerStartValue);
+    }
+    
+    /**
+     * Records a button activation.
+     * 
+     * @param button The button that was activated
+     * @param activated Whether the button was activated or deactivated
+     */
+    public void recordButtonActivation(Button button, boolean activated) {
+        if (currentState != RewindState.RECORDING) {
+            return;
+        }
+        
+        String buttonId = getButtonId(button);
+        long timestamp = System.currentTimeMillis() - recordingStartTime;
+        recordedActions.add(new RecordedAction(ActionType.BUTTON_ACTIVATION, timestamp, buttonId, activated));
+        
+        System.out.println("Rewind: Recorded button " + buttonId + " " + 
+                          (activated ? "activation" : "deactivation") + " at time " + timestamp + "ms");
+    }
+    
+    /**
+     * Starts rewinding the game to the recorded state.
+     */
+    public void startRewinding() {
+        if (currentState != RewindState.RECORDING) {
+            return;
+        }
+        
+        // Reset player position
+        player.setX(playerStartX);
+        player.setY(playerStartY);
+        
+        // Reset timer
+        timer.setTime(timerStartValue);
+        
+        // Reset button states
+        for (ButtonState state : initialButtonStates) {
+            for (Button button : buttons) {
+                String buttonId = getButtonId(button);
+                if (buttonId.equals(state.buttonId)) {
+                    if (state.activated) {
+                        button.activate();
+                    } else {
+                        button.deactivate();
+                    }
+                    break;
+                }
+            }
+        }
+        
+        // Start rewinding
+        currentState = RewindState.REWINDING;
+        rewindStartTime = System.currentTimeMillis();
+        
+        System.out.println("Rewind: Started rewinding to position (" + playerStartX + ", " + playerStartY + 
+                          "), time: " + timerStartValue);
+    }
+    
+    /**
+     * Updates the rewind system.
+     * Should be called on each game tick.
+     */
+    public void update() {
+        if (currentState != RewindState.REWINDING) {
+            return;
+        }
+        
+        // Calculate current time relative to rewind start
+        long currentRelativeTime = System.currentTimeMillis() - rewindStartTime;
+        
+        // Apply any actions that should occur at this time
+        for (RecordedAction action : recordedActions) {
+            if (action.timestamp <= currentRelativeTime && !action.applied) {
+                applyAction(action);
+                action.applied = true;
+            }
+        }
+        
+        // Check if all actions have been applied
+        boolean allApplied = true;
+        for (RecordedAction action : recordedActions) {
+            if (!action.applied) {
+                allApplied = false;
+                break;
+            }
+        }
+        
+        // If all actions are applied, reset rewind state
+        if (allApplied) {
+            currentState = RewindState.IDLE;
+            System.out.println("Rewind: All actions replayed, returning to idle state");
+        }
+    }
+    
+    /**
+     * Applies a recorded action.
+     * 
+     * @param action The action to apply
+     */
+    private void applyAction(RecordedAction action) {
+        if (action.type == ActionType.BUTTON_ACTIVATION) {
+            // Find the button with matching ID
+            for (Button button : buttons) {
+                String buttonId = getButtonId(button);
+                if (buttonId.equals(action.buttonId)) {
+                    if (action.activated) {
+                        button.activate();
+                    } else {
+                        button.deactivate();
+                    }
+                    System.out.println("Rewind: Replayed button " + action.buttonId + 
+                                     " " + (action.activated ? "activation" : "deactivation") + 
+                                     " at time " + action.timestamp + "ms");
+                    break;
+                }
+            }
+        }
+    }
+    
+    /**
+     * Toggles the rewind feature when the 'R' key is pressed.
+     */
+    public void toggleRewind() {
+        switch (currentState) {
+            case IDLE:
+                startRecording();
+                break;
+                
+            case RECORDING:
+                startRewinding();
+                break;
+                
+            case REWINDING:
+                // Do nothing if already rewinding
+                break;
+        }
+    }
+    
+    /**
+     * Gets the current state of the rewind system.
+     * 
+     * @return The current rewind state
+     */
+    public RewindState getCurrentState() {
+        return currentState;
+    }
+    
+    /**
+     * Generate a unique ID for a button based on its position.
+     * 
+     * @param button The button to get an ID for
+     * @return A unique string ID
+     */
+    private String getButtonId(Button button) {
+        // Create a unique ID based on the button's position
+        return "btn_" + (int)button.getX() + "_" + (int)button.getY();
+    }
+    
+    /**
+     * Records the state of a button.
+     */
+    private static class ButtonState {
+        String buttonId;
+        boolean activated;
+        
+        ButtonState(String buttonId, boolean activated) {
+            this.buttonId = buttonId;
+            this.activated = activated;
+        }
+    }
+    
+    /**
+     * Types of actions that can be recorded.
+     */
+    private enum ActionType {
+        BUTTON_ACTIVATION
+    }
+    
+    /**
+     * A recorded action with timestamp.
+     */
+    private static class RecordedAction {
+        ActionType type;
+        long timestamp;
+        String buttonId;
+        boolean activated;
+        boolean applied = false;
+        
+        RecordedAction(ActionType type, long timestamp, String buttonId, boolean activated) {
+            this.type = type;
+            this.timestamp = timestamp;
+            this.buttonId = buttonId;
+            this.activated = activated;
+        }
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/utils/TimerManager.java b/app/src/main/java/com/niravramdhanie/twod/game/utils/TimerManager.java
new file mode 100644
index 0000000..1f5b2bc
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/utils/TimerManager.java
@@ -0,0 +1,163 @@
+package com.niravramdhanie.twod.game.utils;
+
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Graphics2D;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * Manages the game timer.
+ * Displays and updates a countdown timer on screen.
+ */
+public class TimerManager {
+    private int time; // Time in seconds
+    private int maxTime; // Maximum time
+    private boolean running; // Whether the timer is running
+    private long lastUpdateTime; // Time of last update in milliseconds
+    
+    /**
+     * Creates a new timer with the specified maximum time.
+     * 
+     * @param maxTime The maximum time in seconds
+     */
+    public TimerManager(int maxTime) {
+        this.maxTime = maxTime;
+        this.time = maxTime;
+        this.running = false;
+        this.lastUpdateTime = 0;
+    }
+    
+    /**
+     * Starts the timer.
+     */
+    public void start() {
+        running = true;
+        lastUpdateTime = System.currentTimeMillis();
+    }
+    
+    /**
+     * Stops the timer.
+     */
+    public void stop() {
+        running = false;
+    }
+    
+    /**
+     * Resets the timer to the maximum time.
+     */
+    public void reset() {
+        time = maxTime;
+        lastUpdateTime = System.currentTimeMillis();
+    }
+    
+    /**
+     * Updates the timer based on elapsed time.
+     */
+    public void update() {
+        if (!running || time <= 0) {
+            return;
+        }
+        
+        long currentTime = System.currentTimeMillis();
+        long elapsed = currentTime - lastUpdateTime;
+        
+        // Decrease timer by 1 second if 1000ms has passed
+        if (elapsed >= 1000) {
+            time--;
+            lastUpdateTime = currentTime;
+            
+            // Stop timer if it reaches 0
+            if (time <= 0) {
+                time = 0;
+                stop();
+            }
+        }
+    }
+    
+    /**
+     * Renders the timer on screen.
+     * 
+     * @param g The graphics context to render to
+     * @param screenWidth The width of the screen
+     */
+    public void render(Graphics2D g, int screenWidth) {
+        // Save original font and color
+        Font originalFont = g.getFont();
+        Color originalColor = g.getColor();
+        
+        // Set font for timer
+        Font timerFont = new Font("Arial", Font.BOLD, 24);
+        g.setFont(timerFont);
+        
+        // Format time as mm:ss
+        String timeText = String.format("%02d:%02d", time / 60, time % 60);
+        
+        // Determine color based on remaining time
+        if (time > maxTime / 2) {
+            g.setColor(Color.WHITE); // More than half time remains
+        } else if (time > maxTime / 4) {
+            g.setColor(Color.YELLOW); // Between 1/4 and 1/2 time remains
+        } else {
+            g.setColor(Color.RED); // Less than 1/4 time remains
+        }
+        
+        // Center text
+        FontMetrics metrics = g.getFontMetrics();
+        Rectangle2D bounds = metrics.getStringBounds(timeText, g);
+        int x = (screenWidth - (int)bounds.getWidth()) / 2;
+        int y = 30; // Position near the top of the screen
+        
+        // Draw timer
+        g.drawString(timeText, x, y);
+        
+        // Restore original font and color
+        g.setFont(originalFont);
+        g.setColor(originalColor);
+    }
+    
+    /**
+     * Gets the current time.
+     * 
+     * @return The current time in seconds
+     */
+    public int getTime() {
+        return time;
+    }
+    
+    /**
+     * Sets the current time.
+     * 
+     * @param time The time in seconds
+     */
+    public void setTime(int time) {
+        this.time = time;
+    }
+    
+    /**
+     * Gets the maximum time.
+     * 
+     * @return The maximum time in seconds
+     */
+    public int getMaxTime() {
+        return maxTime;
+    }
+    
+    /**
+     * Sets the maximum time.
+     * 
+     * @param maxTime The maximum time in seconds
+     */
+    public void setMaxTime(int maxTime) {
+        this.maxTime = maxTime;
+    }
+    
+    /**
+     * Checks if the timer is running.
+     * 
+     * @return True if the timer is running, false otherwise
+     */
+    public boolean isRunning() {
+        return running;
+    }
+} 
\ No newline at end of file

From 585419fb418f968e874108918ccbedceb8997225 Mon Sep 17 00:00:00 2001
From: Nirav Ramdhanie <nirav@Vincents-MacBook-Pro.local>
Date: Thu, 8 May 2025 15:01:13 -0700
Subject: [PATCH 6/8] Fixed the toggle button to work as intended

---
 .../twod/game/entity/Button.java              |  34 +++++
 .../niravramdhanie/twod/game/entity/Door.java |   3 +-
 .../twod/game/state/PlayState.java            | 131 +++++++++--------
 .../twod/game/utils/RewindManager.java        | 132 ++++++++++++++++--
 4 files changed, 232 insertions(+), 68 deletions(-)

diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
index ebcab9f..1764fde 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
@@ -462,4 +462,38 @@ public void setColor(Color color) {
     public void setActiveColor(Color activeColor) {
         this.activeColor = activeColor;
     }
+    
+    /**
+     * Force sets the toggle state without executing any actions.
+     * Useful for rewind operations where we want to set the state
+     * without triggering the actual toggle behavior.
+     * 
+     * @param toggled The toggle state to set
+     * @return True if the action was a ToggleAction and state was set, false otherwise
+     */
+    public boolean forceSetToggleState(boolean toggled) {
+        if (action instanceof ToggleAction) {
+            ToggleAction toggleAction = (ToggleAction) action;
+            toggleAction.setToggled(toggled);
+            
+            // If this toggle controls a door, update the door state directly
+            if (toggleAction.getOnAction() instanceof DoorAction) {
+                DoorAction doorAction = (DoorAction) toggleAction.getOnAction();
+                doorAction.setDoorOpen(toggled);
+            }
+            
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Sets whether the button is activated without executing any actions.
+     * Useful for rewind operations.
+     * 
+     * @param activated Whether the button should be activated
+     */
+    public void setActivated(boolean activated) {
+        this.activated = activated;
+    }
 } 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
index fb96873..a75e758 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
@@ -12,8 +12,9 @@
  * A door entity that can be opened or closed.
  * When closed, it blocks player movement.
  * When open, it allows the player to pass through.
+ * Extends Block to work with collision detection.
  */
-public class Door extends Entity implements DoorAction.DoorStateChangeListener {
+public class Door extends Block implements DoorAction.DoorStateChangeListener {
     private String id;
     private boolean isOpen;
     private BufferedImage doorImage;
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
index 8da4f92..4f01105 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
@@ -9,11 +9,14 @@
 import java.util.List;
 import java.util.Random;
 
-import com.niravramdhanie.twod.game.actions.Action;
-import com.niravramdhanie.twod.game.actions.ActionFactory;
+import com.niravramdhanie.twod.game.actions.DoorAction;
+import com.niravramdhanie.twod.game.actions.DoorController;
+import com.niravramdhanie.twod.game.actions.ToggleAction;
 import com.niravramdhanie.twod.game.core.GameStateManager;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
+import com.niravramdhanie.twod.game.entity.Block;
 import com.niravramdhanie.twod.game.entity.Button;
+import com.niravramdhanie.twod.game.entity.Door;
 import com.niravramdhanie.twod.game.level.Level;
 import com.niravramdhanie.twod.game.utils.RewindManager;
 import com.niravramdhanie.twod.game.utils.TimerManager;
@@ -41,6 +44,11 @@ public class PlayState extends GameState {
     private RewindManager rewindManager;
     private boolean rewindEnabled = true;
     
+    // Door controls
+    private Door door;
+    private DoorController doorController;
+    private String doorId = "main_door";
+    
     // New variables for button highlighting
     private List<Button> nearButtons = new ArrayList<>();
     
@@ -73,8 +81,11 @@ public void init() {
         // Create a level layout with random blocks
         level.addRandomBlocks(10);
         
-        // Add some buttons to the level
-        addTestButtons();
+        // Initialize door controller
+        doorController = new DoorController();
+        
+        // Add the door and toggle button to the level
+        addDoorWithToggleButton();
         
         try {
             // Create player in the lower middle of the screen
@@ -93,6 +104,9 @@ public void init() {
             // Pass the blocks to the player for collision detection
             player.setBlocks(level.getBlocks());
             
+            // Add door to collision blocks if it's closed
+            updateDoorCollision();
+            
             // Initialize the timer manager
             timerManager = new TimerManager(timerDuration);
             timerManager.start();
@@ -153,6 +167,9 @@ public void update() {
             // Check for interaction with buttons
             checkButtonHighlights();
             
+            // Update door collision if necessary
+            updateDoorCollision();
+            
         } catch (Exception e) {
             System.err.println("Error in PlayState.update(): " + e.getMessage());
             e.printStackTrace();
@@ -396,74 +413,72 @@ private void drawGridInfo(Graphics2D g) {
         }
     }
     
+    /**
+     * Updates collision with the door based on its open/closed state
+     */
+    private void updateDoorCollision() {
+        if (door == null || player == null) return;
+        
+        // Get current blocks from the level
+        List<Block> blocks = new ArrayList<>(level.getBlocks());
+        
+        // Remove the door from blocks if it's in there
+        blocks.removeIf(block -> block.equals(door));
+        
+        // Add door only if it's closed
+        if (!door.isOpen()) {
+            blocks.add(door);
+        }
+        
+        // Update player's collision blocks
+        player.setBlocks(blocks);
+    }
+    
     /**
      * Adds test buttons to the level
      */
     private void addTestButtons() {
+        // Method intentionally left empty since we're using only the door toggle button
+    }
+    
+    /**
+     * Adds a door and a toggle button to control it
+     */
+    private void addDoorWithToggleButton() {
         int cellSize = level.getGrid().getCellSize();
-        
-        // Create one button for each action type at different positions
-        List<ActionFactory.ActionType> actionTypes = List.of(
-            ActionFactory.ActionType.MESSAGE,
-            ActionFactory.ActionType.TIMED,
-            ActionFactory.ActionType.TOGGLE,
-            ActionFactory.ActionType.DOOR,
-            ActionFactory.ActionType.MULTI,
-            ActionFactory.ActionType.CYCLING_MESSAGE
-        );
-        
         int horizontalCells = level.getGrid().getHorizontalCells();
         int verticalCells = level.getGrid().getVerticalCells();
         
-        // Calculate positions based on the number of action types
-        List<int[]> positions = new ArrayList<>();
+        // Place door in the middle right of the level
+        int doorGridX = horizontalCells - 5;
+        int doorGridY = verticalCells / 2;
         
-        // Place buttons in the four corners and center
-        positions.add(new int[]{3, 3});  // Top-left
-        positions.add(new int[]{horizontalCells - 4, 3});  // Top-right
-        positions.add(new int[]{3, verticalCells - 4});  // Bottom-left
-        positions.add(new int[]{horizontalCells - 4, verticalCells - 4});  // Bottom-right
-        positions.add(new int[]{horizontalCells / 2, verticalCells / 2});  // Center
+        // Create the door
+        float doorX = level.getGrid().gridToScreenX(doorGridX);
+        float doorY = level.getGrid().gridToScreenY(doorGridY);
+        door = new Door(doorX, doorY, cellSize, cellSize, doorId);
+        level.addEntity(door, doorGridX, doorGridY);
         
-        // Add extra position if needed
-        if (actionTypes.size() > positions.size()) {
-            positions.add(new int[]{horizontalCells / 3, verticalCells / 3});
-        }
+        // Register door with controller
+        doorController.registerDoor(door);
         
-        // Create buttons for each action type
-        for (int i = 0; i < actionTypes.size() && i < positions.size(); i++) {
-            Button button = new Button(0, 0, cellSize, cellSize);
-            Action action = ActionFactory.createAction(actionTypes.get(i), button);
-            button.setAction(action);
-            
-            int[] pos = positions.get(i);
-            level.addEntity(button, pos[0], pos[1]);
-            
-            System.out.println("Added button with action: " + actionTypes.get(i) + " at " + pos[0] + "," + pos[1]);
-        }
+        // Place button in the middle left of the level
+        int buttonGridX = 5;
+        int buttonGridY = verticalCells / 2;
         
-        // Additionally, add a random button somewhere
-        int attempts = 0;
-        boolean placed = false;
+        // Create a door action
+        DoorAction doorAction = new DoorAction(doorId);
+        doorAction.setDoorStateChangeListener(doorController);
         
-        while (!placed && attempts < 10) {
-            // Try to find a random unoccupied position
-            int[] pos = level.findSuitableButtonPosition();
-            
-            if (pos != null) {
-                Button randomButton = new Button(0, 0, cellSize, cellSize);
-                Action randomAction = ActionFactory.createRandomAction(randomButton);
-                randomButton.setAction(randomAction);
-                
-                level.addEntity(randomButton, pos[0], pos[1]);
-                System.out.println("Added random button at " + pos[0] + "," + pos[1]);
-                placed = true;
-            }
-            
-            attempts++;
-        }
+        // Create a toggle action for the door
+        ToggleAction toggleAction = new ToggleAction(doorAction, doorAction);
+        
+        // Create button with the toggle action
+        Button doorButton = new Button(0, 0, cellSize, cellSize, toggleAction);
+        level.addEntity(doorButton, buttonGridX, buttonGridY);
         
-        System.out.println("Added test buttons to the level");
+        System.out.println("Added door at " + doorGridX + "," + doorGridY + 
+                          " and toggle button at " + buttonGridX + "," + buttonGridY);
     }
     
     @Override
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java b/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
index 2b1bcba..c9c2a0d 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
@@ -1,10 +1,17 @@
 package com.niravramdhanie.twod.game.utils;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
-import com.niravramdhanie.twod.game.entity.Button;
+import com.niravramdhanie.twod.game.actions.Action;
+import com.niravramdhanie.twod.game.actions.DoorAction;
+import com.niravramdhanie.twod.game.actions.ToggleAction;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
+import com.niravramdhanie.twod.game.entity.Button;
 
 /**
  * Manages the rewind feature for the game.
@@ -31,6 +38,8 @@ public enum RewindState {
     private float playerStartY;
     private int timerStartValue;
     private List<ButtonState> initialButtonStates = new ArrayList<>();
+    private Map<String, Boolean> initialToggleStates = new HashMap<>();
+    private Map<String, Boolean> initialDoorStates = new HashMap<>();
     
     // Recorded actions
     private List<RecordedAction> recordedActions = new ArrayList<>();
@@ -40,6 +49,9 @@ public enum RewindState {
     private List<Button> buttons;
     private TimerManager timer;
     
+    // Map to track toggle states during replay
+    private Map<String, Boolean> currentToggleStates = new HashMap<>();
+    
     /**
      * Creates a new RewindManager.
      * 
@@ -60,16 +72,36 @@ public void startRecording() {
         // Clear previous recordings
         recordedActions.clear();
         initialButtonStates.clear();
+        initialToggleStates.clear();
+        initialDoorStates.clear();
+        currentToggleStates.clear();
         
         // Record initial state
         playerStartX = player.getX();
         playerStartY = player.getY();
         timerStartValue = timer.getTime();
         
-        // Record initial button states
+        // Record initial button states and toggle states
         for (Button button : buttons) {
             String buttonId = getButtonId(button);
-            initialButtonStates.add(new ButtonState(buttonId, button.isActivated()));
+            boolean isActivated = button.isActivated();
+            initialButtonStates.add(new ButtonState(buttonId, isActivated));
+            
+            // Store toggle states for ToggleAction buttons
+            Action action = button.getAction();
+            if (action instanceof ToggleAction) {
+                ToggleAction toggleAction = (ToggleAction) action;
+                initialToggleStates.put(buttonId, toggleAction.isToggled());
+                
+                // Store door states for DoorActions inside ToggleActions
+                if (toggleAction.getOnAction() instanceof DoorAction) {
+                    DoorAction doorAction = (DoorAction) toggleAction.getOnAction();
+                    initialDoorStates.put(doorAction.getDoorId(), doorAction.isDoorOpen());
+                }
+            } else if (action instanceof DoorAction) {
+                DoorAction doorAction = (DoorAction) action;
+                initialDoorStates.put(doorAction.getDoorId(), doorAction.isDoorOpen());
+            }
         }
         
         // Set recording state
@@ -114,21 +146,44 @@ public void startRewinding() {
         // Reset timer
         timer.setTime(timerStartValue);
         
-        // Reset button states
+        // Initialize current toggle states with the initial values
+        currentToggleStates.clear();
+        currentToggleStates.putAll(initialToggleStates);
+        
+        // Reset button states and toggle states
         for (ButtonState state : initialButtonStates) {
             for (Button button : buttons) {
                 String buttonId = getButtonId(button);
                 if (buttonId.equals(state.buttonId)) {
-                    if (state.activated) {
-                        button.activate();
-                    } else {
-                        button.deactivate();
+                    // Set button activation state without triggering actions
+                    button.setActivated(state.activated);
+                    
+                    // Handle toggle states using the new method
+                    boolean initialToggled = initialToggleStates.getOrDefault(buttonId, false);
+                    button.forceSetToggleState(initialToggled);
+                    
+                    // For actions that aren't toggles but might be DoorActions
+                    Action action = button.getAction();
+                    if (!(action instanceof ToggleAction) && action instanceof DoorAction) {
+                        DoorAction doorAction = (DoorAction) action;
+                        String doorId = doorAction.getDoorId();
+                        boolean initialDoorOpen = initialDoorStates.getOrDefault(doorId, false);
+                        doorAction.setDoorOpen(initialDoorOpen);
                     }
+                    
                     break;
                 }
             }
         }
         
+        // Mark all actions as not applied
+        for (RecordedAction action : recordedActions) {
+            action.applied = false;
+        }
+        
+        // Sort actions by timestamp to ensure correct replay order
+        Collections.sort(recordedActions, Comparator.comparingLong(a -> a.timestamp));
+        
         // Start rewinding
         currentState = RewindState.REWINDING;
         rewindStartTime = System.currentTimeMillis();
@@ -154,6 +209,13 @@ public void update() {
             if (action.timestamp <= currentRelativeTime && !action.applied) {
                 applyAction(action);
                 action.applied = true;
+                
+                // Add a small delay to make actions visually apparent
+                try {
+                    Thread.sleep(30);
+                } catch (InterruptedException e) {
+                    // Ignore
+                }
             }
         }
         
@@ -168,11 +230,42 @@ public void update() {
         
         // If all actions are applied, reset rewind state
         if (allApplied) {
+            // Sync final states to ensure consistency
+            synchronizeFinalStates();
+            
+            // Reset rewind state
             currentState = RewindState.IDLE;
             System.out.println("Rewind: All actions replayed, returning to idle state");
         }
     }
     
+    /**
+     * Synchronize final states to ensure consistency between buttons, toggles, and doors
+     */
+    private void synchronizeFinalStates() {
+        // Apply the current toggle states from our tracking
+        for (Button button : buttons) {
+            String buttonId = getButtonId(button);
+            Action action = button.getAction();
+            
+            // For toggle actions, apply the final tracked state
+            if (action instanceof ToggleAction) {
+                ToggleAction toggleAction = (ToggleAction) action;
+                if (currentToggleStates.containsKey(buttonId)) {
+                    boolean finalToggleState = currentToggleStates.get(buttonId);
+                    button.forceSetToggleState(finalToggleState);
+                }
+                
+                // Ensure door state is consistent
+                if (toggleAction.getOnAction() instanceof DoorAction) {
+                    DoorAction doorAction = (DoorAction) toggleAction.getOnAction();
+                    boolean toggledState = toggleAction.isToggled();
+                    doorAction.setDoorOpen(toggledState);
+                }
+            }
+        }
+    }
+    
     /**
      * Applies a recorded action.
      * 
@@ -184,11 +277,32 @@ private void applyAction(RecordedAction action) {
             for (Button button : buttons) {
                 String buttonId = getButtonId(button);
                 if (buttonId.equals(action.buttonId)) {
+                    // Record the current state before making changes
+                    boolean wasActivated = button.isActivated();
+                    
+                    // Apply the action
                     if (action.activated) {
+                        // If activating a button, use the regular activate method
+                        // which will trigger any associated actions
                         button.activate();
+                        
+                        // Update toggle state tracking
+                        if (button.getAction() instanceof ToggleAction) {
+                            ToggleAction toggleAction = (ToggleAction) button.getAction();
+                            boolean newToggleState = toggleAction.isToggled();
+                            currentToggleStates.put(buttonId, newToggleState);
+                            
+                            // Ensure door state is consistent with toggle state
+                            if (toggleAction.getOnAction() instanceof DoorAction) {
+                                DoorAction doorAction = (DoorAction) toggleAction.getOnAction();
+                                doorAction.setDoorOpen(newToggleState);
+                            }
+                        }
                     } else {
-                        button.deactivate();
+                        // If deactivating, set without executing actions
+                        button.setActivated(false);
                     }
+                    
                     System.out.println("Rewind: Replayed button " + action.buttonId + 
                                      " " + (action.activated ? "activation" : "deactivation") + 
                                      " at time " + action.timestamp + "ms");

From d7d1a82d0a69eccf3518644cd41d5bd87e11d212 Mon Sep 17 00:00:00 2001
From: Nirav Ramdhanie <nirav@Vincents-MacBook-Pro.local>
Date: Fri, 9 May 2025 12:44:38 -0700
Subject: [PATCH 7/8] Made first level completed

---
 .../twod/game/actions/MultiButtonAction.java  | 174 +++++++++++++
 .../twod/game/actions/TimedAction.java        | 196 +++++++-------
 .../twod/game/entity/Button.java              | 119 +++++++--
 .../niravramdhanie/twod/game/entity/Door.java | 173 ++++++++++++-
 .../niravramdhanie/twod/game/level/Level.java | 122 +--------
 .../twod/game/state/PlayState.java            | 241 +++++++++++++-----
 .../twod/game/utils/RewindManager.java        |  56 +++-
 7 files changed, 778 insertions(+), 303 deletions(-)
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/actions/MultiButtonAction.java

diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/MultiButtonAction.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/MultiButtonAction.java
new file mode 100644
index 0000000..c6e9b51
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/MultiButtonAction.java
@@ -0,0 +1,174 @@
+package com.niravramdhanie.twod.game.actions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * An action that only executes when all required buttons are activated.
+ * Used for scenarios where multiple buttons need to be pressed simultaneously.
+ */
+public class MultiButtonAction implements Action {
+    private List<String> requiredButtonIds;
+    private List<Boolean> buttonStates;
+    private Action targetAction;
+    private boolean permanentActivation;
+    private boolean wasActivated;
+    
+    /**
+     * Creates a new MultiButtonAction.
+     * 
+     * @param targetAction The action to execute when all buttons are activated
+     * @param permanentActivation If true, once activated, the action stays activated even if buttons are released
+     */
+    public MultiButtonAction(Action targetAction, boolean permanentActivation) {
+        this.targetAction = targetAction;
+        this.requiredButtonIds = new ArrayList<>();
+        this.buttonStates = new ArrayList<>();
+        this.permanentActivation = permanentActivation;
+        this.wasActivated = false;
+    }
+    
+    /**
+     * Adds a button requirement.
+     * 
+     * @param buttonId The ID of the required button
+     */
+    public void addRequiredButton(String buttonId) {
+        requiredButtonIds.add(buttonId);
+        buttonStates.add(false);
+    }
+    
+    /**
+     * Updates the state of a button.
+     * 
+     * @param buttonId The ID of the button
+     * @param isActivated Whether the button is activated
+     * @return True if the update changed the overall activation state, false otherwise
+     */
+    public boolean updateButtonState(String buttonId, boolean isActivated) {
+        int index = requiredButtonIds.indexOf(buttonId);
+        if (index == -1) {
+            System.out.println("Button ID not found: " + buttonId);
+            return false;
+        }
+        
+        // Update the button state
+        boolean oldState = buttonStates.get(index);
+        buttonStates.set(index, isActivated);
+        
+        boolean stateChanged = oldState != isActivated;
+        if (stateChanged) {
+            System.out.println("Button " + buttonId + " is now " + (isActivated ? "activated" : "deactivated"));
+        }
+        
+        // Check if all buttons are now activated
+        boolean allActivated = checkAllButtonsActivated();
+        
+        if (allActivated) {
+            System.out.println("All buttons are now activated!");
+            
+            // If this is the first time all buttons are activated, record it
+            if (!wasActivated) {
+                wasActivated = true;
+                System.out.println("Permanent activation achieved!");
+            }
+        } else {
+            // Log which buttons are still needed
+            if (isActivated) {
+                logRemainingButtons();
+            }
+        }
+        
+        // Execute the target action if we're activated
+        if ((allActivated || (permanentActivation && wasActivated)) && targetAction != null) {
+            if (allActivated) {
+                System.out.println("Executing target action because all buttons are active");
+            } else {
+                System.out.println("Executing target action because of permanent activation");
+            }
+            targetAction.execute();
+            return true;
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Logs information about which buttons still need to be activated.
+     */
+    private void logRemainingButtons() {
+        List<String> missingButtons = new ArrayList<>();
+        for (int i = 0; i < requiredButtonIds.size(); i++) {
+            if (!buttonStates.get(i)) {
+                missingButtons.add(requiredButtonIds.get(i));
+            }
+        }
+        
+        if (!missingButtons.isEmpty()) {
+            System.out.println("Still need to activate: " + String.join(", ", missingButtons));
+        }
+    }
+    
+    /**
+     * Checks if all required buttons are activated.
+     * 
+     * @return True if all buttons are activated, false otherwise
+     */
+    private boolean checkAllButtonsActivated() {
+        for (Boolean state : buttonStates) {
+            if (!state) {
+                return false;
+            }
+        }
+        return !buttonStates.isEmpty();
+    }
+    
+    @Override
+    public void execute() {
+        // This action doesn't directly execute; it's controlled by button states
+        // The actual execution happens in updateButtonState
+    }
+    
+    @Override
+    public String getDescription() {
+        int totalButtons = requiredButtonIds.size();
+        int activatedButtons = 0;
+        
+        for (Boolean state : buttonStates) {
+            if (state) {
+                activatedButtons++;
+            }
+        }
+        
+        String actionDesc = targetAction != null ? targetAction.getDescription() : "No action";
+        return "Multi-button (" + activatedButtons + "/" + totalButtons + " active): " + actionDesc;
+    }
+    
+    /**
+     * Resets the activation state.
+     */
+    public void reset() {
+        wasActivated = false;
+        for (int i = 0; i < buttonStates.size(); i++) {
+            buttonStates.set(i, false);
+        }
+    }
+    
+    /**
+     * Gets whether this action has been permanently activated.
+     * 
+     * @return True if permanently activated, false otherwise
+     */
+    public boolean isPermanentlyActivated() {
+        return permanentActivation && wasActivated;
+    }
+    
+    /**
+     * Sets whether this action uses permanent activation.
+     * 
+     * @param permanentActivation True for permanent activation, false for temporary
+     */
+    public void setPermanentActivation(boolean permanentActivation) {
+        this.permanentActivation = permanentActivation;
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/actions/TimedAction.java b/app/src/main/java/com/niravramdhanie/twod/game/actions/TimedAction.java
index f0e0908..238c868 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/actions/TimedAction.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/actions/TimedAction.java
@@ -3,152 +3,166 @@
 import com.niravramdhanie.twod.game.entity.Button;
 
 /**
- * An action that executes another action and then automatically deactivates the button after a specified duration.
+ * An action that executes for a limited time and then automatically deactivates.
  */
 public class TimedAction implements Action {
     private Action wrappedAction;
-    private int duration; // in milliseconds
+    private Action deactivateAction; // Action to execute when deactivated
+    private long durationMillis;
+    private boolean isActive;
+    private long startTime;
     private Button targetButton;
-    private long activationTime;
     
     /**
      * Creates a new timed action.
      * 
-     * @param wrappedAction The action to execute
-     * @param duration The duration in milliseconds before the button deactivates
+     * @param wrappedAction The action to execute for a limited time
+     * @param durationMillis The duration in milliseconds
      */
-    public TimedAction(Action wrappedAction, int duration) {
+    public TimedAction(Action wrappedAction, long durationMillis) {
         this.wrappedAction = wrappedAction;
-        this.duration = duration;
-        this.activationTime = 0;
+        this.durationMillis = durationMillis;
+        this.isActive = false;
+        this.startTime = 0;
+        this.deactivateAction = null;
     }
     
     /**
-     * Creates a timed action with a default duration of 3 seconds.
+     * Sets the button that should be deactivated when the timer expires.
      * 
-     * @param wrappedAction The action to execute
+     * @param button The button to deactivate
      */
-    public TimedAction(Action wrappedAction) {
-        this(wrappedAction, 3000); // Default 3 seconds
+    public void setTargetButton(Button button) {
+        this.targetButton = button;
     }
     
     /**
-     * Creates a timed message action with the specified message and duration.
+     * Sets an action to execute when this timed action deactivates.
      * 
-     * @param message The message to display
-     * @param durationMillis The duration in milliseconds before deactivation
+     * @param deactivateAction The action to execute on deactivation
      */
-    public static TimedAction createTimedMessage(String message, int durationMillis) {
-        MessageAction msgAction = new MessageAction(message);
-        TimedAction timedAction = new TimedAction(msgAction, durationMillis);
-        return timedAction;
+    public void setDeactivateAction(Action deactivateAction) {
+        this.deactivateAction = deactivateAction;
     }
     
     @Override
     public void execute() {
-        // Execute the wrapped action
-        if (wrappedAction != null) {
-            wrappedAction.execute();
-        }
-        
-        // Record the activation time
-        activationTime = System.currentTimeMillis();
-        
-        // Start a thread to deactivate the button after the duration
-        if (targetButton != null) {
-            new Thread(() -> {
-                try {
-                    Thread.sleep(duration);
-                    targetButton.deactivate();
-                } catch (InterruptedException e) {
-                    System.err.println("TimedAction interrupted: " + e.getMessage());
-                }
-            }).start();
+        if (!isActive) {
+            // Start the timer
+            isActive = true;
+            startTime = System.currentTimeMillis();
+            
+            // Execute the wrapped action
+            if (wrappedAction != null) {
+                wrappedAction.execute();
+            }
+            
+            System.out.println("Timed action started for " + durationMillis + "ms");
+        } else {
+            // Already active, check if it should be deactivated
+            long elapsedTime = System.currentTimeMillis() - startTime;
+            if (elapsedTime >= durationMillis) {
+                deactivate();
+                System.out.println("Timed action expired");
+            } else {
+                // Refresh the timer
+                startTime = System.currentTimeMillis();
+                System.out.println("Timed action refreshed for " + durationMillis + "ms");
+            }
         }
     }
     
-    @Override
-    public String getDescription() {
-        String baseDesc = wrappedAction != null ? wrappedAction.getDescription() : "No action";
-        return baseDesc + " (Timed: " + duration / 1000.0 + "s)";
-    }
-    
     /**
-     * Sets the button that this timed action will deactivate.
+     * Updates the timed action status. Should be called regularly.
      * 
-     * @param button The button to deactivate
-     */
-    public void setTargetButton(Button button) {
-        this.targetButton = button;
-    }
-    
-    /**
-     * Gets the button that this action will deactivate.
-     * 
-     * @return The target button
+     * @return True if the action is still active, false if it has expired
      */
-    public Button getTargetButton() {
-        return targetButton;
+    public boolean update() {
+        if (isActive) {
+            long elapsedTime = System.currentTimeMillis() - startTime;
+            if (elapsedTime >= durationMillis) {
+                deactivate();
+                return false;
+            }
+            return true;
+        }
+        return false;
     }
     
     /**
-     * Sets the duration before the button deactivates.
+     * Gets the remaining time in milliseconds.
      * 
-     * @param duration The duration in milliseconds
+     * @return The remaining time, or 0 if not active
      */
-    public void setDuration(int duration) {
-        this.duration = duration;
+    public long getRemainingTime() {
+        if (!isActive) {
+            return 0;
+        }
+        
+        long elapsedTime = System.currentTimeMillis() - startTime;
+        long remaining = durationMillis - elapsedTime;
+        return (remaining > 0) ? remaining : 0;
     }
     
     /**
-     * Gets the duration before the button deactivates.
+     * Gets the fraction of time remaining (0.0 to 1.0).
      * 
-     * @return The duration in milliseconds
+     * @return The fraction of time remaining, or 0 if not active
      */
-    public int getDuration() {
-        return duration;
+    public float getTimeRemainingFraction() {
+        if (!isActive || durationMillis <= 0) {
+            return 0.0f;
+        }
+        
+        return (float)getRemainingTime() / durationMillis;
     }
     
     /**
-     * Sets the wrapped action.
-     * 
-     * @param wrappedAction The action to execute
+     * Forcefully deactivates the timed action.
      */
-    public void setWrappedAction(Action wrappedAction) {
-        this.wrappedAction = wrappedAction;
+    public void deactivate() {
+        isActive = false;
+        
+        // Execute the deactivate action if set
+        if (deactivateAction != null) {
+            deactivateAction.execute();
+        }
+        
+        // Deactivate the target button if set
+        if (targetButton != null) {
+            targetButton.deactivate();
+        }
     }
     
     /**
-     * Gets the wrapped action.
+     * Checks if the action is currently active.
      * 
-     * @return The wrapped action
+     * @return True if active, false otherwise
      */
-    public Action getWrappedAction() {
-        return wrappedAction;
+    public boolean isActive() {
+        return isActive;
     }
     
     /**
-     * Gets the time when this action was activated.
+     * Sets the active state without executing any actions.
+     * Useful for rewinding operations.
      * 
-     * @return The activation time as milliseconds since epoch, or 0 if not activated
+     * @param active Whether the action is active
      */
-    public long getActivationTime() {
-        return activationTime;
+    public void setActive(boolean active) {
+        this.isActive = active;
+        
+        // Set the start time to the current time when activating
+        if (active) {
+            this.startTime = System.currentTimeMillis();
+        } else {
+            this.startTime = 0;
+        }
     }
     
-    /**
-     * Calculates the remaining time before deactivation.
-     * 
-     * @return The remaining time in milliseconds, or 0 if not activated or time expired
-     */
-    public long getRemainingTime() {
-        if (activationTime == 0) {
-            return 0;
-        }
-        
-        long elapsed = System.currentTimeMillis() - activationTime;
-        long remaining = duration - elapsed;
-        
-        return Math.max(0, remaining);
+    @Override
+    public String getDescription() {
+        String baseDesc = wrappedAction != null ? wrappedAction.getDescription() : "No action";
+        return "Timed (" + (durationMillis / 1000f) + "s): " + baseDesc;
     }
 } 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
index 1764fde..36b4e1e 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Button.java
@@ -35,6 +35,10 @@ public class Button extends Entity {
     // Reference to the rewind manager
     private static RewindManager rewindManager;
     
+    // Visual effects for activation
+    private long activationTime;
+    private boolean pulseEffect;
+    
     static {
         // Initialize the icon font
         iconFont = new Font("Arial", Font.BOLD, 14);
@@ -53,6 +57,8 @@ public Button(float x, float y, int width, int height, Action action) {
         super(x, y, width, height);
         this.action = action;
         this.activated = false;
+        this.pulseEffect = true;
+        this.activationTime = 0;
         
         // Default colors
         this.color = new Color(200, 50, 50); // Red when inactive
@@ -88,7 +94,14 @@ public Button(float x, float y, int width, int height) {
     
     @Override
     public void update() {
-        // Button behavior updates handled in activation methods
+        // Update activation time for effects
+        if (activated) {
+            if (activationTime == 0) {
+                activationTime = System.currentTimeMillis();
+            }
+        } else {
+            activationTime = 0;
+        }
     }
     
     @Override
@@ -107,6 +120,11 @@ public void render(Graphics2D g) {
                     drawTimerBar(g);
                 }
             }
+            
+            // Draw activation glow if activated
+            if (activated) {
+                drawActivationIndicator(g);
+            }
         } catch (Exception e) {
             // Ultimate fallback
             System.err.println("Error rendering button: " + e.getMessage());
@@ -262,43 +280,37 @@ private void drawInteractionHint(Graphics2D g) {
     }
     
     /**
-     * Draws a timer bar for timed actions.
-     * 
-     * @param g The graphics context
+     * Draws a timer bar for timed actions
      */
     private void drawTimerBar(Graphics2D g) {
+        if (!(action instanceof TimedAction)) return;
+        
         TimedAction timedAction = (TimedAction) action;
-        long currentTime = System.currentTimeMillis();
-        long activationTime = timedAction.getActivationTime();
-        int durationMillis = timedAction.getDuration();
+        if (!timedAction.isActive()) return;
         
-        if (activationTime == 0) {
-            // Fallback if activation time is not available
-            activationTime = currentTime - 100;
-        }
+        // Store original color
+        Color originalColor = g.getColor();
         
-        float progress = Math.min(1.0f, (float)(currentTime - activationTime) / durationMillis);
+        // Get the timer fraction (0.0 to 1.0)
+        float fraction = timedAction.getTimeRemainingFraction();
         
-        // Draw timer bar underneath the button
-        int barHeight = 5;
-        int barWidth = (int)((1.0f - progress) * width);
+        // Draw the timer bar background
+        g.setColor(Color.DARK_GRAY);
+        g.fillRect((int)position.x, (int)position.y + height + 2, width, 4);
         
-        // Calculate color based on remaining time (green->yellow->red)
-        float remainingRatio = 1.0f - progress;
-        Color timerColor;
-        if (remainingRatio > 0.6f) {
-            timerColor = Color.GREEN;
-        } else if (remainingRatio > 0.3f) {
-            timerColor = Color.YELLOW;
+        // Draw the timer bar foreground
+        if (fraction > 0.6f) {
+            g.setColor(Color.GREEN);
+        } else if (fraction > 0.3f) {
+            g.setColor(Color.YELLOW);
         } else {
-            timerColor = Color.RED;
+            g.setColor(Color.RED);
         }
         
-        g.setColor(timerColor);
-        g.fillRect((int)position.x, (int)position.y + height + 2, barWidth, barHeight);
+        g.fillRect((int)position.x, (int)position.y + height + 2, (int)(width * fraction), 4);
         
-        g.setColor(Color.WHITE);
-        g.drawRect((int)position.x, (int)position.y + height + 2, width, barHeight);
+        // Restore original color
+        g.setColor(originalColor);
     }
     
     /**
@@ -352,6 +364,42 @@ private void drawMessageIndicator(Graphics2D g, MessageAction messageAction) {
         }
     }
     
+    /**
+     * Draws a visual indicator that the button is activated
+     */
+    private void drawActivationIndicator(Graphics2D g) {
+        // Store original color
+        Color originalColor = g.getColor();
+        
+        // Create a pulsating effect
+        float alpha = 0.7f;
+        if (pulseEffect) {
+            long elapsed = System.currentTimeMillis() - activationTime;
+            alpha = 0.3f + (float)Math.abs(Math.sin(elapsed * 0.005f)) * 0.4f;
+        }
+        
+        // Draw a glowing outline
+        g.setColor(new Color(
+            activeColor.getRed() / 255f,
+            activeColor.getGreen() / 255f,
+            activeColor.getBlue() / 255f,
+            alpha
+        ));
+        
+        // Draw outer glow
+        int glowSize = 4;
+        g.fillRoundRect(
+            (int)position.x - glowSize,
+            (int)position.y - glowSize,
+            width + glowSize * 2,
+            height + glowSize * 2,
+            10, 10
+        );
+        
+        // Restore original color
+        g.setColor(originalColor);
+    }
+    
     /**
      * Sets the rewind manager for all buttons.
      * 
@@ -495,5 +543,22 @@ public boolean forceSetToggleState(boolean toggled) {
      */
     public void setActivated(boolean activated) {
         this.activated = activated;
+        
+        // Update activation time when the button is activated during rewind
+        // to ensure the visual indicator plays properly
+        if (activated) {
+            this.activationTime = System.currentTimeMillis();
+        } else {
+            this.activationTime = 0;
+        }
+    }
+    
+    /**
+     * Sets whether this button should use a pulsating effect when activated.
+     * 
+     * @param pulseEffect True to enable pulsing, false for static activation indicators
+     */
+    public void setPulseEffect(boolean pulseEffect) {
+        this.pulseEffect = pulseEffect;
     }
 } 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
index a75e758..182d550 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Door.java
@@ -1,6 +1,8 @@
 package com.niravramdhanie.twod.game.entity;
 
 import java.awt.Color;
+import java.awt.Font;
+import java.awt.FontMetrics;
 import java.awt.GradientPaint;
 import java.awt.Graphics2D;
 import java.awt.image.BufferedImage;
@@ -17,10 +19,14 @@
 public class Door extends Block implements DoorAction.DoorStateChangeListener {
     private String id;
     private boolean isOpen;
+    private boolean isPermanentlyOpen;
     private BufferedImage doorImage;
     private BufferedImage doorOpenImage;
     private Color doorColor = new Color(139, 69, 19); // Brown door color
     private Color frameColor = new Color(101, 67, 33); // Darker frame color
+    private Color openIndicatorColor = new Color(0, 255, 0, 128); // Semi-transparent green
+    private Color permanentIndicatorColor = new Color(255, 215, 0, 160); // Semi-transparent gold
+    private long openTime; // Time when the door was opened
     
     /**
      * Creates a new door entity.
@@ -35,6 +41,8 @@ public Door(float x, float y, int width, int height, String id) {
         super(x, y, width, height);
         this.id = id;
         this.isOpen = false;
+        this.isPermanentlyOpen = false;
+        this.openTime = 0;
         
         try {
             // Load door images
@@ -49,7 +57,12 @@ public Door(float x, float y, int width, int height, String id) {
     
     @Override
     public void update() {
-        // Currently nothing to update for the door
+        // Update door state
+        if (isOpen && openTime == 0) {
+            openTime = System.currentTimeMillis();
+        } else if (!isOpen) {
+            openTime = 0;
+        }
     }
     
     @Override
@@ -58,6 +71,12 @@ public void render(Graphics2D g) {
             // Render using images
             if (isOpen) {
                 g.drawImage(doorOpenImage, (int)position.x, (int)position.y, width, height, null);
+                // Draw open indicator
+                if (isPermanentlyOpen) {
+                    drawPermanentOpenIndicator(g);
+                } else {
+                    drawOpenIndicator(g);
+                }
             } else {
                 g.drawImage(doorImage, (int)position.x, (int)position.y, width, height, null);
             }
@@ -66,6 +85,12 @@ public void render(Graphics2D g) {
             if (isOpen) {
                 // Draw frame but no door
                 drawDoorFrame(g);
+                // Draw open indicator
+                if (isPermanentlyOpen) {
+                    drawPermanentOpenIndicator(g);
+                } else {
+                    drawOpenIndicator(g);
+                }
             } else {
                 // Draw both frame and door
                 drawDoorFrame(g);
@@ -74,6 +99,116 @@ public void render(Graphics2D g) {
         }
     }
     
+    /**
+     * Draws an indicator that the door is permanently open.
+     * 
+     * @param g The graphics context
+     */
+    private void drawPermanentOpenIndicator(Graphics2D g) {
+        // Store original color
+        Color originalColor = g.getColor();
+        
+        // Create a pulsating effect with gold color
+        float alpha = 0.7f;
+        if (openTime > 0) {
+            long elapsed = System.currentTimeMillis() - openTime;
+            alpha = 0.4f + (float)Math.abs(Math.sin(elapsed * 0.002f)) * 0.3f;
+        }
+        
+        // Draw a glowing golden outline around the door frame
+        g.setColor(new Color(
+            permanentIndicatorColor.getRed(), 
+            permanentIndicatorColor.getGreen(), 
+            permanentIndicatorColor.getBlue(), 
+            (int)(alpha * 255)
+        ));
+        
+        // Draw glow over the door frame
+        int glowSize = 6;  // Larger glow for permanent
+        g.fillRoundRect(
+            (int)position.x - glowSize, 
+            (int)position.y - glowSize, 
+            width + glowSize * 2, 
+            height + glowSize * 2,
+            10, 10
+        );
+        
+        // Add "PERMANENTLY OPEN" text
+        g.setColor(Color.WHITE);
+        g.setFont(new Font("Arial", Font.BOLD, 12));
+        String text = "PERMANENTLY OPEN";
+        FontMetrics fm = g.getFontMetrics();
+        int textWidth = fm.stringWidth(text);
+        int textHeight = fm.getHeight();
+        
+        // Draw background for text to improve readability
+        g.setColor(new Color(0, 0, 0, 180));
+        g.fillRect(
+            (int)position.x + (width - textWidth) / 2 - 2, 
+            (int)position.y + height + 2, 
+            textWidth + 4, 
+            textHeight
+        );
+        
+        // Draw text
+        g.setColor(Color.YELLOW);
+        g.drawString(text, 
+            (int)position.x + (width - textWidth) / 2, 
+            (int)position.y + height + textHeight);
+        
+        // Restore original color
+        g.setColor(originalColor);
+    }
+    
+    /**
+     * Draws an indicator that the door is open.
+     * 
+     * @param g The graphics context
+     */
+    private void drawOpenIndicator(Graphics2D g) {
+        // Store original color
+        Color originalColor = g.getColor();
+        
+        // Create a pulsating effect
+        float alpha = 0.6f;
+        if (openTime > 0) {
+            long elapsed = System.currentTimeMillis() - openTime;
+            alpha = 0.3f + (float)Math.abs(Math.sin(elapsed * 0.003f)) * 0.3f;
+        }
+        
+        // Draw a glowing outline around the door frame
+        g.setColor(new Color(
+            openIndicatorColor.getRed(), 
+            openIndicatorColor.getGreen(), 
+            openIndicatorColor.getBlue(), 
+            (int)(alpha * 255)
+        ));
+        
+        // Draw glow over the door frame
+        int glowSize = 4;
+        g.fillRoundRect(
+            (int)position.x - glowSize, 
+            (int)position.y - glowSize, 
+            width + glowSize * 2, 
+            height + glowSize * 2,
+            8, 8
+        );
+        
+        // Add "OPEN" text
+        g.setColor(Color.WHITE);
+        g.setFont(new Font("Arial", Font.BOLD, 12));
+        String text = "OPEN";
+        FontMetrics fm = g.getFontMetrics();
+        int textWidth = fm.stringWidth(text);
+        int textHeight = fm.getHeight();
+        g.drawString(text, 
+            (int)position.x + (width - textWidth) / 2, 
+            (int)position.y + height + textHeight);
+        
+        // Restore original color
+        g.setColor(originalColor);
+    }
+    
     /**
      * Draws the door frame.
      * 
@@ -140,10 +275,30 @@ public void open() {
     }
     
     /**
-     * Closes the door.
+     * Opens the door permanently, so it can't be closed again.
+     */
+    public void openPermanently() {
+        isOpen = true;
+        isPermanentlyOpen = true;
+        System.out.println("Door " + id + " has been permanently opened!");
+    }
+    
+    /**
+     * Checks if the door is permanently open.
+     * 
+     * @return True if permanently open, false otherwise
+     */
+    public boolean isPermanentlyOpen() {
+        return isPermanentlyOpen;
+    }
+    
+    /**
+     * Closes the door if it's not permanently open.
      */
     public void close() {
-        isOpen = false;
+        if (!isPermanentlyOpen) {
+            isOpen = false;
+        }
     }
     
     /**
@@ -174,19 +329,25 @@ public void setId(String id) {
     }
     
     /**
-     * Toggles the door state.
+     * Toggles the door state unless it's permanently open.
      * 
      * @return The new door state
      */
     public boolean toggle() {
-        isOpen = !isOpen;
+        if (!isPermanentlyOpen) {
+            isOpen = !isOpen;
+        }
         return isOpen;
     }
     
     @Override
     public void onDoorStateChanged(String doorId, boolean isOpen) {
         if (this.id.equals(doorId)) {
-            this.isOpen = isOpen;
+            if (isOpen) {
+                open();
+            } else if (!isPermanentlyOpen) {
+                close();
+            }
         }
     }
 } 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java b/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
index 6abbdd3..b2ada73 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
@@ -102,44 +102,6 @@ public Entity getEntityAt(int gridX, int gridY) {
         return grid.getEntity(gridX, gridY);
     }
     
-    /**
-     * Adds blocks at random positions on the grid.
-     * 
-     * @param count The number of blocks to add
-     */
-    public void addRandomBlocks(int count) {
-        int horizontalCells = grid.getHorizontalCells();
-        int verticalCells = grid.getVerticalCells();
-        
-        // Reserve space for player at bottom center
-        int playerGridX = horizontalCells / 2;
-        int playerGridY = verticalCells - 3;
-        int reserveRadius = 2;
-        
-        for (int i = 0; i < count; i++) {
-            int attempts = 0;
-            boolean placed = false;
-            
-            while (!placed && attempts < 100) {
-                int gridX = random.nextInt(horizontalCells);
-                int gridY = random.nextInt(verticalCells);
-                
-                // Avoid the player spawn area
-                if (Math.abs(gridX - playerGridX) <= reserveRadius && 
-                    Math.abs(gridY - playerGridY) <= reserveRadius) {
-                    attempts++;
-                    continue;
-                }
-                
-                if (addBlock(gridX, gridY)) {
-                    placed = true;
-                } else {
-                    attempts++;
-                }
-            }
-        }
-    }
-    
     /**
      * Creates a border of blocks around the level.
      */
@@ -160,6 +122,16 @@ public void addBorderBlocks() {
         }
     }
     
+    /**
+     * Creates the first level layout with blocks and designated areas.
+     */
+    public void createLevel1() {
+        clearLevel();
+        
+        // Add border blocks
+        addBorderBlocks();
+    }
+    
     /**
      * Updates all entities in the level.
      */
@@ -231,33 +203,6 @@ public boolean addButton(Button button, int gridX, int gridY) {
         return addEntity(button, gridX, gridY);
     }
     
-    /**
-     * Finds a suitable position for a button where it won't overlap with blocks.
-     * 
-     * @return An array containing the grid X and Y coordinates, or null if no position was found
-     */
-    public int[] findSuitableButtonPosition() {
-        int horizontalCells = grid.getHorizontalCells();
-        int verticalCells = grid.getVerticalCells();
-        int attempts = 0;
-        int maxAttempts = 100;
-        
-        while (attempts < maxAttempts) {
-            int gridX = random.nextInt(horizontalCells);
-            int gridY = random.nextInt(verticalCells);
-            
-            // Check if the position is unoccupied
-            if (!grid.isOccupied(gridX, gridY)) {
-                return new int[] {gridX, gridY};
-            }
-            
-            attempts++;
-        }
-        
-        // Couldn't find a suitable position
-        return null;
-    }
-    
     /**
      * Gets the grid system.
      * 
@@ -267,53 +212,6 @@ public GridSystem getGrid() {
         return grid;
     }
     
-    /**
-     * Creates a predefined level layout.
-     * 
-     * @param layoutType The type of layout to create (1, 2, 3, etc.)
-     */
-    public void createLayout(int layoutType) {
-        clearLevel();
-        
-        switch (layoutType) {
-            case 1:
-                // Border with some blocks in the middle
-                addBorderBlocks();
-                addBlock(5, 5);
-                addBlock(5, 6);
-                addBlock(6, 5);
-                addBlock(10, 8);
-                addBlock(11, 8);
-                addBlock(12, 8);
-                break;
-                
-            case 2:
-                // Maze-like pattern
-                addBorderBlocks();
-                // Horizontal walls
-                for (int x = 5; x < 10; x++) {
-                    addBlock(x, 5);
-                    addBlock(x + 5, 10);
-                }
-                // Vertical walls
-                for (int y = 6; y < 10; y++) {
-                    addBlock(5, y);
-                    addBlock(15, y);
-                }
-                break;
-                
-            case 3:
-                // Random scattered blocks
-                addRandomBlocks(20);
-                break;
-                
-            default:
-                // Default: just add 10 random blocks
-                addRandomBlocks(10);
-                break;
-        }
-    }
-    
     /**
      * Clears all entities from the level.
      */
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
index 4f01105..4b3f440 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
@@ -9,9 +9,11 @@
 import java.util.List;
 import java.util.Random;
 
+import com.niravramdhanie.twod.game.actions.Action;
 import com.niravramdhanie.twod.game.actions.DoorAction;
 import com.niravramdhanie.twod.game.actions.DoorController;
-import com.niravramdhanie.twod.game.actions.ToggleAction;
+import com.niravramdhanie.twod.game.actions.MultiButtonAction;
+import com.niravramdhanie.twod.game.actions.TimedAction;
 import com.niravramdhanie.twod.game.core.GameStateManager;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
 import com.niravramdhanie.twod.game.entity.Block;
@@ -49,6 +51,16 @@ public class PlayState extends GameState {
     private DoorController doorController;
     private String doorId = "main_door";
     
+    // Button IDs
+    private String buttonTopId = "button_top";
+    private String buttonBottomId = "button_bottom";
+    
+    // List for timed actions that need updates
+    private List<TimedAction> timedActions = new ArrayList<>();
+    
+    // Multi-button action for two buttons
+    private MultiButtonAction multiButtonAction;
+    
     // New variables for button highlighting
     private List<Button> nearButtons = new ArrayList<>();
     
@@ -78,23 +90,23 @@ public void init() {
         // Create the level with a grid
         level = new Level(screenWidth, screenHeight, GRID_CELL_SIZE);
         
-        // Create a level layout with random blocks
-        level.addRandomBlocks(10);
+        // Create level 1 layout with border blocks
+        level.createLevel1();
         
         // Initialize door controller
         doorController = new DoorController();
         
-        // Add the door and toggle button to the level
-        addDoorWithToggleButton();
+        // Add the door and buttons
+        setupLevel1();
         
         try {
-            // Create player in the lower middle of the screen
+            // Create player in the middle left of the screen
             int gridCellSize = level.getGrid().getCellSize();
             int playerSize = gridCellSize; // Make player the same size as grid cells
             
-            // Position player at the bottom middle of the grid
-            int gridX = level.getGrid().getHorizontalCells() / 2;
-            int gridY = level.getGrid().getVerticalCells() - 3;
+            // Position player at the middle left of the grid
+            int gridX = 2; // A few cells from the left border
+            int gridY = level.getGrid().getVerticalCells() / 2;
             int playerX = level.getGrid().gridToScreenX(gridX);
             int playerY = level.getGrid().gridToScreenY(gridY);
             
@@ -125,6 +137,141 @@ public void init() {
         }
     }
     
+    /**
+     * Sets up the level 1 layout with door and timed buttons
+     */
+    private void setupLevel1() {
+        int cellSize = level.getGrid().getCellSize();
+        int horizontalCells = level.getGrid().getHorizontalCells();
+        int verticalCells = level.getGrid().getVerticalCells();
+        
+        // Create the door in the middle of the right side
+        int doorGridX = horizontalCells - 2; // One cell from the right border
+        int doorGridY = verticalCells / 2;
+        
+        float doorX = level.getGrid().gridToScreenX(doorGridX);
+        float doorY = level.getGrid().gridToScreenY(doorGridY);
+        door = new Door(doorX, doorY, cellSize, cellSize, doorId);
+        level.addEntity(door, doorGridX, doorGridY);
+        
+        // Register door with controller
+        doorController.registerDoor(door);
+        
+        // Create a door action that the multi-button action will control
+        DoorAction doorAction = new DoorAction(doorId);
+        doorAction.setDoorStateChangeListener(doorController);
+        
+        // Create a multi-button action that requires both buttons
+        // Use permanent activation so door stays open once opened
+        multiButtonAction = new MultiButtonAction(doorAction, true);
+        multiButtonAction.addRequiredButton(buttonTopId);
+        multiButtonAction.addRequiredButton(buttonBottomId);
+        
+        // Create the top button (1-second timer)
+        int topButtonGridX = horizontalCells / 2;
+        int topButtonGridY = 2; // Two cells from the top
+        
+        float topButtonX = level.getGrid().gridToScreenX(topButtonGridX);
+        float topButtonY = level.getGrid().gridToScreenY(topButtonGridY);
+        
+        // Create a timed action for the top button
+        TimedAction topTimedAction = createTimedButtonAction(buttonTopId, 1000); // 1 second
+        
+        Button topButton = new Button(topButtonX, topButtonY, cellSize, cellSize, topTimedAction);
+        topButton.setColor(new Color(200, 80, 80)); // Red when inactive
+        topButton.setActiveColor(new Color(255, 100, 100)); // Brighter red when active
+        level.addEntity(topButton, topButtonGridX, topButtonGridY);
+        
+        // Register the timed action for updates
+        timedActions.add(topTimedAction);
+        
+        // Create the bottom button (1-second timer)
+        int bottomButtonGridX = horizontalCells / 2;
+        int bottomButtonGridY = verticalCells - 3; // Two cells from the bottom
+        
+        float bottomButtonX = level.getGrid().gridToScreenX(bottomButtonGridX);
+        float bottomButtonY = level.getGrid().gridToScreenY(bottomButtonGridY);
+        
+        // Create a timed action for the bottom button
+        TimedAction bottomTimedAction = createTimedButtonAction(buttonBottomId, 1000); // 1 second
+        
+        Button bottomButton = new Button(bottomButtonX, bottomButtonY, cellSize, cellSize, bottomTimedAction);
+        bottomButton.setColor(new Color(80, 80, 200)); // Blue when inactive
+        bottomButton.setActiveColor(new Color(100, 100, 255)); // Brighter blue when active
+        level.addEntity(bottomButton, bottomButtonGridX, bottomButtonGridY);
+        
+        // Register the timed action for updates
+        timedActions.add(bottomTimedAction);
+        
+        // Start with the door closed
+        door.close();
+        
+        System.out.println("Level 1 setup complete with door and two timed buttons");
+    }
+    
+    /**
+     * Creates a timed action that updates the multi-button action when a button is pressed
+     */
+    private TimedAction createTimedButtonAction(String buttonId, long duration) {
+        // Create action that updates the multi-button action when activated
+        Action activateAction = new UpdateMultiButtonAction(buttonId, true);
+        
+        // Create action that updates when deactivated
+        Action deactivateAction = new UpdateMultiButtonAction(buttonId, false);
+        
+        // Create timed action with both activate and deactivate actions
+        TimedAction timedAction = new TimedAction(activateAction, duration);
+        timedAction.setDeactivateAction(deactivateAction);
+        
+        return timedAction;
+    }
+    
+    /**
+     * Inner class for actions that update the multi-button state
+     */
+    private class UpdateMultiButtonAction implements Action {
+        private String buttonId;
+        private boolean activated;
+        
+        public UpdateMultiButtonAction(String buttonId, boolean activated) {
+            this.buttonId = buttonId;
+            this.activated = activated;
+        }
+        
+        @Override
+        public void execute() {
+            // Update the multi-button action with this button's state
+            boolean changed = multiButtonAction.updateButtonState(buttonId, activated);
+            
+            // Always respect permanent activation - never close the door once it's been fully activated
+            if (multiButtonAction.isPermanentlyActivated()) {
+                // Ensure door stays open if permanently activated
+                if (door != null && !door.isOpen()) {
+                    door.open();
+                    System.out.println("Door will remain open permanently!");
+                }
+                return;
+            }
+            
+            // Only handle non-permanent state below this point
+            
+            // If a button is deactivated and we haven't achieved permanent activation yet,
+            // make sure the door is closed
+            if (!activated) {
+                // Manually update the door state to ensure it closes
+                if (door != null && door.isOpen()) {
+                    door.close();
+                    System.out.println("Door closed - both buttons must be pressed simultaneously!");
+                }
+            }
+        }
+        
+        @Override
+        public String getDescription() {
+            return "Update " + buttonId + " to " + (activated ? "activated" : "deactivated");
+        }
+    }
+    
     /**
      * Get the remaining time in seconds
      * @return Remaining time in seconds (0 if timer has expired)
@@ -139,7 +286,13 @@ private int getRemainingTime() {
      * @param layoutType The type of layout to create
      */
     public void setLevelLayout(int layoutType) {
-        level.createLayout(layoutType);
+        // Clear the level
+        level.clearLevel();
+        
+        // Recreate level 1
+        level.createLevel1();
+        
+        // Update player blocks
         player.setBlocks(level.getBlocks());
     }
     
@@ -156,6 +309,11 @@ public void update() {
                 rewindManager.update();
             }
             
+            // Update timed actions
+            for (TimedAction timedAction : timedActions) {
+                timedAction.update();
+            }
+            
             // Update level (includes buttons, etc.)
             level.update();
             
@@ -167,6 +325,13 @@ public void update() {
             // Check for interaction with buttons
             checkButtonHighlights();
             
+            // Check if door has been successfully opened for the first time
+            if (multiButtonAction != null && multiButtonAction.isPermanentlyActivated() && door != null && !door.isOpen()) {
+                // Force the door to open if it's not already open
+                door.open();
+                System.out.println("Door permanently opened! It will not close again.");
+            }
+            
             // Update door collision if necessary
             updateDoorCollision();
             
@@ -434,53 +599,6 @@ private void updateDoorCollision() {
         player.setBlocks(blocks);
     }
     
-    /**
-     * Adds test buttons to the level
-     */
-    private void addTestButtons() {
-        // Method intentionally left empty since we're using only the door toggle button
-    }
-    
-    /**
-     * Adds a door and a toggle button to control it
-     */
-    private void addDoorWithToggleButton() {
-        int cellSize = level.getGrid().getCellSize();
-        int horizontalCells = level.getGrid().getHorizontalCells();
-        int verticalCells = level.getGrid().getVerticalCells();
-        
-        // Place door in the middle right of the level
-        int doorGridX = horizontalCells - 5;
-        int doorGridY = verticalCells / 2;
-        
-        // Create the door
-        float doorX = level.getGrid().gridToScreenX(doorGridX);
-        float doorY = level.getGrid().gridToScreenY(doorGridY);
-        door = new Door(doorX, doorY, cellSize, cellSize, doorId);
-        level.addEntity(door, doorGridX, doorGridY);
-        
-        // Register door with controller
-        doorController.registerDoor(door);
-        
-        // Place button in the middle left of the level
-        int buttonGridX = 5;
-        int buttonGridY = verticalCells / 2;
-        
-        // Create a door action
-        DoorAction doorAction = new DoorAction(doorId);
-        doorAction.setDoorStateChangeListener(doorController);
-        
-        // Create a toggle action for the door
-        ToggleAction toggleAction = new ToggleAction(doorAction, doorAction);
-        
-        // Create button with the toggle action
-        Button doorButton = new Button(0, 0, cellSize, cellSize, toggleAction);
-        level.addEntity(doorButton, buttonGridX, buttonGridY);
-        
-        System.out.println("Added door at " + doorGridX + "," + doorGridY + 
-                          " and toggle button at " + buttonGridX + "," + buttonGridY);
-    }
-    
     @Override
     public void keyPressed(int k) {
         // Handle player movement
@@ -514,11 +632,10 @@ public void keyPressed(int k) {
             rewindManager.toggleRewind();
         }
         
-        // Level layout switching for testing
-        if (k == KeyEvent.VK_1) setLevelLayout(1);
-        if (k == KeyEvent.VK_2) setLevelLayout(2);
-        if (k == KeyEvent.VK_3) setLevelLayout(3);
-        if (k == KeyEvent.VK_0) setLevelLayout(0); // Random blocks (changed from R to 0)
+        // For now, all level layout keys just reset to level 1
+        if (k == KeyEvent.VK_1 || k == KeyEvent.VK_2 || k == KeyEvent.VK_3 || k == KeyEvent.VK_0) {
+            setLevelLayout(1);
+        }
     }
     
     @Override
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java b/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
index c9c2a0d..3b33998 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
@@ -9,6 +9,7 @@
 
 import com.niravramdhanie.twod.game.actions.Action;
 import com.niravramdhanie.twod.game.actions.DoorAction;
+import com.niravramdhanie.twod.game.actions.TimedAction;
 import com.niravramdhanie.twod.game.actions.ToggleAction;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
 import com.niravramdhanie.twod.game.entity.Button;
@@ -85,10 +86,19 @@ public void startRecording() {
         for (Button button : buttons) {
             String buttonId = getButtonId(button);
             boolean isActivated = button.isActivated();
-            initialButtonStates.add(new ButtonState(buttonId, isActivated));
             
-            // Store toggle states for ToggleAction buttons
+            // Check if the button has a TimedAction and record its state
+            boolean hasTimedAction = false;
+            boolean timedActionActive = false;
             Action action = button.getAction();
+            if (action instanceof TimedAction) {
+                hasTimedAction = true;
+                timedActionActive = ((TimedAction) action).isActive();
+            }
+            
+            initialButtonStates.add(new ButtonState(buttonId, isActivated, hasTimedAction, timedActionActive));
+            
+            // Store toggle states for ToggleAction buttons
             if (action instanceof ToggleAction) {
                 ToggleAction toggleAction = (ToggleAction) action;
                 initialToggleStates.put(buttonId, toggleAction.isToggled());
@@ -158,12 +168,18 @@ public void startRewinding() {
                     // Set button activation state without triggering actions
                     button.setActivated(state.activated);
                     
+                    // Handle TimedAction states
+                    Action action = button.getAction();
+                    if (state.hasTimedAction && action instanceof TimedAction) {
+                        TimedAction timedAction = (TimedAction) action;
+                        timedAction.setActive(state.timedActionActive);
+                    }
+                    
                     // Handle toggle states using the new method
                     boolean initialToggled = initialToggleStates.getOrDefault(buttonId, false);
                     button.forceSetToggleState(initialToggled);
                     
                     // For actions that aren't toggles but might be DoorActions
-                    Action action = button.getAction();
                     if (!(action instanceof ToggleAction) && action instanceof DoorAction) {
                         DoorAction doorAction = (DoorAction) action;
                         String doorId = doorAction.getDoorId();
@@ -286,6 +302,15 @@ private void applyAction(RecordedAction action) {
                         // which will trigger any associated actions
                         button.activate();
                         
+                        // Ensure TimedAction visual state is updated
+                        Action buttonAction = button.getAction();
+                        if (buttonAction instanceof TimedAction) {
+                            TimedAction timedAction = (TimedAction) buttonAction;
+                            if (!timedAction.isActive()) {
+                                timedAction.setActive(true);
+                            }
+                        }
+                        
                         // Update toggle state tracking
                         if (button.getAction() instanceof ToggleAction) {
                             ToggleAction toggleAction = (ToggleAction) button.getAction();
@@ -299,8 +324,18 @@ private void applyAction(RecordedAction action) {
                             }
                         }
                     } else {
-                        // If deactivating, set without executing actions
-                        button.setActivated(false);
+                        // If deactivating, use the proper deactivate method 
+                        // which will update visual indicators properly
+                        button.deactivate();
+                        
+                        // Ensure TimedAction visual state is updated
+                        Action buttonAction = button.getAction();
+                        if (buttonAction instanceof TimedAction) {
+                            TimedAction timedAction = (TimedAction) buttonAction;
+                            if (timedAction.isActive()) {
+                                timedAction.setActive(false);
+                            }
+                        }
                     }
                     
                     System.out.println("Rewind: Replayed button " + action.buttonId + 
@@ -357,10 +392,21 @@ private String getButtonId(Button button) {
     private static class ButtonState {
         String buttonId;
         boolean activated;
+        boolean hasTimedAction;
+        boolean timedActionActive;
         
         ButtonState(String buttonId, boolean activated) {
             this.buttonId = buttonId;
             this.activated = activated;
+            this.hasTimedAction = false;
+            this.timedActionActive = false;
+        }
+        
+        ButtonState(String buttonId, boolean activated, boolean hasTimedAction, boolean timedActionActive) {
+            this.buttonId = buttonId;
+            this.activated = activated;
+            this.hasTimedAction = hasTimedAction;
+            this.timedActionActive = timedActionActive;
         }
     }
     

From 99fcd7a47469f115cc0b9a7ba73ec9a34288b52d Mon Sep 17 00:00:00 2001
From: Nirav Ramdhanie <nirav@Vincents-MacBook-Pro.local>
Date: Fri, 9 May 2025 20:21:31 -0700
Subject: [PATCH 8/8] Adds box with working movement and collision, The Rewind
 feature for the box is still not working

---
 .../twod/game/entity/BallPlayer.java          | 195 +++++++--
 .../niravramdhanie/twod/game/entity/Box.java  | 370 ++++++++++++++++++
 .../niravramdhanie/twod/game/level/Level.java |  12 +
 .../twod/game/state/PlayState.java            | 326 ++++++++++++++-
 .../twod/game/utils/RewindManager.java        | 308 +++++++++++----
 5 files changed, 1096 insertions(+), 115 deletions(-)
 create mode 100644 app/src/main/java/com/niravramdhanie/twod/game/entity/Box.java

diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/BallPlayer.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/BallPlayer.java
index 9430538..ad0671a 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/entity/BallPlayer.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/BallPlayer.java
@@ -40,10 +40,14 @@ public class BallPlayer extends Entity {
     private int screenHeight;
     private List<Block> blocks;
     
+    // Box carrying
+    private Box carriedBox;
+    
     public BallPlayer(float x, float y, int width, int height, int screenWidth, int screenHeight) {
         super(x, y, width, height);
         this.screenWidth = screenWidth;
         this.screenHeight = screenHeight;
+        this.carriedBox = null;
         
         // Set movement properties - instant movement with no friction
         moveSpeed = 0.84f;   // 1.2f * 0.7 = 0.84f
@@ -122,6 +126,33 @@ public void setBlocks(List<Block> blocks) {
         this.blocks = blocks;
     }
     
+    /**
+     * Sets the box being carried by the player.
+     * 
+     * @param box The box being carried, or null if not carrying any box
+     */
+    public void setCarriedBox(Box box) {
+        this.carriedBox = box;
+    }
+    
+    /**
+     * Gets the box being carried by the player.
+     * 
+     * @return The box being carried, or null if not carrying any box
+     */
+    public Box getCarriedBox() {
+        return carriedBox;
+    }
+    
+    /**
+     * Checks if the player is carrying a box.
+     * 
+     * @return True if carrying a box, false otherwise
+     */
+    public boolean isCarryingBox() {
+        return carriedBox != null;
+    }
+    
     @Override
     public void update() {
         // Track previous animation for transition checks
@@ -186,35 +217,21 @@ public void update() {
         // Check block collisions for X movement
         boolean collisionX = false;
         position.x = newX;
-        for (Block block : blocks) {
-            if (checkCollision(block)) {
-                collisionX = true;
-                // Resolve X collision
-                if (velocity.x > 0) { // Moving right
-                    position.x = block.getX() - width;
-                } else if (velocity.x < 0) { // Moving left
-                    position.x = block.getX() + block.getWidth();
-                }
-                velocity.x = 0;
-                break;
-            }
+        
+        if (checkBlockCollisionX()) {
+            collisionX = true;
+            // Position already corrected in checkBlockCollisionX()
+            velocity.x = 0;
         }
         
         // Check block collisions for Y movement
         boolean collisionY = false;
         position.y = newY;
-        for (Block block : blocks) {
-            if (checkCollision(block)) {
-                collisionY = true;
-                // Resolve Y collision
-                if (velocity.y > 0) { // Moving down
-                    position.y = block.getY() - height;
-                } else if (velocity.y < 0) { // Moving up
-                    position.y = block.getY() + block.getHeight();
-                }
-                velocity.y = 0;
-                break;
-            }
+        
+        if (checkBlockCollisionY()) {
+            collisionY = true;
+            // Position already corrected in checkBlockCollisionY()
+            velocity.y = 0;
         }
         
         // If no collision occurred, move normally
@@ -294,4 +311,134 @@ public boolean isAlive() {
     public void setRight(boolean right) { this.right = right; }
     public void setUp(boolean up) { this.up = up; }
     public void setDown(boolean down) { this.down = down; }
+    
+    /**
+     * Gets the player's velocity vector.
+     * 
+     * @return The velocity vector
+     */
+    public com.niravramdhanie.twod.game.utils.Vector2D getVelocity() {
+        return velocity;
+    }
+    
+    /**
+     * Checks for X-axis collisions with blocks.
+     * When carrying a box, the box acts as an extension of the player's hitbox.
+     * 
+     * @return True if a collision occurred, false otherwise
+     */
+    private boolean checkBlockCollisionX() {
+        // First check player collision with blocks (but not with the carried box)
+        for (Block block : blocks) {
+            if (block != carriedBox && checkCollision(block)) {
+                // Resolve X collision
+                if (velocity.x > 0) { // Moving right
+                    position.x = block.getX() - width;
+                } else if (velocity.x < 0) { // Moving left
+                    position.x = block.getX() + block.getWidth();
+                }
+                velocity.x = 0;
+                return true;
+            }
+        }
+        
+        // If carrying a box, check if the box would collide with any blocks
+        if (carriedBox != null && velocity.x != 0) {
+            // Calculate where the box would be after the player's movement
+            float boxX = position.x + width/2 - carriedBox.getWidth()/2 + carriedBox.getRelativeX();
+            float boxY = position.y + height/2 - carriedBox.getHeight()/2 + carriedBox.getRelativeY();
+            
+            // Create a rectangle representing the box's position
+            java.awt.Rectangle boxBounds = new java.awt.Rectangle(
+                (int)boxX, (int)boxY, carriedBox.getWidth(), carriedBox.getHeight()
+            );
+            
+            // Check for collisions with any block
+            for (Block block : blocks) {
+                if (block != carriedBox) {
+                    java.awt.Rectangle blockBounds = block.getBounds();
+                    
+                    if (boxBounds.intersects(blockBounds)) {
+                        // Resolve collision just like we would for the player
+                        if (velocity.x > 0) { // Moving right
+                            position.x = block.getX() - width - (boxX + carriedBox.getWidth() - position.x - width);
+                        } else if (velocity.x < 0) { // Moving left
+                            position.x = block.getX() + block.getWidth() - (boxX - position.x);
+                        }
+                        velocity.x = 0;
+                        return true;
+                    }
+                }
+            }
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Checks for Y-axis collisions with blocks.
+     * When carrying a box, the box acts as an extension of the player's hitbox.
+     * 
+     * @return True if a collision occurred, false otherwise
+     */
+    private boolean checkBlockCollisionY() {
+        // First check player collision with blocks (but not with the carried box)
+        for (Block block : blocks) {
+            if (block != carriedBox && checkCollision(block)) {
+                // Resolve Y collision
+                if (velocity.y > 0) { // Moving down
+                    position.y = block.getY() - height;
+                } else if (velocity.y < 0) { // Moving up
+                    position.y = block.getY() + block.getHeight();
+                }
+                velocity.y = 0;
+                return true;
+            }
+        }
+        
+        // If carrying a box, check if the box would collide with any blocks
+        if (carriedBox != null && velocity.y != 0) {
+            // Calculate where the box would be after the player's movement
+            float boxX = position.x + width/2 - carriedBox.getWidth()/2 + carriedBox.getRelativeX();
+            float boxY = position.y + height/2 - carriedBox.getHeight()/2 + carriedBox.getRelativeY();
+            
+            // Create a rectangle representing the box's position
+            java.awt.Rectangle boxBounds = new java.awt.Rectangle(
+                (int)boxX, (int)boxY, carriedBox.getWidth(), carriedBox.getHeight()
+            );
+            
+            // Check for collisions with any block
+            for (Block block : blocks) {
+                if (block != carriedBox) {
+                    java.awt.Rectangle blockBounds = block.getBounds();
+                    
+                    if (boxBounds.intersects(blockBounds)) {
+                        // Resolve collision just like we would for the player
+                        if (velocity.y > 0) { // Moving down
+                            position.y = block.getY() - height - (boxY + carriedBox.getHeight() - position.y - height);
+                        } else if (velocity.y < 0) { // Moving up
+                            position.y = block.getY() + block.getHeight() - (boxY - position.y);
+                        }
+                        velocity.y = 0;
+                        return true;
+                    }
+                }
+            }
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Override collision detection to disable collision with the carried box
+     */
+    @Override
+    public boolean checkCollision(Entity other) {
+        // Don't collide with the box we're carrying
+        if (carriedBox != null && other == carriedBox) {
+            return false;
+        }
+        // Use standard collision detection for everything else
+        return super.checkCollision(other);
+    }
 }
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/entity/Box.java b/app/src/main/java/com/niravramdhanie/twod/game/entity/Box.java
new file mode 100644
index 0000000..390a411
--- /dev/null
+++ b/app/src/main/java/com/niravramdhanie/twod/game/entity/Box.java
@@ -0,0 +1,370 @@
+package com.niravramdhanie.twod.game.entity;
+
+import java.awt.Color;
+import java.awt.GradientPaint;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+import com.niravramdhanie.twod.game.utils.ResourceLoader;
+
+/**
+ * A box entity that can be picked up and carried by the player.
+ * The box can be in an active or inactive state, where the active state
+ * means it will follow the rewind system.
+ */
+public class Box extends Block {
+    // Movement tracking
+    private boolean isBeingCarried;
+    private float relativeX; // Relative position to player when picked up
+    private float relativeY;
+    
+    // Box properties
+    private boolean isActive; // Whether the box follows the rewind system
+    private boolean isMovable; // Whether the box can be picked up
+    
+    // Visual properties
+    private Color boxColor;
+    private Color activeBoxColor;
+    private BufferedImage boxImage;
+    private BufferedImage activeBoxImage;
+    
+    // Reference to the carrier (player that is carrying this box)
+    private Entity carrier;
+    
+    /**
+     * Creates a new box entity.
+     * 
+     * @param x The x position
+     * @param y The y position
+     * @param width The width
+     * @param height The height
+     * @param isActive Whether the box follows the rewind system
+     * @param isMovable Whether the box can be picked up
+     */
+    public Box(float x, float y, int width, int height, boolean isActive, boolean isMovable) {
+        super(x, y, width, height);
+        this.isBeingCarried = false;
+        this.isActive = isActive;
+        this.isMovable = isMovable;
+        this.carrier = null;
+        
+        // Default colors
+        this.boxColor = new Color(139, 69, 19); // Brown
+        this.activeBoxColor = new Color(205, 133, 63); // Peru (lighter brown)
+        
+        try {
+            // Load box images (fallback to colors if images can't be loaded)
+            boxImage = ResourceLoader.loadImage("/sprites/box.png");
+            activeBoxImage = ResourceLoader.loadImage("/sprites/box_active.png");
+        } catch (Exception e) {
+            System.err.println("Error loading box images: " + e.getMessage());
+            boxImage = null;
+            activeBoxImage = null;
+        }
+    }
+    
+    @Override
+    public void update() {
+        // Box behavior is mainly handled in PlayState
+    }
+    
+    /**
+     * Override collision detection to disable collision when being carried or when colliding with the carrier
+     */
+    @Override
+    public boolean checkCollision(Entity other) {
+        // If being carried, don't register any collisions at all with the carrier
+        if (isBeingCarried && (carrier == other || other == carrier)) {
+            return false;
+        }
+        // Otherwise, use the standard collision detection
+        return super.checkCollision(other);
+    }
+    
+    @Override
+    public void render(Graphics2D g) {
+        // Use images if available, otherwise draw with colors
+        if ((isActive && activeBoxImage != null) || (!isActive && boxImage != null)) {
+            g.drawImage(isActive ? activeBoxImage : boxImage, 
+                       (int)position.x, (int)position.y, width, height, null);
+        } else {
+            // Fallback to drawing with colors
+            drawBox(g);
+        }
+    }
+    
+    /**
+     * Draws the box with gradients and highlights for a 3D effect
+     */
+    private void drawBox(Graphics2D g) {
+        // Save original paint
+        java.awt.Paint originalPaint = g.getPaint();
+        
+        // Choose appropriate color based on state
+        Color baseColor = isActive ? activeBoxColor : boxColor;
+        Color topColor = baseColor.brighter();
+        Color bottomColor = baseColor.darker();
+        
+        // Create gradient for 3D effect
+        GradientPaint gradient = new GradientPaint(
+            (int)position.x, (int)position.y, topColor,
+            (int)position.x, (int)position.y + height, bottomColor
+        );
+        
+        // Apply gradient and draw box
+        g.setPaint(gradient);
+        g.fillRect((int)position.x, (int)position.y, width, height);
+        
+        // Draw box edges (darker)
+        g.setColor(bottomColor.darker());
+        g.drawRect((int)position.x, (int)position.y, width, height);
+        
+        // Draw highlights
+        int highlight = 4;
+        int shadow = 4;
+        
+        // Top highlight
+        g.setColor(new Color(255, 255, 255, 100));
+        g.fillRect((int)position.x + 1, (int)position.y + 1, width - 2, highlight);
+        
+        // Left highlight
+        g.fillRect((int)position.x + 1, (int)position.y + highlight + 1, 
+                   highlight, height - highlight - shadow - 1);
+        
+        // Bottom shadow
+        g.setColor(new Color(0, 0, 0, 80));
+        g.fillRect((int)position.x + 1, (int)position.y + height - shadow, 
+                   width - 2, shadow - 1);
+        
+        // Right shadow
+        g.fillRect((int)position.x + width - shadow, (int)position.y + highlight + 1, 
+                   shadow - 1, height - highlight - shadow - 1);
+        
+        // Draw a small indicator if the box is active
+        if (isActive) {
+            int indicatorSize = 6;
+            g.setColor(new Color(0, 255, 0, 180));
+            g.fillOval((int)position.x + width - indicatorSize - 2, 
+                       (int)position.y + 2, indicatorSize, indicatorSize);
+        }
+        
+        // Restore original paint
+        g.setPaint(originalPaint);
+    }
+    
+    /**
+     * Picks up the box, storing its relative position to the player.
+     * 
+     * @param playerX The player's X position
+     * @param playerY The player's Y position
+     * @param carrier The entity carrying this box
+     * @return True if the box was picked up, false if it can't be picked up
+     */
+    public boolean pickUp(float playerX, float playerY, Entity carrier) {
+        if (!isMovable || isBeingCarried) {
+            return false;
+        }
+        
+        // Store relative position to the player (center to center)
+        float playerCenterX = playerX + carrier.getWidth() / 2;
+        float playerCenterY = playerY + carrier.getHeight() / 2;
+        float boxCenterX = position.x + width / 2;
+        float boxCenterY = position.y + height / 2;
+        
+        // Calculate offset from player center to box center
+        // This preserves the exact relative position at pickup moment
+        relativeX = boxCenterX - playerCenterX;
+        relativeY = boxCenterY - playerCenterY;
+        
+        // Log the pickup for debugging
+        System.out.println("Box picked up with relative position: " + relativeX + ", " + relativeY);
+        System.out.println("Player center: " + playerCenterX + ", " + playerCenterY);
+        System.out.println("Box center: " + boxCenterX + ", " + boxCenterY);
+        
+        isBeingCarried = true;
+        this.carrier = carrier;
+        
+        return true;
+    }
+    
+    /**
+     * Picks up the box without a specific carrier reference.
+     * 
+     * @param playerX The player's X position
+     * @param playerY The player's Y position
+     * @return True if the box was picked up, false if it can't be picked up
+     */
+    public boolean pickUp(float playerX, float playerY) {
+        return pickUp(playerX, playerY, null);
+    }
+    
+    /**
+     * Updates the box position when being carried by the player.
+     * 
+     * @param playerX The player's X position
+     * @param playerY The player's Y position
+     */
+    public void updateCarriedPosition(float playerX, float playerY) {
+        if (!isBeingCarried) return;
+        
+        if (carrier != null) {
+            // Calculate position using the current player position and the relative offset
+            float playerCenterX = playerX + carrier.getWidth() / 2;
+            float playerCenterY = playerY + carrier.getHeight() / 2;
+            
+            // Get player velocity if available (for smoother movement)
+            float playerVelX = 0;
+            float playerVelY = 0;
+            if (carrier instanceof BallPlayer) {
+                playerVelX = ((BallPlayer)carrier).getVelocity().x;
+                playerVelY = ((BallPlayer)carrier).getVelocity().y;
+            }
+            
+            // Position the box with its center at the correct offset from player center
+            // Maintain the original relative position but adjust for any movement direction
+            float boxCenterX = playerCenterX + relativeX;
+            float boxCenterY = playerCenterY + relativeY;
+            
+            // Convert back to top-left corner position
+            position.x = boxCenterX - width / 2;
+            position.y = boxCenterY - height / 2;
+        } else {
+            // Fallback if carrier is null
+            position.x = playerX + relativeX;
+            position.y = playerY + relativeY;
+        }
+    }
+    
+    /**
+     * Drops the box at its current position.
+     */
+    public void drop() {
+        isBeingCarried = false;
+        carrier = null;
+        
+        // Ensure the box is positioned on the grid when dropped
+        // This helps prevent the box from being placed at weird positions
+        if (carrier instanceof BallPlayer) {
+            // Snap to grid if needed - uncomment if you want this behavior
+            /*
+            int gridCellSize = 32; // Should match GRID_CELL_SIZE in PlayState
+            float gridX = Math.round(position.x / gridCellSize) * gridCellSize;
+            float gridY = Math.round(position.y / gridCellSize) * gridCellSize;
+            position.x = gridX;
+            position.y = gridY;
+            */
+        }
+        
+        System.out.println("Box dropped at position: " + position.x + ", " + position.y);
+    }
+    
+    /**
+     * Checks if the box is being carried.
+     * 
+     * @return True if being carried, false otherwise
+     */
+    public boolean isBeingCarried() {
+        return isBeingCarried;
+    }
+    
+    /**
+     * Gets the entity that is carrying this box.
+     * 
+     * @return The entity carrying this box, or null if not being carried
+     */
+    public Entity getCarrier() {
+        return carrier;
+    }
+    
+    /**
+     * Checks if the box is in an active state (follows rewind).
+     * 
+     * @return True if active, false otherwise
+     */
+    public boolean isActive() {
+        return isActive;
+    }
+    
+    /**
+     * Sets whether the box is in an active state.
+     * 
+     * @param isActive Whether the box should follow the rewind system
+     */
+    public void setActive(boolean isActive) {
+        this.isActive = isActive;
+    }
+    
+    /**
+     * Checks if the box is movable.
+     * 
+     * @return True if the box can be picked up, false otherwise
+     */
+    public boolean isMovable() {
+        return isMovable;
+    }
+    
+    /**
+     * Sets whether the box is movable.
+     * 
+     * @param isMovable Whether the box can be picked up
+     */
+    public void setMovable(boolean isMovable) {
+        this.isMovable = isMovable;
+    }
+    
+    /**
+     * Overrides position setter to handle the carried state
+     */
+    @Override
+    public void setX(float x) {
+        if (!isBeingCarried) {
+            super.setX(x);
+        }
+    }
+    
+    /**
+     * Overrides position setter to handle the carried state
+     */
+    @Override
+    public void setY(float y) {
+        if (!isBeingCarried) {
+            super.setY(y);
+        }
+    }
+    
+    /**
+     * Gets the relative X position to the carrier when picked up.
+     * 
+     * @return The relative X position
+     */
+    public float getRelativeX() {
+        return relativeX;
+    }
+    
+    /**
+     * Gets the relative Y position to the carrier when picked up.
+     * 
+     * @return The relative Y position
+     */
+    public float getRelativeY() {
+        return relativeY;
+    }
+    
+    /**
+     * Sets the relative X position to the carrier.
+     * 
+     * @param relativeX The relative X position
+     */
+    public void setRelativeX(float relativeX) {
+        this.relativeX = relativeX;
+    }
+    
+    /**
+     * Sets the relative Y position to the carrier.
+     * 
+     * @param relativeY The relative Y position
+     */
+    public void setRelativeY(float relativeY) {
+        this.relativeY = relativeY;
+    }
+} 
\ No newline at end of file
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java b/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
index b2ada73..5202634 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/level/Level.java
@@ -132,6 +132,18 @@ public void createLevel1() {
         addBorderBlocks();
     }
     
+    /**
+     * Creates the second level layout with blocks and designated areas.
+     */
+    public void createLevel2() {
+        clearLevel();
+        
+        // Add border blocks for level 2
+        addBorderBlocks();
+        
+        // Additional level 2 specific layout will be added here later
+    }
+    
     /**
      * Updates all entities in the level.
      */
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
index 4b3f440..7b9c247 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/state/PlayState.java
@@ -17,8 +17,10 @@
 import com.niravramdhanie.twod.game.core.GameStateManager;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
 import com.niravramdhanie.twod.game.entity.Block;
+import com.niravramdhanie.twod.game.entity.Box;
 import com.niravramdhanie.twod.game.entity.Button;
 import com.niravramdhanie.twod.game.entity.Door;
+import com.niravramdhanie.twod.game.entity.Entity;
 import com.niravramdhanie.twod.game.level.Level;
 import com.niravramdhanie.twod.game.utils.RewindManager;
 import com.niravramdhanie.twod.game.utils.TimerManager;
@@ -64,6 +66,13 @@ public class PlayState extends GameState {
     // New variables for button highlighting
     private List<Button> nearButtons = new ArrayList<>();
     
+    // Track current level number
+    private int currentLevel = 1;
+    
+    // Box handling
+    private Box carriedBox = null;
+    private List<Box> nearBoxes = new ArrayList<>();
+    
     public PlayState(GameStateManager gsm, int screenWidth, int screenHeight) {
         super(gsm);
         this.screenWidth = screenWidth;
@@ -90,6 +99,9 @@ public void init() {
         // Create the level with a grid
         level = new Level(screenWidth, screenHeight, GRID_CELL_SIZE);
         
+        // Set current level to 1
+        currentLevel = 1;
+        
         // Create level 1 layout with border blocks
         level.createLevel1();
         
@@ -129,6 +141,9 @@ public void init() {
             // Set the rewind manager for buttons
             Button.setRewindManager(rewindManager);
             
+            // Update rewind manager with boxes (if any)
+            updateRewindManager();
+            
             initialized = true;
             System.out.println("PlayState initialization complete");
         } catch (Exception e) {
@@ -281,6 +296,55 @@ private int getRemainingTime() {
         return timerManager.getTime();
     }
     
+    /**
+     * Sets up the level 2 layout
+     */
+    private void setupLevel2() {
+        int cellSize = level.getGrid().getCellSize();
+        int horizontalCells = level.getGrid().getHorizontalCells();
+        int verticalCells = level.getGrid().getVerticalCells();
+        
+        // Add a movable, active box in the middle of level 2
+        int boxGridX = horizontalCells / 2;
+        int boxGridY = verticalCells / 2;
+        
+        float boxX = level.getGrid().gridToScreenX(boxGridX);
+        float boxY = level.getGrid().gridToScreenY(boxGridY);
+        
+        Box box = new Box(boxX, boxY, cellSize, cellSize, true, true);
+        level.addEntity(box, boxGridX, boxGridY);
+        
+        // Update the rewind manager with the box list
+        updateRewindManager();
+        
+        System.out.println("Level 2 setup complete");
+    }
+    
+    /**
+     * Updates the RewindManager with the current boxes in the level
+     */
+    private void updateRewindManager() {
+        if (rewindManager != null) {
+            List<Box> boxes = getBoxesFromLevel();
+            rewindManager.setBoxes(boxes);
+        }
+    }
+    
+    /**
+     * Gets all boxes from the level
+     * 
+     * @return List of boxes
+     */
+    private List<Box> getBoxesFromLevel() {
+        List<Box> boxes = new ArrayList<>();
+        for (Entity entity : level.getEntities()) {
+            if (entity instanceof Box) {
+                boxes.add((Box) entity);
+            }
+        }
+        return boxes;
+    }
+    
     /**
      * Changes the current level layout
      * @param layoutType The type of layout to create
@@ -289,13 +353,43 @@ public void setLevelLayout(int layoutType) {
         // Clear the level
         level.clearLevel();
         
-        // Recreate level 1
-        level.createLevel1();
+        // Update current level
+        currentLevel = layoutType;
+        
+        // Create the appropriate level
+        if (currentLevel == 1) {
+            level.createLevel1();
+            setupLevel1();
+        } else if (currentLevel == 2) {
+            level.createLevel2();
+            setupLevel2();
+        }
+        
+        // Reset player position to starting position
+        resetPlayerPosition();
         
         // Update player blocks
         player.setBlocks(level.getBlocks());
     }
     
+    /**
+     * Resets the player to the starting position for the current level
+     */
+    private void resetPlayerPosition() {
+        if (player == null) return;
+        
+        // Position player at the middle left of the grid for any level
+        int gridX = 2; // A few cells from the left border
+        int gridY = level.getGrid().getVerticalCells() / 2;
+        int playerX = level.getGrid().gridToScreenX(gridX);
+        int playerY = level.getGrid().gridToScreenY(gridY);
+        
+        player.setX(playerX);
+        player.setY(playerY);
+        
+        System.out.println("Reset player position to: " + playerX + "," + playerY);
+    }
+    
     @Override
     public void update() {
         if (!initialized) return;
@@ -317,14 +411,23 @@ public void update() {
             // Update level (includes buttons, etc.)
             level.update();
             
-            // Update player position
+            // First, update box collision information before player movement
+            updateBoxCollision();
+            
+            // Second, update player position (this will handle collisions)
             if (player != null) {
                 player.update();
             }
             
+            // Third, update carried box position AFTER player movement
+            updateCarriedBox();
+            
             // Check for interaction with buttons
             checkButtonHighlights();
             
+            // Check for interaction with boxes
+            checkBoxHighlights();
+            
             // Check if door has been successfully opened for the first time
             if (multiButtonAction != null && multiButtonAction.isPermanentlyActivated() && door != null && !door.isOpen()) {
                 // Force the door to open if it's not already open
@@ -335,12 +438,168 @@ public void update() {
             // Update door collision if necessary
             updateDoorCollision();
             
+            // Check if player is entering an open door (level transition)
+            checkDoorEntry();
+            
         } catch (Exception e) {
             System.err.println("Error in PlayState.update(): " + e.getMessage());
             e.printStackTrace();
         }
     }
     
+    /**
+     * Updates the position of a carried box
+     */
+    private void updateCarriedBox() {
+        if (carriedBox != null) {
+            carriedBox.updateCarriedPosition(player.getX(), player.getY());
+        }
+    }
+    
+    /**
+     * Checks for boxes near the player and highlights them
+     */
+    private void checkBoxHighlights() {
+        if (player == null) return;
+        
+        // Get all boxes from the level
+        List<Box> boxes = getBoxesFromLevel();
+        
+        // Clear the list of nearby boxes
+        nearBoxes.clear();
+        
+        // Check each box to see if it's near the player
+        for (Box box : boxes) {
+            // Calculate distance between player center and box center
+            float playerCenterX = player.getX() + player.getWidth() / 2;
+            float playerCenterY = player.getY() + player.getHeight() / 2;
+            float boxCenterX = box.getX() + box.getWidth() / 2;
+            float boxCenterY = box.getY() + box.getHeight() / 2;
+            
+            // Calculate the distance in grid cells (not pixels)
+            float dx = Math.abs(playerCenterX - boxCenterX) / GRID_CELL_SIZE;
+            float dy = Math.abs(playerCenterY - boxCenterY) / GRID_CELL_SIZE;
+            
+            // Box is within 1 cell of player (Manhattan distance)
+            if (dx <= 1 && dy <= 1) {
+                nearBoxes.add(box);
+            }
+        }
+    }
+    
+    /**
+     * Updates collision blocks to include boxes
+     */
+    private void updateBoxCollision() {
+        if (player == null) return;
+        
+        // Get current blocks from the level
+        List<Block> blocks = new ArrayList<>(level.getBlocks());
+        
+        // Get all boxes from the level
+        List<Box> boxes = getBoxesFromLevel();
+        
+        // Add non-carried boxes as collision blocks
+        for (Box box : boxes) {
+            if (!box.isBeingCarried() && !box.equals(carriedBox)) {
+                blocks.add(box);
+            }
+        }
+        
+        // Update player's collision blocks - this only includes level blocks and non-carried boxes
+        player.setBlocks(blocks);
+        
+        // When carrying a box, modify the player's collision handling but don't add the box itself as a collision object
+        if (carriedBox != null) {
+            // Cast player to BallPlayer to use the setCarriedBox method
+            ((BallPlayer)player).setCarriedBox(carriedBox);
+        } else {
+            // Cast player to BallPlayer to use the setCarriedBox method
+            ((BallPlayer)player).setCarriedBox(null);
+        }
+    }
+
+    /**
+     * Handles box interactions (pick up or drop)
+     */
+    private void interactWithBoxes() {
+        // If already carrying a box, drop it
+        if (carriedBox != null) {
+            dropCarriedBox();
+            return;
+        }
+        
+        // Otherwise, check if there's a box nearby to pick up
+        for (Box box : nearBoxes) {
+            if (box.isMovable() && !box.isBeingCarried()) {
+                pickUpBox(box);
+                break;
+            }
+        }
+    }
+    
+    /**
+     * Picks up a box
+     * 
+     * @param box The box to pick up
+     */
+    private void pickUpBox(Box box) {
+        if (box.pickUp(player.getX(), player.getY(), player)) {
+            carriedBox = box;
+            System.out.println("Box picked up!");
+            
+            // Record box interaction in rewind manager
+            if (rewindManager != null && box.isActive()) {
+                rewindManager.recordBoxInteraction(box, true);
+            }
+        }
+    }
+    
+    /**
+     * Drops the currently carried box
+     */
+    private void dropCarriedBox() {
+        if (carriedBox != null) {
+            carriedBox.drop();
+            
+            // Record box interaction in rewind manager
+            if (rewindManager != null && carriedBox.isActive()) {
+                rewindManager.recordBoxInteraction(carriedBox, false);
+            }
+            
+            carriedBox = null;
+            System.out.println("Box dropped!");
+        }
+    }
+    
+    /**
+     * Checks if the player is entering an open door to trigger level transition
+     */
+    private void checkDoorEntry() {
+        if (player == null || door == null || !door.isOpen()) return;
+        
+        // Check if player is overlapping the door
+        float playerCenterX = player.getX() + player.getWidth() / 2;
+        float playerCenterY = player.getY() + player.getHeight() / 2;
+        float doorCenterX = door.getX() + door.getWidth() / 2;
+        float doorCenterY = door.getY() + door.getHeight() / 2;
+        
+        // Calculate distance between centers
+        float distance = (float) Math.sqrt(
+            Math.pow(playerCenterX - doorCenterX, 2) + 
+            Math.pow(playerCenterY - doorCenterY, 2)
+        );
+        
+        // If the player's center is close enough to the door's center
+        if (distance < player.getWidth() / 2) {
+            // Check which level we're on and transition accordingly
+            if (currentLevel == 1) {
+                System.out.println("Player entered the door! Transitioning to level 2...");
+                setLevelLayout(2);
+            }
+        }
+    }
+    
     @Override
     public void render(Graphics2D g) {
         if (!initialized) return;
@@ -367,6 +626,9 @@ public void render(Graphics2D g) {
             // Draw interaction indicator for buttons
             drawButtonHighlights(g);
             
+            // Draw interaction indicator for boxes
+            drawBoxHighlights(g);
+            
             // Draw rewind status indicator
             drawRewindStatusIndicator(g);
             
@@ -513,6 +775,54 @@ private void drawButtonHighlights(Graphics2D g) {
         g.setStroke(originalStroke);
     }
     
+    /**
+     * Draws highlights around boxes that are near the player
+     */
+    private void drawBoxHighlights(Graphics2D g) {
+        if (nearBoxes.isEmpty()) return;
+        
+        // Save original stroke
+        java.awt.Stroke originalStroke = g.getStroke();
+        
+        // Set a thicker stroke for highlighting
+        g.setStroke(new BasicStroke(3));
+        
+        // Draw highlight around each nearby box
+        for (Box box : nearBoxes) {
+            // Only highlight if it's movable
+            if (!box.isMovable()) continue;
+            
+            // Calculate the grid position for the box
+            int gridX = level.getGrid().screenToGridX((int)box.getX());
+            int gridY = level.getGrid().screenToGridY((int)box.getY());
+            
+            // Convert grid position to screen coordinates
+            int screenX = level.getGrid().gridToScreenX(gridX);
+            int screenY = level.getGrid().gridToScreenY(gridY);
+            
+            // Draw the cell outline with a pulsating effect
+            long currentTime = System.currentTimeMillis();
+            float pulseIntensity = (float)Math.abs(Math.sin(currentTime * 0.003)) * 0.5f + 0.5f;
+            
+            // Create a yellow highlight
+            Color highlightColor = new Color(
+                1.0f, 1.0f, 0.0f, 0.3f + pulseIntensity * 0.5f
+            );
+            g.setColor(highlightColor);
+            
+            // Draw the rectangle around the grid cell
+            g.drawRect(screenX, screenY, level.getGrid().getCellSize(), level.getGrid().getCellSize());
+            
+            // Draw "E" to indicate interaction key
+            g.setFont(new Font("Arial", Font.BOLD, 14));
+            g.setColor(Color.YELLOW);
+            g.drawString("E", screenX + level.getGrid().getCellSize() - 15, screenY + 15);
+        }
+        
+        // Restore original stroke
+        g.setStroke(originalStroke);
+    }
+    
     /**
      * Activates buttons near the player
      */
@@ -620,6 +930,7 @@ public void keyPressed(int k) {
         // Handle interaction with 'E' key
         if (k == KeyEvent.VK_E) {
             activateNearbyButtons();
+            interactWithBoxes();
         }
         
         // Handle pause with Escape key
@@ -632,10 +943,15 @@ public void keyPressed(int k) {
             rewindManager.toggleRewind();
         }
         
-        // For now, all level layout keys just reset to level 1
-        if (k == KeyEvent.VK_1 || k == KeyEvent.VK_2 || k == KeyEvent.VK_3 || k == KeyEvent.VK_0) {
+        // Level switching shortcuts
+        if (k == KeyEvent.VK_1) {
+            System.out.println("Switching to level 1");
             setLevelLayout(1);
         }
+        else if (k == KeyEvent.VK_2) {
+            System.out.println("Switching to level 2");
+            setLevelLayout(2);
+        }
     }
     
     @Override
diff --git a/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java b/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
index 3b33998..7a403d4 100644
--- a/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
+++ b/app/src/main/java/com/niravramdhanie/twod/game/utils/RewindManager.java
@@ -12,7 +12,9 @@
 import com.niravramdhanie.twod.game.actions.TimedAction;
 import com.niravramdhanie.twod.game.actions.ToggleAction;
 import com.niravramdhanie.twod.game.entity.BallPlayer;
+import com.niravramdhanie.twod.game.entity.Box;
 import com.niravramdhanie.twod.game.entity.Button;
+import com.niravramdhanie.twod.game.entity.Entity;
 
 /**
  * Manages the rewind feature for the game.
@@ -42,6 +44,10 @@ public enum RewindState {
     private Map<String, Boolean> initialToggleStates = new HashMap<>();
     private Map<String, Boolean> initialDoorStates = new HashMap<>();
     
+    // Box state tracking
+    private List<BoxState> initialBoxStates = new ArrayList<>();
+    private List<Box> boxes = new ArrayList<>();
+    
     // Recorded actions
     private List<RecordedAction> recordedActions = new ArrayList<>();
     
@@ -66,6 +72,15 @@ public RewindManager(BallPlayer player, List<Button> buttons, TimerManager timer
         this.timer = timer;
     }
     
+    /**
+     * Sets the list of boxes to track for rewind.
+     * 
+     * @param boxes The list of boxes to track
+     */
+    public void setBoxes(List<Box> boxes) {
+        this.boxes = boxes;
+    }
+    
     /**
      * Starts recording player actions and game state.
      */
@@ -75,6 +90,7 @@ public void startRecording() {
         initialButtonStates.clear();
         initialToggleStates.clear();
         initialDoorStates.clear();
+        initialBoxStates.clear();
         currentToggleStates.clear();
         
         // Record initial state
@@ -114,6 +130,19 @@ public void startRecording() {
             }
         }
         
+        // Record initial box states
+        for (Box box : boxes) {
+            if (box.isActive()) { // Only record active boxes
+                initialBoxStates.add(new BoxState(
+                    box,
+                    box.getX(),
+                    box.getY(),
+                    box.isBeingCarried(),
+                    box.isBeingCarried() ? player : null
+                ));
+            }
+        }
+        
         // Set recording state
         currentState = RewindState.RECORDING;
         recordingStartTime = System.currentTimeMillis();
@@ -141,6 +170,39 @@ public void recordButtonActivation(Button button, boolean activated) {
                           (activated ? "activation" : "deactivation") + " at time " + timestamp + "ms");
     }
     
+    /**
+     * Records a box interaction (pick up or drop).
+     * 
+     * @param box The box that was interacted with
+     * @param isPickup Whether the box was picked up (true) or dropped (false)
+     */
+    public void recordBoxInteraction(Box box, boolean isPickup) {
+        if (currentState != RewindState.RECORDING || !box.isActive()) {
+            return;
+        }
+        
+        long timestamp = System.currentTimeMillis() - recordingStartTime;
+        
+        // Record the box position and state at time of interaction
+        RecordedAction action = new RecordedAction(
+            isPickup ? ActionType.BOX_PICKUP : ActionType.BOX_DROP,
+            timestamp,
+            null, // No button ID for box interactions
+            false // Not used for box interactions
+        );
+        
+        // Store box reference and current position
+        action.box = box;
+        action.boxX = box.getX();
+        action.boxY = box.getY();
+        
+        recordedActions.add(action);
+        
+        System.out.println("Rewind: Recorded box " + 
+                          (isPickup ? "pickup" : "drop") + " at time " + timestamp + "ms, position (" +
+                          box.getX() + ", " + box.getY() + ")");
+    }
+    
     /**
      * Starts rewinding the game to the recorded state.
      */
@@ -192,6 +254,20 @@ public void startRewinding() {
             }
         }
         
+        // Reset box states
+        for (BoxState state : initialBoxStates) {
+            Box box = state.box;
+            box.setX(state.x);
+            box.setY(state.y);
+            
+            // Reset carried state
+            if (state.isBeingCarried && state.carrier != null) {
+                box.pickUp(state.carrier.getX(), state.carrier.getY(), state.carrier);
+            } else if (box.isBeingCarried()) {
+                box.drop();
+            }
+        }
+        
         // Mark all actions as not applied
         for (RecordedAction action : recordedActions) {
             action.applied = false;
@@ -249,119 +325,156 @@ public void update() {
             // Sync final states to ensure consistency
             synchronizeFinalStates();
             
-            // Reset rewind state
             currentState = RewindState.IDLE;
-            System.out.println("Rewind: All actions replayed, returning to idle state");
+            System.out.println("Rewind: Completed replay of all actions");
         }
     }
     
     /**
-     * Synchronize final states to ensure consistency between buttons, toggles, and doors
+     * Synchronizes final states after rewinding to ensure consistency.
      */
     private void synchronizeFinalStates() {
-        // Apply the current toggle states from our tracking
+        // Ensure all buttons have their final state
         for (Button button : buttons) {
             String buttonId = getButtonId(button);
-            Action action = button.getAction();
+            boolean finalToggled = currentToggleStates.getOrDefault(buttonId, false);
             
-            // For toggle actions, apply the final tracked state
-            if (action instanceof ToggleAction) {
+            // Set final toggle state
+            button.forceSetToggleState(finalToggled);
+            
+            // Update door states via actions
+            Action action = button.getAction();
+            if (action instanceof DoorAction) {
+                DoorAction doorAction = (DoorAction) action;
+                doorAction.setDoorOpen(finalToggled);
+            } else if (action instanceof ToggleAction) {
                 ToggleAction toggleAction = (ToggleAction) action;
-                if (currentToggleStates.containsKey(buttonId)) {
-                    boolean finalToggleState = currentToggleStates.get(buttonId);
-                    button.forceSetToggleState(finalToggleState);
-                }
-                
-                // Ensure door state is consistent
                 if (toggleAction.getOnAction() instanceof DoorAction) {
                     DoorAction doorAction = (DoorAction) toggleAction.getOnAction();
-                    boolean toggledState = toggleAction.isToggled();
-                    doorAction.setDoorOpen(toggledState);
+                    doorAction.setDoorOpen(finalToggled);
+                }
+                if (toggleAction.getOffAction() instanceof DoorAction) {
+                    DoorAction doorAction = (DoorAction) toggleAction.getOffAction();
+                    doorAction.setDoorOpen(!finalToggled);
                 }
             }
         }
+        
+        // Ensure boxes are in proper positions
+        for (Box box : boxes) {
+            if (box.isActive()) {
+                // Final position should already be correct through the action replay
+                System.out.println("Box final position: (" + box.getX() + ", " + box.getY() + 
+                                  "), carried: " + box.isBeingCarried());
+            }
+        }
     }
     
     /**
-     * Applies a recorded action.
+     * Applies a recorded action during rewinding.
      * 
      * @param action The action to apply
      */
     private void applyAction(RecordedAction action) {
-        if (action.type == ActionType.BUTTON_ACTIVATION) {
-            // Find the button with matching ID
-            for (Button button : buttons) {
-                String buttonId = getButtonId(button);
-                if (buttonId.equals(action.buttonId)) {
-                    // Record the current state before making changes
-                    boolean wasActivated = button.isActivated();
-                    
-                    // Apply the action
-                    if (action.activated) {
-                        // If activating a button, use the regular activate method
-                        // which will trigger any associated actions
-                        button.activate();
-                        
-                        // Ensure TimedAction visual state is updated
-                        Action buttonAction = button.getAction();
-                        if (buttonAction instanceof TimedAction) {
-                            TimedAction timedAction = (TimedAction) buttonAction;
-                            if (!timedAction.isActive()) {
-                                timedAction.setActive(true);
-                            }
-                        }
-                        
-                        // Update toggle state tracking
-                        if (button.getAction() instanceof ToggleAction) {
-                            ToggleAction toggleAction = (ToggleAction) button.getAction();
-                            boolean newToggleState = toggleAction.isToggled();
-                            currentToggleStates.put(buttonId, newToggleState);
-                            
-                            // Ensure door state is consistent with toggle state
-                            if (toggleAction.getOnAction() instanceof DoorAction) {
-                                DoorAction doorAction = (DoorAction) toggleAction.getOnAction();
-                                doorAction.setDoorOpen(newToggleState);
-                            }
-                        }
-                    } else {
-                        // If deactivating, use the proper deactivate method 
-                        // which will update visual indicators properly
-                        button.deactivate();
-                        
-                        // Ensure TimedAction visual state is updated
-                        Action buttonAction = button.getAction();
-                        if (buttonAction instanceof TimedAction) {
-                            TimedAction timedAction = (TimedAction) buttonAction;
-                            if (timedAction.isActive()) {
-                                timedAction.setActive(false);
-                            }
-                        }
-                    }
-                    
-                    System.out.println("Rewind: Replayed button " + action.buttonId + 
-                                     " " + (action.activated ? "activation" : "deactivation") + 
-                                     " at time " + action.timestamp + "ms");
-                    break;
+        switch (action.type) {
+            case BUTTON_ACTIVATION:
+                applyButtonActivation(action);
+                break;
+            case BOX_PICKUP:
+                applyBoxPickup(action);
+                break;
+            case BOX_DROP:
+                applyBoxDrop(action);
+                break;
+        }
+    }
+    
+    /**
+     * Applies a button activation action during rewinding.
+     * 
+     * @param action The button activation action to apply
+     */
+    private void applyButtonActivation(RecordedAction action) {
+        for (Button button : buttons) {
+            String buttonId = getButtonId(button);
+            if (buttonId.equals(action.buttonId)) {
+                // Activate or deactivate the button
+                if (action.activated) {
+                    button.activate();
+                } else {
+                    button.deactivate();
                 }
+                
+                // Update toggle state if this is a toggle button
+                Action buttonAction = button.getAction();
+                if (buttonAction instanceof ToggleAction) {
+                    boolean newToggled = action.activated ? !currentToggleStates.getOrDefault(buttonId, false) 
+                                                         : currentToggleStates.getOrDefault(buttonId, false);
+                    currentToggleStates.put(buttonId, newToggled);
+                }
+                
+                System.out.println("Rewind: Applied button " + buttonId + " " + 
+                                  (action.activated ? "activation" : "deactivation") + 
+                                  " at replay time " + action.timestamp + "ms");
+                break;
             }
         }
     }
     
     /**
-     * Toggles the rewind feature when the 'R' key is pressed.
+     * Applies a box pickup action during rewinding.
+     * 
+     * @param action The box pickup action to apply
+     */
+    private void applyBoxPickup(RecordedAction action) {
+        if (action.box != null) {
+            // Set the box position first
+            action.box.setX(action.boxX);
+            action.box.setY(action.boxY);
+            
+            // Then pick it up
+            action.box.pickUp(player.getX(), player.getY(), player);
+            
+            System.out.println("Rewind: Applied box pickup at replay time " + 
+                              action.timestamp + "ms, position (" + action.boxX + ", " + action.boxY + ")");
+        }
+    }
+    
+    /**
+     * Applies a box drop action during rewinding.
+     * 
+     * @param action The box drop action to apply
+     */
+    private void applyBoxDrop(RecordedAction action) {
+        if (action.box != null) {
+            // Drop the box
+            action.box.drop();
+            
+            // Set the final position
+            action.box.setX(action.boxX);
+            action.box.setY(action.boxY);
+            
+            System.out.println("Rewind: Applied box drop at replay time " + 
+                              action.timestamp + "ms, position (" + action.boxX + ", " + action.boxY + ")");
+        }
+    }
+    
+    /**
+     * Toggles the rewind state.
+     * If idle, starts recording.
+     * If recording, starts rewinding.
+     * If rewinding, does nothing.
      */
     public void toggleRewind() {
         switch (currentState) {
             case IDLE:
                 startRecording();
                 break;
-                
             case RECORDING:
                 startRewinding();
                 break;
-                
             case REWINDING:
-                // Do nothing if already rewinding
+                // Do nothing while rewinding
                 break;
         }
     }
@@ -376,18 +489,15 @@ public RewindState getCurrentState() {
     }
     
     /**
-     * Generate a unique ID for a button based on its position.
-     * 
-     * @param button The button to get an ID for
-     * @return A unique string ID
+     * Converts a button to a unique ID for tracking.
      */
     private String getButtonId(Button button) {
-        // Create a unique ID based on the button's position
-        return "btn_" + (int)button.getX() + "_" + (int)button.getY();
+        // Use the location as a unique identifier to avoid requiring IDs
+        return "button_" + button.getX() + "_" + button.getY();
     }
     
     /**
-     * Records the state of a button.
+     * Class to track button state information.
      */
     private static class ButtonState {
         String buttonId;
@@ -411,22 +521,48 @@ private static class ButtonState {
     }
     
     /**
-     * Types of actions that can be recorded.
+     * Class to track box state information.
+     */
+    private static class BoxState {
+        Box box;
+        float x;
+        float y;
+        boolean isBeingCarried;
+        Entity carrier;
+        
+        BoxState(Box box, float x, float y, boolean isBeingCarried, Entity carrier) {
+            this.box = box;
+            this.x = x;
+            this.y = y;
+            this.isBeingCarried = isBeingCarried;
+            this.carrier = carrier;
+        }
+    }
+    
+    /**
+     * Types of recorded actions.
      */
     private enum ActionType {
-        BUTTON_ACTIVATION
+        BUTTON_ACTIVATION,
+        BOX_PICKUP,
+        BOX_DROP
     }
     
     /**
-     * A recorded action with timestamp.
+     * Class to track information about a recorded action.
      */
     private static class RecordedAction {
         ActionType type;
         long timestamp;
-        String buttonId;
-        boolean activated;
+        String buttonId;  // Used for button actions
+        boolean activated; // Used for button actions
         boolean applied = false;
         
+        // Box action properties
+        Box box;          // Used for box actions
+        float boxX;       // Used for box actions
+        float boxY;       // Used for box actions
+        
         RecordedAction(ActionType type, long timestamp, String buttonId, boolean activated) {
             this.type = type;
             this.timestamp = timestamp;