Ticket #1919: pack.patch

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

@@ -1136 +1136 @@
             else
                 rightUsed = false;
         }
-        else if (entState.pack)
+        else
+            rightUsed = false;
+
+        if (entState.pack)
         {
             var items = [];
             var packButton = false;
@@ -1180 +1183 @@
             else
                 rightUsed = false;
         }
-        else
-            rightUsed = false;
 
         if (!rightUsed)
         {

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

@@ -476 +476 @@
     case "pack":
         for each (var ent in entities)
         {
-            var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
-            if (cmpUnitAI)
+            // figure out whether entity is a unit or a building
+            var cmpEntityAI = Engine.QueryInterface(ent, IID_UnitAI);
+            if (!cmpEntityAI)
+                cmpEntityAI = Engine.QueryInterface(ent, IID_BuildingAI);
+            if (cmpEntityAI)
             {
                 if (cmd.pack)
-                    cmpUnitAI.Pack(cmd.queued);
+                    cmpEntityAI.Pack(cmd.queued);
                 else
-                    cmpUnitAI.Unpack(cmd.queued);
+                    cmpEntityAI.Unpack(cmd.queued);
             }
         }
         break;
@@ -490 +493 @@
     case "cancel-pack":
         for each (var ent in entities)
         {
-            var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
-            if (cmpUnitAI)
+            // figure out whether entity is a unit or a building
+            var cmpEntityAI = Engine.QueryInterface(ent, IID_UnitAI);
+            if (!cmpEntityAI)
+                cmpEntityAI = Engine.QueryInterface(ent, IID_BuildingAI);
+            if (cmpEntityAI)
             {
                 if (cmd.pack)
-                    cmpUnitAI.CancelPack(cmd.queued);
+                    cmpEntityAI.CancelPack(cmd.queued);
                 else
-                    cmpUnitAI.CancelUnpack(cmd.queued);
+                    cmpEntityAI.CancelUnpack(cmd.queued);
             }
         }
         break;

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

@@ -252 +252 @@
     }
 };
 
+/**
+ * All packing code taken and adapted from UnitAI
+ */
+BuildingAI.prototype.Pack = function()
+{
+    // Check that we can pack
+    var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
+    if (cmpPack && this.CanPack())
+        cmpPack.Pack();
+};
+
+BuildingAI.prototype.Unpack = function()
+{
+    // Check that we can unpack
+    var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
+    if (cmpPack && this.CanUnpack())
+        cmpPack.Unpack();
+};
+
+BuildingAI.prototype.CancelPack = function()
+{
+    var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
+    if (cmpPack && cmpPack.IsPacking() && !cmpPack.IsPacked())
+        cmpPack.CancelPack();
+};
+
+BuildingAI.prototype.CancelUnpack = function()
+{
+    var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
+    if (cmpPack && cmpPack.IsPacking() && cmpPack.IsPacked())
+        cmpPack.CancelUnpack();
+};
+
+BuildingAI.prototype.CanPack = function()
+{
+    var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
+    return (cmpPack && !cmpPack.IsPacking() && !cmpPack.IsPacked() && cmpPack.CanTransformHere());
+};
+
+BuildingAI.prototype.CanUnpack = function()
+{
+    var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
+    return (cmpPack && !cmpPack.IsPacking() && cmpPack.IsPacked() && cmpPack.CanTransformHere());
+};
+
+BuildingAI.prototype.IsPacking = function()
+{
+    var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
+    return (cmpPack && cmpPack.IsPacking());
+};
+
 Engine.RegisterComponentType(IID_BuildingAI, "BuildingAI", BuildingAI);

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

@@ -49 +49 @@
     return this.packing;
 };
 
