Ticket #1391: shipgarrison-v5.diff

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

@@ -160 +160 @@
         // ignore
     },
 
+    "PickupCanceled": function(msg) {
+        // ignore
+    },
+
     // Formation handlers:
 
     "FormationLeave": function(msg) {
@@ -328 +332 @@
         }
     },
 
+    "Order.PickupUnit": function(msg) {
+        var cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
+        if (!cmpGarrisonHolder || cmpGarrisonHolder.IsFull())
+        {
+            this.FinishOrder();
+            return;
+        }
+
+        if (this.MoveToTarget(this.order.data.target))
+        {
+            this.SetNextState("INDIVIDUAL.PICKUP.APPROACHING");
+        }
+        else
+        {
+        // We are already at the target, or can't move at all
+            this.StopMoving();
+            this.SetNextState("INDIVIDUAL.PICKUP.LOADING");
+        }
+    },
+
     "Order.Flee": function(msg) {
         // We use the distance between the enities to account for ranged attacks
         var distance = DistanceBetweenEntities(this.entity, this.order.data.target) + (+this.template.FleeDistance);
@@ -597 +621 @@
             return;
         }
 
-        if (this.MoveToTarget(this.order.data.target))
+        if (this.MoveToGarrisonRange(this.order.data.target))
         {
             this.SetNextState("INDIVIDUAL.GARRISON.APPROACHING");
         }
@@ -716 +740 @@
         },
 
         "Order.Garrison": function(msg) {
-            // TODO: on what should we base this range?
+            if (!Engine.QueryInterface(msg.data.target, IID_GarrisonHolder))
+            {
+                this.FinishOrder();
+                return;
+            }
             // Check if we are already in range, otherwise walk there
-            if (!this.CheckTargetRangeExplicit(msg.data.target, 0, 10))
+            if (!this.CheckGarrisonRange(msg.data.target))
             {
-                if (!this.TargetIsAlive(msg.data.target) || !this.CheckTargetVisible(msg.data.target))
-                    // The target was destroyed
+                if (!this.CheckTargetVisible(msg.data.target))
+                {
                     this.FinishOrder();
+                    return;
+                }
                 else
+                {
                     // Out of range; move there in formation
-                    this.PushOrderFront("WalkToTargetRange", { "target": msg.data.target, "min": 0, "max": 10 });
-                return;
+                    if (this.MoveToGarrisonRange(msg.data.target))
+                    {
+                        this.SetNextState("GARRISON.APPROACHING");
+                        return;
+                    }
+                }
             }
 
-            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("Garrison", [msg.data.target, false]);
-
-            this.SetNextStateAlwaysEntering("MEMBER");
+            this.SetNextState("GARRISON.GARRISONING");
         },
 
         "Order.Gather": function(msg) {
@@ -966 +995 @@
             },
         },
 
