/**** 
* Classes
****/
var CrashedLander = Container.expand(function () {
	var self = Container.call(this);
	var crashedLanderGraphics = self.createAsset('crashedlander', 'Crashed Lander', 0.5, 0.5);
	self.destroyAfterOneSecond = function () {
		LK.setTimeout(function () {
			self.destroy();
		}, 1000);
	};
});
var LandedLander = Container.expand(function () {
	var self = Container.call(this);
	var landedLanderGraphics = self.createAsset('landedlander', 'Landed Lander', 0.5, 0.5);
	self.destroyAfterOneSecond = function () {
		LK.setTimeout(function () {
			self.destroy();
		}, 1000);
	};
});
// Thruster class
var Thruster = Container.expand(function () {
	var self = Container.call(this);
	var thrusterGraphics = self.createAsset('thruster', 'Thruster', 0.5, 0.5);
	self.update = function () {
		// Thruster update code here
	};
});
// Lander class
var Lander = Container.expand(function () {
	var self = Container.call(this);
	var landerGraphics = self.createAsset('lander', 'Player Lander', 0.5, 0.5);
	self.speedX = 0;
	self.speedY = 0;
	self.fuel = 500;
	self.isThrusting = false;
	self.isLanding = false;
	self.update = function () {
		if (!self.isLanding) {
			self.x += self.speedX;
			self.y += self.speedY;
			if (self.isThrusting && self.fuel > 0) {
				self.speedY -= 0.2; // Thruster effect
				self.fuel -= 1;
				fuelTxt.setText(Math.round(self.fuel / 500 * 100) + '% Fuel'); // Show fuel as a percentage
			} else {
				self.speedY += 0.05; // Gravity effect
			}
			ySpeedTxt.setText('Y Speed: ' + self.speedY.toFixed(2)); // Update Y Speed display
		}

		// Update thruster position and visibility
		thruster.x = self.x;
		thruster.y = self.y + self.height - 50; // Position thruster 50 pixels above the lander
		thruster.visible = self.isThrusting;
	};
	self.land = function () {
		self.isLanding = true;
		var landedLander = game.addChild(new LandedLander());
		landedLander.x = self.x;
		landedLander.y = self.y;
		landedLander.destroyAfterOneSecond();
		levelManager.incrementLevel();
	};
	self.refuel = function () {
		self.fuel = 500;
		fuelTxt.setText('100% Fuel'); // Show fuel as a percentage when refueled
	};
});
// Platform class
var MovingPlatform = Container.expand(function () {
	var self = Container.call(this);
	var platformGraphics = self.createAsset('platform', 'Landing Platform', 0.5, 0.5);
	self.speedX = 0;
	self.startMoving = function (level) {
		if (level >= 3) {
			self.speedX = 2.8 + (level - 3) * 0.2; // Increase sideways speed by 0.2 for each level above 3
		}
	};
	self.update = function () {
		self.x += self.speedX;
		if (self.x > 1524 || self.x < 524) {
			self.speedX *= -1; // Change direction when hitting screen bounds
		}
	};
	self.checkLanding = function (lander) {
		if (lander.intersects(self)) {
			if (lander.speedY < 2 && lander.x > self.x - self.width / 2 && lander.x < self.x + self.width / 2) {
				return true;
			} else {
				isGameOver = true;
				var crashedLander = game.addChild(new CrashedLander());
				crashedLander.x = lander.x;
				crashedLander.y = lander.y;
				crashedLander.destroyAfterOneSecond();
				if (levelManager.currentLevel <= 2) {
					var crashMessage = new Text2('Slow down cap! Keep Y speed below 2!', {
						size: 100,
						fill: '#ffffff',
						align: 'center'
					});
					crashMessage.anchor.set(0.5, 0.5);
					crashMessage.x = 1024;
					crashMessage.y = 1266;
					game.addChild(crashMessage);
					LK.setTimeout(function () {
						crashMessage.destroy();
					}, 2000);
				}
				if (levelManager.currentLevel <= 2) {
					LK.setTimeout(function () {
						LK.showGameOver();
					}, 2000);
				} else {
					LK.showGameOver();
				}
				return false;
			}
		}
		return false;
	};
});
// Level class
var Level = Container.expand(function () {
	var self = Container.call(this);
	self.currentLevel = 1;
	var levelTxt = new Text2('Level: ' + self.currentLevel, {
		size: 100,
		// Double the size
		fill: "#ffffff"
	});
	levelTxt.anchor.set(0.5, 0);
	LK.gui.top.addChild(levelTxt);
	self.incrementLevel = function () {
		self.currentLevel += 1;
		levelTxt.setText('Level: ' + self.currentLevel);
		platform.startMoving(self.currentLevel);
		isPaused = true;
		pauseTimer = 60;
	};
});
// Asteroid class
var Asteroid = Container.expand(function () {
	var self = Container.call(this);
	var asteroidGraphics = self.createAsset('asteroid', 'Asteroid', 0.5, 0.5);
	self.speedX = Math.random() * 2 - 1; // Random horizontal speed
	self.speedY = Math.random() * 3 + 1; // Random vertical speed
	self.update = function () {
		self.x += self.speedX;
		self.y += self.speedY;

		// Destroy asteroid if it goes off-screen
		if (self.y > 2732 || self.x < 0 || self.x > 2048) {
			self.destroy();
		}
	};
});