+/**
+ * @return True if the entity to transform into is allowed on the
+ *         current terrain/territory.
+ */
+Pack.prototype.CanTransformHere = function ()
+{
+    var canTransform = true;
+    // temporarily creating an entity for a check
+    var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
+    var previewEntityTemplate = this.template.Entity;
+    if (cmpIdentity)
+        previewEntityTemplate = previewEntityTemplate.replace(/\{civ\}/g, cmpIdentity.GetCiv());
+    var previewEntity = Engine.AddEntity(previewEntityTemplate);
+    if (previewEntity == INVALID_ENTITY)
+        canTransform = false; // Error (e.g. invalid template names)
+    else
+    {
+        var cmpBuildRestrictions = Engine.QueryInterface(previewEntity, IID_BuildRestrictions);
+        if (cmpBuildRestrictions)
+        {
+            // Position and ownership needs to be set for placement checks
+            var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+            var cmpNewPosition = Engine.QueryInterface(previewEntity, IID_Position);
+            if (cmpPosition.IsInWorld())
+            {
+                var pos = cmpPosition.GetPosition2D();
+                var angle = cmpPosition.GetRotation();
+                cmpNewPosition.JumpTo(pos.x, pos.y);
+                cmpNewPosition.SetYRotation(angle.y);
+            }
+            var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+            var cmpNewOwnership = Engine.QueryInterface(previewEntity, IID_Ownership);
+            cmpNewOwnership.SetOwner(cmpOwnership.GetOwner());
+
+            var cmpObstruction = Engine.QueryInterface(previewEntity, IID_Obstruction);
+            if (cmpObstruction)
+                cmpObstruction.SetActive(false); // entity is not really obstructing anything
+
+            // TODO: territory checks via CheckPlacement are currently not functional,
+            // since in that function the tileOwner always gives the current playerID
+            // (when calling the same code here, it does give the correct owner...)
+            var checkPlacement = cmpBuildRestrictions.CheckPlacement();
+            if (checkPlacement && !checkPlacement.success)
+                canTransform = false;
+            // move temporary entity out of world so it won't interfere with additional calls
+            // to this function for this entity on the same sim update.
+            // specifically, CheckPlacement() would incorrectly spot and fail on earlier temp entities
+            // if those are left in the world.
+            cmpNewPosition.MoveOutOfWorld();
+        }
+    }
+
+    Engine.DestroyEntity(previewEntity);
+    return canTransform;
+};
+
 Pack.prototype.Pack = function()
 {
     // Ignore pointless pack command
@@ -124 +180 @@
         Engine.PostMessage(this.entity, MT_PackFinished, { packed: this.packed });
 
         // Done un/packing, copy our parameters to the final entity
-        var newEntity = Engine.AddEntity(this.template.Entity);
+        // Replace the "{civ}" codes with this entity's civ ID
+        var cmpIdentity = Engine.QueryInterface(this.entity, IID_Identity);
+        var newEntityTemplate = this.template.Entity;
+        if (cmpIdentity)
+            newEntityTemplate = newEntityTemplate.replace(/\{civ\}/g, cmpIdentity.GetCiv());
+        var newEntity = Engine.AddEntity(newEntityTemplate);
         if (newEntity == INVALID_ENTITY)
         {
             // Error (e.g. invalid template names)
@@ -164 +225 @@
             cmpNewUnitAI.AddOrders(cmpUnitAI.GetOrders());
         }
 
+        // Transfer production queue
+        // note: default behaviour upon destroying an entity is to reset queue,
+        //       that case is thus not handled here.
+        var cmpQueue = Engine.QueryInterface(this.entity, IID_ProductionQueue);
+        var cmpNewQueue = Engine.QueryInterface(newEntity, IID_ProductionQueue);
+        if (cmpQueue && cmpNewQueue)
+        {
+            var queue = cmpQueue.GetQueue(true); // with true returns copy, not just summary
+            if (queue.length > 0)
+            {
+                var transferableQueue = [];
+                for (var i = queue.length-1; i >= 0; i--)
+                {
+                    var templateName = queue[i].unitTemplate ? queue[i].unitTemplate : queue[i].technologyTemplate;
+                    if (cmpNewQueue.CanAcceptTemplate(templateName))
+                        transferableQueue.push( queue.splice(i,1)[0] );
+                }
+                cmpQueue.SetQueue(queue); // set old queue with untransferable batches
+                cmpNewQueue.SetQueue(transferableQueue); // set new queue with transferable batches
+            }
+        }
+
+        // Transfer garrisoned units if possible, or unload them
+        var cmpGarrison = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
+        var cmpNewGarrison = Engine.QueryInterface(newEntity, IID_GarrisonHolder);
+        if (cmpGarrison && cmpGarrison.GetEntities().length > 0)
+        {
+            if (cmpNewGarrison)
+            {
+                // note: the code cannot rely on the garrisoning entity's indexing
+                //       due to removal of elements. This is why a reference to the
+                //       garrisoned entity is stored in a temporary variable
+                var garrisonedEntity,  // initiated outside for loop to reuse (reduces garbage)
+                    garrisonedEntities = cmpGarrison.GetEntities();
+                for (var j = garrisonedEntities.length-1; j >= 0; j--)
+                {
+                    garrisonedEntity = garrisonedEntities[j];
+                    cmpGarrison.Unload(garrisonedEntity, true); // always kick out entity
+                    cmpNewGarrison.Garrison(garrisonedEntity);  // then try to garrison
+                }
+            }
+            else
+                cmpGarrison.UnloadAll(true);
+        }
+        
         Engine.BroadcastMessage(MT_EntityRenamed, { entity: this.entity, newentity: newEntity });
 
         // Play notification sound

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

@@ -4380 +4380 @@
 UnitAI.prototype.CanPack = function()
 {
     var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
-    return (cmpPack && !cmpPack.IsPacking() && !cmpPack.IsPacked());
+    return (cmpPack && !cmpPack.IsPacking() && !cmpPack.IsPacked() && cmpPack.CanTransformHere());
 };
 
 UnitAI.prototype.CanUnpack = function()
 {
     var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
-    return (cmpPack && !cmpPack.IsPacking() && cmpPack.IsPacked());
+    return (cmpPack && !cmpPack.IsPacking() && cmpPack.IsPacked() && cmpPack.CanTransformHere());
 };
 
 UnitAI.prototype.IsPacking = function()

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

@@ -148 +148 @@
     return ret;
 };
 
