Ticket #2266: Guard.diff

binaries/data/mods/public/art/textures/cursors/action-guard-disabled.txt

@@ +1 @@
+1 1

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

@@ -15 +15 @@
 const ACTION_NONE = 0;
 const ACTION_GARRISON = 1;
 const ACTION_REPAIR = 2;
+const ACTION_GUARD = 3;
 var preSelectedAction = ACTION_NONE;
 
 const INPUT_NORMAL = 0;
@@ -246 +247 @@
             if (targetState.garrisonHolder.garrisonedEntitiesCount >= targetState.garrisonHolder.capacity)
                 tooltip = "[color=\"orange\"]" + tooltip + "[/color]";
         }
+        if (targetState.guard && (playerOwned || mutualAllyOwned))
+        {
+            data.command = "guard";
+            data.target = target;
+            cursor = "action-guard";
+            tooltip = "Current guard: " + targetState.guard.entities.length
+                + "/" + targetState.guard.capacity;
+            if (targetState.guard.entities.length >= targetState.guard.capacity)
+                tooltip = "[color=\"red\"]" + tooltip + "[/color]";
+        }
         else if (targetState.resourceSupply)
         {
             var resourceType = targetState.resourceSupply.type;
@@ -303 +314 @@
                 if (target === selection[i])
                     return {"possible": false};
         }
+        // Don't allow the rally point to be set on any of the currently selected entities
+        for (var i = 0; i < selection.length; i++)
+            if (target === selection[i])
+                return {"possible": false};
 
         return {"possible": true, "data": data, "position": targetState.position, "cursor": cursor, "tooltip": tooltip};
     }
@@ -347 +362 @@
                 }
             }
             break;
+        case "guard":
+            if (hasClass(entState, "Unit") && targetState.guard && (playerOwned || mutualAllyOwned))
+            {
+                var tooltip = "Current guarding: " + targetState.guard.entities.length
+                    + "/" + targetState.guard.capacity;
+                if (targetState.guard.entities.length >= targetState.guard.capacity)
+                    tooltip = "[color=\"orange\"]" + tooltip + "[/color]";
+                var allowedClasses = targetState.guard.allowedClasses;
+                        return {"possible": true, "tooltip": tooltip};
+            }
+            break;
         case "setup-trade-route":
             // If ground or sea trade possible
             if (!targetState.foundation && ((entState.trader && hasClass(entState, "Organic") && (playerOwned || allyOwned) && hasClass(targetState, "Market")) ||
@@ -502 +528 @@
             else
                 return {"type": "none", "cursor": "action-repair-disabled", "target": undefined};
             break;
+        case ACTION_GUARD:
+            if ((actionInfo = getActionInfo("guard", target)).possible)
+                return {"type": "guard", "cursor": "action-guard", "tooltip": actionInfo.tooltip, "target": target};
+            else
+                return {"type": "none", "cursor": "action-guard-disabled", "target": undefined};
+            break;
         }
     }
     else if (Engine.HotkeyIsPressed("session.attack") && getActionInfo("attack", target).possible)
@@ -516 +548 @@
     {
             return {"type": "attack-move", "cursor": "action-attack-move"};
     }
