/**** 
* Plugins
****/ 
var tween = LK.import("@upit/tween.v1");

/**** 
* Classes
****/ 
// Coin class
var Coin = Container.expand(function () {
	var self = Container.call(this);
	var coinAsset = self.attachAsset('coinCircle', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lane = 1;
	self.speed = 0;
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
// Obstacle class (trains, barriers)
var Obstacle = Container.expand(function () {
	var self = Container.call(this);
	// Asset will be attached in spawnObstacle based on type/size
	self.obsAsset = null;
	self.lane = 1;
	self.type = 'barrier'; // or 'train'
	self.size = 'double'; // default, can be 'single' or 'double'
	self.speed = 0; // set by game
	self.attachCorrectAsset = function () {
		if (self.obsAsset) {
			self.removeChild(self.obsAsset);
		}
		if (self.size === 'single') {
			self.obsAsset = self.attachAsset('obstacleSingle', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		} else {
			self.obsAsset = self.attachAsset('obstacleBox', {
				anchorX: 0.5,
				anchorY: 0.5
			});
		}
	};
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
// Powerup class
var Powerup = Container.expand(function () {
	var self = Container.call(this);
	var powerupAsset = self.attachAsset('powerupStar', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.lane = 1;
	self.speed = 0;
	self.kind = 'invincible'; // or 'magnet'
	self.update = function () {
		self.y += self.speed;
	};
	return self;
});
// Player character class
var Runner = Container.expand(function () {
	var self = Container.call(this);
	// Attach two runner assets for animation
	var runnerAsset1 = self.attachAsset('runnerBox', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	var runnerAsset2 = self.attachAsset('runnerBox2', {
		anchorX: 0.5,
		anchorY: 0.5,
		visible: false
	});
	// Lane index: 0 (left), 1 (center), 2 (right)
	self.lane = 1;
	self.y = 0; // Will be set by game
	self.isJumping = false;
	self.jumpStartY = 0;
	self.jumpTime = 0;
	self.jumpDuration = 32; // frames (about 0.5s)
	self.jumpHeight = 320; // px
	// Animation state
	self.animFrame = 0;
	self.animInterval = 16; // frames between switching (slower animation)
	self.animTick = 0;
	// Move to lane (with tween)
	self.moveToLane = function (laneIdx) {
		self.lane = laneIdx;
		var targetX = laneX(laneIdx);
		tween(self, {
			x: targetX
		}, {
			duration: 120,
			easing: tween.cubicOut
		});
	};
	// Start jump
	self.jump = function () {
		if (self.isJumping) return;
		self.isJumping = true;
		self.jumpStartY = self.y;
		self.jumpTime = 0;
	};
	// Update per frame
	self.update = function () {
		// Animation: alternate visible asset every animInterval frames
		self.animTick++;
		if (self.animTick >= self.animInterval) {
			self.animTick = 0;
			self.animFrame = 1 - self.animFrame;
			runnerAsset1.visible = self.animFrame === 0;
			runnerAsset2.visible = self.animFrame === 1;
		}
		if (self.isJumping) {
			self.jumpTime++;
			// Simple parabolic jump
			var t = self.jumpTime / self.jumpDuration;
			if (t > 1) t = 1;
			var jumpOffset = -4 * self.jumpHeight * t * (t - 1);
			self.y = runnerY() + jumpOffset;
			if (self.jumpTime >= self.jumpDuration) {
				self.isJumping = false;
				self.y = runnerY();
			}
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// TODO: Replace NEW_ASSET_ID_FOR_SINGLE with your new asset id
// Rail images for 3 lanes (tiled vertically for better appearance)
var rails = [];
var railAssetNames = ['railLeft', 'railCenter', 'railRight'];
var railTileHeight = 400; // Use a reasonable tile height for the rail image
var railImageHeight = LK.getAsset(railAssetNames[0], {
	anchorX: 0.5,
	anchorY: 0
}).height;
var railImageWidth = LK.getAsset(railAssetNames[0], {
	anchorX: 0.5,
	anchorY: 0
}).width;
var railTilesCount = Math.ceil(2732 / railTileHeight) + 1;
for (var i = 0; i < 3; i++) {
	rails[i] = [];
	for (var t = 0; t < railTilesCount; t++) {
		var rail = LK.getAsset(railAssetNames[i], {
			anchorX: 0.5,
			anchorY: 0,
			x: laneX(i),
			y: t * railTileHeight,
			width: railImageWidth,
			height: railTileHeight
		});
		rails[i].push(rail);
		game.addChild(rail);
	}
}
// --- Lane positions ---
function laneX(idx) {
	// 3 lanes, centered, with 320px between centers
	var center = 2048 / 2;
	return center + (idx - 1) * 320;
}
function runnerY() {
	// Place runner near bottom, but above bottom edge
	return 2732 - 420;
}
// --- Game state ---
var runner;
var obstacles = [];
var coins = [];
var powerups = [];
var score = 0;
var coinScore = 0;
var speed = 10; // px per frame, much slower start, increases over time
var ticks = 0;
var invincibleTicks = 0;
var magnetTicks = 0;
var lastSwipeX = null;
var lastSwipeY = null;
var swipeStartX = null;
var swipeStartY = null;
var swipeStartTime = null;
var isGameOver = false;
// --- Score display ---
var scoreTxt = new Text2('0', {
	size: 120,
	fill: "#fff"
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// --- Coin display ---
var coinTxt = new Text2('0', {
	size: 80,
	fill: 0xF7D038
});
coinTxt.anchor.set(0, 0);
LK.gui.topRight.addChild(coinTxt);
// --- Powerup display ---
var powerupTxt = new Text2('', {
	size: 60,
	fill: 0x83DE44
});
powerupTxt.anchor.set(1, 0);
LK.gui.topRight.addChild(powerupTxt);
// --- Initialize runner ---
runner = new Runner();
runner.x = laneX(1);
runner.y = runnerY();
game.addChild(runner);
// --- Touch/Swipe controls ---
game.down = function (x, y, obj) {
	swipeStartX = x;
	swipeStartY = y;
	swipeStartTime = LK.ticks;
	lastSwipeX = x;
	lastSwipeY = y;
};
game.move = function (x, y, obj) {
	if (swipeStartX === null) return;
	var dx = x - swipeStartX;
	var dy = y - swipeStartY;
	var absDx = Math.abs(dx);
	var absDy = Math.abs(dy);
	var swipeThreshold = 120;
	var swipeTime = LK.ticks - swipeStartTime;
	if (swipeTime > 36) {
		// Too slow, reset
		swipeStartX = null;
		swipeStartY = null;
		return;
	}
	if (absDx > absDy && absDx > swipeThreshold) {
		// Horizontal swipe
		if (dx > 0 && runner.lane < 2) {
			runner.moveToLane(runner.lane + 1);
		} else if (dx < 0 && runner.lane > 0) {
			runner.moveToLane(runner.lane - 1);
		}
		swipeStartX = null;
		swipeStartY = null;
	} else if (absDy > absDx && dy < -swipeThreshold) {
		// Upward swipe (jump)
		runner.jump();
		swipeStartX = null;
		swipeStartY = null;
	}
};
game.up = function (x, y, obj) {
	swipeStartX = null;
	swipeStartY = null;
};
// --- Helper: spawn obstacle ---
function spawnObstacle() {
	var obs = new Obstacle();
	obs.lane = Math.floor(Math.random() * 3);
	obs.x = laneX(obs.lane);
	obs.y = -120;
	obs.type = Math.random() < 0.7 ? 'barrier' : 'train';
	obs.speed = speed;
	// Only spawn double obstacles for barriers, never single
	obs.size = 'double';
	obs.attachCorrectAsset();
	// Only spawn double obstacles for barriers, never single
	if (obs.type === 'barrier') {
		obs.size = 'double';
	} else {
		obs.size = 'double'; // trains always double (or you can add logic for single train if needed)
	}
	obs.attachCorrectAsset();
	// For trains, make them taller
	if (obs.type === 'train') {
		obs.height = 320;
		obs.width = 200;
		obs.getChildAt(0).height = 320;
		obs.getChildAt(0).width = 200;
	}
	obstacles.push(obs);
	game.addChild(obs);
}
// --- Helper: spawn coin ---
function spawnCoin() {
	var coin = new Coin();
	coin.lane = Math.floor(Math.random() * 3);
	coin.x = laneX(coin.lane);
	coin.y = -80;
	coin.speed = speed;
	coins.push(coin);
	game.addChild(coin);
}
// --- Helper: spawn powerup ---
function spawnPowerup() {
	var powerup = new Powerup();
	powerup.lane = Math.floor(Math.random() * 3);
	powerup.x = laneX(powerup.lane);
	powerup.y = -100;
	powerup.speed = speed;
	powerup.kind = Math.random() < 0.5 ? 'invincible' : 'magnet';
	powerups.push(powerup);
	game.addChild(powerup);
}
// --- Main update loop ---
game.update = function () {
	if (isGameOver) return;
	ticks++;
	// Increase speed over time
	// Old: every 180 ticks, +1.2, max 38
	// New: every 180 ticks, +0.6, max 38 (so it takes twice as long to reach max speed)
	if (ticks % 180 === 0 && speed < 38) {
		speed += 0.6;
	}
	// Update runner
	runner.update();
	// Update powerup timers
	if (invincibleTicks > 0) {
		invincibleTicks--;
		powerupTxt.setText("INVINCIBLE");
	} else if (magnetTicks > 0) {
		magnetTicks--;
		powerupTxt.setText("MAGNET");
	} else {
		powerupTxt.setText("");
	}
	// Spawn obstacles
	// 25% more obstacles: reduce interval by 25%
	if (ticks % Math.max(36, Math.floor((120 - speed * 2) * 0.75)) === 0) {
		spawnObstacle();
	}
	// Spawn coins
	if (ticks % 36 === 0) {
		spawnCoin();
	}
	// Spawn powerups
	if (ticks % 420 === 0) {
		spawnPowerup();
	}
	// --- Update obstacles ---
	for (var i = obstacles.length - 1; i >= 0; i--) {
		var obs = obstacles[i];
		obs.speed = speed;
		obs.update();
		// Remove if off screen
		if (obs.y > 2732 + 200) {
			obs.destroy();
			obstacles.splice(i, 1);
			continue;
		}
		// Collision with runner
		var collides = false;
		if (obs.lane === runner.lane) {
			// If runner is jumping, only collide with trains (tall obstacles)
			if (obs.type === 'train') {
				// Trains are tall, can hit in air
				if (Math.abs(obs.y - runner.y) < 180) {
					collides = true;
				}
			} else {
				// Barriers: only if runner is not jumping
				if (!runner.isJumping && Math.abs(obs.y - runner.y) < 160) {
					collides = true;
				}
			}
		}
		if (collides && invincibleTicks === 0) {
			// Game over
			LK.effects.flashScreen(0xff0000, 800);
			isGameOver = true;
			LK.setScore(score);
			LK.showGameOver();
			return;
		}
	}
	// --- Update coins ---
	for (var j = coins.length - 1; j >= 0; j--) {
		var coin = coins[j];
		coin.speed = speed;
		coin.update();
		// Remove if off screen
		if (coin.y > 2732 + 100) {
			coin.destroy();
			coins.splice(j, 1);
			continue;
		}
		// Collect coin
		var collect = false;
		if (magnetTicks > 0) {
			// Magnet: collect if in any lane and close
			if (Math.abs(coin.y - runner.y) < 220) {
				collect = true;
			}
		} else {
			if (coin.lane === runner.lane && Math.abs(coin.y - runner.y) < 120) {
				collect = true;
			}
		}
		if (collect) {
			coinScore++;
			score += 10;
			coinTxt.setText(coinScore);
			scoreTxt.setText(score);
			coin.destroy();
			coins.splice(j, 1);
		}
	}
	// --- Update powerups ---
	for (var k = powerups.length - 1; k >= 0; k--) {
		var p = powerups[k];
		p.speed = speed;
		p.update();
		// Remove if off screen
		if (p.y > 2732 + 120) {
			p.destroy();
			powerups.splice(k, 1);
			continue;
		}
		// Collect powerup
		var collectP = false;
		if (p.lane === runner.lane && Math.abs(p.y - runner.y) < 140) {
			collectP = true;
		}
		if (collectP) {
			if (p.kind === 'invincible') {
				invincibleTicks = 180; // 3 seconds
				LK.effects.flashObject(runner, 0x83de44, 800);
			} else if (p.kind === 'magnet') {
				magnetTicks = 240; // 4 seconds
				LK.effects.flashObject(runner, 0xf7d038, 800);
			}
			p.destroy();
			powerups.splice(k, 1);
		}
	}
	// --- Score increases over time ---
	if (ticks % 12 === 0) {
		score++;
		scoreTxt.setText(score);
	}
};
// --- Reset state on game over ---
game.on('destroy', function () {
	// Clean up arrays
	for (var i = 0; i < obstacles.length; i++) obstacles[i].destroy();
	for (var j = 0; j < coins.length; j++) coins[j].destroy();
	for (var k = 0; k < powerups.length; k++) powerups[k].destroy();
	obstacles = [];
	coins = [];
	powerups = [];
	isGameOver = false;
	score = 0;
	coinScore = 0;
	speed = 18;
	ticks = 0;
	invincibleTicks = 0;
	magnetTicks = 0;
	scoreTxt.setText('0');
	coinTxt.setText('0');
	powerupTxt.setText('');
});

===================================================================
--- original.js
+++ change.js
@@ -22,16 +22,30 @@
 });
 // Obstacle class (trains, barriers)
 var Obstacle = Container.expand(function () {
 	var self = Container.call(this);
-	// Attach obstacle asset (box for now)
-	var obsAsset = self.attachAsset('obstacleBox', {
-		anchorX: 0.5,
-		anchorY: 0.5
-	});
+	// Asset will be attached in spawnObstacle based on type/size
+	self.obsAsset = null;
 	self.lane = 1;
 	self.type = 'barrier'; // or 'train'
+	self.size = 'double'; // default, can be 'single' or 'double'
 	self.speed = 0; // set by game
+	self.attachCorrectAsset = function () {
+		if (self.obsAsset) {
+			self.removeChild(self.obsAsset);
+		}
+		if (self.size === 'single') {
+			self.obsAsset = self.attachAsset('obstacleSingle', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		} else {
+			self.obsAsset = self.attachAsset('obstacleBox', {
+				anchorX: 0.5,
+				anchorY: 0.5
+			});
+		}
+	};
 	self.update = function () {
 		self.y += self.speed;
 	};
 	return self;
@@ -129,8 +143,9 @@
 
 /**** 
 * Game Code
 ****/ 
+// TODO: Replace NEW_ASSET_ID_FOR_SINGLE with your new asset id
 // Rail images for 3 lanes (tiled vertically for better appearance)
 var rails = [];
 var railAssetNames = ['railLeft', 'railCenter', 'railRight'];
 var railTileHeight = 400; // Use a reasonable tile height for the rail image
@@ -260,8 +275,18 @@
 	obs.x = laneX(obs.lane);
 	obs.y = -120;
 	obs.type = Math.random() < 0.7 ? 'barrier' : 'train';
 	obs.speed = speed;
+	// Only spawn double obstacles for barriers, never single
+	obs.size = 'double';
+	obs.attachCorrectAsset();
+	// Only spawn double obstacles for barriers, never single
+	if (obs.type === 'barrier') {
+		obs.size = 'double';
+	} else {
+		obs.size = 'double'; // trains always double (or you can add logic for single train if needed)
+	}
+	obs.attachCorrectAsset();
 	// For trains, make them taller
 	if (obs.type === 'train') {
 		obs.height = 320;
 		obs.width = 200;