Ticket #745: rallypoint_on_entities.diff

binaries/data/mods/public/gui/session/input.js

@@ -139 +139 @@
     if (!target)
     {
         if (action == "set-rallypoint" && haveRallyPoints)
-            return {"possible": true};
+            return {"possible": true, "command": "walk"};
         else if (action == "move")
             return {"possible": true};
         else
@@ -163 +163 @@
     // Check if any entities in the selection can gather the requested resource,
     // can return to the dropsite, can build the foundation, or can attack the enemy
     var simState = Engine.GuiInterfaceCall("GetSimulationState");
+    
+    // Look to see what type of command units going to the rally point should use
+    if (haveRallyPoints && action == "set-rallypoint"){
+        // haveRallyPoints ensures all selected entities can have rally points.
+        // We assume that all entities are owned by the same player.
+        var entState = GetEntityState(selection[0]);
+        
+        var playerState = simState.players[entState.player];
+        var playerOwned = (targetState.player == entState.player);
+        var allyOwned = playerState.isAlly[targetState.player];
+        var enemyOwned = playerState.isEnemy[targetState.player];
+        var gaiaOwned = (targetState.player == 0);
+        
+        // default to walking there
+        var data = {command: "walk"};
+        if (targetState.garrisonHolder && playerOwned)
+        {
+            data.command = "garrison";
+            data.target = target;
+        }
+        else if (targetState.resourceSupply && (playerOwned || gaiaOwned))
+        {
+            var resourceType = targetState.resourceSupply.type.generic;
+            if (resourceType === "treasure")
+            {
+                resourceType = targetState.resourceSupply.type.specific;
+            }
+            data.command = "gather";
+            data.resourceType = resourceType;
+        }
+        else if (targetState.foundation && entState.buildEntities)
+        {
+            data.command = "build";
+            data.target = target;
+        }
+        else if (targetState.needsRepair && allyOwned)
+        {
+            data.command = "repair";
+            data.target = target;
+        }
+        else if (targetState.hitpoints && enemyOwned){
+            data.command = "attack";
+            data.target = target;
+        }
+        
+        return {"possible": true, "data": data, "position": targetState.position};
+    }
 
     for each (var entityID in selection)
     {
@@ -312 +359 @@
             return {"type": "build", "cursor": "action-repair", "target": target};
         else if (getActionInfo("attack", target).possible)
             return {"type": "attack", "cursor": "action-attack", "target": target};
-        else if(getActionInfo("set-rallypoint", target).possible)
-            return {"type": "set-rallypoint"};
+        else if((actionInfo = getActionInfo("set-rallypoint", target)).possible)
+            return {"type": "set-rallypoint", "data": actionInfo.data, "position": actionInfo.position};
         else if(getActionInfo("unset-rallypoint", target).possible)
                 return {"type": "unset-rallypoint"};
         else if (getActionInfo("move", target).possible)
@@ -932 +979 @@
         return true;
 
     case "set-rallypoint":
-        var target = Engine.GetTerrainAtPoint(ev.x, ev.y);
-        Engine.PostNetworkCommand({"type": "set-rallypoint", "entities": selection, "x": target.x, "z": target.z});
+        var pos = undefined;
+        // if there is a position set in the action then use this so that when setting a 
+        // rally point on an entity it is centered on that entity
+        if (action.position)
+        {
+            pos = action.position;
+        }
+        else
+        {
+            pos = Engine.GetTerrainAtPoint(ev.x, ev.y);
+        }
+        Engine.PostNetworkCommand({"type": "set-rallypoint", "entities": selection, "x": pos.x, "z": pos.z, "data": action.data});
         // Display rally point at the new coordinates, to avoid display lag
         Engine.GuiInterfaceCall("DisplayRallyPoint", {
             "entities": selection,
-            "x": target.x,
-            "z": target.z
+            "x": pos.x,
+            "z": pos.z
         });
         return true;
 

binaries/data/mods/public/simulation/components/TrainingQueue.js

@@ -286 +286 @@
             var rallyPos = cmpRallyPoint.GetPosition();
             if (rallyPos)
             {
-                ProcessCommand(cmpOwnership.GetOwner(), {
-                    "type": "walk",
-                    "entities": spawnedEnts,
-                    "x": rallyPos.x,
-                    "z": rallyPos.z,
-                    "queued": false
-                });
+                // Look and see if there is a command in the rally point data, otherwise just walk there.
+                var data = cmpRallyPoint.GetData();
+                var command = undefined;
+                if (data && data.command){
+                    command = data.command;
+                }else{
+                    command = "walk";
+                }
+                
+                // If a target was set and the target no longer exists them just walk to the rally point.
+                if (data && data.target){
+                    if (! Engine.QueryInterface(data.target, IID_Position)){
+                        command = "walk";
+                    }
+                }
+                
+                switch (command)
+                {
+                case "gather":
+                    ProcessCommand(cmpOwnership.GetOwner(), {
+                        "type": "gatherNearPosition",
+                        "entities": spawnedEnts,
+                        "x": rallyPos.x,
+                        "z": rallyPos.z,
+                        "resourceType": data.resourceType,
+                        "queued": false
+                    });
+                    break;
+                case "repair": 
+                case "build":
+                    ProcessCommand(cmpOwnership.GetOwner(), {
+                        "type": "repair",
+                        "entities": spawnedEnts,
+                        "target": data.target,
+                        "queued": false,
+                        "autocontinue": true
+                    });
+                    break;
+                case "garrison": 
+                    ProcessCommand(cmpOwnership.GetOwner(), {
+                        "type": "garrison",
+                        "entities": spawnedEnts,
+                        "target": data.target,
+                        "queued": false
+                    });
+                    break;
+                case "attack": 
+                    ProcessCommand(cmpOwnership.GetOwner(), {
+                        "type": "attack",
+                        "entities": spawnedEnts,
+                        "target": data.target,
+                        "queued": false
+                    });
+                    break;
+                default:
+                    ProcessCommand(cmpOwnership.GetOwner(), {
+                        "type": "walk",
+                        "entities": spawnedEnts,
+                        "x": rallyPos.x,
+                        "z": rallyPos.z,
+                        "queued": false
+                    });
+                }
             }
         }
 

binaries/data/mods/public/simulation/components/UnitAI.js

@@ -284 +284 @@
     },
 
     "Order.Gather": function(msg) {
+        
         // If the target is still alive, we need to kill it first
         if (this.MustKillGatherTarget(this.order.data.target) && this.CheckTargetVisible(this.order.data.target))
         {
@@ -315 +316 @@
             this.SetNextState("INDIVIDUAL.GATHER.GATHERING");
         }
     },
