/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");
var storage = LK.import("@upit/storage.v1");

/**** 
* Classes
****/ 
var MazeGenerator = Container.expand(function () {
	var self = Container.call(this);
	self.generate = function (width, height) {
		var maze = {
			width: width,
			height: height,
			grid: [],
			startX: 1,
			startY: 1,
			endX: width - 2,
			endY: height - 2,
			rooms: [],
			currentRoom: 0
		};
		// Initialize maze with walls
		for (var y = 0; y < height; y++) {
			maze.grid[y] = [];
			for (var x = 0; x < width; x++) {
				maze.grid[y][x] = 1; // Wall
			}
		}
		// Create linear sequence of rooms like Doors game
		self.createLinearRooms(maze);
		// Ensure start and end are open
		maze.grid[maze.startY][maze.startX] = 0;
		maze.grid[maze.endY][maze.endX] = 2; // Exit
		return maze;
	};
	self.createLinearRooms = function (maze) {
		// Create a linear sequence of rooms connected by doors (like Doors game)
		var roomCount = 3 + Math.floor(Math.random() * 2); // 3-4 rooms
		var roomWidth = 5;
		var roomHeight = 5;
		var hallwayWidth = 3;
		// Calculate total width needed
		var totalWidth = roomCount * roomWidth + (roomCount - 1) * hallwayWidth;
		var startX = Math.floor((maze.width - totalWidth) / 2);
		var startY = Math.floor((maze.height - roomHeight) / 2);
		maze.rooms = [];
		// Create rooms and connecting hallways
		for (var r = 0; r < roomCount; r++) {
			var roomX = startX + r * (roomWidth + hallwayWidth);
			var roomY = startY;
			// Store room info
			maze.rooms.push({
				x: roomX,
				y: roomY,
				width: roomWidth,
				height: roomHeight,
				number: r + 1
			});
			// Clear room area
			for (var y = roomY; y < roomY + roomHeight; y++) {
				for (var x = roomX; x < roomX + roomWidth; x++) {
					if (x < maze.width && y < maze.height) {
						maze.grid[y][x] = 0;
					}
				}
			}
			// Add door to next room (except for last room)
			if (r < roomCount - 1) {
				var doorX = roomX + roomWidth;
				var doorY = roomY + Math.floor(roomHeight / 2);
				// Create hallway to next room
				for (var h = 0; h < hallwayWidth; h++) {
					if (doorX + h < maze.width) {
						maze.grid[doorY][doorX + h] = 0;
					}
				}
				// Place door at end of hallway
				if (doorX + hallwayWidth - 1 < maze.width) {
					maze.grid[doorY][doorX + hallwayWidth - 1] = 3; // Door
				}
			}
		}
		// Set start in first room
		maze.startX = maze.rooms[0].x + 1;
		maze.startY = maze.rooms[0].y + 1;
		// Set exit in last room
		var lastRoom = maze.rooms[maze.rooms.length - 1];
		maze.endX = lastRoom.x + lastRoom.width - 2;
		maze.endY = lastRoom.y + lastRoom.height - 2;
	};
	return self;
});
var Minimap = Container.expand(function () {
	var self = Container.call(this);
	self.cellSize = 8;
	self.mapCells = [];
	self.playerDot = null;
	self.setup = function (maze) {
		// Clear existing map
		for (var i = 0; i < self.mapCells.length; i++) {
			self.mapCells[i].destroy();
		}
		self.mapCells = [];
		if (self.playerDot) {
			self.playerDot.destroy();
		}
		// Create minimap cells
		for (var y = 0; y < maze.height; y++) {
			for (var x = 0; x < maze.width; x++) {
				var cell = null;
				if (maze.grid[y][x] === 1) {
					// Wall
					cell = LK.getAsset('wall', {
						width: self.cellSize,
						height: self.cellSize,
						anchorX: 0,
						anchorY: 0
					});
					cell.tint = 0x444444;
				} else if (maze.grid[y][x] === 2) {
					// Exit
					cell = LK.getAsset('exit', {
						width: self.cellSize,
						height: self.cellSize,
						anchorX: 0,
						anchorY: 0
					});
					cell.tint = 0x00FF00;
				} else if (maze.grid[y][x] === 3) {
					// Door
					cell = LK.getAsset('door', {
						width: self.cellSize,
						height: self.cellSize,
						anchorX: 0,
						anchorY: 0
					});
					cell.tint = 0x654321;
				} else {
					// Open path
					cell = LK.getAsset('floor', {
						width: self.cellSize,
						height: self.cellSize,
						anchorX: 0,
						anchorY: 0
					});
					cell.tint = 0x888888;
				}
				if (cell) {
					cell.x = x * self.cellSize;
					cell.y = y * self.cellSize;
					self.addChild(cell);
					self.mapCells.push(cell);
				}
			}
		}
		// Create player dot
		self.playerDot = LK.getAsset('player', {
			width: self.cellSize,
			height: self.cellSize,
			anchorX: 0.5,
			anchorY: 0.5
		});
		self.addChild(self.playerDot);
	};
	self.updatePlayer = function (playerX, playerY) {
		if (self.playerDot) {
			self.playerDot.x = playerX * self.cellSize;
			self.playerDot.y = playerY * self.cellSize;
		}
	};
	return self;
});
var RaycastRenderer = Container.expand(function () {
	var self = Container.call(this);
	self.fov = Math.PI / 3; // 60 degrees field of view
	self.rayCount = 256; // Number of rays to cast (expanded for full screen)
	self.maxDistance = 15; // Reduced max distance
	self.wallHeight = 300;
	self.walls = [];
	self.render = function (playerX, playerY, playerAngle, maze) {
		// Initialize walls array if needed
		if (self.walls.length === 0) {
			for (var i = 0; i < self.rayCount; i++) {
				var wall = LK.getAsset('raycast_wall', {
					width: 8,
					height: self.wallHeight,
					anchorX: 0,
					anchorY: 0.5
				});
				wall.x = i * 8;
				wall.y = 2732 / 2;
				wall.visible = false;
				self.addChild(wall);
				self.walls.push(wall);
			}
		}
		var angleStep = self.fov / self.rayCount;
		var rayAngle = playerAngle - self.fov / 2;
		for (var i = 0; i < self.rayCount; i++) {
			var distance = self.castRay(playerX, playerY, rayAngle, maze);
			var wall = self.walls[i];
			if (distance < self.maxDistance) {
				// Calculate wall height based on distance
				var wallHeight = self.wallHeight / distance;
				if (wallHeight > 600) wallHeight = 600; // Cap wall height
				// Update existing wall segment
				wall.height = wallHeight;
				wall.visible = true;
				// Add depth shading
				var shade = Math.max(0.2, 1 - distance / self.maxDistance);
				wall.tint = self.interpolateColor(0x000000, 0x8B4513, shade);
			} else {
				wall.visible = false;
			}
			rayAngle += angleStep;
		}
	};
	self.castRay = function (x, y, angle, maze) {
		var dx = Math.cos(angle) * 0.1;
		var dy = Math.sin(angle) * 0.1;
		var distance = 0;
		var stepSize = 0.1;
		var maxSteps = 200; // Prevent infinite loops
		var steps = 0;
		while (distance < self.maxDistance && steps < maxSteps) {
			x += dx;
			y += dy;
			distance += stepSize;
			steps++;
			var mapX = Math.floor(x);
			var mapY = Math.floor(y);
			if (mapX < 0 || mapX >= maze.width || mapY < 0 || mapY >= maze.height) {
				return distance;
			}
			if (maze.grid[mapY][mapX] === 1 || maze.grid[mapY][mapX] === 3) {
				return distance;
			}
		}
		return self.maxDistance;
	};
	self.interpolateColor = function (color1, color2, factor) {
		var r1 = color1 >> 16 & 0xFF;
		var g1 = color1 >> 8 & 0xFF;
		var b1 = color1 & 0xFF;
		var r2 = color2 >> 16 & 0xFF;
		var g2 = color2 >> 8 & 0xFF;
		var b2 = color2 & 0xFF;
		var r = Math.floor(r1 + (r2 - r1) * factor);
		var g = Math.floor(g1 + (g2 - g1) * factor);
		var b = Math.floor(b1 + (b2 - b1) * factor);
		return r << 16 | g << 8 | b;
	};
	return self;
});