+        "GARRISON":{
+            "enter": function() {
+                // If the garrisonholder should pickup, warn it so it can take needed action
+                var cmpGarrisonHolder = Engine.QueryInterface(this.order.data.target, IID_GarrisonHolder);
+                if (cmpGarrisonHolder && cmpGarrisonHolder.ShouldPickup())
+                {
+                    this.pickup = this.order.data.target;       // temporary, deleted in "leave"
+                    Engine.PostMessage(this.pickup, MT_PickupRequested, { "entity": this.entity });
+                }
+            },
+
+            "leave": function() {
+                // If a pickup has been requested and not yet canceled, cancel it
+                if (this.pickup)
+                {
+                    Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
+                    delete this.pickup;
+                }
+            },
+
+
+            "APPROACHING": {
+                "MoveStarted": function(msg) {
+                    var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
+                    cmpFormation.SetRearrange(true);
+                    cmpFormation.MoveMembersIntoFormation(true, true);
+                },
+
+                "MoveCompleted": function(msg) {
+                    this.SetNextState("GARRISONING");
+                },
+            },
+
+            "GARRISONING": {
+                "enter": function() {
+                    // If a pickup has been requested, cancel it as it will be requested by members
+                    if (this.pickup)
+                    {
+                        Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
+                        delete this.pickup;
+                    }
+                    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("Garrison", [this.order.data.target, false]);
+                    this.SetNextStateAlwaysEntering("MEMBER");
+                },
+            },
+        },
+
         "FORMING": {
             "MoveStarted": function(msg) {
                 var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
@@ -2186 +2266 @@
         },
 
         "GARRISON": {
+            "enter": function() {
+                // If the garrisonholder should pickup, warn it so it can take needed action
+                var cmpGarrisonHolder = Engine.QueryInterface(this.order.data.target, IID_GarrisonHolder);
+                if (cmpGarrisonHolder && cmpGarrisonHolder.ShouldPickup())
+                {
+                    this.pickup = this.order.data.target;       // temporary, deleted in "leave"
+                    Engine.PostMessage(this.pickup, MT_PickupRequested, { "entity": this.entity });
+                }
+            },
+
+            "leave": function() {
+                // If a pickup has been requested and not yet canceled, cancel it
+                if (this.pickup)
+                {
+                    Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
+                    delete this.pickup;
+                }
+
+                if (this.stationary)
+                    delete this.stationary;
+            },
+
             "APPROACHING": {
                 "enter": function() {
                     this.SelectAnimation("move");
@@ -2194 +2296 @@
                 "MoveCompleted": function() {
                     this.SetNextState("GARRISONED");
                 },
-                
-                "leave": function() {
-                    this.StopTimer();
-                }
             },
 
             "GARRISONED": {
@@ -2229 +2327 @@
                                         this.SetGathererAnimationOverride();
                                     }
                                 }
+
+                                // If a pickup has been requested, remove it
+                                if (this.pickup)
+                                {
+                                    Engine.PostMessage(this.pickup, MT_PickupCanceled, { "entity": this.entity });
+                                    delete this.pickup;
+                                }
                                 
                                 return false;
                             }
                         }
                         else
                         {
-                            // Unable to reach the target, try again
-                            // (or follow if it's a moving target)
-                            if (this.MoveToTarget(target))
+                            // Unable to reach the target, we try again or follow it if it's a moving target
+ 
+                            if (this.stationary && this.stationary.n > 10)
                             {
-                                this.SetNextState("APPROACHING");
-                                return false;
+                                // If we've been stationary in the last trials, we delay the following trials
+                                // and eventually stop trying (more trials if target can pickup and not full to leave it time to come))
+                                if (!cmpGarrisonHolder.ShouldPickup() || cmpGarrisonHolder.IsFull() || this.stationary.n > 100)
+                                {
+                                    this.FinishOrder();
+                                    return true;
+                                }
                             }
+
+                            var pos = Engine.QueryInterface(this.entity, IID_Position).GetPosition();
+                            if (!this.stationary || Math.abs(this.stationary.x-pos.x) > 0.00001 || Math.abs(this.stationary.z-pos.z) > 0.00001)
+                                this.stationary = { "x": pos.x, "z": pos.z, "n": 0}; 
+                            else
+                                this.stationary.n += 1;
+
+                            if (this.stationary.n < 5)
+                                this.StartTimer(0);
+                            else if (this.stationary.n < 10)
+                                this.StartTimer(200);
+                            else
+                                this.StartTimer(1000);
+
+                            return false;
                         }
                     }
                     // Garrisoning failed for some reason, so finish the order
                     this.FinishOrder();
                     return true;
                 },
+
+                "Timer": function(msg) {
+                    if (this.MoveToGarrisonRange(this.order.data.target))
+                    {
+                        // If the target should pickup, warn it again from time to time (in case its orders were changed)
+                        if (this.pickup && this.stationary.n%5 == 0)
+                            Engine.PostMessage(this.pickup, MT_PickupRequested, { "entity": this.entity });
+                        this.SetNextState("APPROACHING");
+                    }
+                    else
+                    {
+                        this.FinishOrder();
+                    }
+                },
                 
                 "Order.Ungarrison": function() {
                     if (this.FinishOrder())
@@ -2256 +2395 @@
 
                 "leave": function() {
                     this.isGarrisoned = false;
-                }
+                },
             },
         },
 
