/**** * Classes ****/ var ActionItemIcon = Container.expand(function (action, x, y) { var self = Container.call(this); self.action = action; self.asset = self.attachAsset(action.icon, { anchorX: 0.5, anchorY: 0.5, x: x, y: y, width: 200, height: 200 }); self.asset.on('down', function () { if (self.action && typeof self.action.handler === 'function') { currentSelection.selectedAction = self.action.code; if (self.action.noTarget) { self.action.handler(currentSelection); highlightBorder(self.asset.x); LK.setTimeout(function () { highlightBorder(); }, 1000); } else { currentUserActionState = UserActionState.SET_ORDER_TARGET; //console.log('Wait target for action ' + self.action.name); if (!targetMoveCursor) { targetMoveCursor = game.addChild(new TargetMoveCursor()); } highlightBorder(self.asset.x); } } else { currentSelection.selectedAction = null; } }); self.label = new Text2(action.name, { size: 30, fill: '#000000', font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); self.label.x = self.asset.x - action.name.length / 2 * 13; self.label.y = self.asset.y + 120; self.addChild(self.label); return self; }); var ActionRepository = Container.expand(function () { var self = Container.call(this); self.actions = { 'harvest': { 'code': 'harvest', 'name': 'Harvest', 'icon': 'harvestIcon', 'handler': harvestActionLogic }, 'move': { 'code': 'move', 'name': 'Move', 'icon': 'moveIcon', 'handler': moveActionLogic }, 'return': { 'code': 'return', 'noTarget': true, 'name': 'Retreat', 'icon': 'returnIcon', 'handler': retreatActionLogic }, 'attack': { 'code': 'attack', 'name': 'Attack', 'icon': 'attackIcon', 'handler': attackActionLogic } }; self.getActionInfo = function (actionType) { return self.actions[actionType]; }; return self; }); var BuildableItemIcon = Container.expand(function (type, x, y, sourceFactory) { var self = Container.call(this); self.type = type; self.progressDisplay = null; self.sourceFactory = sourceFactory; self.asset = self.attachAsset(type, { anchorX: 0.5, anchorY: 0.5, x: x, y: y, width: 200, height: 200 }); self.asset.on('down', function () { if (!self.asset.interactive) { //console.log("BuildableItemIcon : Not interactive. ignore"); return; } else { //console.log("BuildableItemIcon : Is interactive. continue"); } if (currentBuildingForPlacement) { currentUserActionState = UserActionState.PLACING_BUILDINGS; //console.log("BuildableItemIcon : User is placing ", currentBuildingForPlacement); game.addChild(currentBuildingForPlacement); return; } else { //console.log("BuildableItemIcon : No current building for placement. ignore"); } if (!self.progressDisplay) { //console.log("BuildableItemIcon : No progress display => create one"); self.progressDisplay = new BuildingProgressDisplay(self); } else { //console.log("BuildableItemIcon : Progress display already exists"); } self.progressDisplay.show(); game.addChild(self.progressDisplay); enqueueBuildable(self.type, self.sourceFactory, player1, self.progressDisplay); game.children.forEach(function (child) { if (child instanceof BuildableItemIcon) { child.alpha = 0.75; } }); }); var buildableInfo = buildableRepository.getBuildableInfo(type); if (buildableInfo) { self.label = new Text2(buildableInfo.name, { size: 30, fill: '#000000', font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); self.label.x = self.asset.x - (buildableInfo.name ? buildableInfo.name.length / 2 * 13 : 0); self.label.y = self.asset.y + 120; self.addChild(self.label); } self.setLabelToPlace = function () { self.label.setText('Place'); self.label.x = self.asset.x - 38; // Recalculate x position for new text }; self.restoreLabel = function () { self.label.setText(buildableInfo.name); self.label.x = self.asset.x - buildableInfo.name.length / 2 * 13; // Recalculate x position for new text }; // Restore progress display from global queue return self; }); // BuildableRepository class to store reference information about all buildables var BuildableRepository = Container.expand(function () { var self = Container.call(this); self.buildables = { 'constructionYard': { 'name': 'Construction Yard', 'cost': 300, 'energy': 0, 'health': 100, 'constructionTime': 10, 'className': 'ConstructionYard', 'buildable': ['windTrap', 'spiceRefinery', 'lightFactory', 'heavyFactory'] }, 'windTrap': { 'name': 'Wind Trap', 'cost': 300, 'energy': 100, 'health': 50, 'constructionTime': 5, 'className': 'WindTrap', 'buildable': [] }, 'spiceRefinery': { 'name': 'Spice Refinery', 'cost': 600, 'energy': -50, 'health': 75, 'constructionTime': 15, 'className': 'SpiceRefinery', 'buildable': [] }, 'lightFactory': { 'name': 'Light Factory', 'cost': 400, 'energy': -30, 'health': 60, 'constructionTime': 15, 'className': 'LightFactory', 'buildable': ['unitQuad'], 'requires': 'spiceRefinery' }, 'heavyFactory': { 'name': 'Heavy Factory', 'cost': 600, 'energy': -50, 'health': 80, 'constructionTime': 20, 'className': 'HeavyFactory', 'buildable': ['unitLightTank', 'unitHeavyTank', 'unitHarvester'], 'requires': 'lightFactory' }, 'unitQuad': { 'name': 'Quad', 'cost': 200, 'energy': 0, 'constructionTime': 5, 'className': 'UnitQuad', 'buildable': [] }, 'unitLightTank': { 'name': 'Light Tank', 'cost': 400, 'energy': 0, 'constructionTime': 8, 'className': 'UnitLightTank', 'buildable': [] }, 'unitHeavyTank': { 'name': 'Heavy Tank', 'cost': 600, 'energy': 0, 'constructionTime': 15, 'className': 'UnitHeavyTank', 'buildable': [] }, 'unitHarvester': { 'name': 'Harvester', 'cost': 500, 'energy': 0, 'constructionTime': 12, 'className': 'UnitHarvester', 'buildable': [] } // Add more buildables as needed }; self.getBuildableInfo = function (type) { return self.buildables[type]; }; return self; }); // Base Building class var Building = Container.expand(function (x, y, type, name, playerId, cellW, cellH, buildable) { var self = Container.call(this); self.cellX = x; self.cellY = y; self.cellW = cellW || 1; // Default to 1x1 if not specified self.cellH = cellH || 1; // Default to 1x1 if not specified self.x = x * tileSize; self.y = y * tileSize; self.type = type; self.isBuilding = true; self.playerId = playerId; self.id = getNextId(); self.name = name; var buildableInfo = buildableRepository.getBuildableInfo(type); self.health = buildableInfo.health; self.buildable = buildable || []; // New property to store what the building can build self.asset = self.attachAsset(type, { anchorX: 0.5, anchorY: 0.5 }); self.asset.x = self.x; self.asset.y = self.y; self.buildingQueue = []; self.lastAttackTime = 0; self.lastHitTime = 0; self.lastAttaker = null; self.defenders = []; self.damage = function (attacker) { //console.log("Building " + self.name + " hit! " + attacker.attackDamage); self.lastAttaker = attacker; self.health -= attacker.attackDamage; self.lastHitTime = Date.now(); self.asset.tint = 0xff0000; LK.setTimeout(function () { self.asset.tint = 0xFFFFFF; }, 500); if (self.health <= 0) { //console.log("Building " + self.name + " destroyed"); self.clean(); self.assetEffect = self.attachAsset('buildingExplosion', { anchorX: 0.5, anchorY: 0.5, x: self.x + self.cellW / 2 * tileSize, y: self.y + self.cellH / 2 * tileSize, width: 20, height: 20 }); var growExplosion = function growExplosion(size) { if (size < 300) { self.assetEffect.width = size; self.assetEffect.height = size; LK.setTimeout(function () { growExplosion(size + 3); }, 10); } else { // Remove building from gameMap cells and game for (var w = 0; w < self.cellW; w++) { for (var h = 0; h < self.cellH; h++) { if (gameMap.cells[self.cellX + w] && gameMap.cells[self.cellX + w][self.cellY + h]) { gameMap.cells[self.cellX + w][self.cellY + h].building = null; } } } //console.log("update selection destroyed ", currentSelection, self, currentSelection == self); if (currentSelection && currentSelection == self) { currentSelection = null; selectionMarker.setOnElement(); } // Remove building from player's list of buildings if (self.playerId === player1.playerId) { player1.buildings = player1.buildings.filter(function (building) { return building !== self; }); } else if (self.playerId === player2.playerId) { player2.buildings = player2.buildings.filter(function (building) { return building !== self; }); } game.removeChild(self); self.destroy(); updateActionBoard(); checkGameEnd(); } }; growExplosion(1); } LK.setTimeout(function () { if (self.health > 0 && Date.now() - self.lastHitTime > aiUnderAttackDelayMs) { // Not under attack anymore self.lastAttaker = null; self.defenders = []; } }, aiUnderAttackDelayMs * 1.1); }; self.clean = function () { self.buildingQueue = []; self.lastAttackTime = 0; self.lastHitTime = 0; self.lastAttaker = null; self.defenders = []; }; return self; }); var WindTrap = Building.expand(function (x, y, playerId) { var self = Building.call(this, x, y, 'windTrap', 'Wind Trap', playerId, 2, 2); // Additional properties and methods for WindTrap can be added here return self; }); var SpiceRefinery = Building.expand(function (x, y, playerId) { var self = Building.call(this, x, y, 'spiceRefinery', 'Spice Refinery', playerId, 3, 2); // Additional properties and methods for SpiceRefinery can be added here return self; }); // LightFactory class to represent the Light Factory building var LightFactory = Building.expand(function (x, y, playerId) { var self = Building.call(this, x, y, 'lightFactory', 'Light Factory', playerId, 2, 2, buildableRepository.getBuildableInfo('lightFactory').buildable); // Additional properties and methods for LightFactory can be added here return self; }); // HeavyFactory class to represent the Heavy Factory building var HeavyFactory = Building.expand(function (x, y, playerId) { var self = Building.call(this, x, y, 'heavyFactory', 'Heavy Factory', playerId, 3, 2, buildableRepository.getBuildableInfo('heavyFactory').buildable); // Additional properties and methods for HeavyFactory can be added here return self; }); var ConstructionYard = Building.expand(function (x, y, playerId) { var self = Building.call(this, x, y, 'constructionYard', 'Construction Yard', playerId, 2, 2, buildableRepository.getBuildableInfo('constructionYard').buildable); // Additional properties and methods for ConstructionYard can be added here return self; }); var BuildingProgressDisplay = Container.expand(function (parentIcon) { var self = Container.call(this); self.blinkRed = function () { self.progressAsset.tint = 0xFF0000; // Set progress display color to red self.setProgress(1); self.progressAsset.alpha = 0.5; // Make it fully visible self.visible = true; // Ensure it's visible self.blinkInterval = LK.setInterval(function () { self.progressAsset.alpha = self.progressAsset.alpha > 0 ? 0 : 0.5; }, 250); // Blink effect LK.setTimeout(function () { if (self.blinkInterval) { LK.clearInterval(self.blinkInterval); self.progressAsset.alpha = 0.5; self.progressAsset.tint = 0x00FF00; self.hide(); } }, 1500); // Blink effect }; self.parentIcon = parentIcon; self.progressAsset = self.attachAsset('buildingProgress', { anchorX: 0, anchorY: .5, alpha: 0.5, width: 0, tint: 0x00FF00, x: parentIcon.asset.x - parentIcon.asset.width / 2, y: parentIcon.asset.y }); self.setProgress = function (progress) { self.progressAsset.width = parentIcon.asset.width * progress; }; self.hide = function () { self.progressAsset.width = 0; self.visible = false; }; self.show = function () { self.visible = true; }; return self; }); var CancelActionButton = Container.expand(function (x, y) { var self = Container.call(this); self.asset = self.attachAsset('cancelAction', { anchorX: 0.5, anchorY: 0.5, x: x, y: y }); // Add a label 'Cancel' below the cancel action button self.label = new Text2('Cancel', { size: 30, fill: '#000000', font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); self.label.x = self.asset.x - 40; self.label.y = self.asset.y + 120; self.addChild(self.label); self.asset.on('down', function () { // Cancel current building if (!currentBuildingForPlacement) { // Browse the currentSelection.buildingQueue if (currentSelection && currentSelection.buildingQueue.length > 0) { // Check for non null buildable and stop it's constructionTimer for (var i = 0; i < currentSelection.buildingQueue.length; i++) { if (currentSelection.buildingQueue[i] && currentSelection.buildingQueue[i].constructionTimer) { //console.log("Stop constructionTimer on ", currentSelection.buildingQueue[i]); var initialCost = buildableRepository.getBuildableInfo(currentSelection.buildingQueue[i].type).cost; var initialTime = buildableRepository.getBuildableInfo(currentSelection.buildingQueue[i].type).constructionTime; //console.log("constructionProgress = ", currentSelection.buildingQueue[i].constructionProgress); player1.spice += initialCost * currentSelection.buildingQueue[i].constructionProgress * initialTime / 100; updateBaseInfo(); LK.clearInterval(currentSelection.buildingQueue[i].constructionTimer); currentSelection.buildingQueue[i].constructionTimer = null; currentSelection.buildingQueue[i].progressDisplay.hide(); game.children.forEach(function (child) { if (child instanceof BuildableItemIcon) { child.asset.interactive = true; child.alpha = 1.0; } }); } } } self.visible = false; // Hide the CancelActionButton } // Cancel current placement if (currentBuildingForPlacement) { player1.spice += buildableRepository.getBuildableInfo(currentBuildingForPlacement.type).cost; updateBaseInfo(); currentBuildingForPlacement.destroy(); currentBuildingForPlacement = null; currentUserActionState = UserActionState.NAVIGATING; self.visible = false; // Hide the CancelActionButton } // Cancel Order if (currentUserActionState === UserActionState.SET_ORDER_TARGET) { currentUserActionState = UserActionState.NAVIGATING; self.visible = false; // Hide the CancelActionButton } // Restore labels on all BuildableItemIcon instances game.children.forEach(function (child) { if (child instanceof BuildableItemIcon) { child.restoreLabel(); } }); //console.log('Cancel action button pressed and building placement cancelled.'); }); return self; }); // Command Panel class var CommandPanel = Container.expand(function () { var self = Container.call(this); self.graphics = self.attachAsset('boardBackground', { width: game.width, height: game.height * 0.22, color: 0x333333 }); // Set the center box position to the center of the screen self.x = game.width / 2 - self.graphics.width / 2; self.y = game.height - self.height + game.height * 0.01; }); var IconBorder = Container.expand(function (x, y) { var self = Container.call(this); self.asset = self.attachAsset('iconBorder', { anchorX: 0.5, anchorY: 0.5, x: x, y: y }); return self; }); // Initialize game elements // Map class to represent the grid-based map system var Map = Container.expand(function () { var self = Container.call(this); // Method to clear spice from a specified cell self.clearCellSpice = function (x, y) { if (self.cells[x] && self.cells[x][y]) { self.cells[x][y].spice = false; if (self.cells[x][y].spiceAsset) { self.cells[x][y].spiceAsset.destroy(); self.cells[x][y].spiceAsset = null; } // Update spiceSpots array spiceSpots = spiceSpots.filter(function (spot) { return spot.x !== x || spot.y !== y; }); } }; self.cells = []; self.init = function (width, height) { for (var x = 0; x < width; x++) { self.cells[x] = []; for (var y = 0; y < height; y++) { // Initialize each cell with default terrain, height, resources self.cells[x][y] = { height: 0, resources: null, terrain: null, asset: null, building: null, spiceAsset: null }; } } }; self.initTerrain = function (width, height) { for (var x = 0; x < width; x++) { for (var y = 0; y < height; y++) { // Initialize each cell with default terrain, height, resources self.cells[x][y].terrain = globalTerrain[x][y] === 1 ? 'rock' : 'sand'; self.cells[x][y].asset = globalTerrain[x][y] === 1 ? new Rock(x, y) : new Sand(x, y); } } }; self.currentViewCenter = { x: 15, y: 20 }; // Create a Text2 object to display the currentViewCenter coordinates self.viewCenterText = new Text2('', { size: 50, fill: '#ffffff', align: 'center' }); // Position the text at the top center of the screen LK.gui.top.addChild(self.viewCenterText); self.render = function () { self.removeChildren(); // Move tiles instead of the view for (var x = viewPort.wCellX; x < viewPort.wCellX + viewPort.cellW; x++) { for (var y = viewPort.wCellY; y < viewPort.wCellY + viewPort.cellH; y++) { if (x >= 0 && x < self.cells.length && y >= 0 && y < self.cells[x].length) { var cell = self.cells[x][y]; var asset = cell.asset; var screenCoord = worldCellToScreenCoord(x, y); var screenX = screenCoord.x; var screenY = screenCoord.y; asset.x = screenX; asset.y = screenY; if (!asset.parent) { self.addChild(asset); } // Render spice terrain if (cell.spice) { var spiceAsset = cell.spiceAsset; spiceAsset.x = screenX; spiceAsset.y = screenY; if (!spiceAsset.parent) { self.addChild(spiceAsset); } } // Render buildings var building = cell.building; if (building) { if (building.playerId === player2.playerId) { building.asset.visible = !cell.fog; } building.asset.x = screenX - (building.cellW - 2) / 2 * tileSize; building.asset.y = screenY - (building.cellH - 2) / 2 * tileSize; self.addChild(building.asset); if (building.assetEffect) { self.addChild(building.assetEffect); } } if (cell.fog) { var fogAsset = cell.fogAsset; fogAsset.x = screenX - 1; fogAsset.y = screenY - 1; if (!fogAsset.parent) { self.addChild(fogAsset); } } } } } }; self.getNavigationMesh = function () { // Create and return the navigation mesh for pathfinding }; self.findPath = function (start, end, range, ignoreSpecificBuilding) { range = range || 0; if (range == 13) { //console.log("findPath ", start, end, range); } // A* pathfinding algorithm implementation // Avoid buildings by checking if the cell is occupied var openSet = []; var closedSet = []; var path = []; var startNode = { x: start.x, y: start.y, f: 0, g: 0, h: 0, parent: null }; var endNode = { x: end.x, y: end.y, f: 0, g: 0, h: 0, parent: null }; openSet.push(startNode); while (openSet.length > 0) { var lowestIndex = 0; for (var i = 0; i < openSet.length; i++) { if (openSet[i].f < openSet[lowestIndex].f) { lowestIndex = i; } } var currentNode = openSet[lowestIndex]; var dx = currentNode.x - endNode.x; var dy = currentNode.y - endNode.y; if (Math.sqrt(dx * dx + dy * dy) <= range) { if (range == 13) { //console.log("findPath Ok Within range :", currentNode.x, currentNode.y + " / dist=" + Math.sqrt(dx * dx + dy * dy)); } var curr = currentNode; while (curr.parent) { var prev = curr.parent; if (prev) { // Calculate relative move var moveX = curr.x - prev.x; var moveY = curr.y - prev.y; //console.log("Pushing : " + moveX, ',', moveY); path.push({ cellX: moveX, cellY: moveY }); } curr = curr.parent; } path.reverse(); if (range == 13) { //console.log("Return path 1", path); } return path; } openSet.splice(lowestIndex, 1); closedSet.push(currentNode); var neighbors = getNeighbors(currentNode); for (i = 0; i < neighbors.length; i++) { var neighbor = neighbors[i]; if (closedSet.findIndex(function (node) { return node.x === neighbor.x && node.y === neighbor.y; }) !== -1 || self.cells[neighbor.x][neighbor.y].building && !ignoreSpecificBuilding || self.cells[neighbor.x][neighbor.y].unit) { continue; } var gScore = currentNode.g + 1; // 1 is the distance from a node to a neighbor var gScoreIsBest = false; if (openSet.findIndex(function (node) { return node.x === neighbor.x && node.y === neighbor.y; }) === -1) { gScoreIsBest = true; neighbor.h = heuristic(neighbor, endNode); openSet.push(neighbor); } else if (gScore < neighbor.g) { gScoreIsBest = true; } if (gScoreIsBest) { neighbor.parent = currentNode; neighbor.g = gScore; neighbor.f = neighbor.g + neighbor.h; } } } // If the openSet is empty but we haven't reached the destination, return the path to the closest node if (openSet.length === 0) { var closestNode = closedSet.reduce(function (prev, curr) { var prevDistance = heuristic(prev, endNode); var currDistance = heuristic(curr, endNode); return prevDistance < currDistance ? prev : curr; }); var dx = closestNode.x - endNode.x; var dy = closestNode.y - endNode.y; if (Math.sqrt(dx * dx + dy * dy) <= range) { var curr = closestNode; while (curr.parent) { var prev = curr.parent; if (prev) { var moveX = curr.x - prev.x; var moveY = curr.y - prev.y; path.push({ cellX: moveX, cellY: moveY }); } curr = curr.parent; } path.reverse(); } } //console.log("Return best effort path", path); return path; }; function heuristic(node, endNode) { // Use Manhattan distance as heuristic return Math.abs(node.x - endNode.x) + Math.abs(node.y - endNode.y); } function getNeighbors(node) { // Get all valid neighbors (up, down, left, right) var neighbors = []; var directions = [{ x: -1, y: 0 }, { x: 1, y: 0 }, { x: 0, y: -1 }, { x: 0, y: 1 }, { x: -1, y: -1 }, { x: -1, y: 1 }, { x: 1, y: -1 }, { x: 1, y: 1 }]; directions.forEach(function (dir) { var newX = node.x + dir.x; var newY = node.y + dir.y; if (newX >= 0 && newX < self.cells.length && newY >= 0 && newY < self.cells[0].length) { neighbors.push({ x: newX, y: newY }); } }); return neighbors; } self.lastInputPosition = null; self.handleDrag = function (input) { viewPort.wCellX = Math.max(0, Math.min(mapXSize - viewPort.cellW, viewPort.wCellX + input.x)); viewPort.wCellY = Math.max(0, Math.min(mapYSize - viewPort.cellH, viewPort.wCellY + input.y)); viewPort.wX = viewPort.wCellX * tileSize; viewPort.wY = viewPort.wCellY * tileSize; // Update the Text2 object with the new coordinates //self.viewCenterText.setText(viewPort.wCellX + ',' + viewPort.wCellY); }; self.checkCollisions = function () { // Handle collisions between units and obstacles }; self.serialize = function () { // Serialize map data to a file }; self.load = function (data) { // Load map data from a file }; }); var Player = Container.expand(function (playerId, tint) { var self = Container.call(this); self.playerId = playerId; self.resources = 0; self.tint = tint; self.spice = 2000; // Initial player spice self.energy = 0; // Initialize player-specific properties here self.buildings = []; // Array to store all the player's buildings self.units = []; // Array to store all the player's units self.isCurrentlyBuilding = false; self.isCurrentlyBuildingUnit = false; // ... self.addUnit = function (unit) { // Add the unit to the player's units array self.units.push(unit); // Update any unit-related properties or behaviors // ... }; self.addBuilding = function (building) { // Add the building to the player's buildings array self.buildings.push(building); // Update the energy production based on the new building self.updateEnergy(); // If the building can produce or store resources, update those as well // ... (additional resource management code can be added here) }; self.updateEnergy = function () { var counter = 0; // Iterate through all buildings owned by the player self.buildings.forEach(function (building) { // Sum the energy provided by the building var buildingInfo = buildableRepository.getBuildableInfo(building.type); //console.log("Count energy of " + buildingInfo.name); var buildingInfo = buildableRepository.getBuildableInfo(building.type); counter = Math.min(Math.max(counter + buildingInfo.energy, 0), 100); }); self.energy = counter; //console.log("Player " + self.playerId + " energy updated: " + self.energy); }; return self; }); var Rock = Container.expand(function (x, y) { var self = Container.call(this); self.asset = LK.getAsset('rock', { x: x * 100, y: y * 100 }); // Pre-create the asset for this cell return self.asset; }); var Sand = Container.expand(function (x, y) { var self = Container.call(this); self.asset = LK.getAsset('sand', { x: x * 100, y: y * 100 }); // Pre-create the asset for this cell return self.asset; }); var SelectionMarker = Container.expand(function () { var self = Container.call(this); self.selectionCross = self.attachAsset('selectionCross', { anchorX: 0.5, anchorY: 0.5, alpha: 1 }); self.selectionCircle = self.attachAsset('selectionCircle', { anchorX: 0.5, anchorY: 0.5, alpha: 0 }); self.alpha = 0.5; self.visible = false; // Initially, we display the selectionCross self.addChild(self.selectionCross); self.currentElement = null; self.setOnElement = function (element) { //console.log('SelectionMarker setOnElement:', element); self.currentElement = element; if (!element || element.health <= 0) { self.visible = false; updateActionBoard(); return; } var elementDeltaX = 0; var elementDeltaY = 0; if (element.isBuilding) { elementDeltaX = element.cellW / 2 * tileSize; elementDeltaY = element.cellH / 2 * tileSize; self.selectionCross.alpha = 1; self.selectionCircle.alpha = 0; } if (element.isUnit) { elementDeltaX = tileSize / 2; elementDeltaY = tileSize / 2; self.selectionCross.alpha = 0; self.selectionCircle.alpha = 0.9; } var eltCoord = worldCellToScreenCell(element.cellX, element.cellY); self.x = eltCoord.cellX * tileSize + elementDeltaX; self.y = eltCoord.cellY * tileSize + elementDeltaY; //console.log("setOnElement => " + element.x + ',' + element.y, ' => ' + self.x + ',' + self.y); if (self.y > mapHeight) { self.visible = false; } else { self.visible = true; } }; self.hide = function () { //console.log('SelectionMarker hidden'); self.visible = false; }; return self; }); var TargetMoveCursor = Container.expand(function () { var self = Container.call(this); self.asset = self.attachAsset('targetMoveCursor', { anchorX: 0.5, anchorY: 0.5 }); self.updatePosition = function (position) { self.x = position.x; self.y = position.y; }; game.on('move', function (obj) { if (currentUserActionState != UserActionState.SET_ORDER_TARGET) { return; } //console.log("moving cursor"); var pos = obj.event.getLocalPosition(game); if (pos.y > game.height * 0.80) { self.visible = false; } else { self.visible = true; self.updatePosition(pos); } }); return self; }); var Unit = Container.expand(function (cellX, cellY, playerId, type) { var self = Container.call(this); self.playerId = playerId; self.type = type; self.isUnit = true; self.id = getNextId(); var unitInfo = unitRepository.getUnitInfo(type); self.name = unitInfo.name; self.health = unitInfo.health; // Range for attacking self.isDestroyed = false; self.isDestroying = false; self.sightRange = unitInfo.sightRange; self.attackRange = unitInfo.attackRange; // Range for attacking self.attackDamage = unitInfo.attackDamage; self.attackSpeed = unitInfo.attackSpeed; // Speed of attack (time between attacks) self.attackMode = 0; // 0 = not attacking, 1 = attacking, 2 = moving to target self.lastAttackTime = 0; self.lastHitTime = 0; self.lastAttaker = null; self.isArmy = false; self.defenders = []; self.actions = unitInfo.actions; self.asset = self.attachAsset(type, { anchorX: 0.5, anchorY: 0.5, tint: getPlayerTint(playerId) }); self.speed = 200; // Set the unit speed self.cellX = cellX; self.cellY = cellY; var screenCoord = worldCellToScreenCoord(cellX, cellY); self.x = screenCoord.x; self.y = screenCoord.y; self.cellW = 1; self.cellH = 1; //console.log("clear onArrivedCallback 0"); self.onArrivedCallback = null; //console.log("New unit " + self.name + ' at ', self.x, ',', self.y, ' [' + self.cellX + ',' + self.cellY + ']'); self.asset.on('down', function () { if (currentUserActionState === UserActionState.NAVIGATING || currentUserActionState === UserActionState.GIVING_ORDERS) { //console.log("Unit selected"); currentSelection = self; // Update map to fix unselectable units gameMap.cells[self.cellX][self.cellY].unit = self; selectionMarker.setOnElement(currentSelection); currentUserActionState = UserActionState.GIVING_ORDERS; updateActionBoard(); } else { //console.log("Not Navigating don't select unit...", currentUserActionState); } }); self.moveAlongPath = function (path, callback) { if (self.isArmy) { //console.log("Army " + self.type + " #" + self.id + " moveAlongPath", path, callback); } self.path = path; self.pathIndex = 0; self.isMoving = true; self.onArrivedCallback = callback; }; self.updateMovement = function (delta) { if (!self.isMoving || self.isDestroying) { //console.log("Not isMoving", self.isMoving, self.isDestroying); if (self.y > mapHeight) { self.visible = false; } else { self.visible = true; } return; } if (!self.path || self.pathIndex >= self.path.length) { //console.log("updateMovement will stop ", self.path, self.pathIndex, self.onArrivedCallback); self.isMoving = false; if (self.onArrivedCallback) { //console.log("updateMovement call onArrivedCallback 1"); self.onArrivedCallback(); //console.log("clear onArrivedCallback 1"); self.onArrivedCallback = null; } return; } var targetPathStep = self.path[self.pathIndex]; var targetCell = { cellX: self.cellX + targetPathStep.cellX, cellY: self.cellY + targetPathStep.cellY }; var targetCoords = worldCellToScreenCoord(targetCell.cellX, targetCell.cellY); var dx = targetCoords.x + tileSize / 2 - self.x; var dy = targetCoords.y + tileSize / 2 - self.y; var distance = Math.sqrt(dx * dx + dy * dy); var step = self.speed * delta; if (distance < step) { //console.log("updateMovement reached step"); self.x = targetCoords.x + tileSize / 2; self.y = targetCoords.y + tileSize / 2; if (self.y > mapHeight) { self.visible = false; } else { self.visible = true; } // Update map gameMap.cells[self.cellX][self.cellY].unit = null; self.cellX = targetCell.cellX; self.cellY = targetCell.cellY; // Update map gameMap.cells[self.cellX][self.cellY].unit = self; if (self.playerId == player1.playerId) { updateFogOfWar(); } self.pathIndex++; if (self.pathIndex >= self.path.length) { self.isMoving = false; if (self.onArrivedCallback) { //console.log("updateMovement call onArrivedCallback 2", self.onArrivedCallback); self.onArrivedCallback(); self.onArrivedCallback = null; } else { //console.log("No onArrivedCallback", self, self.onArrivedCallback); } } else { //console.log("Not self.pathIndex >= self.path.length", self.pathIndex >= self.path.length, self.pathIndex, self.path.length); } } else { var angle = Math.atan2(dy, dx); self.asset.rotation = angle - Math.PI / 2; self.x += Math.cos(angle) * step; self.y += Math.sin(angle) * step; if (self.y > mapHeight) { self.visible = false; } else { self.visible = true; } } if (selectionMarker.currentElement == self) { selectionMarker.setOnElement(self); } }; self.handleDrag = function () { // OK var newCoord = worldCellToScreenCoord(self.cellX, self.cellY); self.x = newCoord.x + tileSize / 2; self.y = newCoord.y + tileSize / 2; }; self.guard = function () { //console.log("Guard area"); var enemies = []; var allTargets = this.playerId === player1.playerId ? player2.buildings.concat(player2.units) : player1.buildings.concat(player1.units); allTargets.forEach(function (target) { if (target.health > 0) { var distance = calculateDistance(self, target); if (distance <= self.sightRange) { enemies.push(target); } } }); if (enemies.length > 0) { //console.log(enemies.length + " enemies spotted."); self.startAttack(enemies[0]); // Start attacking the first enemy spotted } }; self.attackTarget = null; // Target unit to attack self.startAttack = function (target) { self.attackTarget = target; self.attackMode = 1; self.lastAttackTime = 0; }; self.update = function () { if (self.attackMode && self.attackTarget && self.attackTarget.health > 0 && !self.attackTarget.destroyed) { // Wait for attack speed before firing again if (Date.now() - self.lastAttackTime < self.attackSpeed * 1000) { return; } self.lastAttackTime = Date.now(); // Check if target is in range var distanceToTarget = calculateDistance(self, self.attackTarget); if (distanceToTarget <= self.attackRange) { //console.log(self.playerId + " - " + self.type + " : Target at range => fire"); // Rotate towards the target var angleToTarget = calculateAngle(self, self.attackTarget); self.asset.rotation = angleToTarget; // Fire at the target self.fire(); } else { //console.log(self.playerId + " - " + self.type + " : Target too far => move to target"); self.attackMode = 2; // Move towards the target if it's out of range var path = gameMap.findPath({ x: self.cellX, y: self.cellY }, { x: self.attackTarget.cellX, y: self.attackTarget.cellY }, self.attackRange); //console.log("Path to target:", path); self.moveAlongPath(path, function () { //console.log("Reached to target !"); self.attackMode = 1; }); } } else if (!self.isMoving) { self.guard(); } }; self.fire = function () { // Code to perform firing action //console.log("Firing at target!", self.attackTarget); if (self.attackTarget && self.health > 0) { // Reduce target's health self.attackTarget.damage(self); if (!self.attackTarget || self.attackTarget.health <= 0) { self.attackMode = 0; self.attackTarget = null; } } }; self.damage = function (attacker) { //console.log("Unit " + self.name + " hit! ", attacker); self.asset.tint = 0xff0000; self.lastAttaker = attacker; self.lastHitTime = Date.now(); LK.setTimeout(function () { self.asset.tint = getPlayerTint(self.playerId); }, 300); self.health -= attacker.attackDamage; if (self.health <= 0 && !self.isDestroying) { self.isDestroying = true; //console.log("Unit " + self.name + " destroyed"); self.clean(); self.assetEffect = self.attachAsset('buildingExplosion', { anchorX: 0.5, anchorY: 0.5, x: self.x, y: self.y, width: 10, height: 10 }); var growExplosion = function growExplosion(size) { if (size < 150) { self.assetEffect.width = size; self.assetEffect.height = size; LK.setTimeout(function () { growExplosion(size + 3); }, 5); } else { // Remove building from gameMap cells and game //console.log("unit destruction..."); gameMap.cells[self.cellX][self.cellY].unit = null; game.removeChild(self); if (self.assetEffect) { game.removeChild(self.assetEffect); self.assetEffect.destroy(); } // Remove the unit from the player's units array var playerUnits = self.playerId === player1.playerId ? player1.units : player2.units; var unitIndex = playerUnits.indexOf(self); if (unitIndex !== -1) { playerUnits.splice(unitIndex, 1); } self.destroy(); self.isDestroyed = true; if (currentUserActionState === UserActionState.SET_ORDER_TARGET && currentSelection == self) { currentSelection = null; currentUserActionState = UserActionState.NAVIGATING; if (cancelActionBtn) { cancelActionBtn.visible = false; } } updateActionBoard(); } }; growExplosion(1); } LK.setTimeout(function () { if (self.health > 0 && Date.now() - self.lastHitTime > aiUnderAttackDelayMs) { // Not under attack anymore self.lastAttaker = null; self.defenders = []; } }, aiUnderAttackDelayMs * 1.1); }; self.stopAttack = function () { self.attackMode = false; self.attackTarget = null; }; self.stopOtherActions = function () { //console.log("Unit stopOtherActions :"); self.attackMode = false; // Stop attacking }; self.clean = function () { self.lastAttackTime = 0; self.lastHitTime = 0; self.lastAttaker = null; self.defenders = []; }; return self; }); var UnitQuad = Unit.expand(function (x, y, playerId) { var self = Unit.call(this, x, y, playerId, 'unitQuad'); // Additional properties and methods for UnitQuad can be added here return self; }); var UnitLightTank = Unit.expand(function (x, y, playerId) { var self = Unit.call(this, x, y, playerId, 'unitLightTank'); // Additional properties and methods for UnitLightTank can be added here return self; }); var UnitHeavyTank = Unit.expand(function (x, y, playerId) { var self = Unit.call(this, x, y, playerId, 'unitHeavyTank'); // Additional properties and methods for UnitHeavyTank can be added here return self; }); var UnitHarvester = Unit.expand(function (x, y, playerId) { var self = Unit.call(this, x, y, playerId, 'unitHarvester'); self.harvestedSpiceCapacity = 600; self.harvestedSpiceOnTripCounter = 0; self.harvestedSpiceOnCellCounter = 0; self.harvestingMode = 0; // 0 : Idle / 1 : harvesting / 2 : returning / 3 : unload self.harvestSpeed = 0.3; // Adjust this value to control the speed of harvesting self.unloadSpeed = 0.4; // Adjust this value to control the speed of harvesting self.setHarvesting = function () { //console.log("Ok at site setHarvesting..."); self.harvestingMode = 1; }; self.startHarvesting = function (alternate) { //console.log("startHarvesting..."); self.harvestingMode = 0; var deltaX = 0; var deltaY = 0; if (alternate) { //console.log("search alternate spot..."); deltaX = -1 + Math.floor(Math.random() * 3); deltaY = -1 + Math.floor(Math.random() * 3); } var closestSpiceSpot = findClosestSpiceSpot(self.cellX + deltaX, self.cellY + deltaY); if (closestSpiceSpot) { //console.log("closestSpiceSpot :", closestSpiceSpot); var path = gameMap.findPath({ x: self.cellX, y: self.cellY }, { x: closestSpiceSpot.x, y: closestSpiceSpot.y }); if (!path || path.length == 0) { console.warn(self.playerId + " - No path to spot! ", " pos:", self.cellX, ",", self.cellY, " Found:", closestSpiceSpot, ". Retry later"); console.warn("Destination contains :", gameMap.cells[closestSpiceSpot.x][closestSpiceSpot.y]); LK.setTimeout(function () { self.startHarvesting(true); }, 1000); return; } self.moveAlongPath(path); //self.setHarvesting //console.log("Ok at site setHarvesting..."); self.harvestingMode = 1; } else { console.warn("No spice found! retry later"); // Try again later LK.setTimeout(function () { self.startHarvesting(true); }, 1000); } }; self.startUnloading = function () { self.harvestingMode = 3; //console.log("Unloading spice..."); }; self.update = function () { if (self.harvestingMode == 1 && self.harvestedSpiceOnCellCounter < 200) { if (!gameMap.cells[self.cellX][self.cellY].spice) { if (!self.isMoving) { //console.log("No spice here "); //self.startHarvesting(true); } return; } self.harvestedSpiceOnTripCounter += self.harvestSpeed; self.harvestedSpiceOnCellCounter += self.harvestSpeed; if (self.harvestedSpiceOnCellCounter >= 200) { self.asset.tint = getPlayerTint(self.playerId); gameMap.clearCellSpice(self.cellX, self.cellY); self.harvestedSpiceOnCellCounter = 0; if (self.harvestedSpiceOnTripCounter >= self.harvestedSpiceCapacity) { self.harvestingMode = 2; // Returning } else { self.startHarvesting(); } } else { // Make the unit blink in orange more smoothly var blinkPhase = Math.sin(Date.now() * 0.01) * 0.5 + 0.5; self.asset.tint = blinkPhase < 0.5 ? 0xFFA500 : getPlayerTint(self.playerId); self.asset.rotation += 45 / 400 * (Math.PI / 180); } } if (self.harvestingMode == 2) { // Returning var closestRefinery = findClosestRefinery(self); if (closestRefinery) { var path = gameMap.findPath({ x: self.cellX, y: self.cellY }, { x: closestRefinery.cellX, y: closestRefinery.cellY }, 0, closestRefinery); if (path.length > 0) { //console.log("Returning to Refiniery..."); self.moveAlongPath(path, self.startUnloading); } else { console.warn("No path to Refinery !"); // Wait for the refinery to be ready self.harvestingMode = 0; // Idle LK.setTimeout(function () { self.harvestingMode = 2; }, 2000); } } } if (self.harvestingMode == 3) { // Unloading self.harvestedSpiceOnTripCounter -= self.unloadSpeed; // Add the unloaded spice to the player's spice counter if (self.playerId === player1.playerId) { player1.spice += self.unloadSpeed; } else if (self.playerId === player2.playerId) { player2.spice += self.unloadSpeed; } updateBaseInfo(); // Make the unit blink in green to indicate unloading var blinkPhase = Math.sin(Date.now() * 0.01) * 0.5 + 0.5; self.asset.tint = blinkPhase < 0.5 ? 0x00FFA5 : getPlayerTint(self.playerId); if (self.harvestedSpiceOnTripCounter <= 0) { //console.log("Unloading finished..."); self.asset.tint = getPlayerTint(self.playerId); self.harvestedSpiceOnTripCounter = 0; self.harvestingMode = 0; // Reset harvesting mode self.startHarvesting(); // Start a new harvesting cycle } } }; self.stopOtherActions = function () { //console.log("UnitHarvester stopOtherActions :"); self.harvestingMode = 0; // Reset harvesting mode self.asset.tint = getPlayerTint(self.playerId); }; // Additional properties and methods for UnitHarvester can be added here return self; }); //{15.1} var UnitRepository = Container.expand(function () { var self = Container.call(this); self.units = { 'unitHarvester': { 'name': 'Spice Harvester', 'cost': 400, 'energy': 0, 'constructionTime': 5, 'className': 'UnitHarvester', 'actions': ['harvest', 'move', 'return'], 'health': 50, 'sightRange': 4, 'attackRange': 0, 'attackSpeed': 0, 'attackDamage': 0 }, 'unitQuad': { 'name': 'Quad', 'cost': 300, 'energy': 0, 'constructionTime': 3, 'className': 'UnitQuad', 'actions': ['move', 'attack', 'return'], 'health': 10, 'sightRange': 4, 'attackRange': 2, 'attackSpeed': 2, 'attackDamage': 1 }, 'unitLightTank': { 'name': 'Light Tank', 'cost': 400, 'energy': 0, 'constructionTime': 2, // 10 'className': 'UnitLightTank', 'actions': ['move', 'attack', 'return'], 'health': 20, 'sightRange': 6, 'attackRange': 4, 'attackSpeed': 3, 'attackDamage': 3 }, 'unitHeavyTank': { 'name': 'Heavy Tank', 'cost': 800, 'energy': 0, 'constructionTime': 15, 'className': 'UnitHeavyTank', 'actions': ['move', 'attack', 'return'], 'health': 60, 'sightRange': 8, 'attackRange': 6, 'attackSpeed': 5, 'attackDamage': 6 } // Add more units as needed }; self.getUnitInfo = function (type) { return self.units[type]; }; return self; }); /**** * Initialize Game ****/ // Event listeners // Instantiate and initialize the Map var game = new LK.Game({ backgroundColor: 0x000000 // Init game with black background }); /**** * Game Code ****/ // Global function to calculate the angle between two points function calculateAngle(element1, element2) { var dx = element2.cellX - element1.cellX; var dy = element2.cellY - element1.cellY; if (dx === 0 && dy === 0) { return 0; // Default angle or another appropriate value } return Math.atan2(dy, dx) - Math.PI / 2; } // Global function to calculate the distance between two points function calculateDistance(element1, element2) { var dx = element1.cellX - element2.cellX; var dy = element1.cellY - element2.cellY; return Math.floor(Math.sqrt(dx * dx + dy * dy)); } // Global function to find the closest refinery to a given unit function findClosestRefinery(unit) { var closestRefinery = null; var minDistance = Number.MAX_VALUE; var playerBuildings = unit.playerId === player1.playerId ? player1.buildings : player2.buildings; //console.log("Player has " + playerBuildings.length + " buildings"); playerBuildings.forEach(function (building) { if (building instanceof SpiceRefinery && !gameMap.cells[building.cellX][building.cellY].unit) { //console.log("Found Refinery at " + building.cellX + "," + building.cellY); var dx = unit.cellX - building.cellX; var dy = unit.cellY - building.cellY; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < minDistance) { closestRefinery = building; minDistance = distance; } } }); //console.log("OK result ", closestRefinery); return closestRefinery ? { cellX: closestRefinery.cellX, cellY: closestRefinery.cellY } : null; } function findClosestConstructionYard(unit) { var closestBuilding = null; var minDistance = Number.MAX_VALUE; var playerBuildings = unit.playerId === player1.playerId ? player1.buildings : player2.buildings; //console.log("Player has " + playerBuildings.length + " buildings"); playerBuildings.forEach(function (building) { if (building instanceof ConstructionYard) { //console.log("Found ConstructionYard at " + building.cellX + "," + building.cellY); var dx = unit.cellX - building.cellX; var dy = unit.cellY - building.cellY; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < minDistance) { closestBuilding = building; minDistance = distance; } } }); //console.log("OK result ", closestBuilding); return closestBuilding ? { cellX: closestBuilding.cellX, cellY: closestBuilding.cellY } : null; } // Function to find an emplacement for a building based on its size and a starting cell function findEmplacementForBuilding(building, cellX, cellY) { // Check if the building size is defined if (!building.cellW || !building.cellH) { console.error("Building size is not defined."); return null; } // Define the search area around the given cellX, cellY var searchRadius = 10; // Search within 5 cells around the given cell for (var dx = -searchRadius; dx <= searchRadius; dx++) { for (var dy = -searchRadius; dy <= searchRadius; dy++) { var candidateX = cellX + dx; var candidateY = cellY + dy; // Check if the candidate area is within the map bounds if (candidateX >= 0 && candidateX + building.cellW <= mapXSize && candidateY >= 0 && candidateY + building.cellH <= mapYSize) { var fits = true; // Check if the entire building area is on rocks and not occupied for (var w = 0; w < building.cellW; w++) { for (var h = 0; h < building.cellH; h++) { var targetCell = gameMap.cells[candidateX + w][candidateY + h]; if (targetCell.terrain !== 'rock' || targetCell.building) { fits = false; break; } } if (!fits) { break; } } // If the area fits, return the top-left corner cell of the area if (fits) { return { cellX: candidateX, cellY: candidateY }; } } } } // If no suitable area is found, return null return null; } function findFactoryForUnit(unitType, player) { // Determine the required factory type based on the unit type var requiredFactoryType; switch (unitType) { case 'unitQuad': requiredFactoryType = 'lightFactory'; break; case 'unitLightTank': case 'unitHeavyTank': case 'unitHarvester': requiredFactoryType = 'heavyFactory'; break; default: console.error('Unknown unit type for factory requirement:', unitType); return null; } // Find the first factory of the required type that belongs to the player var suitableFactory = player.buildings.find(function (building) { return building.type === requiredFactoryType; }); return suitableFactory || null; // Return the factory or null if not found } function spawnUnit(unitType, x, y, playerId) { var unitInfo = unitRepository.getUnitInfo(unitType); var unit; switch (unitInfo.className) { case 'UnitHarvester': unit = new UnitHarvester(x, y, playerId); // Find the first available place around the refinery var path = findAvailablePositionAroundBuilding(x, y); if (path.length > 0) { unit.moveAlongPath(path, function () { harvestActionLogic(unit); }); } break; case 'UnitQuad': unit = new UnitQuad(x, y, playerId); var path = findAvailablePositionAroundBuilding(x, y); if (path.length > 0) { unit.moveAlongPath(path, function () {}); } break; case 'UnitLightTank': unit = new UnitLightTank(x, y, playerId); var path = findAvailablePositionAroundBuilding(x, y); if (path.length > 0) { unit.moveAlongPath(path, function () {}); } break; case 'UnitHeavyTank': unit = new UnitHeavyTank(x, y, playerId); var path = findAvailablePositionAroundBuilding(x, y); if (path.length > 0) { unit.moveAlongPath(path, function () {}); } break; // Add additional cases for other unit classes as needed default: throw new Error('Unknown unit class: ' + unitInfo.className); } gameMap.cells[x][y].unit = unit; if (playerId === player1.playerId) { player1.addUnit(unit); } else if (playerId === player2.playerId) { if (aiCurrentlyBuildingForArmy) { unit.isArmy = true; aiCurrentArmyUnits.push(unit); } player2.addUnit(unit); } game.addChild(unit); return unit; } function findAvailablePositionAroundBuilding(buildingX, buildingY) { var directions = [{ x: -1, y: 0 }, { x: 1, y: 0 }, { x: 0, y: -1 }, { x: 0, y: 1 }, { x: -1, y: -1 }, { x: 1, y: 1 }, { x: -1, y: 1 }, { x: 1, y: -1 }]; for (var i = 0; i < directions.length; i++) { var checkX = buildingX + directions[i].x; var checkY = buildingY + directions[i].y; if (gameMap.cells[checkX] && gameMap.cells[checkX][checkY] && !gameMap.cells[checkX][checkY].unit && !gameMap.cells[checkX][checkY].building) { return [{ cellX: directions[i].x, cellY: directions[i].y }]; // Return relative move to the first available cell } } return []; // No available position found } function findAvailableCellAtRange(targetX, targetY, range) { //console.log("findAvailableCellAtRange", targetX, targetY, range); range = range || 1; for (var dx = -range; dx <= range; dx++) { for (var dy = -range; dy <= range; dy++) { var checkX = targetX + dx; var checkY = targetY + dy; if (gameMap.cells[checkX] && gameMap.cells[checkX][checkY] && !gameMap.cells[checkX][checkY].unit && !gameMap.cells[checkX][checkY].building && (dx !== 0 || dy !== 0)) { //console.log("Found available cell at", checkX, checkY); return { cellX: checkX, cellY: checkY }; // Return the absolute cell } } } //console.log("No available position found"); return []; // No available position found } 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 moveActionLogic(targetUnit, destinationX, destinationY, isAttack) { //console.log("MoveActionLogic...", destinationX, ',', destinationY, ", isAttack=", isAttack); if (targetUnit && targetUnit.isUnit) { targetUnit.stopOtherActions(); var path = gameMap.findPath({ x: targetUnit.cellX, y: targetUnit.cellY }, { x: destinationX, y: destinationY }, isAttack ? targetUnit.attackRange : 0); targetUnit.moveAlongPath(path); } } function attackActionLogic(theUnit, targetCellX, targetCellY) { //console.log("AttackActionLogic...", targetCellX, ',', targetCellY); var target = gameMap.cells[targetCellX][targetCellY].unit || gameMap.cells[targetCellX][targetCellY].building; if (theUnit && theUnit.isUnit && target) { theUnit.stopOtherActions(); var attackPosition = findAvailableCellAtRange(targetCellX, targetCellY, theUnit.attackRange); var path = gameMap.findPath({ x: theUnit.cellX, y: theUnit.cellY }, { x: attackPosition.cellX, y: attackPosition.cellY }); theUnit.moveAlongPath(path, function () { theUnit.startAttack(target); }); } } function harvestActionLogic(targetUnit, destinationX, destinationY) { //console.log("HarvestActionLogic...", targetUnit, ' pos=', destinationX, ',', destinationY); if (targetUnit && targetUnit.isUnit && targetUnit.type === "unitHarvester") { var path = []; if (destinationX && destinationY) { path = gameMap.findPath({ x: targetUnit.cellX, y: targetUnit.cellY }, { x: destinationX, y: destinationY }); } if (path && path.length > 0) { //console.log("Valid harvesting, path:", path); targetUnit.moveAlongPath(path, targetUnit.startHarvesting); } else { //console.log("No path, direct harvesting "); targetUnit.startHarvesting(); } } } function retreatActionLogic(targetUnit) { //console.log("Retreat Action Logic..."); if (targetUnit && targetUnit.isUnit) { targetUnit.stopOtherActions(); var baseBuilding = findClosestConstructionYard(targetUnit); if (!baseBuilding) { if (targetUnit.player1Id === player1.playerId) { baseBuilding = { cellX: rockIlot1Center.x, cellY: rockIlot1Center.y }; } else { baseBuilding = { cellX: rockIlot2Center.x, cellY: rockIlot2Center.y }; } } //console.log("Building = ", baseBuilding); var freePosition = findAvailablePositionAroundBuilding(baseBuilding.cellX, baseBuilding.cellY); //console.log("freePosition = ", freePosition); if (freePosition && freePosition.length === 1) { baseBuilding.cellX += freePosition[0].cellX; baseBuilding.cellY += freePosition[0].cellY; } var path = gameMap.findPath({ x: targetUnit.cellX, y: targetUnit.cellY }, { x: baseBuilding.cellX, y: baseBuilding.cellY }, 0, true); //console.log("Retreat path:", path); targetUnit.moveAlongPath(path); } } function highlightBorder(borderX) { var iconBorders = game.children.filter(function (child) { return child instanceof IconBorder; }); for (var i = 0; i < iconBorders.length; i++) { var iconAsset = iconBorders[i].asset; iconAsset.tint = iconAsset.x === borderX ? 0xffAAAA : 0xFFFFFF; } } function getEnergyColor(energy) { if (energy < 25) { return '#ff1100'; // Red color for low energy } else if (energy < 75) { return '#d26600'; // Orange color for medium energy } else { return '#037d50'; // Original green color for high energy } } function checkBuildingPlacement(newBuilding, cellX, cellY) { if (newBuilding && 'cellW' in newBuilding) { for (var w = 0; w < newBuilding.cellW; w++) { for (var h = 0; h < newBuilding.cellH; h++) { if (!gameMap.cells[cellX + w] || !gameMap.cells[cellX + w][cellY + h] || gameMap.cells[cellX + w][cellY + h].terrain !== 'rock' || gameMap.cells[cellX + w][cellY + h].building) { return false; } } } } return true; } function enqueueBuildable(buildableType, buildableSourceFactory, currentPlayer, progressDisplay) { //console.log(currentPlayer.playerId + " - enqueueBuildable...", buildableType, buildableSourceFactory); if (currentPlayer.playerId === player1.playerId && (!currentSelection || !currentSelection.buildable.includes(buildableType))) { //console.log(currentPlayer.playerId + " - Cannot build this item here."); return; } var buildableInfo = buildableRepository.getBuildableInfo(buildableType); if (buildableInfo && currentPlayer.spice < buildableInfo.cost) { //console.log(currentPlayer.playerId + " - Not enough resources to build."); if (currentPlayer.playerId === player1.playerId) { progressDisplay.blinkRed(); } return; } if (currentPlayer.playerId === player1.playerId) { updateBaseInfo(); } var constructionTime = buildableInfo.constructionTime; var buildable; switch (buildableInfo.className) { case 'ConstructionYard': buildable = new ConstructionYard(0, 0, currentPlayer.playerId); break; case 'WindTrap': buildable = new WindTrap(0, 0, currentPlayer.playerId); break; case 'SpiceRefinery': buildable = new SpiceRefinery(0, 0, currentPlayer.playerId); break; case 'LightFactory': buildable = new LightFactory(0, 0, currentPlayer.playerId); break; case 'HeavyFactory': buildable = new HeavyFactory(0, 0, currentPlayer.playerId); break; case 'UnitQuad': buildable = new UnitQuad(0, 0, currentPlayer.playerId); break; case 'UnitLightTank': buildable = new UnitLightTank(0, 0, currentPlayer.playerId); break; case 'UnitHeavyTank': buildable = new UnitHeavyTank(0, 0, currentPlayer.playerId); break; case 'UnitHarvester': buildable = new UnitHarvester(0, 0, currentPlayer.playerId); break; // Add cases for other buildings as needed } if (!buildable) { console.error(currentPlayer.playerId + " - Building object is not defined."); return; } buildable.constructionProgress = 0; buildable.constructionTimer = LK.setInterval(function () { buildable.constructionProgress += 0.1; var progressFraction = buildable.constructionProgress / constructionTime; if (currentPlayer.playerId === player1.playerId) { buildable.progressDisplay.setProgress(progressFraction); } // Deduct spice progressively based on construction progress var costPerTick = buildableInfo.cost * 0.1 / constructionTime; currentPlayer.spice -= costPerTick; if (currentPlayer.playerId === player1.playerId) { updateBaseInfo(); } // When construction is complete... if (buildable.constructionProgress >= constructionTime) { LK.clearInterval(buildable.constructionTimer); //console.log(currentPlayer.playerId + " - " + buildableType + " construction completed."); buildable.constructionTimer = null; if (currentPlayer.playerId === player1.playerId) { buildable.progressDisplay.hide(); if (buildable.isBuilding) { currentPlayer.isCurrentlyBuilding = false; //console.log(currentPlayer.playerId + " - Building Ready for placement ", buildable); if (progressDisplay.parentIcon && typeof progressDisplay.parentIcon.setLabelToPlace === 'function') { progressDisplay.parentIcon.setLabelToPlace(); // Change label text to 'Place' } currentBuildingForPlacement = buildable; } //console.log("REMOVING PROGRESS DISPLAY ON ", buildable.progressDisplay.parent); //buildable.progressDisplay.parent.progressDisplay = null; } else { if (buildable.isBuilding) { currentPlayer.isCurrentlyBuilding = false; aiPlaceBuilding(buildable); } } if (buildable.isUnit) { //console.log(currentPlayer.playerId + " - Unit Ready to spawn ", buildable); currentPlayer.isCurrentlyBuildingUnit = false; var spawnCell = { cellX: 0, cellY: 0 }; if (buildableSourceFactory) { //console.log(currentPlayer.playerId + " - Found source factory ", buildableSourceFactory); spawnCell.cellX = buildableSourceFactory.cellX; spawnCell.cellY = buildableSourceFactory.cellY; } else { //console.log(currentPlayer.playerId + " - No source factory found ", buildableSourceFactory); } spawnUnit(buildable.type, spawnCell.cellX, spawnCell.cellY, currentPlayer.playerId); } if (currentPlayer.playerId === player1.playerId) { game.children.forEach(function (child) { if (child instanceof BuildableItemIcon) { child.asset.interactive = true; child.alpha = 1.0; } }); } } }, 100); if (currentPlayer.playerId === player1.playerId) { buildable.progressDisplay = progressDisplay; currentSelection.buildingQueue.push(buildable); game.children.forEach(function (child) { if (child instanceof BuildableItemIcon) { child.asset.interactive = false; } }); // Instantiate and display the CancelActionButton on the command panel for buildings if (buildable.isBuilding) { cancelActionBtn = new CancelActionButton(commandPanel.x + commandPanel.width - 200, commandPanel.y + 200); } game.addChild(cancelActionBtn); } } var applyCellOccupation = function applyCellOccupation(cellX, cellY) { var building = gameMap.cells[cellX][cellY].building; if (building) { for (var w = 0; w < building.cellW; w++) { for (var h = 0; h < building.cellH; h++) { if (cellX + w < gameMap.cells.length && cellY + h < gameMap.cells[0].length) { //console.log("applyCellOccupation", cellX, cellY, " to ", cellX + w, cellY + h); gameMap.cells[cellX + w][cellY + h].building = building; } } } } }; var getPlayerTint = function getPlayerTint(id) { //console.log("getPlayerTint", id); return player1.playerId === id ? player1.tint : player2.tint; }; var getNextId = function getNextId() { return nextId++; }; var orderEntitiesPerDistance = function orderEntitiesPerDistance(position, entityList) { var orderedEntityList = []; // Calculer la distance de chaque unité par rapport à la position donnée entityList.forEach(function (entity) { var distance = Math.sqrt(Math.pow(position.cellX - entity.cellX, 2) + Math.pow(position.cellY - entity.cellY, 2)); // Ajouter l'unité à la liste orderedEntityList.push({ entity: entity, distance: distance }); //console.log("entity", entity.id, " ", entity.type, " Pos:", entity.cellX, entity.cellY, " distance", distance); }); // Trier les unités en fonction de leurs distances orderedEntityList.sort(function (a, b) { return a.distance - b.distance; }); //console.log("orderedEntityList", orderedEntityList); return orderedEntityList; }; /* ******************************************** GLOBAL GAME VARIABLES ******************************************** */ /* ******************************************** GLOBAL GAME VARIABLES ******************************************** */ /* ******************************************** GLOBAL GAME VARIABLES ******************************************** */ var gameIsRunning = false; var gameState = 0; // 0 - Start, 1 - Game running, 2 - Game over var mapXSize = 20 * 2; var mapYSize = 21 * 2; var tileSize = 100; var mapHeight = game.height * 0.80; var viewSize = Math.ceil(Math.max(game.width, game.height) / 2 / 100); var viewPort = { wX: 0, wY: 0, wCellX: 0, wCellY: 0, cellW: Math.floor(game.width / tileSize) + 1, // ~20 cellH: Math.floor(mapHeight / tileSize) + 1 // ~21 }; var nextId = 1; // Init view port viewPort.wCellX = Math.max(0, Math.min(mapXSize - viewPort.cellW, viewPort.wCellX)); viewPort.wCellY = Math.max(0, Math.min(mapYSize - viewPort.cellH, viewPort.wCellY)); viewPort.wX = viewPort.wCellX * tileSize; viewPort.wY = viewPort.wCellY * tileSize; var dragSpeed = 0.15; var gameMap = new Map(); var buildableRepository = new BuildableRepository(); var unitRepository = new UnitRepository(); var actionRepository = new ActionRepository(); // Define user action states var UserActionState = { NAVIGATING: 'navigating', BUILDING: 'building', PLACING_BUILDINGS: 'placing_buildings', GIVING_ORDERS: 'giving_orders', SET_ORDER_TARGET: 'set_order_target' }; // Current state of user action var currentUserActionState = UserActionState.NAVIGATING; var globalTerrain = null; var player1 = null; var player2 = null; var spiceSpots = []; var fogOfWar = []; // Global variable to keep track of the previous energy level var previousEnergyLevel = 0; var currentSelection = null; var currentBuildingForPlacement = null; var selectionMarker = null; var tickCounter = 0; var fps = 0; // Gui var commandPanel = null; var player1SpiceText = null; var player1EnergyText = null; var energyOffsetSufix = '% '; var currentSelectionText = null; var fpsText = null; var targetMoveCursor = null; var cancelActionBtn = null; var rockIlot1Center = { x: 0, y: 0 }; var rockIlot2Center = { x: 0, y: 0 }; /* ***************************************************************************************************** */ /* ********************************************* AI FUNCTIONS ****************************************** */ /* ***************************************************************************************************** */ var AI_LEVEL = { EASY: { actingDelay: 2000, thinkingDelay: 2000 }, NORMAL: { actingDelay: 300, thinkingDelay: 600 }, HARD: { actingDelay: 100, thinkingDelay: 200 } }; var aiCurrentLevel = AI_LEVEL.EASY; var aiBaseUnitList = { 'unitHarvester': 2, 'unitQuad': 3, 'unitLightTank': 2, 'unitHeavyTank': 4 }; var aiBaseBuildingList = { 'windTrap': 3, 'spiceRefinery': 1, 'lightFactory': 1, 'heavyFactory': 1 }; var aiCurrentUnitConstruction = null; var aiCurrentBuildingConstruction = null; var aiNeededBuildingList = null; var aiNeededDefenseUnitsList = null; var aiBuildingsUnderAttackList = null; var aiUnitsUnderAttackList = null; var aiCurrentArmyUnits = []; var aiCurrentlyBuildingForArmy = false; var aiArmyIsReady = false; var aiNeededAttackUnitsList = null; var aiLastAttackWaveTime = 0; var aiNextAttackWaveSize = 0; var aiCurrentAttackWave = 1; var aiNextAttackWaveDelayMs = 1000 * 60; // TODO : handle in AiLevel var aiUnderAttackDelayMs = aiCurrentLevel.thinkingDelay * 10; // Think of what AI must do function aiThinking() { if (LK.ticks % aiCurrentLevel.thinkingDelay !== 0) { return; } //console.log("aiThinking..."); // Check buildings requirements aiNeededBuildingList = checkBuildingRequirements(); // Check units requirements aiNeededDefenseUnitsList = checkDefenseUnitsRequirements(); // Check buildings defense needs aiBuildingsUnderAttackList = checkBuildingUnderAttack(); // Check units defense needs aiUnitsUnderAttackList = checkUnitsUnderAttack(); // Check attack opportunities aiNeededAttackUnitsList = checkAttckWaveUnitNeeds(); } function checkBuildingRequirements() { //console.log("checkBuildingRequirements..."); //console.log("player2 buildings:", player2.buildings); // 1) Count currently owned buildings var aiCurrentBuildingList = { 'windTrap': 0, 'spiceRefinery': 0, 'lightFactory': 0, 'heavyFactory': 0 }; player2.buildings.forEach(function (building) { aiCurrentBuildingList[building.type] = (aiCurrentBuildingList[building.type] || 0) + 1; }); //console.log("aiCurrentBuildingList:", aiCurrentBuildingList); // 2) Check if all requirements are met var tempNeededBuildingList = {}; // Compare aiBaseBuildingList and aiCurrentBuildingList for (var building in aiBaseBuildingList) { if (aiBaseBuildingList[building] > aiCurrentBuildingList[building]) { tempNeededBuildingList[building] = aiBaseBuildingList[building] - aiCurrentBuildingList[building]; } } return tempNeededBuildingList; } function checkBuildingUnderAttack() { //console.log("checkBuildingUnderAttack..."); // Check delay since lastHitTime of all AI buildings var tempUnderAttackBuildingArray = []; player2.buildings.forEach(function (building) { if (Date.now() - building.lastHitTime < aiUnderAttackDelayMs) { // Building is under attack tempUnderAttackBuildingArray.push(building); } }); return tempUnderAttackBuildingArray; } function checkUnitsUnderAttack() { //console.log("checkUnitsUnderAttack..."); // Check delay since lastHitTime of all AI units except army var tempUnderAttackUnitsArray = []; player2.units.forEach(function (unit) { if (!unit.isArmy && Date.now() - unit.lastHitTime < aiUnderAttackDelayMs) { // Unit is under attack tempUnderAttackUnitsArray.push(unit); } }); return tempUnderAttackUnitsArray; } function checkAttckWaveUnitNeeds() { //console.log("checkAttckWaveUnitNeeds...Wave ", aiCurrentAttackWave); var tempNeededUnitList = {}; var aiBaseUnitListPerWave = getUnitNeedsPerWave(aiCurrentAttackWave); //console.log("Wave requires :", aiBaseUnitListPerWave); // aiThinking : evaluate army needs => list needed units // Browse aiCurrentArmyUnits and compare with aiBaseUnitListPerWave var tempNbQuads = 0; var tempNbLightTanks = 0; var tempNbHeavyTanks = 0; //console.log("check current ", aiCurrentArmyUnits.length, " army units:", aiCurrentArmyUnits); for (var i = 0; i < aiCurrentArmyUnits.length; i++) { //console.log("check army unit:", aiCurrentArmyUnits[i]); if (!aiCurrentArmyUnits[i] || aiCurrentArmyUnits[i].health <= 0) { continue; } //console.log("Take ", aiCurrentArmyUnits[i].type, "#", aiCurrentArmyUnits[i].id ," H=",aiCurrentArmyUnits[i].health); switch (aiCurrentArmyUnits[i].type) { case "unitQuad": tempNbQuads++; break; case "unitLightTank": tempNbLightTanks++; break; case "unitHeavyTank": tempNbHeavyTanks++; break; default: console.error("unknown army unit type:", aiCurrentArmyUnits[i].type); break; } } //console.log("=> We have:", tempNbQuads, tempNbLightTanks, tempNbHeavyTanks, " units"); for (var j = 0; j < Object.keys(aiBaseUnitListPerWave).length; j++) { var tempUnitType = Object.keys(aiBaseUnitListPerWave)[j]; if (!aiBaseUnitListPerWave[tempUnitType]) { continue; } switch (tempUnitType) { case "unitQuad": if (tempNbQuads < aiBaseUnitListPerWave[tempUnitType]) { tempNeededUnitList[tempUnitType] = aiBaseUnitListPerWave[tempUnitType] - tempNbQuads; } break; case "unitLightTank": if (tempNbLightTanks < aiBaseUnitListPerWave[tempUnitType]) { tempNeededUnitList[tempUnitType] = aiBaseUnitListPerWave[tempUnitType] - tempNbLightTanks; } break; case "unitHeavyTank": if (tempNbHeavyTanks < aiBaseUnitListPerWave[tempUnitType]) { tempNeededUnitList[tempUnitType] = aiBaseUnitListPerWave[tempUnitType] - tempNbHeavyTanks; } break; default: console.error("unknown base unit type:", tempUnitType); } } //console.log("=> We need:", tempNeededUnitList); return tempNeededUnitList; } function getUnitNeedsPerWave(waveIndex) { //console.log("getUnitNeedsPerWave...", waveIndex); /* Wave 1 : 1 Quad Wave 2 : 2 Quad Wave 3 : 2 Quad + 1 LightTank Wave 4 : 2 Quad + 2 LightTank Wave 5 : 2 Quad + 2 LightTank + 1 HeavyTank Wave 6+ : 2 Quad + 2 LightTank + 2 HeavyTank */ var tempNbQuads = Math.min(2, waveIndex); var tempNbLightTanks = Math.min(2, Math.max(0, waveIndex - 2)); var tempNbHeavyTanks = Math.min(2, Math.max(0, waveIndex - 4)); return { 'unitQuad': tempNbQuads, 'unitLightTank': tempNbLightTanks, 'unitHeavyTank': tempNbHeavyTanks }; } function checkDefenseUnitsRequirements() { //console.log("checkDefenseUnitsRequirements..."); //console.log("player2 units:", player2.units); // 1) Count currently owned units var aiCurrentUnitList = { 'unitHarvester': 0, 'unitQuad': 0, 'unitLightTank': 0, 'unitHeavyTank': 0 }; player2.units.forEach(function (unit) { aiCurrentUnitList[unit.type] = (aiCurrentUnitList[unit.type] || 0) + 1; }); //console.log("aiCurrentUnitList:", aiCurrentUnitList); // 2) Check if all requirements are met var tempNeededUnitList = {}; // Compare aiBaseUnitList and aiCurrentUnitList for (var unit in aiBaseUnitList) { if (aiBaseUnitList[unit] > aiCurrentUnitList[unit]) { tempNeededUnitList[unit] = aiBaseUnitList[unit] - aiCurrentUnitList[unit]; } } return tempNeededUnitList; } // Do what AI thought about function aiActing() { if (LK.ticks % aiCurrentLevel.actingDelay !== 0) { return; } //console.log("aiActing..."); // 1) Meet buildings requirements //console.log("aiNeededBuildingList:", aiNeededBuildingList); if (Object.keys(aiNeededBuildingList).length > 0 && !player2.isCurrentlyBuilding) { aiHandleBuildingConstruction(Object.keys(aiNeededBuildingList)[0]); } // 2) Meet units requirements //console.log("aiNeededUnitsList:", aiNeededDefenseUnitsList); if (Object.keys(aiNeededDefenseUnitsList).length > 0 && !player2.isCurrentlyBuildingUnit) { var tempUnitToBuild = Object.keys(aiNeededDefenseUnitsList)[0]; var tempSourceFactory = findFactoryForUnit(tempUnitToBuild, player2); if (tempSourceFactory) { aiHandleUnitConstruction(tempUnitToBuild, tempSourceFactory); } else { console.warn("2 - No factory found for unit " + tempUnitToBuild); } } // 3) Meet building defense needs //console.log("aiBuildingsUnderAttackList:", aiBuildingsUnderAttackList); if (aiBuildingsUnderAttackList.length > 0) { aiBuildingsUnderAttackList.forEach(function (building) { aiHandleBuildingUnderAttack(building); }); } // 4) Meet unit defense needs //console.log("aiUnitsUnderAttackList:", aiUnitsUnderAttackList); if (aiUnitsUnderAttackList.length > 0) { aiUnitsUnderAttackList.forEach(function (unit) { aiHandleUnitUnderAttack(unit); }); } // 5) Meet attack wave needs if (Object.keys(aiNeededAttackUnitsList).length > 0) { aiArmyIsReady = false; //console.log("Army not ready:", aiNeededAttackUnitsList); // Take 1st needed unit var tempUnitToBuild = Object.keys(aiNeededAttackUnitsList)[0]; var tempSourceFactory = findFactoryForUnit(tempUnitToBuild, player2); if (tempSourceFactory) { aiHandleUnitConstruction(tempUnitToBuild, tempSourceFactory, true); } else { //console.warn("5 - No factory found for unit " + tempUnitToBuild); } } else { //console.log("Clean Army...", aiCurrentArmyUnits); var tempCleanArmy = aiCurrentArmyUnits.filter(function (unit) { // keep only units alive return !unit.isDestroyed; }); aiCurrentArmyUnits = tempCleanArmy; if (aiCurrentArmyUnits.length >= Math.min(6, aiCurrentAttackWave)) { // ATTENTION !!! Arbitray rue : Nb units == Wave index //console.log("Army is ready:", aiCurrentArmyUnits); aiArmyIsReady = true; } } // 6) Launch attack wave if (aiArmyIsReady && Date.now() - aiLastAttackWaveTime > aiNextAttackWaveDelayMs) { aiLastAttackWaveTime = Date.now(); //console.warn("6 - ATTACK !!! Wave "+aiCurrentAttackWave + " at ", (new Date()).toLocaleTimeString()); aiCurrentAttackWave++; aiNextAttackWaveDelayMs = Math.min(3 * 60 * 1000, aiCurrentAttackWave * 60 * 1000); // Find a building to attack var firstAttaker = null; for (var i = 0; i < aiCurrentArmyUnits.length; i++) { if (!aiCurrentArmyUnits[i] || aiCurrentArmyUnits[i].health <= 0) { continue; } firstAttaker = aiCurrentArmyUnits[i]; break; } var nextBuildingTarget = aiFindClosestBuildingToAttack(firstAttaker); if (nextBuildingTarget) { aiStartAttack(nextBuildingTarget); } else { console.warn("6 - No building found to attack"); } } } function aiHandleBuildingConstruction(buildingToBuild) { //console.log("aiHandleBuildingConstruction...", buildingToBuild); if (player2.isCurrentlyBuilding) { //console.log("Already building building..."); return; } player2.isCurrentlyBuilding = true; enqueueBuildable(buildingToBuild, null, player2); } function aiPlaceBuilding(buildable) { //console.log("aiPlaceBuilding...", buildable); if (!buildable || !buildable.isBuilding) { return; } var baseBuilding = findClosestConstructionYard(buildable); if (!baseBuilding) { //console.warn(buildable.playerId + " - No Construction Yard to place building " + buildable.type + " around"); return; } var freePosition = findEmplacementForBuilding(buildable, baseBuilding.cellX, baseBuilding.cellY); if (!freePosition) { //console.warn(buildable.playerId + " - No free space to place building " + buildable.type); return; } var placeX = freePosition.cellX; var placeY = freePosition.cellY; handleBuildingPlacement(buildable, placeX, placeY); } function aiHandleBuildingUnderAttack(buildingToDefend) { //console.log("aiHandleBuildingUnderAttack...", buildingToDefend); // Check if already have defenders if (buildingToDefend.defenders.length > 1) { //console.log("already have defenders...", buildingToDefend.defenders); return; } // List all units per distance to building [] = { unit: unit, distance: distance } var potentialDefenders = orderEntitiesPerDistance(buildingToDefend, player2.units); // Browse potentialDefenders and add as defenders the ones that can attack & are idle potentialDefenders.forEach(function (defenderEntry) { var defender = defenderEntry.entity; //console.log("potential defender ", defender.id, " attackDamage:", defender.attackDamage, " / moving:", defender.isMoving, " / attackMode:", defender.attackMode); if (buildingToDefend.defenders.length < 2 && defender.attackDamage && !defender.isMoving && defender.attackMode == 0) { buildingToDefend.defenders.push(defender); } }); if (buildingToDefend.defenders.length > 0) { //console.log(buildingToDefend.defenders.length + " defenders found"); // Start attacking the first enemy spotted buildingToDefend.defenders.forEach(function (defender) { //console.log("defender ", defender.id, " ", defender.type, " Will attack:", buildingToDefend.lastAttaker); defender.startAttack(buildingToDefend.lastAttaker); }); } else { //console.log("No defenders found"); } //console.warn("potentialDefenders:", potentialDefenders); } function aiHandleUnitUnderAttack(unitToDefend) { //console.log("aiHandleUnitUnderAttack...", unitToDefend); // Check if already have defenders if (unitToDefend.defenders.length > 1) { //console.log("unit already have defenders...", unitToDefend.defenders); return; } // List all units per distance to building [] = { unit: unit, distance: distance } var potentialDefenders = orderEntitiesPerDistance(unitToDefend, player2.units); // Browse potentialDefenders and add as defenders the ones that can attack & are idle potentialDefenders.forEach(function (defenderEntry) { var defender = defenderEntry.entity; //console.log("potential defender ", defender.id, " attackDamage:", defender.attackDamage, " / moving:", defender.isMoving, " / attackMode:", defender.attackMode); if (unitToDefend.defenders.length < 2 && defender.attackDamage && !defender.isMoving && defender.attackMode == 0) { unitToDefend.defenders.push(defender); } }); if (unitToDefend.defenders.length > 0) { //console.log(unitToDefend.defenders.length + " defenders found"); // Start attacking the first enemy spotted unitToDefend.defenders.forEach(function (defender) { //console.log("defender ", defender.id, " ", defender.type, " Will attack:", unitToDefend.lastAttaker); defender.startAttack(unitToDefend.lastAttaker); }); } else { //console.log("No defenders found"); } } function aiHandleUnitConstruction(unitToBuild, sourceFactory, forArmy) { //console.log("aiHandleUnitConstruction...", unitToBuild, sourceFactory, forArmy); if (player2.isCurrentlyBuildingUnit) { //console.log("Already building unit..."); return; } player2.isCurrentlyBuildingUnit = true; aiCurrentlyBuildingForArmy = !!forArmy; // Flag to add the unit to the army enqueueBuildable(unitToBuild, sourceFactory, player2); } function aiFindClosestBuildingToAttack(firstAttaker) { if (!firstAttaker) { console.warn("AI : No attack leader!"); return null; } // Browse player1.buildings var potientialTargetBuildings = orderEntitiesPerDistance(firstAttaker, player1.buildings); if (potientialTargetBuildings && potientialTargetBuildings.length > 0) { return potientialTargetBuildings[0].entity; } console.warn("AI : Found no building to attack!"); return null; } function aiStartAttack(target) { var nbUnits = aiCurrentArmyUnits.length; //console.log("aiStartAttack... nbUnits=", nbUnits, " target=", target); // Send all army around the target for (var i = 0; i < nbUnits; i++) { // Find a place for each unit by adding a delta depending on index var deltaX = -1 + i % 3; var deltaY = Math.floor(i / 3); moveActionLogic(aiCurrentArmyUnits[i], target.cellX + deltaX, target.cellY + deltaY, true); } } /* ***************************************************************************************************** */ /* ********************************************* INIT FUNCTIONS ****************************************** */ /* ***************************************************************************************************** */ // Prepare the map function prepareMap() { globalTerrain = new Array(mapXSize).fill(0).map(function () { return new Array(mapYSize).fill(0); }); gameMap = new Map(); gameMap.init(mapXSize, mapYSize); // Initialize with a 20x20 grid // Define a fixed rock ilot near the center left of the map // Randomize starting positions for rockIlot1Center and rockIlot2Center var startingPositions = [{ x: 8, y: 8 }, // Top left { x: 30, y: 8 }, // Top right { x: 8, y: 32 }, // Bottom left { x: 30, y: 32 } // Bottom right ]; var randomIndex = Math.floor(Math.random() * startingPositions.length); rockIlot1Center = startingPositions[randomIndex]; // Remove selected position and choose next for rockIlot2Center startingPositions.splice(randomIndex, 1); rockIlot2Center = startingPositions[Math.floor(Math.random() * startingPositions.length)]; //console.log("rockIlot1Center : ", rockIlot1Center); var rockIlot1Radius = 4; for (var x = rockIlot1Center.x - rockIlot1Radius; x <= rockIlot1Center.x + rockIlot1Radius; x++) { for (var y = rockIlot1Center.y - rockIlot1Radius; y <= rockIlot1Center.y + rockIlot1Radius; y++) { if (x >= 0 && x < mapXSize && y >= 0 && y < mapYSize) { globalTerrain[x][y] = 1; } } } var initialConstructionYard = new ConstructionYard(rockIlot1Center.x, rockIlot1Center.y, 1); gameMap.cells[rockIlot1Center.x][rockIlot1Center.y].building = initialConstructionYard; applyCellOccupation(rockIlot1Center.x, rockIlot1Center.y); player1.addBuilding(initialConstructionYard); // 3 quads for player 1 var p1Quad1 = new UnitQuad(rockIlot1Center.x - 2, rockIlot1Center.y + 1, 1); gameMap.cells[rockIlot1Center.x - 2][rockIlot1Center.y + 1].unit = p1Quad1; player1.addUnit(p1Quad1); game.addChild(p1Quad1); var p1Quad2 = new UnitQuad(rockIlot1Center.x + 3, rockIlot1Center.y + 1, 1); gameMap.cells[rockIlot1Center.x + 3][rockIlot1Center.y + 1].unit = p1Quad2; player1.addUnit(p1Quad2); game.addChild(p1Quad2); var p1Quad3 = new UnitQuad(rockIlot1Center.x + 0, rockIlot1Center.y + 3, 1); gameMap.cells[rockIlot1Center.x][rockIlot1Center.y + 3].unit = p1Quad3; player1.addUnit(p1Quad3); game.addChild(p1Quad3); // Player 2 base // Define a fixed rock ilot near the center right of the map var rockIlot2Radius = 4; for (var x = rockIlot2Center.x - rockIlot2Radius; x <= rockIlot2Center.x + rockIlot2Radius; x++) { for (var y = rockIlot2Center.y - rockIlot2Radius; y <= rockIlot2Center.y + rockIlot2Radius; y++) { if (x >= 0 && x < mapXSize && y >= 0 && y < mapYSize) { globalTerrain[x][y] = 1; } } } //console.log("rockIlot2Center at " + rockIlot2Center.x + ',' + rockIlot2Center.y); var initialConstructionYard2 = new ConstructionYard(rockIlot2Center.x, rockIlot2Center.y, 2); gameMap.cells[rockIlot2Center.x][rockIlot2Center.y].building = initialConstructionYard2; applyCellOccupation(rockIlot2Center.x, rockIlot2Center.y); player2.addBuilding(initialConstructionYard2); var windTrap1 = new WindTrap(rockIlot2Center.x + 3, rockIlot2Center.y, 2); gameMap.cells[rockIlot2Center.x + 3][rockIlot2Center.y].building = windTrap1; applyCellOccupation(rockIlot2Center.x + 3, rockIlot2Center.y); player2.addBuilding(windTrap1); var windTrap2 = new WindTrap(rockIlot2Center.x - 3, rockIlot2Center.y, 2); gameMap.cells[rockIlot2Center.x - 3][rockIlot2Center.y].building = windTrap2; applyCellOccupation(rockIlot2Center.x - 3, rockIlot2Center.y); player2.addBuilding(windTrap2); var refinery1 = new SpiceRefinery(rockIlot2Center.x - 3, rockIlot2Center.y + 3, 2); gameMap.cells[rockIlot2Center.x - 3][rockIlot2Center.y + 3].building = refinery1; applyCellOccupation(rockIlot2Center.x - 3, rockIlot2Center.y + 3); player2.addBuilding(refinery1); var heavyFactory1 = new HeavyFactory(rockIlot2Center.x + 2, rockIlot2Center.y + 3, 2); gameMap.cells[rockIlot2Center.x + 2][rockIlot2Center.y + 3].building = heavyFactory1; applyCellOccupation(rockIlot2Center.x + 2, rockIlot2Center.y + 3); player2.addBuilding(heavyFactory1); var lightFactory1 = new LightFactory(rockIlot2Center.x, rockIlot2Center.y - 3, 2); gameMap.cells[rockIlot2Center.x][rockIlot2Center.y - 3].building = lightFactory1; applyCellOccupation(rockIlot2Center.x, rockIlot2Center.y - 3); player2.addBuilding(lightFactory1); var quad1 = new UnitQuad(rockIlot2Center.x, rockIlot2Center.y - 6, 2); gameMap.cells[rockIlot2Center.x][rockIlot2Center.y - 6].unit = quad1; player2.addUnit(quad1); game.addChild(quad1); var quad2 = new UnitQuad(rockIlot2Center.x, rockIlot2Center.y + 6, 2); gameMap.cells[rockIlot2Center.x][rockIlot2Center.y + 6].unit = quad2; player2.addUnit(quad2); game.addChild(quad2); var heavyTank1 = new UnitHeavyTank(rockIlot2Center.x - 5, rockIlot2Center.y - 5, 2); gameMap.cells[rockIlot2Center.x - 5][rockIlot2Center.y - 5].unit = heavyTank1; player2.addUnit(heavyTank1); game.addChild(heavyTank1); var heavyTank2 = new UnitHeavyTank(rockIlot2Center.x + 5, rockIlot2Center.y - 5, 2); gameMap.cells[rockIlot2Center.x + 5][rockIlot2Center.y - 5].unit = heavyTank2; player2.addUnit(heavyTank2); game.addChild(heavyTank2); var heavyTank3 = new UnitHeavyTank(rockIlot2Center.x + 5, rockIlot2Center.y + 5, 2); gameMap.cells[rockIlot2Center.x + 5][rockIlot2Center.y + 5].unit = heavyTank3; player2.addUnit(heavyTank3); game.addChild(heavyTank3); var heavyTank4 = new UnitHeavyTank(rockIlot2Center.x - 5, rockIlot2Center.y + 5, 2); gameMap.cells[rockIlot2Center.x - 5][rockIlot2Center.y + 5].unit = heavyTank4; player2.addUnit(heavyTank4); game.addChild(heavyTank4); var lightTank5 = new UnitLightTank(rockIlot2Center.x - 1, rockIlot2Center.y - 1, 2); gameMap.cells[rockIlot2Center.x - 1][rockIlot2Center.y - 1].unit = lightTank5; player2.addUnit(lightTank5); game.addChild(lightTank5); var lightTank6 = new UnitLightTank(rockIlot2Center.x + 2, rockIlot2Center.y + 2, 2); gameMap.cells[rockIlot2Center.x + 2][rockIlot2Center.y + 2].unit = lightTank6; player2.addUnit(lightTank6); game.addChild(lightTank6); var harvester1 = new UnitHarvester(rockIlot2Center.x - 3, rockIlot2Center.y + 5, 2); gameMap.cells[rockIlot2Center.x - 3][rockIlot2Center.y + 5].unit = harvester1; player2.addUnit(harvester1); game.addChild(harvester1); gameMap.initTerrain(mapXSize, mapYSize); // Initialize with a 20x20 grid initSpiceSpots(); //console.log('ConstructionYard1 cell :', gameMap.cells[rockIlot1Center.x][rockIlot1Center.y]); selectionMarker = new SelectionMarker(); // Add the map to the game game.addChild(gameMap); game.addChild(selectionMarker); harvester1.startHarvesting(); initFogOfWar(); updateFogOfWar(); } function initSpiceSpots() { var quarterWidth = Math.floor(mapXSize / 2); var quarterHeight = Math.floor(mapYSize / 2); for (var i = 0; i < 4; i++) { var startX = i % 2 * quarterWidth; var startY = Math.floor(i / 2) * quarterHeight; var ilotCenterX = startX + Math.floor(Math.random() * quarterWidth); var ilotCenterY = startY + Math.floor(Math.random() * quarterHeight); var ilotRadius = 4 + Math.floor(Math.random() * 3); for (var x = ilotCenterX - ilotRadius; x <= ilotCenterX + ilotRadius; x++) { for (var y = ilotCenterY - ilotRadius; y <= ilotCenterY + ilotRadius; y++) { if (x >= 0 && x < mapXSize && y >= 0 && y < mapYSize && globalTerrain[x][y] === 0) { globalTerrain[x][y] = 2; // Mark as spice spiceSpots.push({ x: x, y: y }); gameMap.cells[x][y].spice = true; gameMap.cells[x][y].spiceAsset = LK.getAsset('terrainSpice', { x: x * 100, y: y * 100 }); } } } } } function initFogOfWar() { for (var x = 0; x < mapXSize; x++) { for (var y = 0; y < mapYSize; y++) { fogOfWar.push({ x: x, y: y }); gameMap.cells[x][y].fog = true; gameMap.cells[x][y].fogAsset = LK.getAsset('fogOfWar', { x: x * 100, y: y * 100, tint: 0x222222 }); } } } function updateFogOfWar() { //console.log("updateFogOfWar..."); player1.units.concat(player1.buildings).forEach(function (element) { for (var dx = -5; dx <= 5; dx++) { for (var dy = -5; dy <= 5; dy++) { var x = element.cellX + dx; var y = element.cellY + dy; if (x >= 0 && x < mapXSize && y >= 0 && y < mapYSize) { gameMap.cells[x][y].fog = false; } } } }); } //#region Event listeners var dragStart = null; var dragDelta = 0; function handleDragStart(obj) { //console.log("Drag start..."); dragStart = obj.event.getLocalPosition(game); } function handleDragMove(obj) { var currentPos = obj.event.getLocalPosition(game); var input = { x: currentPos.x, y: currentPos.y }; //updateMouseCoords(input.x, input.y); if (currentUserActionState === UserActionState.PLACING_BUILDINGS) { var cellCoord = screenCoordToWorldCell(input.x, input.y); var cellX = cellCoord.wCellX; var cellY = cellCoord.wCellY; //console.log("Trying cell ", cellX + ',' + cellY); var isValidPlacement = checkBuildingPlacement(currentBuildingForPlacement, cellX, cellY); if (currentBuildingForPlacement && currentBuildingForPlacement.asset) { currentBuildingForPlacement.asset.tint = isValidPlacement ? 0x00FF00 : 0xFF0000; currentBuildingForPlacement.visible = input.y + currentBuildingForPlacement.cellH * tileSize < mapHeight; } currentBuildingForPlacement.x = (cellX + currentBuildingForPlacement.cellW / 2 - viewPort.wCellX) * tileSize; currentBuildingForPlacement.y = (cellY + currentBuildingForPlacement.cellH / 2 - viewPort.wCellY) * tileSize; } else if (dragStart) { var deltaX = currentPos.x - dragStart.x; var deltaY = currentPos.y - dragStart.y; var inputPosition = { x: Math.round(-deltaX / tileSize), y: Math.round(-deltaY / tileSize) }; var allUnits = player1.units.concat(player2.units); allUnits.forEach(function (unit) { unit.handleDrag(inputPosition); //unit.visible = false; }); gameMap.handleDrag(inputPosition); dragDelta = Math.sqrt(deltaX * deltaX + deltaY * deltaY); if (currentSelection && currentSelection.health > 0) { selectionMarker.setOnElement(currentSelection); } } } function handleDragEnd(obj) { var currentPos = obj.event.getLocalPosition(game); var input = { x: currentPos.x, y: currentPos.y }; //console.log("Clicked at " + input.x + ',' + input.y); if (input.y > game.height * 0.80) { //console.log("Clicked on board at " + input.x + ',' + input.y); dragStart = null; dragDelta = 0; return; } if (currentUserActionState === UserActionState.PLACING_BUILDINGS) { var cellCoord = screenCoordToWorldCell(input.x, input.y); var cellX = cellCoord.wCellX; var cellY = cellCoord.wCellY; var isValidPlacement = checkBuildingPlacement(currentBuildingForPlacement, cellX, cellY); if (!isValidPlacement) { return; } //console.log("Placing building ", currentBuildingForPlacement, " at " + cellX + ',' + cellY); handleBuildingPlacement(currentBuildingForPlacement, cellX, cellY); currentUserActionState = UserActionState.NAVIGATING; dragStart = null; dragDelta = 0; } else if (currentUserActionState === UserActionState.SET_ORDER_TARGET) { if (currentSelection && currentSelection.isUnit) { var cellCoord = screenCoordToWorldCell(input.x, input.y); //convertCoordsToCell(input.x, input.y); currentSelection.destinationTarget = { x: cellCoord.wCellX, y: cellCoord.wCellY }; // Call the action handler with the target position if (currentSelection.actions && currentSelection.selectedAction) { //console.log(currentSelection.selectedAction + ' received '); var actionInfo = actionRepository.getActionInfo(currentSelection.selectedAction); if (actionInfo && actionInfo.handler) { //console.log('Call action handler : ', actionInfo); actionInfo.handler(currentSelection, cellCoord.wCellX, cellCoord.wCellY); } } if (targetMoveCursor) { //console.log('hiding move cursor ...'); targetMoveCursor.visible = false; } } highlightBorder(); if (cancelActionBtn) { cancelActionBtn.visible = false; } currentUserActionState = UserActionState.NAVIGATING; dragStart = null; dragDelta = 0; } else { // Normal click var clickCell = screenCoordToWorldCell(input.x, input.y); var cellX = clickCell.wCellX; var cellY = clickCell.wCellY; //console.log("Click at cell " + cellX + ',' + cellY); var allUnits = player1.units.concat(player2.units); allUnits.forEach(function (unit) { unit.handleDrag(input); unit.visible = true; }); var deltaToSelection = 99; if (currentSelection && currentSelection.isUnit) { var selCell = getCellForUnit(currentSelection); deltaToSelection = Math.sqrt(Math.pow(Math.abs(selCell.cellX - cellX), 2) + Math.pow(Math.abs(selCell.cellY - cellY), 2)); } if (cellX >= 0 && cellX < gameMap.cells.length && cellY >= 0 && cellY < gameMap.cells[cellX].length) { var cell = gameMap.cells[cellX][cellY]; if (!cell.building && !cell.unit && deltaToSelection > 1) { if (dragDelta < tileSize * 0.25) { if (currentSelection && currentSelection.isUnit && currentSelection.cellX == cellX && currentSelection.cellY == cellY) { //console.log("Already selected unit at " + cellX + ',' + cellY); } else { currentSelection = null; selectionMarker.setOnElement(); selectionMarker.hide(); //console.log("Nothing selected at " + cellX + ',' + cellY, " deltaToSelection=" + deltaToSelection, " dragDelta=", dragDelta); updateActionBoard(); } } } else if (cell.building && !cell.fog) { //console.log("Selected building at " + cellX + ',' + cellY, " cell:", cell, " units:", player1.units); if (!cell.unit) { currentSelection = cell.building; selectionMarker.setOnElement(currentSelection); updateActionBoard(); } } else if (cell.unit) { //console.log("Selected cell with unit at " + cellX + ',' + cellY); //console.log("unit at " + cell.unit.x + ',' + cell.unit.y); } } dragStart = null; dragDelta = 0; } } game.on('down', handleDragStart); game.on('move', handleDragMove); game.on('up', handleDragEnd); //#endregion Event listeners // Global function to handle building placement var handleBuildingPlacement = function handleBuildingPlacement(building, cellX, cellY) { //console.log("handle " + building.name + " Placement at " + cellX + ',' + cellY); if (!gameMap.cells[cellX] || !gameMap.cells[cellX][cellY]) { //console.log('Invalid cell for building placement.'); return; } var cell = gameMap.cells[cellX][cellY]; if (cell.building) { //console.log('Cell is already occupied.'); return; } // Place the building on the map cell.building = building; building.cellX = cellX; building.cellY = cellY; building.x = cellX * tileSize; building.y = cellY * tileSize; building.asset.tint = 0xFFFFFF; gameMap.addChild(building); // Call addBuilding for the player who owns the building if (building.playerId === player1.playerId) { player1.addBuilding(building); } else if (building.playerId === player2.playerId) { player2.addBuilding(building); } applyCellOccupation(cellX, cellY); //console.log(building.name + ' placed at ' + cellX + ',' + cellY); if (building instanceof SpiceRefinery) { spawnUnit('unitHarvester', cellX, cellY, building.playerId); } if (player1.playerId === building.playerId) { player1.updateEnergy(); updateBaseInfo(); currentUserActionState = UserActionState.NAVIGATING; currentBuildingForPlacement = null; if (cancelActionBtn) { cancelActionBtn.visible = false; } updateActionBoard(true); updateFogOfWar(); } }; // Screen <-> World Coordinates var screenCoordToWorldCell = function screenCoordToWorldCell(x, y) { var wCellX = Math.floor(x / tileSize) + viewPort.wCellX; var wCellY = Math.floor(y / tileSize) + viewPort.wCellY; return { wCellX: wCellX, wCellY: wCellY }; }; var screenCoordToWorldCoord = function screenCoordToWorldCoord(x, y) { var wX = x + viewPort.wX; var wY = y + viewPort.wY; return { wX: wX, wY: wY }; }; var screenCellToWorldCell = function screenCellToWorldCell(cellX, cellY) { var wCellX = cellX + viewPort.wCellX; var wCellY = cellY + viewPort.wCellY; return { wCellX: wCellX, wCellY: wCellY }; }; var screenCellToWorldCoord = function screenCellToWorldCoord(cellX, cellY) { var wX = cellX * tileSize + viewPort.wX; var wY = cellY * tileSize + viewPort.wY; return { wX: wX, wY: wY }; }; // World <-> Screen Coordinates var worldCoordToScreenCell = function worldCoordToScreenCell(wX, wY) { var cellX = Math.floor(wX / tileSize) - viewPort.wCellX; var cellY = Math.floor(wY / tileSize) - viewPort.wCellY; return { cellX: cellX, cellY: cellY }; }; var worldCoordToScreenCoord = function worldCoordToScreenCoord(wX, wY) { var x = wX - viewPort.wX; var y = wY - viewPort.wY; return { x: x, y: y }; }; var worldCellToScreenCell = function worldCellToScreenCell(wCellX, wCellY) { var cellX = wCellX - viewPort.wCellX; var cellY = wCellY - viewPort.wCellY; return { cellX: cellX, cellY: cellY }; }; var worldCellToScreenCoord = function worldCellToScreenCoord(wCellX, wCellY) { var x = wCellX * tileSize - viewPort.wX; var y = wCellY * tileSize - viewPort.wY; return { x: x, y: y }; }; var getScreenToWorldCell = function getScreenToWorldCell(x, y) { var wCellX = Math.floor(x / tileSize) + viewPort.wX; var wCellY = Math.floor(y / tileSize) + viewPort.wY; return { wCellX: wCellX, wCellY: wCellY }; }; var getScreenToWorldCoord = function getScreenToWorldCoord(x, y) { var wX = x + viewPort.wX * tileSize; var wY = y + viewPort.wY * tileSize; return { wX: wX, wY: wY }; }; var convertCoordsToCell = function convertCoordsToCell(x, y) { return { cellX: Math.floor(x / 100) + gameMap.currentViewCenter.x - Math.ceil(game.width / 2 / 100) - 3, cellY: Math.floor(y / 100) + gameMap.currentViewCenter.y - Math.ceil(game.height / 2 / 100) }; }; var getCellForUnit = function getCellForUnit(unit) { var centerDeltaX = gameMap.currentViewCenter.x - Math.ceil(game.width / 2 / 100); var centerDeltaY = gameMap.currentViewCenter.y - Math.ceil(game.height / 2 / 100); var cX = Math.floor(unit.x / 100) + centerDeltaX + unit.cellW / 2 + Math.floor(unit.cellW / 2) - 5; var cY = Math.floor(unit.y / 100) + centerDeltaY + Math.floor(unit.cellH / 2) + unit.cellH / 2 - 7; return { cellX: cX, cellY: cY }; }; // Global function to find the closest spice spot to a given position var findClosestSpiceSpot = function findClosestSpiceSpot(x, y) { var closestSpot = null; var minDistance = Number.MAX_VALUE; spiceSpots.forEach(function (spot) { if (!gameMap.cells[spot.x][spot.y].unit) { var dx = x - spot.x; var dy = y - spot.y; var distance = Math.sqrt(dx * dx + dy * dy); if (distance < minDistance) { closestSpot = spot; minDistance = distance; } } }); return closestSpot; }; // Global function to handle action board updates var updateActionBoard = function updateActionBoard(resetProgress) { //console.log('updateActionBoard...' + (currentSelection ? currentSelection.name : 'No selection')); if (!currentSelection || currentSelection.health <= 0) { currentSelection = null; } currentSelectionText.setText(currentSelection ? currentSelection.name : ''); clearIconBorders(); displayBuildableItems(resetProgress); // Call displayBuildableItems to show items that can be built displayActionItems(); // Call displayActionItems to show action items }; function clearIconBorders() { var iconBorders = game.children.filter(function (child) { return child instanceof IconBorder; }); iconBorders.forEach(function (border) { border.destroy(); }); } function displayBuildableItems(resetProgress) { //console.log('displayBuildableItems...', currentSelection); var buildableItemIcons = game.children.filter(function (child) { return child instanceof BuildableItemIcon; }); buildableItemIcons.forEach(function (icon) { if (icon.progressDisplay) { icon.progressDisplay.visible = !resetProgress && !!currentSelection; } icon.visible = false; }); if (currentSelection && currentSelection.playerId === player1.playerId && currentSelection.buildable && currentSelection.buildable.length) { var iconX = commandPanel.x + 200; // Starting X position for the first icon var iconY = commandPanel.y + 220; // Y position for all icons currentSelection.buildable.forEach(function (itemType) { //console.log("Prepare icon for ", itemType); var buildableInfo = buildableRepository.getBuildableInfo(itemType); if (buildableInfo.requires) { var requiredBuildingExists = player1.buildings.some(function (building) { return building.type === buildableInfo.requires; }); if (!requiredBuildingExists) { return; } } var border = new IconBorder(iconX, iconY); game.addChild(border); var icon = null; // Search if icon already exists var existingIcons = game.children.filter(function (child) { return child instanceof BuildableItemIcon && child.type === itemType; }); //console.log("Found existing icons", existingIcons); if (existingIcons.length > 0) { icon = existingIcons[0]; if (resetProgress) { icon.restoreLabel(); } icon.visible = true; } else { icon = new BuildableItemIcon(itemType, iconX, iconY, currentSelection); } game.addChild(icon); if (icon.progressDisplay) { icon.progressDisplay.visible = true; game.addChild(icon.progressDisplay); } iconX += 300; // Increment X position for the next icon }); } } // Global function to display action items var displayActionItems = function displayActionItems() { //console.log('displayActionItems...', currentSelection); var actionItemIcons = game.children.filter(function (child) { return child instanceof ActionItemIcon; }); actionItemIcons.forEach(function (icon) { //console.log('removing...', icon.action.name); icon.destroy(); }); if (currentSelection && currentSelection.playerId === player1.playerId && currentSelection.isUnit && currentSelection.health > 0 && currentSelection.actions && currentSelection.actions.length) { var iconX = commandPanel.x + 200; // Starting X position for the first icon var iconY = commandPanel.y + 220; // Y position for all icons currentSelection.actions.forEach(function (actionType) { //console.log('Add action button for ', actionType); var actionInfo = actionRepository.getActionInfo(actionType); if (actionInfo) { //console.log('ok Action found => display', actionInfo); var border = new IconBorder(iconX, iconY); game.addChild(border); var icon = new ActionItemIcon(actionInfo, iconX, iconY); game.addChild(icon); iconX += 300; // Increment X position for the next icon } else { //console.log('Action not found', actionType); } }); } }; // Global function to update mouse coordinates text var updateMouseCoords = function updateMouseCoords(x, y) { var wCell = screenCoordToWorldCell(x, y); if (game.mouseCoordsText) { game.mouseCoordsText.setText("S:" + Math.floor(x) + ',' + Math.floor(y) + '\r\n' + Math.floor(x / tileSize) + ',' + Math.floor(y / tileSize) + '\r\nW:' + Math.floor(wCell.wCellX) + ',' + Math.floor(wCell.wCellY)); } gameMap.viewCenterText.setText(viewPort.wCellX + ',' + viewPort.wCellY); }; // Global function to update base info text var updateBaseInfo = function updateBaseInfo() { player1SpiceText.setText('| ' + Math.floor(player1.spice).toString()); // Animate the change of the energy value if (previousEnergyLevel !== player1.energy) { var energyDifference = player1.energy - previousEnergyLevel; var duration = 2000; // Duration of the animation in milliseconds var steps = duration / (1000 / 60); // Number of steps based on 60FPS var stepValue = energyDifference / steps; var currentStep = 0; var animateEnergyChange = function animateEnergyChange() { var energyColor = getEnergyColor(previousEnergyLevel); player1EnergyText.setStyle({ fill: energyColor }); if (currentStep < steps) { previousEnergyLevel += stepValue; player1EnergyText.setText(previousEnergyLevel.toFixed(0).toString() + energyOffsetSufix); currentStep++; LK.setTimeout(animateEnergyChange, 1000 / 60); } else { // Ensure the final value is set correctly player1EnergyText.setText(player1.energy.toString() + energyOffsetSufix); previousEnergyLevel = player1.energy; // Update the previous energy level } }; animateEnergyChange(); } else { player1EnergyText.setText(player1.energy.toString() + energyOffsetSufix); } }; var startFpsCounter = function startFpsCounter() { var fpsInterval = LK.setInterval(function () { // Set the FPS value to the tick counter fps = tickCounter; // Reset the tick counter tickCounter = 0; // Update the FPS text on the screen fpsText.setText('FPS: ' + fps); }, 1000); // 1000 milliseconds = 1 second }; function checkGameEnd() { //console.log("checkGameEnd..."); // Check if either player1 or player2 has no more buildings if (gameIsRunning && (player1.buildings.length === 0 || player2.buildings.length === 0)) { LK.setTimeout(function () { gameIsRunning = false; var gameOverPopup = LK.getAsset('popup', { x: game.width / 2, y: game.height / 2, anchorX: 0.5, anchorY: 0.5 }); var gameOverLabel = player1.buildings.length === 0 ? "DEFEAT!" : "VICTORY!"; var gameOverText = new Text2(gameOverLabel, { size: 100, fill: "#ffffff", font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); gameOverText.anchor.set(0.5, 6); LK.gui.center.addChild(gameOverText); game.addChild(gameOverPopup); LK.showGameOver(); }, 2000); } } function initGame() { // Create players player1 = new Player(1, 0xFFFFFF); player2 = new Player(2, 0xFF8888); // Prepare the map prepareMap(); // Instantiate CommandPanel commandPanel = game.addChild(new CommandPanel()); // Create a Text2 object for current selection currentSelectionText = new Text2('', { size: 50, fill: '#000000', font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); currentSelectionText.anchor.set(0.5, 6.8); LK.gui.bottom.addChild(currentSelectionText); // Create a Text2 object to display mouse coordinates if (!game.mouseCoordsText) { game.mouseCoordsText = new Text2('', { size: 50, fill: '#ffffff', font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); game.mouseCoordsText.anchor.set(0, 0); LK.gui.topLeft.addChild(game.mouseCoordsText); } // Create a Text2 object to display player1's spice level player1SpiceText = new Text2('| ' + Math.floor(player1.spice).toString(), { size: 50, fill: '#FFFFFF', font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); player1SpiceText.anchor.set(1.0, 0.25); LK.gui.topRight.addChild(player1SpiceText); // Create a Text2 object to display player1's energy level player1EnergyText = new Text2(player1.energy.toString() + energyOffsetSufix, { size: 50, fill: '#FFFFFF', font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); player1EnergyText.anchor.set(1.0, 0.25); LK.gui.topRight.addChild(player1EnergyText); // Create a Text2 object to display the FPS in the bottom right corner fpsText = new Text2('', { size: 50, fill: '#000000', font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); fpsText.anchor.set(1.5, 1.0); LK.gui.bottomRight.addChild(fpsText); //gameIsRunning = true; //startFpsCounter(); } // Game tick LK.on('tick', function () { // Render the map and update unit movement each tick if (gameIsRunning) { gameMap.render(); player2.units.forEach(function (unit) { unit.asset.visible = !gameMap.cells[unit.cellX][unit.cellY].fog; }); var allUnits = player1.units.concat(player2.units); allUnits.forEach(function (unit) { if (unit.isDestroyed) { //console.log("unit is already destroyed"); //unit.asset.visible = false; return; } unit.updateMovement(1 / 60); // Assuming tick operates at 60FPS if (unit.update) { unit.update(); } game.addChild(unit); if (unit.assetEffect) { game.addChild(unit.assetEffect); } }); aiThinking(); aiActing(); } tickCounter++; }); // Show popup before game starts var popup = LK.getAsset('popup', { x: game.width / 2, y: game.height / 2, anchorX: 0.5, anchorY: 0.5 }); var welcomeText = new Text2("Welcome on Sandoria", { size: 90, fill: "#ffffff", font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); welcomeText.anchor.set(0.5, 6.4); LK.gui.center.addChild(welcomeText); var helpText = new Text2("Planet of sand and Spice, the most valuable \nresource of the universe.\n\nYou have just been promoted as a commander of\nthe Adrians family army.\nYour mission is to HARVEST SPICE in this area\nand CLEAR ALL ENEMY presence.\n\nFrom your CONSTRUCTION YARD, build a\nSPICE REFINERY and use SPICE HARVESTERS to\ncollect the orange SPICE on the soil.\nBuild WIND TRAPS to produce energy. Monitor\nyour energy and Spice counters at the top right.\n\nEnemy Kojrims troops have been reported\nin the area: build LIGHT FACTORY OR \nHEAVY FACTORY to train more troops.\n\nGood luck Commander!", { size: 50, fill: "#ffffff", font: "'GillSans-Bold',Impact,'Arial Black',Tahoma" }); helpText.anchor.set(0.5, 0.488); LK.gui.center.addChild(helpText); popup.on('down', function () { game.removeChild(popup); LK.gui.center.removeChild(welcomeText); LK.gui.center.removeChild(helpText); // Start the game with Player 1 construction yard preselected initGame(); LK.setTimeout(function () { gameIsRunning = true; viewPort.wCellX = Math.max(0, Math.min(mapXSize - viewPort.cellW, rockIlot1Center.x - Math.floor(viewPort.cellW / 2))); viewPort.wCellY = Math.max(0, Math.min(mapYSize - viewPort.cellH, rockIlot1Center.y - Math.floor(viewPort.cellH / 2))); gameMap.handleDrag({ x: 0, y: 0 }); // Call handleDrag on player1 units player1.units.forEach(function (unit) { unit.handleDrag({ x: 0, y: 0 }); }); currentSelection = gameMap.cells[rockIlot1Center.x][rockIlot1Center.y].building; selectionMarker.setOnElement(currentSelection); updateActionBoard(); updateFogOfWar(); }, 100); }); game.addChild(popup);