Ticket #1919: pack_v2.patch

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

@@ -1148 +1148 @@
             else
                 rightUsed = false;
         }
-        else if (entState.pack)
+        else
+            rightUsed = false;
+        
+        // An entity can have both trainable actions and pack/unpack commands
+        if (entState.pack)
         {
             var items = [];
             var packButton = false;
@@ -1188 +1192 @@
                 items.push({ "packing": true, "packed": true, "tooltip": "Cancel unpacking", "callback": function() { cancelPackUnit(false); } });
 
             if (items.length)
+            {
+                rightUsed = true; // might have gone false before, around line 1152
                 setupUnitPanel(PACK, usedPanels, entState, playerState, items);
-            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

@@ -4 +4 @@
 
 function BuildingAI() {}
 
-BuildingAI.prototype.Schema = 
+BuildingAI.prototype.Schema =
     "<element name='DefaultArrowCount'>" +
         "<data type='nonNegativeInteger'/>" +
     "</element>" +
@@ -329 +329 @@
     return true;
 };
 
+/**
+ * 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("preview|"+previewEntityTemplate);
+
+    if (previewEntity == INVALID_ENTITY)
+        return false; // Error (e.g. invalid template name)
+    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 checkPlacement = cmpBuildRestrictions.CheckPlacement();
+            if (checkPlacement && !checkPlacement.success)
+                canTransform = false; print('\n'+JSON.stringify(checkPlacement, null, 2));
+            // Move preview 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 preview entities
+            //    if those are left in the world.
+            cmpNewPosition.MoveOutOfWorld();
+        }
+    }
+
+    Engine.DestroyEntity(previewEntity); print('\nCanTransformHere: '+canTransform+'\n');
+    return canTransform;
+};
+
 Pack.prototype.Pack = function()
 {
     // Ignore pointless pack command
@@ -124 +174 @@
         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 +219 @@
             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.GetFullQueue(); // fn 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.
+                //       Also, this is why a counting down for loop is used.
+                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

@@ -4491 +4491 @@
 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/BuildRestrictions.js

@@ -185 +185 @@
 
     var pos = cmpPosition.GetPosition2D();
     var tileOwner = cmpTerritoryManager.GetOwner(pos.x, pos.y);
+    //print('\nTileOwner: '+tileOwner);
+    //print('\nPlayerID: '+cmpPlayer.GetPlayerID());
     var isOwn = (tileOwner == cmpPlayer.GetPlayerID());
     var isNeutral = (tileOwner == 0);
     var isAlly = !isOwn && cmpPlayer.IsAlly(tileOwner);

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

@@ -153 +153 @@
     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)
@@ -386 +408 @@
 };
 
 /*
+ * Returns a copy of the batches in the production queue
+ * Compare with GetQueue function, which returns only basic data.
+ */
+ProductionQueue.prototype.GetFullQueue = function()
+{
+    var out = [];
+    for each (var item in this.queue)
+    {
+        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);
+    }
+    return out;
+};
+
+/*
  * Removes all existing batches from the queue.
  */
 ProductionQueue.prototype.ResetQueue = function()
@@ -399 +450 @@
 };
 
 /*
+ * Swaps the current queue for a new one. Only use this functionality
+ * to transfer a queue from one entity to another without rechecking validity.
+ * This is useful when swapping one entity for another, e.g. when transforming.
+ * 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)