@@ -2316 +2455 @@
                 // Ignore attacks while unpacking
             },
         },
+
+        "PICKUP": {
+            "APPROACHING": {
+                "enter": function() {
+                    this.SelectAnimation("move");
+                },
+
+                "MoveCompleted": function() {
+                    this.SetNextState("LOADING");
+                },
+
+                "PickupCanceled": function() {
+                    this.StopMoving();
+                    this.FinishOrder();
+                },
+            },
+
+            "LOADING": {
+                "enter": function() {
+                    this.SelectAnimation("idle");
+                    var cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
+                    if (!cmpGarrisonHolder || cmpGarrisonHolder.IsFull())
+                    {
+                        this.FinishOrder();
+                        return true;
+                    }
+                    return false;
+                },
+
+                "PickupCanceled": function() {
+                    this.FinishOrder();
+                },
+            },
+        },
     },
 
     "ANIMAL": {
@@ -2585 +2758 @@
         this.SetupRangeQueries();
 };
 
+UnitAI.prototype.OnPickupRequested = function(msg)
+{
+    var cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
+    if (cmpGarrisonHolder && !cmpGarrisonHolder.IsFull())
+    {
+        // First check if we already have such a requirement
+        for each (var order in this.orderQueue)
+        {
+            if (order.type == "PickupUnit" && order.data.target == msg.entity)
+                return;
+        }
+        // Insert the PickUp order after the last forced order
+        this.PushOrderAfterForced("PickupUnit", { "target": msg.entity });
+    }
+};
+
+UnitAI.prototype.OnPickupCanceled = function(msg)
+{
+    var cmpUnitAI = Engine.QueryInterface(msg.entity, IID_UnitAI);
+    for (var i = 0; i < this.orderQueue.length; ++i)
+    {
+        if (this.orderQueue[i].type == "PickupUnit" && this.orderQueue[i].data.target == msg.entity)
+        {
+            if (i == 0)
+                UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg});
+            else
+                this.orderQueue.splice(i, 1);
+            break;
+        }
+    }
+};
+
 // Wrapper function that sets up the normal, healer, and Gaia range queries.
 UnitAI.prototype.SetupRangeQueries = function()
 {
@@ -2850 +3055 @@
     }
 };
 
+/**
+ * Insert an order after the last forced order onto the queue
+ * and after the other orders of the same type
+ */
+UnitAI.prototype.PushOrderAfterForced = function(type, data)
+{
+    if (!this.order || ((!this.order.data || !this.order.data.force) && this.order.type != type))
+    {
+        this.PushOrderFront(type, data);
+    }
+    else
+    {
+        for (var i = 1; i < this.orderQueue.length; ++i)
+        {
+            if (this.orderQueue[i].data && this.orderQueue[i].data.force)
+                continue;
+            if (this.orderQueue[i].type == type)
+                continue;
+            this.orderQueue.splice(i, 0, {"type": type, "data": data});
+            return;
+        }
+        this.PushOrder(type, data);
+    }
+};
+
 UnitAI.prototype.ReplaceOrder = function(type, data)
 {
     // Special cases of orders that shouldn't be replaced:
@@ -3288 +3518 @@
     return cmpUnitMotion.MoveToTargetRange(target, min, max);
 };
 