/**** 
* Initialize Game
****/
// Stars class
// Center vertically
// Initialize lander
var game = new LK.Game({
	backgroundColor: 0x000000 // Init game with black background
});

/**** 
* Game Code
****/
// Initialize lander
// Stars class
function _typeof(o) {
	"@babel/helpers - typeof";

	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
		return typeof o;
	} : function (o) {
		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
	}, _typeof(o);
}
function _classCallCheck(instance, Constructor) {
	if (!(instance instanceof Constructor)) {
		throw new TypeError("Cannot call a class as a function");
	}
}
function _defineProperties(target, props) {
	for (var i = 0; i < props.length; i++) {
		var descriptor = props[i];
		descriptor.enumerable = descriptor.enumerable || false;
		descriptor.configurable = true;
		if ("value" in descriptor) {
			descriptor.writable = true;
		}
		Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor);
	}
}
function _createClass(Constructor, protoProps, staticProps) {
	if (protoProps) {
		_defineProperties(Constructor.prototype, protoProps);
	}
	if (staticProps) {
		_defineProperties(Constructor, staticProps);
	}
	Object.defineProperty(Constructor, "prototype", {
		writable: false
	});
	return Constructor;
}
function _toPropertyKey(t) {
	var i = _toPrimitive(t, "string");
	return "symbol" == _typeof(i) ? i : String(i);
}
function _toPrimitive(t, r) {
	if ("object" != _typeof(t) || !t) {
		return t;
	}
	var e = t[Symbol.toPrimitive];
	if (void 0 !== e) {
		var i = e.call(t, r || "default");
		if ("object" != _typeof(i)) {
			return i;
		}
		throw new TypeError("@@toPrimitive must return a primitive value.");
	}
	return ("string" === r ? String : Number)(t);
}
function _inherits(subClass, superClass) {
	if (typeof superClass !== "function" && superClass !== null) {
		throw new TypeError("Super expression must either be null or a function");
	}
	subClass.prototype = Object.create(superClass && superClass.prototype, {
		constructor: {
			value: subClass,
			writable: true,
			configurable: true
		}
	});
	Object.defineProperty(subClass, "prototype", {
		writable: false
	});
	if (superClass) {
		_setPrototypeOf(subClass, superClass);
	}
}
function _setPrototypeOf(o, p) {
	_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
		o.__proto__ = p;
		return o;
	};
	return _setPrototypeOf(o, p);
}
function _createSuper(Derived) {
	var hasNativeReflectConstruct = _isNativeReflectConstruct();
	return function _createSuperInternal() {
		var Super = _getPrototypeOf(Derived),
			result;
		if (hasNativeReflectConstruct) {
			var NewTarget = _getPrototypeOf(this).constructor;
			result = Reflect.construct(Super, arguments, NewTarget);
		} else {
			result = Super.apply(this, arguments);
		}
		return _possibleConstructorReturn(this, result);
	};
}
function _possibleConstructorReturn(self, call) {
	if (call && (_typeof(call) === "object" || typeof call === "function")) {
		return call;
	} else if (call !== void 0) {
		throw new TypeError("Derived constructors may only return object or undefined");
	}
	return _assertThisInitialized(self);
}
function _assertThisInitialized(self) {
	if (self === void 0) {
		throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	}
	return self;
}
function _isNativeReflectConstruct() {
	if (typeof Reflect === "undefined" || !Reflect.construct) {
		return false;
	}
	if (Reflect.construct.sham) {
		return false;
	}
	if (typeof Proxy === "function") {
		return true;
	}
	try {
		Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
		return true;
	} catch (e) {
		return false;
	}
}
function _getPrototypeOf(o) {
	_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
		return o.__proto__ || Object.getPrototypeOf(o);
	};
	return _getPrototypeOf(o);
}
var Stars = /*#__PURE__*/function (_Container) {
	_inherits(Stars, _Container);
	var _super = _createSuper(Stars);
	function Stars() {
		var _this;
		_classCallCheck(this, Stars);
		_this = _super.call(this);
		_this.createStars();
		return _this;
	}
	_createClass(Stars, [{
		key: "createStars",
		value: function createStars() {
			for (var i = 0; i < 100; i++) {
				var star = this.addChild(LK.getAsset('star', 'Star', 0.5, 0.5));
				star.x = Math.random() * 2048;
				star.y = Math.random() * 2732;
				star.alpha = Math.random() * 0.5 + 0.5; // Random transparency for twinkling effect
				var randomScale = Math.random() * 0.3 + 0.2; // Random scale for different sizes
				star.scale.x = randomScale;
				star.scale.y = randomScale;
			}
		}
	}]);
	return Stars;
}(Container);
var background = game.addChild(LK.getAsset('background', 'Game Background', 0, 0));
background.x = 1024; // Center horizontally
background.y = 1366;
// Add stars behind the main background
var stars = game.addChild(new Stars());

