/**** 
* Classes
****/ 
var Player = Container.expand(function () {
	var self = Container.call(this);
	self.x = 1024;
	self.y = 1366;
	self.angle = 0;
	self.speed = 8;
	self.rotSpeed = 0.1;
	// Player visual for debugging (will be hidden in first person)
	var playerGraphics = self.attachAsset('player', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	playerGraphics.visible = false; // Hide for first person view
	self.moveForward = function () {
		var newX = self.x + Math.cos(self.angle) * self.speed;
		var newY = self.y + Math.sin(self.angle) * self.speed;
		// Simple boundary check
		if (newX > 100 && newX < 1948 && newY > 100 && newY < 2632) {
			self.x = newX;
			self.y = newY;
		}
	};
	self.moveBackward = function () {
		var newX = self.x - Math.cos(self.angle) * self.speed;
		var newY = self.y - Math.sin(self.angle) * self.speed;
		if (newX > 100 && newX < 1948 && newY > 100 && newY < 2632) {
			self.x = newX;
			self.y = newY;
		}
	};
	self.turnLeft = function () {
		self.angle -= self.rotSpeed;
	};
	self.turnRight = function () {
		self.angle += self.rotSpeed;
	};
	return self;
});
var Renderer3D = Container.expand(function () {
	var self = Container.call(this);
	self.wallColumns = [];
	self.floorColumns = [];
	self.ceilingColumns = [];
	// Create pseudo-3D rendering columns
	for (var i = 0; i < 512; i++) {
		var wallCol = self.addChild(LK.getAsset('wall', {
			anchorX: 0.5,
			anchorY: 1.0
		}));
		wallCol.x = i * 4;
		wallCol.y = 1366;
		self.wallColumns.push(wallCol);
		var floorCol = self.addChild(LK.getAsset('floorStrip', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		floorCol.x = i * 4;
		floorCol.y = 2000;
		self.floorColumns.push(floorCol);
		var ceilCol = self.addChild(LK.getAsset('ceilingStrip', {
			anchorX: 0.5,
			anchorY: 0.5
		}));
		ceilCol.x = i * 4;
		ceilCol.y = 700;
		self.ceilingColumns.push(ceilCol);
	}
	self.render = function (player) {
		var fov = Math.PI / 3; // 60 degrees field of view
		var halfFov = fov / 2;
		for (var i = 0; i < 512; i++) {
			var rayAngle = player.angle - halfFov + i / 512 * fov;
			var distance = self.castRay(player.x, player.y, rayAngle);
			// Calculate wall height based on distance
			var wallHeight = Math.max(50, 20000 / (distance + 1));
			var wallY = 1366 - wallHeight / 2;
			// Update wall column
			self.wallColumns[i].height = wallHeight;
			self.wallColumns[i].y = wallY;
			// Add backrooms wall texture variation based on distance and position
			var textureVariation = Math.sin(i * 0.1 + distance * 0.01) * 0.1;
			var baseColor = 0xf4f4a0; // Backrooms yellow
			var colorVariation = Math.floor(textureVariation * 20);
			self.wallColumns[i].tint = baseColor + colorVariation;
			// Calculate floor perspective
			var floorY = 1366 + wallHeight / 2 + distance / 10;
			self.floorColumns[i].y = Math.min(2632, floorY);
			self.floorColumns[i].height = Math.max(2, distance / 50);
			// Calculate ceiling perspective
			var ceilY = 1366 - wallHeight / 2 - distance / 10;
			self.ceilingColumns[i].y = Math.max(0, ceilY);
			self.ceilingColumns[i].height = Math.max(2, distance / 50);
		}
	};
	self.castRay = function (startX, startY, angle) {
		var rayX = startX;
		var rayY = startY;
		var deltaX = Math.cos(angle) * 2;
		var deltaY = Math.sin(angle) * 2;
		var distance = 0;
		// Simple raycasting - check for boundaries
		while (distance < 1000) {
			rayX += deltaX;
			rayY += deltaY;
			distance += 2;
			// Hit wall boundaries
			if (rayX <= 100 || rayX >= 1948 || rayY <= 100 || rayY >= 2632) {
				break;
			}
			// Add backrooms maze pattern - more complex wall generation
			var gridX = Math.floor(rayX / 150);
			var gridY = Math.floor(rayY / 150);
			// Create backrooms-style maze pattern
			var cellHash = (gridX * 73 + gridY * 37) % 100;
			if (cellHash < 30 && distance > 30) {
				break;
			}
			// Add occasional pillars for backrooms feel
			var pillarX = Math.floor(rayX / 300) * 300 + 150;
			var pillarY = Math.floor(rayY / 300) * 300 + 150;
			var pillarDist = Math.sqrt((rayX - pillarX) * (rayX - pillarX) + (rayY - pillarY) * (rayY - pillarY));
			if (pillarDist < 30 && distance > 20) {
				break;
			}
		}
		return distance;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Create player
var player = new Player();
game.addChild(player);
// Create 3D renderer
var renderer3D = new Renderer3D();
game.addChild(renderer3D);
// Movement flags
var moveForward = false;
var moveBackward = false;
var turnLeft = false;
var turnRight = false;
// Touch controls for movement
var touchStartX = 0;
var touchStartY = 0;
var touchActive = false;
game.down = function (x, y, obj) {
	touchStartX = x;
	touchStartY = y;
	touchActive = true;
	// Forward movement on touch
	moveForward = true;
};
game.up = function (x, y, obj) {
	touchActive = false;
	moveForward = false;
	moveBackward = false;
	turnLeft = false;
	turnRight = false;
};
game.move = function (x, y, obj) {
	if (!touchActive) return;
	var deltaX = x - touchStartX;
	var deltaY = y - touchStartY;
	// Horizontal movement for turning
	if (Math.abs(deltaX) > 50) {
		if (deltaX > 0) {
			turnRight = true;
			turnLeft = false;
		} else {
			turnLeft = true;
			turnRight = false;
		}
	} else {
		turnLeft = false;
		turnRight = false;
	}
	// Vertical movement for forward/backward
	if (Math.abs(deltaY) > 50) {
		if (deltaY < 0) {
			moveForward = true;
			moveBackward = false;
		} else {
			moveBackward = true;
			moveForward = false;
		}
	}
};
game.update = function () {
	// Handle movement
	if (moveForward) {
		player.moveForward();
	}
	if (moveBackward) {
		player.moveBackward();
	}
	if (turnLeft) {
		player.turnLeft();
	}
	if (turnRight) {
		player.turnRight();
	}
	// Render the pseudo-3D view
	renderer3D.render(player);
};

===================================================================
--- original.js
+++ change.js
@@ -79,8 +79,13 @@
 			var wallY = 1366 - wallHeight / 2;
 			// Update wall column
 			self.wallColumns[i].height = wallHeight;
 			self.wallColumns[i].y = wallY;
+			// Add backrooms wall texture variation based on distance and position
+			var textureVariation = Math.sin(i * 0.1 + distance * 0.01) * 0.1;
+			var baseColor = 0xf4f4a0; // Backrooms yellow
+			var colorVariation = Math.floor(textureVariation * 20);
+			self.wallColumns[i].tint = baseColor + colorVariation;
 			// Calculate floor perspective
 			var floorY = 1366 + wallHeight / 2 + distance / 10;
 			self.floorColumns[i].y = Math.min(2632, floorY);
 			self.floorColumns[i].height = Math.max(2, distance / 50);
@@ -104,14 +109,23 @@
 			// Hit wall boundaries
 			if (rayX <= 100 || rayX >= 1948 || rayY <= 100 || rayY >= 2632) {
 				break;
 			}
-			// Add some procedural walls for the backrooms feel
-			var gridX = Math.floor(rayX / 200);
-			var gridY = Math.floor(rayY / 200);
-			if ((gridX + gridY) % 3 === 0 && distance > 50) {
+			// Add backrooms maze pattern - more complex wall generation
+			var gridX = Math.floor(rayX / 150);
+			var gridY = Math.floor(rayY / 150);
+			// Create backrooms-style maze pattern
+			var cellHash = (gridX * 73 + gridY * 37) % 100;
+			if (cellHash < 30 && distance > 30) {
 				break;
 			}
+			// Add occasional pillars for backrooms feel
+			var pillarX = Math.floor(rayX / 300) * 300 + 150;
+			var pillarY = Math.floor(rayY / 300) * 300 + 150;
+			var pillarDist = Math.sqrt((rayX - pillarX) * (rayX - pillarX) + (rayY - pillarY) * (rayY - pillarY));
+			if (pillarDist < 30 && distance > 20) {
+				break;
+			}
 		}
 		return distance;
 	};
 	return self;