Ticket #3481: visibleGarrison.diff

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

@@ -224 +224 @@
  * Garrison a unit inside.
  * Returns true if successful, false if not
  * The timer for AutoHeal is started here
+ * if vgpEntity is given, this visualGarrisonPoint will be used for the entity
  */
-GarrisonHolder.prototype.Garrison = function(entity)
+GarrisonHolder.prototype.Garrison = function(entity, vgpEntity)
 {
     var cmpPosition = Engine.QueryInterface(entity, IID_Position);
     if (!cmpPosition)
@@ -234 +235 @@
     if (!this.PerformGarrison(entity))
         return false;
 
-    var visiblyGarrisoned = false;
-    for (var vgp of this.visibleGarrisonPoints)
+    let visibleGarrisonPoint = vgpEntity;
+    if (!visibleGarrisonPoint)
     {
-        if (vgp.entity)
-            continue;
-        vgp.entity = entity;
-        cmpPosition.SetTurretParent(this.entity, vgp.offset);
-        visiblyGarrisoned = true;
-        var cmpUnitAI = Engine.QueryInterface(entity, IID_UnitAI);
+        for (let vgp of this.visibleGarrisonPoints)
+        {
+            if (vgp.entity)
+                continue;
+            visibleGarrisonPoint = vgp;
+            break;
+        }
+    }
+
+    if (visibleGarrisonPoint)
+    {
+        visibleGarrisonPoint.entity = entity;
+        cmpPosition.SetTurretParent(this.entity, visibleGarrisonPoint.offset);
+        let cmpUnitAI = Engine.QueryInterface(entity, IID_UnitAI);
         if (cmpUnitAI)
             cmpUnitAI.SetTurretStance();
-        break;
     }
-    if (!visiblyGarrisoned)
+    else
         cmpPosition.MoveOutOfWorld();
+
     return true;
 };
 
@@ -674 +683 @@
     var entityIndex = this.entities.indexOf(msg.entity);
     if (entityIndex != -1)
     {
+        let vgpRenamed;
+        for (let vgp of this.visibleGarrisonPoints)
+        {
+            if (vgp.entity != msg.entity)
+                continue;
+            vgpRenamed = vgp;
+            break;
+        }
         this.Eject(msg.entity);
-        this.Garrison(msg.newentity);
+        this.Garrison(msg.newentity, vgpRenamed);
     }
 
     if (!this.initGarrison)

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

@@ -80 +80 @@
 
     var orders = cmpCurrentUnitAI.GetOrders();
     if (cmpCurrentUnitAI.IsGarrisoned())
-    {
-        if (orders.length > 0 && (orders[0].type == "Garrison" || orders[0].type == "Autogarrison"))
-        {
-            // Replace the garrison order by an autogarrison order,
-            // as we are already garrisoned and do not need to do
-            // any further checks (or else we should do them here).
-            var garrisonHolder = orders[0].data.target;
-            orders.shift();
-            cmpPromotedUnitAI.Autogarrison(garrisonHolder);
-        }
-        else
-            warn("Promoted garrisoned entity with empty order queue.");
-    }
-    else
-        cmpPromotedUnitAI.Cheer();
-
+        cmpPromotedUnitAI.isGarrisoned = true;
+    if (cmpCurrentUnitPosition.IsInWorld()) // do not cheer if not visibly garrisoned
+        cmpPromotedUnitAI.Cheer();  
     cmpPromotedUnitAI.AddOrders(orders);
 
     var workOrders = cmpCurrentUnitAI.GetWorkOrders();

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

@@ -687 +687 @@
     "Order.Garrison": function(msg) {
         if (this.IsTurret())
         {
-            this.FinishOrder();
+            this.SetNextState("IDLE");
             return;
         }
+        else if (this.IsGarrisoned())
+        {
+            this.SetNextState("INDIVIDUAL.AUTOGARRISON");
+            return;
+        }
+
         // 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.
@@ -713 +719 @@
     },
 
     "Order.Autogarrison": function(msg) {
+        if (this.IsTurret())
+        {
+            this.SetNextState("IDLE");
+            return;
+        }
+
         this.SetNextState("INDIVIDUAL.AUTOGARRISON");
     },
 
@@ -1438 +1450 @@
                 // from FinishOrder (SetNextState("IDLE") is only executed when we get
                 // a ProcessMessage), and thus we should not start an attack which could
                 // put us in a weird state
-                if (this.orderQueue.length > 0)
+                if (this.orderQueue.length > 0 && !this.IsGarrisoned())
                     return false;
 
                 // If a unit can heal and attack we first want to heal wounded units,
@@ -1501 +1513 @@
                     Engine.PostMessage(this.entity, MT_UnitIdleChanged, { "idle": this.isIdle });
                 }
             },
+
+            "Order.Ungarrison": function() {    // Needed for turrets
+                this.FinishOrder();
+                this.isGarrisoned = false;
+            },
         },
 
         "WALKING": {
@@ -2918 +2935 @@
                 },
 
                 "Order.Ungarrison": function() {
-                    if (this.FinishOrder())
-                        return;
+                    this.FinishOrder();
+                    this.isGarrisoned = false;
                 },
 
                 "leave": function() {
-                    this.isGarrisoned = false;
                 }
             },
         },
@@ -2935 +2951 @@
             },
 
             "Order.Ungarrison": function() {
-                if (this.FinishOrder())
-                    return;
+                this.FinishOrder();
+                this.isGarrisoned = false;
             },
 
             "leave": function() {
-                this.isGarrisoned = false;
             }
         },
 
@@ -3318 +3333 @@
 {
     var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
     if (cmpOwnership && cmpOwnership.GetOwner() == msg.player)
-        this.SetupRangeQuery();
+        this.SetupRangeQueries();
 };
 
 UnitAI.prototype.OnOwnershipChanged = function(msg)
@@ -4976 +4991 @@
 UnitAI.prototype.Ungarrison = function()
 {
     if (this.IsGarrisoned())
+    {
+        // Turret may be attacking, so we must finish all orders except the last one 
+        // which must be Garrison or Autogarrison
+        while (this.orderQueue.length > 1)
+            this.FinishOrder();
         this.AddOrder("Ungarrison", null, false);
+    }
 };
 
 /**