// Add second background
var secondBackground = game.addChildAt(LK.getAsset('secondBackground', 'Second Game Background', 0.5, 0.5), 0);
secondBackground.width = 2048;
secondBackground.height = 2732;
secondBackground.x = 2048 / 2; // Center horizontally
secondBackground.y = 2732 / 2; // Center vertically
var scoreTxt = new Text2('0', {
	size: 50,
	fill: "#ffffff"
});
scoreTxt.anchor.set(0.5, 0);
//LK.gui.top.addChild(scoreTxt);
var lander = game.addChild(new Lander());
lander.x = 1024; // Start in the middle of the screen horizontally
lander.y = 100; // Start 100 pixels down from the top

// Initialize thruster
var thruster = game.addChild(new Thruster());
thruster.x = lander.x;
thruster.y = lander.y + lander.height + 5; // Position thruster 5 pixels below the lander
// Initialize level manager
var levelManager = game.addChild(new Level());

// Initialize moving platform
var platform = game.addChild(new MovingPlatform());
platform.x = 1024; // Center horizontally
platform.y = 2632; // Place at the bottom

// Game variables
var isGameOver = false;
var isPaused = false;
var pauseTimer = 0;
var score = 0;
var asteroids = [];

// Fuel display text
var fuelTxt = new Text2('100% Fuel', {
	size: 50,
	fill: "#ffffff"
});
fuelTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(fuelTxt);

// Y Speed display text
var ySpeedTxt = new Text2('Y Speed: ' + lander.speedY.toFixed(2), {
	size: 50,
	fill: "#ffffff"
});
ySpeedTxt.anchor.set(1, 0);
ySpeedTxt.y = 50;
LK.gui.topRight.addChild(ySpeedTxt);

// Gravity display text
var gravityTxt = new Text2('Gravity: 1.62', {
	size: 50,
	fill: "#ffffff"
});
gravityTxt.anchor.set(1, 0);
gravityTxt.y = 100;
LK.gui.topRight.addChild(gravityTxt);

// Event listeners
game.on('down', function (obj) {
	lander.isThrusting = true;
});
game.on('up', function (obj) {
	lander.isThrusting = false;
});

// Game tick update
LK.on('tick', function () {
	if (isPaused) {
		lander.visible = false;
		pauseTimer--;
		if (pauseTimer <= 0) {
			isPaused = false;
			lander.visible = true;
		}
		return;
	}
	if (!isGameOver) {
		// Update all asteroids
		asteroids = game.children.filter(function (child) {
			return child instanceof Asteroid;
		});
		lander.update();
		platform.update(); // Update platform position

		// Check for landing
		if (platform.checkLanding(lander)) {
			lander.land();
			score += 1;
			scoreTxt.setText(score.toString());
			lander.refuel();
			lander.x = 1024;
			lander.y = 100;
			lander.speedY = 0;
			lander.isLanding = false;
		}
		// Check for collision with asteroids and game over conditions
		for (var i = 0; i < asteroids.length; i++) {
			if (lander.intersects(asteroids[i])) {
				isGameOver = true;
				LK.showGameOver();
				break;
			}
		}
		// Check if lander is off-screen for game over
		if (lander.y > 2732) {
			isGameOver = true;
			LK.showGameOver();
		}

		// Asteroid spawning
		if (levelManager.currentLevel >= 5 && LK.ticks % (240 - (levelManager.currentLevel - 1) * 20) == 0) {
			// Spawn an asteroid less frequently as levels progress
			var newAsteroid = new Asteroid();
			var safeZoneRadius = 200;
			var landerSpawnX = 1024;
			var minDistanceFromLander;
			do {
				newAsteroid.x = Math.random() * 2048; // Random horizontal start position
				minDistanceFromLander = Math.abs(newAsteroid.x - landerSpawnX);
			} while (minDistanceFromLander <= safeZoneRadius);
			newAsteroid.y = -50; // Start just above the screen
			game.addChild(newAsteroid);
		}

		// Update all asteroids
		asteroids = game.children.filter(function (child) {
			return child instanceof Asteroid;
		});
		for (var i = 0; i < asteroids.length; i++) {
			asteroids[i].update();
		}

		// Check for game over conditions
		if (lander.y > 2732) {
			isGameOver = true;
			LK.showGameOver();
		}
	}
});