===================================================================
--- original.js
+++ change.js
@@ -1470,37 +1470,159 @@
 
 /**** 
 * Game Code
 ****/
-// Start a new countdown from 10 seconds before the game begins
+// SagaMap class
 // Dragon spawn timer
 // Goal gem type and count
 // Initialize large countdown at the beginning of the game
 // Initialize score
 // Initialize 2-minute timer
 // Initialize a timer for showing hints
-var countdownFrom = 10;
-var countdownText = new Text2(countdownFrom.toString(), {
-	size: 300,
-	fill: "#ffffff",
-	x: 1024,
-	// Center of the screen
-	y: 1366,
-	// Middle of the screen
-	anchorX: 0.5,
-	anchorY: 0.5
-});
-LK.gui.center.addChild(countdownText);
-var countdownInterval = LK.setInterval(function () {
-	countdownFrom--;
-	if (countdownFrom >= 0) {
-		countdownText.setText(countdownFrom.toString());
-	} else {
-		LK.clearInterval(countdownInterval);
-		countdownText.destroy();
-		// Start the game logic here
+function _typeof2(o) {
+	"@babel/helpers - typeof";
+	return _typeof2 = "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;
+	}, _typeof2(o);
+}
+function _classCallCheck(instance, Constructor) {
+	if (!(instance instanceof Constructor)) {
+		throw new TypeError("Cannot call a class as a function");
 	}
-}, 1000);
+}
+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, _toPropertyKey2(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 _toPropertyKey2(t) {
+	var i = _toPrimitive2(t, "string");
+	return "symbol" == _typeof2(i) ? i : String(i);
+}
+function _toPrimitive2(t, r) {
+	if ("object" != _typeof2(t) || !t) {
+		return t;
+	}
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof2(i)) {
+			return i;
+		}
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+function _callSuper(t, o, e) {
+	return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+}
+function _possibleConstructorReturn(self, call) {
+	if (call && (_typeof2(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() {
+	try {
+		var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+	} catch (t) {}
+	return (_isNativeReflectConstruct = function _isNativeReflectConstruct() {
+		return !!t;
+	})();
+}
+function _getPrototypeOf(o) {
+	_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+		return o.__proto__ || Object.getPrototypeOf(o);
+	};
+	return _getPrototypeOf(o);
+}
+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);
+}
+var SagaMap = /*#__PURE__*/function (_Container) {
+	_inherits(SagaMap, _Container);
+	function SagaMap() {
+		var _this;
+		_classCallCheck(this, SagaMap);
+		_this = _callSuper(this, SagaMap);
+		_this.levels = [];
+		_this.currentLevel = 0;
+		return _this;
+	}
+	_createClass(SagaMap, [{
+		key: "addLevel",
+		value: function addLevel(level) {
+			this.levels.push(level);
+		}
+	}, {
+		key: "goToLevel",
+		value: function goToLevel(index) {
+			this.currentLevel = index;
+			// Logic to switch to the specified level
+			console.log('Switching to level:', index);
+		}
+	}, {
+		key: "nextLevel",
+		value: function nextLevel() {
+			if (this.currentLevel < this.levels.length - 1) {
+				this.goToLevel(this.currentLevel + 1);
+			} else {
+				console.log('No more levels!');
+			}
+		}
+	}]);
+	return SagaMap;
+}(Container);
 var dragonSpawnTimer;
 var isDragoning = false;
 function triggerDragon() {
 	if (dragonSpawnTimer) {
@@ -1724,8 +1846,11 @@
 	}
 }, 1000); // Update countdown every second
 game.timer = 120; // 2 minutes in seconds
 // Implement a three second delay before starting the timer text interval
+LK.setTimeout(function () {
+	// Timer control is now handled inside the modal display logic to pause during the modal display.
+}, 3000);
 var score = 0; // Starting score
 var scoreBg;
 var scoreBgNode = LK.getAsset('scoreBg', {
 	x: 1024 - 150,