+        else if (haveUnitAI && Engine.HotkeyIsPressed("session.guard") && getActionInfo("guard", target).possible)
+    {
+            return {"type": "guard", "cursor": "action-guard"};
+    }
     else
     {
         if ((actionInfo = getActionInfo("setup-trade-route", target)).possible)
@@ -1373 +1409 @@
         Engine.PostNetworkCommand({"type": "repair", "entities": selection, "target": action.target, "autocontinue": true, "queued": queued});
         Engine.GuiInterfaceCall("PlaySound", { "name": "order_repair", "entity": selection[0] });
         return true;
-
+    case "guard":
+        Engine.PostNetworkCommand({"type": "guard", "entities": selection, "target": action.target, "queued": queued});
+        Engine.GuiInterfaceCall("PlaySound", { "name": "order_guard", "entity": selection[0] });
+        return true;
     case "gather":
         Engine.PostNetworkCommand({"type": "gather", "entities": selection, "target": action.target, "queued": queued});
         Engine.GuiInterfaceCall("PlaySound", { "name": "order_gather", "entity": selection[0] });
@@ -1816 +1855 @@
                 inputState = INPUT_PRESELECTEDACTION;
                 preSelectedAction = ACTION_GARRISON;
                 break;
+            case "guard":
+                inputState = INPUT_PRESELECTEDACTION;
+                preSelectedAction = ACTION_GUARD;
+                break;
             case "repair":
                 inputState = INPUT_PRESELECTEDACTION;
                 preSelectedAction = ACTION_REPAIR;

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

@@ -2 +2 @@
 const SELECTION = "Selection";
 const QUEUE = "Queue";
 const GARRISON = "Garrison";
+const GUARD = "Guard";
 const FORMATION = "Formation";
 const TRAINING = "Training";
 const RESEARCH = "Research";

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

@@ -274 +274 @@
             "tooltip": "Garrison",
             "icon": "garrison.png"
         });
+        commands.push({
+            "name": "guard",
+            "tooltip": "Guard",
+            "icon": "guard.png"
+        });
     }
 
     if (entState.buildEntities)

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