+    
+    "Order.GatherNearPosition": function(msg){
+        // Move the unit to the position to gather from.
+        this.MoveToPoint(this.order.data.x, this.order.data.z);
+        this.SetNextState("INDIVIDUAL.GATHER.WALKING");
+    },
 
     "Order.ReturnResource": function(msg) {
         // Try to move to the dropsite
@@ -408 +415 @@
             cmpFormation.CallMemberFunction("Gather", [msg.data.target, false]);
             cmpFormation.Disband();
         },
+        
+        "Order.GatherNearPosition": function(msg){
+            var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            cmpFormation.CallMemberFunction("GatherNearPosition", [[msg.data.x, msg.data.z], msg.data.type, false]);
+            cmpFormation.Disband();
+        },
 
         "Order.ReturnResource": function(msg) {
             // TODO: see notes in Order.Attack
@@ -815 +828 @@
                     this.SetNextState("GATHERING");
                 },
             },
+            
+            // Walking to a good place to gather resoruce near, ued by gatherNearPosition
+            "WALKING": {
+                "enter": function() {
+                    this.SelectAnimation("move");
+                },
 
+                "MoveCompleted": function(msg) {
+                        var resourceType = this.order.data.type;
+                        
+                        // Try to find another nearby target of the same specific type
+                        var nearby = this.FindNearbyResource(function (ent, type) {
+                            if (type.generic === "treasure"){
+                                return (type.specific == resourceType);
+                            }
+                            return (type.generic == resourceType);
+                        });
+                        
+                        // If there is a nearby resource start gathering
+                        if (nearby)
+                        {
+                            this.Gather(nearby, false);
+                            return;
+                        }
+                        
+                        // Couldn't find nearby resources, so give up
+                        this.FinishOrder();
+
+                },
+            },
+
             "GATHERING": {
                 "enter": function() {
                     this.StartTimer(1000, 1000);
@@ -2179 +2222 @@
         switch (order.type)
         {
         case "Walk":
+        case "GatherNearPosition":
             // Add the distance to the target point
             var dx = order.data.x - pos.x;
             var dz = order.data.z - pos.z;
@@ -2307 +2351 @@
     this.AddOrder("Gather", { "target": target, "type": type, "lastPos": lastPos }, queued);
 };
 
+UnitAI.prototype.GatherNearPosition = function(position, type, queued){
+    this.AddOrder("GatherNearPosition", { "type": type, "x": position[0], "z": position[1] }, queued);
+}
+
 UnitAI.prototype.ReturnResource = function(target, queued)
 {
     if (!this.CanReturnResource(target, true))

binaries/data/mods/public/simulation/components/RallyPoint.js

@@ -16 +16 @@
     }
 };
 
-RallyPoint.prototype.Unset = function()
+RallyPoint.prototype.GetPosition = function()
 {
-    this.pos = undefined;
+    return this.pos;
 };
 
-RallyPoint.prototype.GetPosition = function()
+// Extra data for the rally point, should have a command property and then helpful data for that command
+// See getActionInfo in gui/input.js
+RallyPoint.prototype.SetData = function(data)
 {
-    return this.pos;
+    this.data = data;
 };
 
+RallyPoint.prototype.GetData = function()
+{
+    return this.data;
+};
+
+RallyPoint.prototype.Unset = function()
+{
+    this.pos = undefined;
+    this.data = undefined;
+};
+
+
 Engine.RegisterComponentType(IID_RallyPoint, "RallyPoint", RallyPoint);