/**** 
* 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;
		// Check wall collision using same logic as raycasting
		if (self.checkCollision(newX, newY)) {
			return; // Don't move if collision detected
		}
		// 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;
		// Check wall collision using same logic as raycasting
		if (self.checkCollision(newX, newY)) {
			return; // Don't move if collision detected
		}
		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;
	};
	self.checkCollision = function (x, y) {
		// Use same collision logic as raycasting for consistency
		// Check wall boundaries first
		if (x <= 100 || x >= 1948 || y <= 100 || y >= 2632) {
			return true; // Boundary wall collision
		}
		// Add backrooms maze pattern - more complex wall generation
		var gridX = Math.floor(x / 150);
		var gridY = Math.floor(y / 150);
		// Create backrooms-style maze pattern
		var cellHash = (gridX * 73 + gridY * 37) % 100;
		if (cellHash < 30) {
			return true; // Wall collision
		}
		// Add occasional pillars for backrooms feel
		var pillarX = Math.floor(x / 300) * 300 + 150;
		var pillarY = Math.floor(y / 300) * 300 + 150;
		var pillarDist = Math.sqrt((x - pillarX) * (x - pillarX) + (y - pillarY) * (y - pillarY));
		if (pillarDist < 40) {
			// Slightly larger collision radius than visual
			return true; // Pillar collision
		}
		return false; // No collision - clear floor/ceiling space
	};
	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 rayResult = self.castRay(player.x, player.y, rayAngle);
			var distance = rayResult.distance;
			var surfaceType = rayResult.type;
			// Calculate wall height based on distance
			var wallHeight = Math.max(50, 20000 / (distance + 1));
			var wallY = 1366 - wallHeight / 2;
			// Update wall column based on surface type
			if (surfaceType === 'wall') {
				self.wallColumns[i].visible = true;
				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;
			} else {
				// Hide wall if not hitting a wall surface
				self.wallColumns[i].visible = false;
			}
			// Auto-detect and render floor
			var floorY = 1366 + wallHeight / 2 + distance / 10;
			self.floorColumns[i].y = Math.min(2632, floorY);
			self.floorColumns[i].height = Math.max(2, distance / 50);
			self.floorColumns[i].visible = floorY < 2632; // Only show if within screen bounds
			// Auto-detect and render ceiling
			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.ceilingColumns[i].visible = ceilY > 0; // Only show if within screen bounds
		}
	};
	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;
		var hitType = 'wall'; // Track what we hit: 'wall', 'floor', 'ceiling'
		// 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) {
				hitType = 'wall';
				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) {
				hitType = 'wall';
				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) {
				hitType = 'wall';
				break;
			}
		}
		return {
			distance: distance,
			type: hitType
		};
	};
	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
@@ -46,8 +46,12 @@
 		self.angle += self.rotSpeed;
 	};
 	self.checkCollision = function (x, y) {
 		// Use same collision logic as raycasting for consistency
+		// Check wall boundaries first
+		if (x <= 100 || x >= 1948 || y <= 100 || y >= 2632) {
+			return true; // Boundary wall collision
+		}
 		// Add backrooms maze pattern - more complex wall generation
 		var gridX = Math.floor(x / 150);
 		var gridY = Math.floor(y / 150);
 		// Create backrooms-style maze pattern
@@ -62,9 +66,9 @@
 		if (pillarDist < 40) {
 			// Slightly larger collision radius than visual
 			return true; // Pillar collision
 		}
-		return false; // No collision
+		return false; // No collision - clear floor/ceiling space
 	};
 	return self;
 });
 var Renderer3D = Container.expand(function () {
@@ -100,62 +104,79 @@
 		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);
+			var rayResult = self.castRay(player.x, player.y, rayAngle);
+			var distance = rayResult.distance;
+			var surfaceType = rayResult.type;
 			// 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
+			// Update wall column based on surface type
+			if (surfaceType === 'wall') {
+				self.wallColumns[i].visible = true;
+				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;
+			} else {
+				// Hide wall if not hitting a wall surface
+				self.wallColumns[i].visible = false;
+			}
+			// Auto-detect and render floor
 			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
+			self.floorColumns[i].visible = floorY < 2632; // Only show if within screen bounds
+			// Auto-detect and render ceiling
 			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.ceilingColumns[i].visible = ceilY > 0; // Only show if within screen bounds
 		}
 	};
 	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;
+		var hitType = 'wall'; // Track what we hit: 'wall', 'floor', 'ceiling'
 		// 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) {
+				hitType = 'wall';
 				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) {
+				hitType = 'wall';
 				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) {
+				hitType = 'wall';
 				break;
 			}
 		}
-		return distance;
+		return {
+			distance: distance,
+			type: hitType
+		};
 	};
 	return self;
 });