+UnitAI.prototype.MoveToGarrisonRange = function(target)
+{
+    if (!this.CheckTargetVisible(target))
+        return false;
+
+    var cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
+    if (!cmpGarrisonHolder)
+        return false;
+    var range = cmpGarrisonHolder.GetLoadingRange();
+
+    var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
+    return cmpUnitMotion.MoveToTargetRange(target, range.min, range.max);
+};
+
 UnitAI.prototype.CheckPointRangeExplicit = function(x, z, min, max)
 {
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
@@ -3312 +3556 @@
 UnitAI.prototype.CheckGarrisonRange = function(target)
 {
     var cmpGarrisonHolder = Engine.QueryInterface(target, IID_GarrisonHolder);
+    if (!cmpGarrisonHolder)
+        return false;
     var range = cmpGarrisonHolder.GetLoadingRange();
 
     var cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);

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

@@ -11 +11 @@
 // Message of the form { "to": orderData }.
 // sent whenever the unit changes state
 Engine.RegisterMessageType("UnitAIOrderDataChanged");
+
+// Message of the form { "entity": entity },
+// sent whenever a pickup is requested
+Engine.RegisterMessageType("PickupRequested");
+
+// Message of the form { "entity": entity },
+// sent whenever a pickup is no more needed
+Engine.RegisterMessageType("PickupCanceled");

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

@@ -18 +18 @@
     "</element>" +
     "<element name='LoadingRange' a:help='The maximum distance from this holder at which entities are allowed to garrison. Should be about 2.0 for land entities and preferably greater for ships'>" +
         "<ref name='nonNegativeDecimal'/>" +
-    "</element>";
+    "</element>" +
+    "<optional>" +
+        "<element name='Pickup' a:help='This garrisonHolder will move to pick up units to be garrisoned'>" +
+            "<data type='boolean'/>" +
+        "</element>" +
+    "</optional>";
 
 /**
  * Initialize GarrisonHolder Component
@@ -41 +46 @@
 };
 
 /**
+ * Return true if this garrisonHolder should pickup units
+ */
+GarrisonHolder.prototype.ShouldPickup = function()
+{
+    return (this.template.Pickup || false);
+};
+
+
+/**
  * Return the list of entities garrisoned inside
  */
 GarrisonHolder.prototype.GetEntities = function()
@@ -67 +81 @@
 };
 
 /**
+ * Return true if this garrisonHolder is full
+ */
+GarrisonHolder.prototype.IsFull = function()
+{
+    return this.entities.length >= this.GetCapacity();
+};
+
+/**
  * Get the heal rate with which garrisoned units will be healed
  */
 GarrisonHolder.prototype.GetHealRate = function()

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

@@ -25 +25 @@
     <List datatype="tokens">Support Infantry</List>
     <BuffHeal>1</BuffHeal>
     <LoadingRange>10</LoadingRange>
+    <Pickup>true</Pickup>
   </GarrisonHolder>
   <Identity>
     <GenericName>Fishing Boat</GenericName>
@@ -42 +43 @@
       <treasure disable=""/>
     </Rates>
   </ResourceGatherer>
-  <Sound>
-    <SoundGroups>
-      <order_walk>actor/ship/boat_move.xml</order_walk>
-      <order_attack>actor/ship/boat_move.xml</order_attack>
-    </SoundGroups>
-  </Sound>
   <UnitMotion>
     <WalkSpeed>8.5</WalkSpeed>
   </UnitMotion>

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

@@ -35 +35 @@
     <List datatype="tokens">Support Infantry Cavalry</List>
     <BuffHeal>1</BuffHeal>
     <LoadingRange>10</LoadingRange>
+    <Pickup>true</Pickup>
   </GarrisonHolder>
   <Health>
     <Max>800</Max>

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

@@ -31 +31 @@
     <List datatype="tokens">Support Infantry Cavalry Siege</List>
     <BuffHeal>1</BuffHeal>
     <LoadingRange>10</LoadingRange>
+    <Pickup>true</Pickup>
   </GarrisonHolder>
   <Health>
     <Max>2000</Max>

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

@@ -17 +17 @@
     <List datatype="tokens">Support Infantry Cavalry</List>
     <BuffHeal>1</BuffHeal>
     <LoadingRange>10</LoadingRange>
+    <Pickup>true</Pickup>
   </GarrisonHolder>
   <Health>
     <Max>400</Max>

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

@@ -35 +35 @@
     <List datatype="tokens">Support Infantry Cavalry Siege</List>
     <BuffHeal>1</BuffHeal>
     <LoadingRange>10</LoadingRange>
+    <Pickup>true</Pickup>
   </GarrisonHolder>
   <Health>
     <Max>1400</Max>