@@ +1 @@
+function Guard() {}
+
+Guard.prototype.Schema =
+    "<a:component type='system'/><empty/>";
+
+Guard.prototype.Init = function()
+{
+    this.VIP={};
+    // Guardian Units
+    this.entities = [];
+    this.timer = undefined;
+    this.allowGuarding = true;
+        this.capacity = 20;
+};
+
+Guard.prototype.GetEntities = function()
+{
+    return this.entities;
+};
+Guard.prototype.GetCapacity = function()
+{
+    return this.capacity;
+};
+Guard.prototype.GetVIP = function()
+{
+    return this.VIP;
+};
+
+Guard.prototype.AllowGuarding = function(allow, callerID)
+{
+    this.allowGuarding[callerID] = allow;
+};
+Guard.prototype.AddGuards = function(entity)
+{
+    if (this.entities.length >= this.GetCapacity())
+        return false;
+
+    var cmpPosition = Engine.QueryInterface(entity, IID_Position);
+    if (!cmpPosition)
+        return false;
+        //code
+    
+    this.entities.push(entity);
+    Engine.PostMessage(this.entity, MT_GuardingUnitsChanged, {});
+    return true;
+};
+Guard.prototype.EntityLeave = function(entity)
+{
+        var entityIndex = this.entities.indexOf(entity)
+        if (entityIndex != -1)
+        {
+        this.entities.splice(entityIndex, 1);
+        Engine.PostMessage(this.entity, MT_GuardingUnitsChanged, {});
+        }
+        
+};
+Guard.prototype.CanGuard = function(target)
+{
+    const cmpIdentity = Engine.QueryInterface(target, IID_Identity);
+    if (!cmpIdentity) 
+        return undefined;
+
+    const targetClasses = cmpIdentity.GetClassesList();
+
+            return true;
+    return false;
+};
+Guard.prototype.CheckGuardRange = function(target)
+{
+    const cmpIdentity = Engine.QueryInterface(target, IID_Identity);
+    if (!cmpIdentity) 
+        return undefined;
+
+    const targetClasses = cmpIdentity.GetClassesList();
+
+            return true;
+    return false;
+};
+Guard.prototype.OnOwnershipChanged = function(msg)
+{
+    
+};
+Guard.prototype.OnDestroy = function(msg)
+{
+    
+};
+/**
+ * If a guarded entity is captured, or about to be killed (so its owner
+ * changes to '-1'), remove it from the building so we only ever contain valid
+ * entities
+ */
+Guard.prototype.OnGlobalOwnershipChanged = function(msg)
+{
+    // the ownership change may be on the VIP
+    if (this.entity == msg.entity)
+    {
+        var entities = [];
+        for each (var entity in this.entities)
+        {
+            if (msg.to == -1 || !IsOwnedByMutualAllyOfEntity(this.entity, entity))
+                entities.push(entity);
+        }
+        this.EjectOrKill(entities);
+        return;
+    }
+
+    // or on some of its guarded units
+    var entityIndex = this.entities.indexOf(msg.entity);
+    if (entityIndex != -1)
+    {
+        // If the entity is dead, remove it directly instead of ejecting the corpse
+        var cmpHealth = Engine.QueryInterface(msg.entity, IID_Health);
+        if (cmpHealth && cmpHealth.GetHitpoints() == 0)
+        {
+            this.entities.splice(entityIndex, 1);
+            Engine.PostMessage(this.entity, MT_GuardingUnitsChanged, {});
+        }
+        else if(!IsOwnedByMutualAllyOfEntity(this.entity, this.entities[entityIndex]))
+            this.EjectOrKill([this.entities[entityIndex]]);
+    }
+};
+
+Guard.prototype.OnGlobalEntityRenamed = function(msg)
+{
+    var entityIndex = this.entities.indexOf(msg.entity);
+    if (entityIndex != -1)
+    {
+        this.entities[entityIndex] = msg.newentity;
+        Engine.PostMessage(this.entity, MT_GuardingUnitsChanged, {});
+    }
+};
+Guard.prototype.EjectOrKill = function(entities)
+{
+
+    // And destroy all remaining entities
+    for each (var entity in entities)
+    {
+        var entityIndex = this.entities.indexOf(entity);
+        if (entityIndex == -1)
+            continue;
+        var cmpHealth = Engine.QueryInterface(entity, IID_Health);
+        if (cmpHealth)
+        
+        this.entities.splice(entityIndex, 1);
+    }
+
+    Engine.PostMessage(this.entity, MT_GuardingUnitsChanged, {});
+};
+Guard.prototype.Unload = function(entity, forced)
+{
+    return this.PerformEject([entity], forced);
+};
+Guard.prototype.OnHealthChanged = function(msg)
+{
+};
+Guard.prototype.HasEnoughHealth = function()
+{
+    var cmpHealth = Engine.QueryInterface(this.entity, IID_Health)
+    var hitpoints = cmpHealth.GetHitpoints();
+    var maxHitpoints = cmpHealth.GetMaxHitpoints();
+    var ejectHitpoints = Math.floor((+this.template.EjectHealth) * maxHitpoints);
+    return hitpoints > ejectHitpoints;
+};
+/**
+ * Ejects units and orders them to move to the Rally Point.
+ * Returns true if successful, false if not
+ */
+Guard.prototype.PerformEject = function(entities, forced)
+{
+    if (!this.allowGuarding() && !forced)
+        return false;
+
+    var ejectedEntities = [];
+    var success = true;
+    for each (var entity in entities)
+    {
+        if (this.Eject(entity, forced))
+        {
+            var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+            var cmpEntOwnership = Engine.QueryInterface(entity, IID_Ownership);
+            if (cmpOwnership && cmpEntOwnership && cmpOwnership.GetOwner() == cmpEntOwnership.GetOwner())
+                ejectedEntities.push(entity);
+        }
+        else
+            success = false;
+    }
+
+    return success;
+};
+
+Engine.RegisterComponentType(IID_Guard, "Guard", Guard);
+ No newline at end of file

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

@@ -308 +308 @@
     {
         ret.resourceGatherRates = cmpResourceGatherer.GetGatherRates();
         ret.resourceCarrying = cmpResourceGatherer.GetCarryingStatus();
+    }
+    var cmpGuard = Engine.QueryInterface(ent, IID_Guard);
+    if (cmpGuard)
+    {
+        ret.guard = {
+            "entities": cmpGuard.GetEntities(),
+            "capacity": cmpGuard.GetCapacity(),
+        };
     }
-
     var cmpResourceDropsite = Engine.QueryInterface(ent, IID_ResourceDropsite);
     if (cmpResourceDropsite)
     {

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

@@ -331 +331 @@
             this.FinishOrder();
         }
     },