/**** 
* Initialize Game
****/ 
var game = new LK.Game({
	backgroundColor: 0x000000
});

/**** 
* Game Code
****/ 
// Game variables
var currentLevel = storage.currentLevel || 1;
var playerX = 1.5;
var playerY = 1.5;
var playerAngle = 0;
var moveSpeed = 0.05;
var turnSpeed = 0.05;
var maze = null;
var mazeGenerator = new MazeGenerator();
var raycastRenderer = new RaycastRenderer();
var minimap = new Minimap();
// Touch controls
var touchStartX = 0;
var touchStartY = 0;
var isTouching = false;
var moveForward = false;
var moveBackward = false;
var turnLeft = false;
var turnRight = false;
// UI elements
var levelText = new Text2('Level: ' + currentLevel, {
	size: 60,
	fill: 0xFFFFFF
});
levelText.anchor.set(0.5, 0);
LK.gui.top.addChild(levelText);
var instructionText = new Text2('Find the exit!', {
	size: 40,
	fill: 0xFFFFFF
});
instructionText.anchor.set(0.5, 0);
instructionText.y = 80;
LK.gui.top.addChild(instructionText);
var roomText = new Text2('Room 1', {
	size: 50,
	fill: 0xFFFF00
});
roomText.anchor.set(0.5, 0);
roomText.y = 140;
LK.gui.top.addChild(roomText);
// Control arrows
var forwardArrow = new Text2('↑', {
	size: 120,
	fill: 0xFFFFFF
});
forwardArrow.anchor.set(0.5, 0.5);
forwardArrow.alpha = 0.7;
LK.gui.bottomLeft.addChild(forwardArrow);
forwardArrow.x = 150;
forwardArrow.y = -150;
var leftArrow = new Text2('←', {
	size: 120,
	fill: 0xFFFFFF
});
leftArrow.anchor.set(0.5, 0.5);
leftArrow.alpha = 0.7;
LK.gui.bottomRight.addChild(leftArrow);
leftArrow.x = -300;
leftArrow.y = -150;
var rightArrow = new Text2('→', {
	size: 120,
	fill: 0xFFFFFF
});
rightArrow.anchor.set(0.5, 0.5);
rightArrow.alpha = 0.7;
LK.gui.bottomRight.addChild(rightArrow);
rightArrow.x = -150;
rightArrow.y = -150;
// Initialize first level
function initLevel() {
	var mazeSize = 25; // Fixed size for room-based design
	maze = mazeGenerator.generate(mazeSize, mazeSize);
	// Set player starting position
	playerX = maze.startX + 0.5;
	playerY = maze.startY + 0.5;
	playerAngle = 0;
	maze.currentRoom = 0;
	// Setup minimap
	minimap.setup(maze);
	minimap.x = 2048 - maze.width * minimap.cellSize - 50;
	minimap.y = 50;
	game.addChild(minimap);
	// Update UI
	levelText.setText('Level: ' + currentLevel);
	roomText.setText('Room 1');
	instructionText.setText('Find the exit!');
}
// Control functions
function handleMovement() {
	var newX = playerX;
	var newY = playerY;
	if (moveForward) {
		newX += Math.cos(playerAngle) * moveSpeed;
		newY += Math.sin(playerAngle) * moveSpeed;
	}
	if (moveBackward) {
		newX -= Math.cos(playerAngle) * moveSpeed;
		newY -= Math.sin(playerAngle) * moveSpeed;
	}
	// Collision detection
	var mapX = Math.floor(newX);
	var mapY = Math.floor(newY);
	if (mapX >= 0 && mapX < maze.width && mapY >= 0 && mapY < maze.height) {
		if (maze.grid[mapY][mapX] !== 1) {
			// Check for door interaction
			if (maze.grid[mapY][mapX] === 3) {
				// Door found - flash green and allow passage
				LK.effects.flashScreen(0x00FF00, 200);
				maze.grid[mapY][mapX] = 0; // Open the door
				instructionText.setText('Door opened!');
				LK.setTimeout(function () {
					instructionText.setText('Find the exit!');
				}, 1000);
			}
			playerX = newX;
			playerY = newY;
			// Update current room display
			if (maze.rooms) {
				for (var r = 0; r < maze.rooms.length; r++) {
					var room = maze.rooms[r];
					if (mapX >= room.x && mapX < room.x + room.width && mapY >= room.y && mapY < room.y + room.height) {
						if (maze.currentRoom !== r) {
							maze.currentRoom = r;
							roomText.setText('Room ' + (r + 1));
							LK.effects.flashScreen(0x0000FF, 300);
						}
						break;
					}
				}
			}
			// Check if reached exit
			if (maze.grid[mapY][mapX] === 2) {
				completeLevel();
			}
		}
	}
	if (turnLeft) {
		playerAngle -= turnSpeed;
	}
	if (turnRight) {
		playerAngle += turnSpeed;
	}
	// Normalize angle
	while (playerAngle < 0) playerAngle += Math.PI * 2;
	while (playerAngle >= Math.PI * 2) playerAngle -= Math.PI * 2;
}
function completeLevel() {
	LK.getSound('complete').play();
	LK.setScore(currentLevel);
	currentLevel++;
	storage.currentLevel = currentLevel;
	if (currentLevel > 10) {
		LK.showYouWin();
	} else {
		// Flash effect and move to next level
		LK.effects.flashScreen(0x00FF00, 500);
		LK.setTimeout(function () {
			initLevel();
		}, 500);
	}
}
// Arrow control event handlers
forwardArrow.down = function (x, y, obj) {
	moveForward = true;
	forwardArrow.alpha = 1.0;
};
forwardArrow.up = function (x, y, obj) {
	moveForward = false;
	forwardArrow.alpha = 0.7;
};
leftArrow.down = function (x, y, obj) {
	turnLeft = true;
	leftArrow.alpha = 1.0;
};
leftArrow.up = function (x, y, obj) {
	turnLeft = false;
	leftArrow.alpha = 0.7;
};
rightArrow.down = function (x, y, obj) {
	turnRight = true;
	rightArrow.alpha = 1.0;
};
rightArrow.up = function (x, y, obj) {
	turnRight = false;
	rightArrow.alpha = 0.7;
};
// Touch event handlers
game.down = function (x, y, obj) {
	isTouching = true;
	touchStartX = x;
	touchStartY = y;
};
game.move = function (x, y, obj) {
	if (!isTouching) return;
	var deltaX = x - touchStartX;
	var deltaY = y - touchStartY;
	// Reset movement flags
	moveForward = false;
	moveBackward = false;
	turnLeft = false;
	turnRight = false;
	// Determine movement based on touch direction
	if (Math.abs(deltaY) > Math.abs(deltaX)) {
		// Vertical movement
		if (deltaY < -30) {
			moveForward = true;
		} else if (deltaY > 30) {
			moveBackward = true;
		}
	} else {
		// Horizontal movement
		if (deltaX < -30) {
			turnLeft = true;
		} else if (deltaX > 30) {
			turnRight = true;
		}
	}
};
game.up = function (x, y, obj) {
	isTouching = false;
	moveForward = false;
	moveBackward = false;
	turnLeft = false;
	turnRight = false;
};
// Add renderer to game
game.addChild(raycastRenderer);
raycastRenderer.x = 0;
raycastRenderer.y = 0;
// Main game loop
var lastRenderTime = 0;
var renderInterval = 33; // ~30fps to reduce load
game.update = function () {
	if (maze) {
		handleMovement();
		// Only render raycast every few frames to improve performance
		if (LK.ticks - lastRenderTime >= 2) {
			raycastRenderer.render(playerX, playerY, playerAngle, maze);
			lastRenderTime = LK.ticks;
		}
		minimap.updatePlayer(playerX, playerY);
	}
};
// Start the game
initLevel();

