===================================================================
--- original.js
+++ change.js
@@ -140,8 +140,9 @@
 
 /**** 
 * Initialize Game
 ****/
+// Stars class
 // Center vertically
 // Initialize lander
 var game = new LK.Game({
 	backgroundColor: 0x000000 // Init game with black background
@@ -149,14 +150,172 @@
 
 /**** 
 * Game Code
 ****/
+// Stars class
 // Initialize lander
+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
+			}
+		}
+	}]);
+	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.addChildAt(new Stars(), 0);
+
 // Add second background
-var secondBackground = game.addChildAt(LK.getAsset('secondBackground', 'Second Game Background', 0.5, 0.5), 0);
+var secondBackground = game.addChildAt(LK.getAsset('secondBackground', 'Second Game Background', 0.5, 0.5), 1);
 secondBackground.width = 2048;
 secondBackground.height = 2732;
 secondBackground.x = 2048 / 2; // Center horizontally
 secondBackground.y = 2732 / 2; // Center vertically