-
+    "Order.WalkToTargetRange": function(msg) {
+            if (this.MoveToTargetRangeExplicit(this.order.data.target, this.order.data.min, this.order.data.max))
+                this.SetNextState("WALKING");
+            else
+                this.FinishOrder();
+        },
     "Order.PickupUnit": function(msg) {
         var cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
         if (!cmpGarrisonHolder || cmpGarrisonHolder.IsFull())
@@ -659 +664 @@
             this.SetNextState("INDIVIDUAL.GARRISON.GARRISONED");
         }
     },
-
+    "Order.Guard": function(msg) {
+        // For packable units:
+        // 1. If packed, we can move to the garrison target.
+        // 2. If unpacked, we first need to pack, then follow case 1.
+        this.SetNextState("INDIVIDUAL.GUARD.APPROACHING");
+        if (this.CanPack())
+        {
+            // Case 2: pack
+            this.PushOrderFront("Pack", { "force": true });
+            return;
+        }
+    },
     "Order.Autogarrison": function(msg) {
         this.SetNextState("INDIVIDUAL.AUTOGARRISON");
     },
@@ -797 +813 @@
 
             this.SetNextState("GARRISON.GARRISONING");
         },
+        "Order.Guard": function(msg) {
+            // TODO: on what should we base this range?
+            // Check if we are already in range, otherwise walk there
+            if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
+            {
+                if (!this.CheckTargetVisible(msg.data.target))
+                {
+                if (!this.TargetIsAlive(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
+                    // The target was destroyed
+                    this.FinishOrder();
+                }
+                else
+                {
+                    // Out of range; move there in formation
+                    this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
+                    return;
+                }
+                
+            // We don't want to rearrange the formation if the individual units are carrying
+            // out a task and one of the members dies/leaves the formation.
+            }
+            var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+            // We don't want to rearrange the formation if the individual units are carrying
+            // out a task and one of the members dies/leaves the formation.
+            cmpFormation.SetRearrange(false);
+            cmpFormation.CallMemberFunction("Guard", [msg.data.target, false]);
 
+            
+
+            this.SetNextStateAlwaysEntering("MEMBER");
+        },
+
         "Order.Gather": function(msg) {
             if (this.MustKillGatherTarget(msg.data.target))
             {
@@ -1097 +1144 @@
                 cmpFormation.FindInPosition();
             }
         },
-
         "MEMBER": {
             // Wait for individual members to finish
             "enter": function(msg) {
@@ -2002 +2048 @@
                 },
             },
         },
+        "GUARD": {
+            "APPROACHING": {
+                "enter": function() {
+                    this.SelectAnimation("move");
+                },
+                "MoveCompleted": function() {
+                    this.SetNextState("GUARDING");
+                },
+                
+                "leave": function() {
+                    this.StopTimer();
+                }
+                    }
+            },
+        "GUARDING":{
+        "enter": function() {
+        var target = this.order.data.target;
+        var cmpGuard = Engine.QueryInterface(target, IID_Guard);
+        this.VIP=cmpGuard.GetVIP;
 
+        // Check that we can guard here
+                if (cmpGuard.CanGuard(target))
+                {
+                    // Check that we're in range of the guarded target
+                    if (cmpGuard.CheckGuardRange(target))
+                    {
+                        // Check that garrisoning succeeds
+                        if (cmpGuard.AddGuards(this.entity))
+                        {
+                            this.isGuarding = true;
+                            this.VIP=target;
+                            return;}
+                    }   
+                }
+                },
+        "leave": function() {
+        this.StopTimer();
+        this.isGuarding = false;
+        var cmpGuard = Engine.QueryInterface(this.VIP, IID_Guard);
+        cmpGuard.EntityLeave(this.entity);
+        this.VIP=undefined;
+        return;
+                }
+    },
         "HEAL": {
             "Attacked": function(msg) {
                 // If we stand ground we will rather die than flee
@@ -2705 +2794 @@
     this.order = undefined; // always == this.orderQueue[0]
     this.formationController = INVALID_ENTITY; // entity with IID_Formation that we belong to
     this.isGarrisoned = false;
+    this.isGuarding = false;
     this.isIdle = false;
     this.lastFormationName = "";
     this.finishedOrder = false; // used to find if all formation members finished the order
@@ -2772 +2862 @@
 {
     return this.isGarrisoned;
 };
-
+UnitAI.prototype.IsGuarding = function()
+{
+    return this.IsGuarding;
+};
 UnitAI.prototype.IsWalking = function()
 {
     var state = this.GetCurrentState().split(".").pop();
@@ -4182 +4275 @@
         case "ReturnResource":
         case "Repair":
         case "Garrison":
+        case "Guard":
             // Find the target unit's position
             var cmpTargetPosition = Engine.QueryInterface(order.data.target, IID_Position);
             if (!cmpTargetPosition || !cmpTargetPosition.IsInWorld())
@@ -4209 +4303 @@
     // Return the total distance to the end of the order queue
     return distance;
 };
-
+UnitAI.prototype.Guard = function(target, queued)
+{
+    if (!this.CanGuard(target))
+    {
+        this.WalkToTarget(target, queued);
+        return;
+    }
+    this.WalkToTarget(target, queued);
++   this.AddOrder("Guard", { "target": target, "force": true }, queued);
+};
 UnitAI.prototype.AddOrder = function(type, data, queued)
 {
     if (queued)
@@ -4907 +5010 @@
 
     return true;
 };
+UnitAI.prototype.CanGuard = function(target)
+{
+    // Formation controllers should always respond to commands
+    // (then the individual units can make up their own minds)
+    if (this.IsFormationController())
+        return true;
+ 
+    var cmpGuard = Engine.QueryInterface(target, IID_Guard);
+    if (!cmpGuard)
+        return false;
 
+    // Verify that the target is owned by this entity's player or a mutual ally of this player
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (!cmpOwnership || !(IsOwnedByPlayer(cmpOwnership.GetOwner(), target) || IsOwnedByMutualAllyOfPlayer(cmpOwnership.GetOwner(), target)))
+        return false;
+
+    // Don't let animals garrison for now
+    // (If we want to support that, we'll need to change Order.Garrison so it
+    // doesn't move the animal into an INVIDIDUAL.* state)
+    if (this.IsAnimal())
+        return false;
+    return true;
+};
 UnitAI.prototype.CanPack = function()
 {
     var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);

binaries/data/mods/public/simulation/components/interfaces/Guard.js

@@ +1 @@
+Engine.RegisterInterface("Guard");
+
+// Message of the form { } (use GetEntities if you want the current details),
+// sent to the current entity whenever the garrisoned units change.
+Engine.RegisterMessageType("GuardingUnitsChanged");
+ No newline at end of file

binaries/data/mods/public/simulation/helpers/Commands.js

@@ -156 +156 @@
             cmpUnitAI.GatherNearPosition(cmd.x, cmd.z, cmd.resourceType, cmd.resourceTemplate, cmd.queued);
         });
         break;
-
+    case "guard":
+        // Verify that the building can be controlled by the player or is mutualAlly
+        if (CanControlUnitOrIsAlly(cmd.target, player, controlAllUnits))
+        {
+            GetFormationUnitAIs(entities, player).forEach(function(cmpUnitAI) {
+                cmpUnitAI.Guard(cmd.target, cmd.queued);
+            });
+            warn("Invalid command: guard is in alpha state "+player+" (or ally): "+uneval(cmd));
+        
+        }
+        else if (g_DebugCommands)
+        {
+            warn("Invalid command: garrison target cannot be controlled by player "+player+" (or ally): "+uneval(cmd));
+        }
+        break;
     case "returnresource":
         // Check dropsite is owned by player
         if (g_DebugCommands && !IsOwnedByPlayer(player, cmd.target))

binaries/data/mods/public/simulation/templates/template_unit.xml

@@ -53 +53 @@
     </Formations>
   </Identity>
   <Looter/>
+  <Guard>
+  </Guard>
   <Minimap>
     <Type>unit</Type>
   </Minimap>

binaries/system/Quickstart.bat

@@ -1 @@
-start pyrogenesis.exe -quickstart
+start pyrogenesis.exe -quickstart
+ No newline at end of file