===================================================================
--- original.js
+++ change.js
@@ -16,113 +16,80 @@
 			grid: [],
 			startX: 1,
 			startY: 1,
 			endX: width - 2,
-			endY: height - 2
+			endY: height - 2,
+			rooms: [],
+			currentRoom: 0
 		};
 		// Initialize maze with walls
 		for (var y = 0; y < height; y++) {
 			maze.grid[y] = [];
 			for (var x = 0; x < width; x++) {
 				maze.grid[y][x] = 1; // Wall
 			}
 		}
-		// Simple maze generation using recursive backtracking
-		self.carvePath(maze, 1, 1);
-		// Create rooms with doors
-		self.createRooms(maze);
+		// Create linear sequence of rooms like Doors game
+		self.createLinearRooms(maze);
 		// Ensure start and end are open
 		maze.grid[maze.startY][maze.startX] = 0;
 		maze.grid[maze.endY][maze.endX] = 2; // Exit
 		return maze;
 	};
-	self.carvePath = function (maze, x, y) {
-		maze.grid[y][x] = 0; // Open path
-		var directions = [{
-			dx: 0,
-			dy: -2
-		},
-		// Up
-		{
-			dx: 2,
-			dy: 0
-		},
-		// Right
-		{
-			dx: 0,
-			dy: 2
-		},
-		// Down
-		{
-			dx: -2,
-			dy: 0
-		} // Left
-		];
-		// Shuffle directions
-		for (var i = directions.length - 1; i > 0; i--) {
-			var j = Math.floor(Math.random() * (i + 1));
-			var temp = directions[i];
-			directions[i] = directions[j];
-			directions[j] = temp;
-		}
-		for (var i = 0; i < directions.length; i++) {
-			var newX = x + directions[i].dx;
-			var newY = y + directions[i].dy;
-			if (newX > 0 && newX < maze.width - 1 && newY > 0 && newY < maze.height - 1 && maze.grid[newY][newX] === 1) {
-				// Carve wall between current and new position
-				maze.grid[y + directions[i].dy / 2][x + directions[i].dx / 2] = 0;
-				self.carvePath(maze, newX, newY);
-			}
-		}
-	};
-	self.createRooms = function (maze) {
-		// Create 2-4 rooms in the maze
-		var roomCount = 2 + Math.floor(Math.random() * 3);
+	self.createLinearRooms = function (maze) {
+		// Create a linear sequence of rooms connected by doors (like Doors game)
+		var roomCount = 3 + Math.floor(Math.random() * 2); // 3-4 rooms
+		var roomWidth = 5;
+		var roomHeight = 5;
+		var hallwayWidth = 3;
+		// Calculate total width needed
+		var totalWidth = roomCount * roomWidth + (roomCount - 1) * hallwayWidth;
+		var startX = Math.floor((maze.width - totalWidth) / 2);
+		var startY = Math.floor((maze.height - roomHeight) / 2);
+		maze.rooms = [];
+		// Create rooms and connecting hallways
 		for (var r = 0; r < roomCount; r++) {
-			var roomWidth = 3 + Math.floor(Math.random() * 3);
-			var roomHeight = 3 + Math.floor(Math.random() * 3);
-			var roomX = 2 + Math.floor(Math.random() * (maze.width - roomWidth - 4));
-			var roomY = 2 + Math.floor(Math.random() * (maze.height - roomHeight - 4));
+			var roomX = startX + r * (roomWidth + hallwayWidth);
+			var roomY = startY;
+			// Store room info
+			maze.rooms.push({
+				x: roomX,
+				y: roomY,
+				width: roomWidth,
+				height: roomHeight,
+				number: r + 1
+			});
 			// Clear room area
 			for (var y = roomY; y < roomY + roomHeight; y++) {
 				for (var x = roomX; x < roomX + roomWidth; x++) {
 					if (x < maze.width && y < maze.height) {
 						maze.grid[y][x] = 0;
 					}
 				}
 			}
-			// Add doors to room walls
-			var doorCount = 1 + Math.floor(Math.random() * 2);
-			for (var d = 0; d < doorCount; d++) {
-				var side = Math.floor(Math.random() * 4);
-				var doorX, doorY;
-				switch (side) {
-					case 0:
-						// Top
-						doorX = roomX + 1 + Math.floor(Math.random() * (roomWidth - 2));
-						doorY = roomY - 1;
-						break;
-					case 1:
-						// Right
-						doorX = roomX + roomWidth;
-						doorY = roomY + 1 + Math.floor(Math.random() * (roomHeight - 2));
-						break;
-					case 2:
-						// Bottom
-						doorX = roomX + 1 + Math.floor(Math.random() * (roomWidth - 2));
-						doorY = roomY + roomHeight;
-						break;
-					case 3:
-						// Left
-						doorX = roomX - 1;
-						doorY = roomY + 1 + Math.floor(Math.random() * (roomHeight - 2));
-						break;
+			// Add door to next room (except for last room)
+			if (r < roomCount - 1) {
+				var doorX = roomX + roomWidth;
+				var doorY = roomY + Math.floor(roomHeight / 2);
+				// Create hallway to next room
+				for (var h = 0; h < hallwayWidth; h++) {
+					if (doorX + h < maze.width) {
+						maze.grid[doorY][doorX + h] = 0;
+					}
 				}
-				if (doorX >= 0 && doorX < maze.width && doorY >= 0 && doorY < maze.height) {
-					maze.grid[doorY][doorX] = 3; // Door
+				// Place door at end of hallway
+				if (doorX + hallwayWidth - 1 < maze.width) {
+					maze.grid[doorY][doorX + hallwayWidth - 1] = 3; // Door
 				}
 			}
 		}
+		// Set start in first room
+		maze.startX = maze.rooms[0].x + 1;
+		maze.startY = maze.rooms[0].y + 1;
+		// Set exit in last room
+		var lastRoom = maze.rooms[maze.rooms.length - 1];
+		maze.endX = lastRoom.x + lastRoom.width - 2;
+		maze.endY = lastRoom.y + lastRoom.height - 2;
 	};
 	return self;
 });
 var Minimap = Container.expand(function () {
@@ -330,8 +297,15 @@
 });
 instructionText.anchor.set(0.5, 0);
 instructionText.y = 80;
 LK.gui.top.addChild(instructionText);
+var roomText = new Text2('Room 1', {
+	size: 50,
+	fill: 0xFFFF00
+});
+roomText.anchor.set(0.5, 0);
+roomText.y = 140;
+LK.gui.top.addChild(roomText);
 // Control arrows
 var forwardArrow = new Text2('↑', {
 	size: 120,
 	fill: 0xFFFFFF
@@ -360,22 +334,24 @@
 rightArrow.x = -150;
 rightArrow.y = -150;
 // Initialize first level
 function initLevel() {
-	var mazeSize = 11 + (currentLevel - 1) * 2; // Increasing maze size
-	if (mazeSize > 21) mazeSize = 21; // Cap maze size
+	var mazeSize = 25; // Fixed size for room-based design
 	maze = mazeGenerator.generate(mazeSize, mazeSize);
 	// Set player starting position
 	playerX = maze.startX + 0.5;
 	playerY = maze.startY + 0.5;
 	playerAngle = 0;
+	maze.currentRoom = 0;
 	// Setup minimap
 	minimap.setup(maze);
 	minimap.x = 2048 - maze.width * minimap.cellSize - 50;
 	minimap.y = 50;
 	game.addChild(minimap);
 	// Update UI
 	levelText.setText('Level: ' + currentLevel);
+	roomText.setText('Room 1');
+	instructionText.setText('Find the exit!');
 }
 // Control functions
 function handleMovement() {
 	var newX = playerX;
@@ -392,10 +368,34 @@
 	var mapX = Math.floor(newX);
 	var mapY = Math.floor(newY);
 	if (mapX >= 0 && mapX < maze.width && mapY >= 0 && mapY < maze.height) {
 		if (maze.grid[mapY][mapX] !== 1) {
+			// Check for door interaction
+			if (maze.grid[mapY][mapX] === 3) {
+				// Door found - flash green and allow passage
+				LK.effects.flashScreen(0x00FF00, 200);
+				maze.grid[mapY][mapX] = 0; // Open the door
+				instructionText.setText('Door opened!');
+				LK.setTimeout(function () {
+					instructionText.setText('Find the exit!');
+				}, 1000);
+			}
 			playerX = newX;
 			playerY = newY;
+			// Update current room display
+			if (maze.rooms) {
+				for (var r = 0; r < maze.rooms.length; r++) {
+					var room = maze.rooms[r];
+					if (mapX >= room.x && mapX < room.x + room.width && mapY >= room.y && mapY < room.y + room.height) {
+						if (maze.currentRoom !== r) {
+							maze.currentRoom = r;
+							roomText.setText('Room ' + (r + 1));
+							LK.effects.flashScreen(0x0000FF, 300);
+						}
+						break;
+					}
+				}
+			}
 			// Check if reached exit
 			if (maze.grid[mapY][mapX] === 2) {
 				completeLevel();
 			}