/**** 
* 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 = [];
	self.init = function (floorArea, wallArea, ceilingArea) {
		self.floorArea = floorArea;
		self.wallArea = wallArea;
		self.ceilingArea = ceilingArea;
		// Create pseudo-3D rendering columns in their respective areas
		for (var i = 0; i < 512; i++) {
			// Wall columns in wall area
			var wallCol = self.wallArea.addChild(LK.getAsset('wall', {
				anchorX: 0.5,
				anchorY: 1.0
			}));
			wallCol.x = i * 4;
			wallCol.y = 1366;
			self.wallColumns.push(wallCol);
			// Floor columns in floor area - positioned below walls
			var floorCol = self.floorArea.addChild(LK.getAsset('floorStrip', {
				anchorX: 0.5,
				anchorY: 0.5
			}));
			floorCol.x = i * 4;
			floorCol.y = 2000;
			self.floorColumns.push(floorCol);
			// Ceiling columns in ceiling area - positioned above walls
			var ceilCol = self.ceilingArea.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 in wall area (middle layer)
			self.wallColumns[i].height = wallHeight;
			self.wallColumns[i].y = wallY;
			// Update floor column in floor area (below walls and player)
			var floorY = 1366 + wallHeight / 2 + distance / 10;
			self.floorColumns[i].y = Math.min(2632, floorY);
			self.floorColumns[i].height = Math.max(2, distance / 50);
			// Update ceiling column in ceiling area (above walls and player)
			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 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) {
				break;
			}
		}
		return distance;
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Create separate areas for different pseudo-3D layers
var floorArea = new Container();
var wallArea = new Container();
var ceilingArea = new Container();
// Position areas correctly - floor below, walls middle, ceiling above
floorArea.y = 1366; // Floor area positioned below player level
wallArea.y = 0; // Wall area at player level
ceilingArea.y = -366; // Ceiling area positioned above player level
// Add areas to game in correct order (back to front)
game.addChild(ceilingArea); // Ceiling at back
game.addChild(wallArea); // Walls in middle
game.addChild(floorArea); // Floor at front (closest to player)
// Create player
var player = new Player();
wallArea.addChild(player); // Player exists in wall area
// Create 3D renderer
var renderer3D = new Renderer3D();
renderer3D.init(floorArea, wallArea, ceilingArea);
// 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);
};