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

/**** 
* Classes
****/ 
// Cube class
var Cube = Container.expand(function () {
	var self = Container.call(this);
	// Cube base
	var cubeGfx = self.attachAsset('cube', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	// Arrow overlay
	self.arrowGfx = null;
	// Grid position
	self.gridX = 0;
	self.gridY = 0;
	// Direction index (0:up, 1:down, 2:left, 3:right)
	self.dir = 0;
	// Is this cube currently animating?
	self.isSliding = false;
	// Set direction and update arrow
	self.setDirection = function (dirIdx) {
		self.dir = dirIdx;
		if (self.arrowGfx) self.removeChild(self.arrowGfx);
		var dir = DIRS[dirIdx];
		self.arrowGfx = self.attachAsset(dir.arrow, {
			anchorX: 0.5,
			anchorY: 0.5
		});
		// For left/right, rotate arrow to point correctly
		if (dir.name === 'left') {
			self.arrowGfx.rotation = Math.PI;
		} else if (dir.name === 'up') {
			self.arrowGfx.rotation = -Math.PI / 2;
		} else if (dir.name === 'down') {
			self.arrowGfx.rotation = Math.PI / 2;
		} else {
			self.arrowGfx.rotation = 0;
		}
	};
	// Called when tapped
	self.down = function (x, y, obj) {
		if (self.isSliding) return;
		if (game.isAnimating) return;
		game.trySlideCube(self);
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Cube directions
// Tween for sliding animation
// Arrow assets: 120x60, colored arrows for each direction
// Cube asset: 200x200, white box
// Grid config
var DIRS = [{
	name: 'up',
	dx: 0,
	dy: -1,
	arrow: 'arrow_up',
	rot: 0
}, {
	name: 'down',
	dx: 0,
	dy: 1,
	arrow: 'arrow_down',
	rot: 0
}, {
	name: 'left',
	dx: -1,
	dy: 0,
	arrow: 'arrow_left',
	rot: 0
}, {
	name: 'right',
	dx: 1,
	dy: 0,
	arrow: 'arrow_right',
	rot: 0
}];
var GRID_SIZE = 4;
var CELL_SIZE = 260; // 200px cube + 60px gap
var GRID_ORIGIN_X = Math.floor((2048 - GRID_SIZE * CELL_SIZE) / 2) + CELL_SIZE / 2;
var GRID_ORIGIN_Y = Math.floor((2732 - GRID_SIZE * CELL_SIZE) / 2) + CELL_SIZE / 2;
// Game state
var cubes = []; // 2D array [y][x] of Cube or null
var cubeList = []; // Flat list of all Cube objects
var isAnimating = false;
// Score text
var scoreTxt = new Text2('0', {
	size: 120,
	fill: 0xFFFFFF
});
scoreTxt.anchor.set(0.5, 0);
LK.gui.top.addChild(scoreTxt);
// Helper: get grid cell center position
function gridToPos(gx, gy) {
	return {
		x: GRID_ORIGIN_X + gx * CELL_SIZE,
		y: GRID_ORIGIN_Y + gy * CELL_SIZE
	};
}
// Helper: check if (gx,gy) is inside grid
function inGrid(gx, gy) {
	return gx >= 0 && gx < GRID_SIZE && gy >= 0 && gy < GRID_SIZE;
}
// Helper: update score display
function updateScore() {
	var left = 0;
	for (var y = 0; y < GRID_SIZE; ++y) {
		for (var x = 0; x < GRID_SIZE; ++x) {
			if (cubes[y][x]) left++;
		}
	}
	scoreTxt.setText(left + "");
}
// Try to slide a cube in its direction
game.trySlideCube = function (cube) {
	// All movement disabled
	return;
};
// Build initial puzzle
function buildLevel() {
	// Clear previous
	for (var i = 0; i < cubeList.length; ++i) {
		cubeList[i].destroy();
	}
	cubeList = [];
	cubes = [];
	for (var y = 0; y < GRID_SIZE; ++y) {
		var row = [];
		for (var x = 0; x < GRID_SIZE; ++x) row.push(null);
		cubes.push(row);
	}
	// Example level: 6 cubes, hand-crafted for solvability
	// (Can be randomized in future)
	var levelCubes = [{
		x: 0,
		y: 0,
		dir: 3
	},
	// right
	{
		x: 1,
		y: 0,
		dir: 1
	},
	// down
	{
		x: 2,
		y: 1,
		dir: 2
	},
	// left
	{
		x: 3,
		y: 2,
		dir: 0
	},
	// up
	{
		x: 1,
		y: 3,
		dir: 3
	},
	// right
	{
		x: 2,
		y: 2,
		dir: 1
	} // down
	];
	for (var i = 0; i < levelCubes.length; ++i) {
		var c = levelCubes[i];
		var cube = new Cube();
		cube.gridX = c.x;
		cube.gridY = c.y;
		cube.setDirection(c.dir);
		var pos = gridToPos(c.x, c.y);
		cube.x = pos.x;
		cube.y = pos.y;
		cubes[c.y][c.x] = cube;
		cubeList.push(cube);
		game.addChild(cube);
	}
	updateScore();
}
// Prevent accidental drag
game.move = function (x, y, obj) {};
// No drag
game.down = function (x, y, obj) {};
game.up = function (x, y, obj) {};
// No per-tick logic needed
game.update = function () {};
// Start game
buildLevel();

===================================================================
--- original.js
+++ change.js
@@ -129,67 +129,10 @@
 	scoreTxt.setText(left + "");
 }
 // Try to slide a cube in its direction
 game.trySlideCube = function (cube) {
-	if (isAnimating) return;
-	// Prevent blue (up arrow) cubes from moving
-	if (cube.dir === 0) return;
-	var dir = DIRS[cube.dir];
-	var gx = cube.gridX;
-	var gy = cube.gridY;
-	var nx = gx;
-	var ny = gy;
-	// Move in direction until out of grid or blocked
-	while (true) {
-		var tx = nx + dir.dx;
-		var ty = ny + dir.dy;
-		if (!inGrid(tx, ty)) {
-			// Can slide off grid
-			break;
-		}
-		if (cubes[ty][tx]) {
-			// Blocked
-			return;
-		}
-		nx = tx;
-		ny = ty;
-	}
-	// Animate slide
-	isAnimating = true;
-	cube.isSliding = true;
-	cubes[cube.gridY][cube.gridX] = null;
-	var targetPos = gridToPos(nx, ny);
-	// If sliding off grid, move further in direction
-	if (!inGrid(nx + dir.dx, ny + dir.dy)) {
-		targetPos.x += dir.dx * CELL_SIZE;
-		targetPos.y += dir.dy * CELL_SIZE;
-	}
-	tween(cube, {
-		x: targetPos.x,
-		y: targetPos.y
-	}, {
-		duration: 250 + 80 * (Math.abs(nx - cube.gridX) + Math.abs(ny - cube.gridY)),
-		easing: tween.cubicOut,
-		onFinish: function onFinish() {
-			// If off grid, remove
-			if (!inGrid(nx, ny)) {
-				cube.destroy();
-				var idx = cubeList.indexOf(cube);
-				if (idx !== -1) cubeList.splice(idx, 1);
-			} else {
-				cubes[ny][nx] = cube;
-				cube.gridX = nx;
-				cube.gridY = ny;
-			}
-			cube.isSliding = false;
-			isAnimating = false;
-			updateScore();
-			// Win check
-			if (cubeList.length === 0) {
-				LK.showYouWin();
-			}
-		}
-	});
+	// All movement disabled
+	return;
 };
 // Build initial puzzle
 function buildLevel() {
 	// Clear previous