/**** 
* Classes
****/ 
var Character = Container.expand(function () {
	var self = Container.call(this);
	var characterGraphics = self.attachAsset('character', {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.row = 0;
	self.col = 0;
	self.previousRow = 0;
	self.previousCol = 0;
	self.moveToTile = function (tile) {
		self.previousRow = self.row;
		self.previousCol = self.col;
		self.x = tile.x;
		self.y = tile.y;
		self.row = tile.row;
		self.col = tile.col;
		LK.getSound('move').play();
	};
	self.returnToPreviousPosition = function () {
		if (hexGrid[self.previousRow] && hexGrid[self.previousRow][self.previousCol]) {
			var previousTile = hexGrid[self.previousRow][self.previousCol];
			self.x = previousTile.x;
			self.y = previousTile.y;
			self.row = self.previousRow;
			self.col = self.previousCol;
			LK.getSound('move').play();
		}
	};
	return self;
});
var HexTile = Container.expand(function (type, row, col) {
	var self = Container.call(this);
	self.type = type;
	self.row = row;
	self.col = col;
	self.hasBuilding = false;
	self.building = null;
	var assetName = 'hexGrass';
	if (type === 'barn') assetName = 'hexRed';else if (type === 'well') assetName = 'hexBlue';else if (type === 'orchard') assetName = 'hexPurple';else if (type === 'wheat') assetName = 'hexYellow';else if (type === 'stable') assetName = 'hexBrown';
	var hexGraphics = self.attachAsset(assetName, {
		anchorX: 0.5,
		anchorY: 0.5
	});
	self.addBuilding = function () {
		if (self.hasBuilding || self.type === 'grass') return false;
		var buildingAsset = null;
		var points = 0;
		if (self.type === 'barn') {
			buildingAsset = 'barn';
			points = 15;
		} else if (self.type === 'well') {
			buildingAsset = 'well';
			points = 10;
		} else if (self.type === 'orchard') {
			buildingAsset = 'orchard';
			points = 20;
		} else if (self.type === 'wheat') {
			buildingAsset = 'wheat';
			points = 12;
		} else if (self.type === 'stable') {
			buildingAsset = 'stable';
			points = 18;
		}
		if (buildingAsset) {
			self.building = self.attachAsset(buildingAsset, {
				anchorX: 0.5,
				anchorY: 0.5
			});
			self.hasBuilding = true;
			LK.getSound('build').play();
			return points;
		}
		return 0;
	};
	self.removeBuilding = function () {
		if (self.hasBuilding && self.building) {
			self.building.destroy();
			self.building = null;
			self.hasBuilding = false;
		}
	};
	return self;
});

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

/**** 
* Game Code
****/ 
// Game state
var currentTurn = 1;
var maxTurns = 20;
var score = 0;
var character = null;
var hexGrid = [];
var selectedTile = null;
var gameStarted = false;
var hasMovedThisTurn = false;
var lastTurnBuilding = null; // Track building created this turn
var lastTurnPoints = 0; // Track points gained this turn
// Game history for proper undo functionality
var gameHistory = [];
// Hex grid dimensions
var gridWidth = 8;
var gridHeight = 12;
var hexSize = 120;
var hexHeight = 104;
// UI elements
var turnText = new Text2('Turn: 1/20', {
	size: 60,
	fill: 0x000000
});
turnText.anchor.set(0.5, 0);
LK.gui.top.addChild(turnText);
var scoreText = new Text2('Score: 0', {
	size: 60,
	fill: 0x000000
});
scoreText.anchor.set(0, 0);
LK.gui.topRight.addChild(scoreText);
scoreText.x = -300;
var buildButton = new Text2('BUILD', {
	size: 50,
	fill: 0xFFFFFF
});
buildButton.anchor.set(0.5, 1);
LK.gui.bottom.addChild(buildButton);
buildButton.y = -50;
var returnButton = new Text2('RETURN', {
	size: 50,
	fill: 0xFFFFFF
});
returnButton.anchor.set(0.5, 1);
LK.gui.bottom.addChild(returnButton);
returnButton.y = -120;
// Create hex grid
function createHexGrid() {
	var startX = 200;
	var startY = 300;
	for (var row = 0; row < gridHeight; row++) {
		hexGrid[row] = [];
		for (var col = 0; col < gridWidth; col++) {
			var xOffset = row % 2 * (hexSize * 0.75);
			var x = startX + col * (hexSize * 1.5) + xOffset;
			var y = startY + row * (hexHeight * 0.75);
			// Skip if position would be off screen
			if (x > 1900 || y > 2400) continue;
			var tileType = 'grass';
			// Add special tiles randomly
			if (Math.random() < 0.2) {
				var specialTypes = ['barn', 'well', 'orchard', 'wheat', 'stable'];
				tileType = specialTypes[Math.floor(Math.random() * specialTypes.length)];
			}
			var tile = new HexTile(tileType, row, col);
			tile.x = x;
			tile.y = y;
			hexGrid[row][col] = tile;
			game.addChild(tile);
		}
	}
}
// Get adjacent tiles
function getAdjacentTiles(row, col) {
	var adjacent = [];
	var directions;
	if (row % 2 === 0) {
		directions = [[-1, -1], [-1, 0], [0, -1], [0, 1], [1, -1], [1, 0]];
	} else {
		directions = [[-1, 0], [-1, 1], [0, -1], [0, 1], [1, 0], [1, 1]];
	}
	for (var i = 0; i < directions.length; i++) {
		var newRow = row + directions[i][0];
		var newCol = col + directions[i][1];
		if (newRow >= 0 && newRow < gridHeight && newCol >= 0 && newCol < gridWidth && hexGrid[newRow] && hexGrid[newRow][newCol]) {
			adjacent.push(hexGrid[newRow][newCol]);
		}
	}
	return adjacent;
}
// Initialize game
function initGame() {
	createHexGrid();
	// Collect all available tiles
	var availableTiles = [];
	for (var row = 0; row < gridHeight; row++) {
		for (var col = 0; col < gridWidth; col++) {
			if (hexGrid[row] && hexGrid[row][col]) {
				availableTiles.push(hexGrid[row][col]);
			}
		}
	}
	// Place character on random available tile
	if (availableTiles.length > 0) {
		var randomIndex = Math.floor(Math.random() * availableTiles.length);
		var randomTile = availableTiles[randomIndex];
		character = new Character();
		character.moveToTile(randomTile);
		game.addChild(character);
		gameStarted = true;
	}
}
// Save current game state to history
function saveGameState() {
	var currentState = {
		turn: currentTurn,
		score: score,
		characterRow: character.row,
		characterCol: character.col,
		buildings: []
	};
	// Save all buildings in the grid
	for (var row = 0; row < gridHeight; row++) {
		for (var col = 0; col < gridWidth; col++) {
			if (hexGrid[row] && hexGrid[row][col] && hexGrid[row][col].hasBuilding) {
				currentState.buildings.push({
					row: row,
					col: col,
					type: hexGrid[row][col].type
				});
			}
		}
	}
	// Keep only the last two states - add current state and limit to 2 entries
	gameHistory.push(currentState);
	if (gameHistory.length > 2) {
		gameHistory.shift(); // Remove oldest state if we have more than 2
	}
}
// Update UI
function updateUI() {
	turnText.setText('Turn: ' + currentTurn + '/' + maxTurns);
	scoreText.setText('Score: ' + score);
}
// Check if character can move to tile
function canMoveTo(tile) {
	var adjacents = getAdjacentTiles(character.row, character.col);
	return adjacents.indexOf(tile) !== -1;
}
// End turn
function endTurn() {
	// Save state before incrementing turn to capture previous turn state
	saveGameState();
	currentTurn++;
	selectedTile = null;
	hasMovedThisTurn = false;
	lastTurnBuilding = null; // Reset building tracking
	lastTurnPoints = 0; // Reset points tracking
	if (character) {
		character.previousRow = character.row;
		character.previousCol = character.col;
	}
	if (currentTurn > maxTurns) {
		LK.setScore(score);
		LK.showYouWin();
		return;
	}
	updateUI();
}
// Handle tile clicks
game.down = function (x, y, obj) {
	if (!gameStarted || hasMovedThisTurn) return;
	// Check if clicking on a hex tile
	for (var row = 0; row < gridHeight; row++) {
		for (var col = 0; col < gridWidth; col++) {
			if (hexGrid[row] && hexGrid[row][col]) {
				var tile = hexGrid[row][col];
				var distance = Math.sqrt(Math.pow(x - tile.x, 2) + Math.pow(y - tile.y, 2));
				if (distance < 60) {
					if (canMoveTo(tile)) {
						character.moveToTile(tile);
						selectedTile = tile;
						hasMovedThisTurn = true;
						endTurn();
					}
					return;
				}
			}
		}
	}
};
// Build button handler
buildButton.down = function (x, y, obj) {
	if (!gameStarted) return;
	var currentTile = null;
	for (var row = 0; row < gridHeight; row++) {
		for (var col = 0; col < gridWidth; col++) {
			if (hexGrid[row] && hexGrid[row][col] && hexGrid[row][col].row === character.row && hexGrid[row][col].col === character.col) {
				currentTile = hexGrid[row][col];
				break;
			}
		}
	}
	if (currentTile && currentTile.type !== 'grass' && !currentTile.hasBuilding) {
		var points = currentTile.addBuilding();
		if (points > 0) {
			score += points;
			lastTurnBuilding = currentTile; // Track building created this turn
			lastTurnPoints = points; // Track points gained this turn
			updateUI();
		}
	}
};
// Return button handler
returnButton.down = function (x, y, obj) {
	if (!gameStarted || currentTurn <= 1 || gameHistory.length < 2) return;
	// Get the second most recent saved state (skip the most recent one)
	var lastState = gameHistory[gameHistory.length - 2];
	// Remove both the most recent and second most recent states from history
	gameHistory.pop();
	gameHistory.pop();
	// Remove all current buildings
	for (var row = 0; row < gridHeight; row++) {
		for (var col = 0; col < gridWidth; col++) {
			if (hexGrid[row] && hexGrid[row][col] && hexGrid[row][col].hasBuilding) {
				hexGrid[row][col].removeBuilding();
			}
		}
	}
	// Restore game state
	currentTurn = lastState.turn;
	score = lastState.score;
	// Move character back to previous position
	if (hexGrid[lastState.characterRow] && hexGrid[lastState.characterRow][lastState.characterCol]) {
		var previousTile = hexGrid[lastState.characterRow][lastState.characterCol];
		character.x = previousTile.x;
		character.y = previousTile.y;
		character.row = lastState.characterRow;
		character.col = lastState.characterCol;
	}
	// Restore buildings
	for (var i = 0; i < lastState.buildings.length; i++) {
		var building = lastState.buildings[i];
		if (hexGrid[building.row] && hexGrid[building.row][building.col]) {
			hexGrid[building.row][building.col].addBuilding();
		}
	}
	selectedTile = null;
	hasMovedThisTurn = false;
	lastTurnBuilding = null;
	lastTurnPoints = 0;
	updateUI();
};
// Initialize the game
initGame();
updateUI();

===================================================================
--- original.js
+++ change.js
@@ -310,13 +310,14 @@
 	}
 };
 // Return button handler
 returnButton.down = function (x, y, obj) {
-	if (!gameStarted || currentTurn <= 1 || gameHistory.length === 0) return;
-	// Get the most recent saved state
-	var lastState = gameHistory[gameHistory.length - 1];
-	// Remove the most recent state from history
+	if (!gameStarted || currentTurn <= 1 || gameHistory.length < 2) return;
+	// Get the second most recent saved state (skip the most recent one)
+	var lastState = gameHistory[gameHistory.length - 2];
+	// Remove both the most recent and second most recent states from history
 	gameHistory.pop();
+	gameHistory.pop();
 	// Remove all current buildings
 	for (var row = 0; row < gridHeight; row++) {
 		for (var col = 0; col < gridWidth; col++) {
 			if (hexGrid[row] && hexGrid[row][col] && hexGrid[row][col].hasBuilding) {