+/*
+ * Returns true if the given template can be produced by this entity
+ * @param templateName String of the template name
+ */
+ProductionQueue.prototype.CanAcceptTemplate = function(templateName)
+{
+    var unitTemplates = this.GetEntitiesList();
+    if (unitTemplates.indexOf(templateName) !== -1)
+        return true;
+
+    var techTemplates = this.GetTechnologiesList();
+    for (var tech in techTemplates)
+    {
+        if (typeof tech === 'string' && tech === templateName)
+            return true;
+        else if (typeof tech === 'object' && (tech.top === templateName || tech.bottom === templateName))
+            return true;
+    }
+
+    return false;
+};
+
 ProductionQueue.prototype.IsTechnologyResearchedOrInProgress = function(tech)
 {
     if (!tech)
@@ -361 +383 @@
 
 /*
  * Returns basic data from all batches in the production queue.
+ * With complete = true, returns a full copy of the queue.
  */
-ProductionQueue.prototype.GetQueue = function()
+ProductionQueue.prototype.GetQueue = function(complete)
 {
     var out = [];
     for each (var item in this.queue)
     {
-        out.push({
-            "id": item.id,
-            "unitTemplate": item.unitTemplate,
-            "technologyTemplate": item.technologyTemplate,
-            "count": item.count,
-            "neededSlots": item.neededSlots,
-            "progress": 1-(item.timeRemaining/item.timeTotal),
-            "metadata": item.metadata,
-        });
+        if (complete)
+        {
+            var batch = {
+                "id": item.id,
+                "player": item.player,
+                "count": item.count,
+                "metadata": item.metadata,
+                "resources": item.resources, // need to copy to avoid serialization problems
+                "population": item.population,
+                "productionStarted": item.productionStarted,
+                "timeTotal": item.timeTotal,
+                "timeRemaining": item.timeRemaining
+            };
+            if (item.unitTemplate)
+                batch["unitTemplate"] = item.unitTemplate;
+            if (item.technologyTemplate)
+                batch["technologyTemplate"] = item.technologyTemplate;
+            out.push(batch);
+        }
+        else
+        {
+            out.push({
+                "id": item.id,
+                "unitTemplate": item.unitTemplate,
+                "technologyTemplate": item.technologyTemplate,
+                "count": item.count,
+                "neededSlots": item.neededSlots,
+                "progress": 1-(item.timeRemaining/item.timeTotal),
+                "metadata": item.metadata,
+            });
+        }
     }
     return out;
 };
@@ -394 +439 @@
 };
 
 /*
+ * Swaps the current queue for a new one. Only use this functionality
+ * to transfer a queue from one entity to another without rechecking validity.
+ * For other uses, please go with the other functions in this Component.
+ * @param queue New queue which replaces the current one.
+ */
+ProductionQueue.prototype.SetQueue = function(queue)
+{
+    if (queue && typeof queue === 'object' && queue.length) // checks for type array
+    {
+        this.queue = queue;
+        Engine.PostMessage(this.entity, MT_ProductionQueueChanged, {});
+        if (this.queue.length > 0 && !this.timer) // if 0 timer will expire on its own
+        {
+            var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+            this.timer = cmpTimer.SetTimeout(this.entity, IID_ProductionQueue, "ProgressTimeout", g_ProgressInterval, {});
+        }
+    }
+};
+
+/*
  * Returns batch build time.
  */
 ProductionQueue.prototype.GetBatchTime = function(batchSize)