Ticket #1807: garrison-v4.diff

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

@@ -59 +59 @@
                 continue;
 
             var templateName = entState.template;
-            var template = GetTemplateData(templateName);
-            var key = template.selectionGroupName || templateName;
-            
+            if (templateName && templateName.indexOf("&") != -1)
+            {
+                var key = templateName;   // Garrisoned units have an extended template
+            }
+            else
+            {
+                var template = GetTemplateData(templateName);
+                var key = template.selectionGroupName || templateName;
+            }
+
             if (this.groups[key])
                 this.groups[key] += 1;
             else

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

@@ -62 +62 @@
             "teamsLocked": playerState.teamsLocked,
             "state": playerState.state,
             "isAlly": playerState.isAlly,
+            "isMutualAlly": playerState.isMutualAlly,
             "isNeutral": playerState.isNeutral,
             "isEnemy": playerState.isEnemy,
             "guid": undefined, // network guid for players controlled by hosts

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

@@ -217 +217 @@
         var playerState = simState.players[entState.player];
         var playerOwned = (targetState.player == entState.player);
         var allyOwned = playerState.isAlly[targetState.player];
+        var mutualAllyOwned = playerState.isMutualAlly[targetState.player];
         var enemyOwned = playerState.isEnemy[targetState.player];
         var gaiaOwned = (targetState.player == 0);
 
@@ -225 +226 @@
 
         // default to walking there
         var data = {command: "walk"};
-        if (targetState.garrisonHolder && playerOwned)
+        if (targetState.garrisonHolder && (playerOwned || mutualAllyOwned))
         {
             data.command = "garrison";
             data.target = target;
@@ -297 +298 @@
         var playerState = simState.players[entState.player];
         var playerOwned = (targetState.player == entState.player);
         var allyOwned = playerState.isAlly[targetState.player];
+        var mutualAllyOwned = playerState.isMutualAlly[targetState.player];
         var neutralOwned = playerState.isNeutral[targetState.player];
         var enemyOwned = playerState.isEnemy[targetState.player];
         var gaiaOwned = (targetState.player == 0);
@@ -308 +310 @@
         switch (action)
         {
         case "garrison":
-            if (hasClass(entState, "Unit") && targetState.garrisonHolder && playerOwned)
+            if (hasClass(entState, "Unit") && targetState.garrisonHolder && (playerOwned || mutualAllyOwned))
             {
                 var allowedClasses = targetState.garrisonHolder.allowedClasses;
                 for each (var unitClass in entState.identity.classes)
@@ -1732 +1734 @@
         var unitName = getEntityName(template);
 
         var playerID = Engine.GetPlayerID();
+        var simState = Engine.GuiInterfaceCall("GetSimulationState");
+
         if (entState.player == playerID || g_DevSettings.controlAll)
         {
             switch (commandName)
@@ -1780 +1784 @@
                 break;
             }
         }
+        else if (simState.players[playerID].isMutualAlly[entState.player])
+        {
+            switch (commandName)
+            {
+            case "garrison":
+                inputState = INPUT_PRESELECTEDACTION;
+                preSelectedAction = ACTION_GARRISON;
+                break;
+            default:
+                break;
+            }
+        }
     }
 }
 

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

@@ -689 +689 @@
                 affordableMask.hidden = false;
                 affordableMask.sprite = "colour: 0 0 0 127";
             }
+
+            if (guiName == GARRISON)
+            {
+                var ents = garrisonGroups.getEntsByName(item);
+                var entplayer = GetEntityState(ents[0]).player;
+                button.sprite = "colour: " + g_Players[entplayer].color.r + " " + g_Players[entplayer].color.g + " " + g_Players[entplayer].color.b;
+
+                var player = Engine.GetPlayerID();
+                if(player != unitEntState.player && !g_DevSettings.controlAll)
+                {
+                    if (entplayer != player) 
+                    {
+                        button.enabled = false;
+                        grayscale = "grayscale:";
+                    }
+                }
+            }
             
             icon.sprite = "stretched:" + grayscale + "session/portraits/" + template.icon;
             
@@ -1003 +1020 @@
 
     // If the selection is friendly units, add the command panels
     var player = Engine.GetPlayerID();
+    // Get player state to check some constraints
+    // e.g. presence of a hero or build limits
+    var simState = Engine.GuiInterfaceCall("GetSimulationState");
+    var playerState = simState.players[player];
+
     if (entState.player == player || g_DevSettings.controlAll)
     {
-        // Get player state to check some constraints
-        // e.g. presence of a hero or build limits
-        var simState = Engine.GuiInterfaceCall("GetSimulationState");
-        var playerState = simState.players[player];
 
         if (selection.length > 1)
             setupUnitPanel(SELECTION, usedPanels, entState, playerState, g_Selection.groups.getTemplateNames(),
@@ -1024 +1042 @@
             var groups = new EntityGroups();
             for (var i in selection)
             {
-                state = GetEntityState(selection[i]);
+                var state = GetEntityState(selection[i]);
                 if (state.garrisonHolder)
                     groups.add(state.garrisonHolder.entities)
             }
@@ -1191 +1209 @@
         supplementalDetailsPanel.hidden = false;
         commandsPanel.hidden = false;
     }
+    else if (playerState.isMutualAlly[entState.player]) // owned by allied player
+    {
+
+        if (entState.garrisonHolder)
+        {
+            var groups = new EntityGroups();
+            for (var i in selection)
+            {
+                var state = GetEntityState(selection[i]);
+                if (state.garrisonHolder)
+                    groups.add(state.garrisonHolder.entities)
+            }
+
+            setupUnitPanel(GARRISON, usedPanels, entState, playerState, groups.getTemplateNames(),
+                function (item) { unloadTemplate(item); } );
+
+            supplementalDetailsPanel.hidden = false;
+        }
+        else
+        {
+            supplementalDetailsPanel.hidden = true;
+        }
+
+        commandsPanel.hidden = true;
+    }
     else // owned by another player
     {
         supplementalDetailsPanel.hidden = true;

binaries/data/mods/public/simulation/ai/common-api-v3/entity.js

@@ -580 +580 @@
     unloadAll: function() {
         if (!this._template.GarrisonHolder)
             return undefined;
-        Engine.PostCommand({"type": "unload-all", "garrisonHolders": [this.id()]});
+        Engine.PostCommand({"type": "unload-all-own", "garrisonHolders": [this.id()]});
         return this;
     },
 

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

@@ -214 +214 @@
     if (cmpOwnership)
         owner = cmpOwnership.GetOwner();
 
-    // Figure out which player controls the foundation being built
+    // Figure out which player controls the target entity
     var targetOwner = 0;
     var cmpOwnershipTarget = Engine.QueryInterface(target, IID_Ownership);
     if (cmpOwnershipTarget)
@@ -231 +231 @@
 }
 
 /**
+ * Returns true if the entity 'target' is owned by a mutual ally of
+ * the owner of 'entity'.
+ */
+function IsOwnedByMutualAllyOfEntity(entity, target)
+{
+    // Figure out which player controls us
+    var owner = 0;
+    var cmpOwnership = Engine.QueryInterface(entity, IID_Ownership);
+    if (cmpOwnership)
+        owner = cmpOwnership.GetOwner();
+
+    // Figure out which player controls the target entity
+    var targetOwner = 0;
+    var cmpOwnershipTarget = Engine.QueryInterface(target, IID_Ownership);
+    if (cmpOwnershipTarget)
+        targetOwner = cmpOwnershipTarget.GetOwner();
+
+    var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+    var cmpPlayer = Engine.QueryInterface(cmpPlayerManager.GetPlayerByID(owner), IID_Player);
+
+    // Check for allied diplomacy status
+    if (cmpPlayer.IsMutualAlly(targetOwner))
+        return true;
+
+    return false;
+}
+
+/**
  * Returns true if the entity 'target' is owned by player
  */
 function IsOwnedByPlayer(player, target)
@@ -269 +297 @@
 }
 
 /**
+ * Returns true if the entity 'target' is owned by a mutual ally of player
+ */
+function IsOwnedByMutualAllyOfPlayer(player, target)
+{
+    var targetOwner = 0;
+    var cmpOwnershipTarget = Engine.QueryInterface(target, IID_Ownership);
+    if (cmpOwnershipTarget)
+        targetOwner = cmpOwnershipTarget.GetOwner();
+
+    var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+    var cmpPlayer = Engine.QueryInterface(cmpPlayerManager.GetPlayerByID(player), IID_Player);
+
+    // Check for allied diplomacy status
+    if (cmpPlayer.IsMutualAlly(targetOwner))
+        return true;
+
+    return false;
+}
+
+/**
  * Returns true if the entity 'target' is owned by someone neutral to player
  */
 function IsOwnedByNeutralOfPlayer(player,target)
@@ -312 +360 @@
 Engine.RegisterGlobal("QueryOwnerInterface", QueryOwnerInterface);
 Engine.RegisterGlobal("QueryPlayerIDInterface", QueryPlayerIDInterface);
 Engine.RegisterGlobal("IsOwnedByAllyOfEntity", IsOwnedByAllyOfEntity);
+Engine.RegisterGlobal("IsOwnedByMutualAllyOfEntity", IsOwnedByMutualAllyOfEntity);
 Engine.RegisterGlobal("IsOwnedByPlayer", IsOwnedByPlayer);
 Engine.RegisterGlobal("IsOwnedByGaia", IsOwnedByGaia);
 Engine.RegisterGlobal("IsOwnedByAllyOfPlayer", IsOwnedByAllyOfPlayer);
+Engine.RegisterGlobal("IsOwnedByMutualAllyOfPlayer", IsOwnedByMutualAllyOfPlayer);
 Engine.RegisterGlobal("IsOwnedByNeutralOfPlayer", IsOwnedByNeutralOfPlayer);
 Engine.RegisterGlobal("IsOwnedByEnemyOfPlayer", IsOwnedByEnemyOfPlayer);

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

@@ -314 +314 @@
         break;
 
     case "garrison":
-        // Verify that the building can be controlled by the player
-        if (CanControlUnit(cmd.target, player, controlAllUnits))
+        // Verify that the building can be controlled by the player or is mutualAlly
+        if (CanControlUnitOrIsAlly(cmd.target, player, controlAllUnits))
         {
             var entities = FilterEntityList(cmd.entities, player, controlAllUnits);
             GetFormationUnitAIs(entities, player).forEach(function(cmpUnitAI) {
@@ -336 +336 @@
         break;
 
     case "unload":
-        // Verify that the building can be controlled by the player
-        if (CanControlUnit(cmd.garrisonHolder, player, controlAllUnits))
+        // Verify that the building can be controlled by the player or is mutualAlly
+        if (CanControlUnitOrIsAlly(cmd.garrisonHolder, player, controlAllUnits))
         {
             var cmpGarrisonHolder = Engine.QueryInterface(cmd.garrisonHolder, IID_GarrisonHolder);
             var notUngarrisoned = 0;
-            for each (ent in cmd.entities)
+            if (IsOwnedByPlayer(player, cmd.garrisonHolder))
+                var entities = cmd.entities;
+            else
+                var entities = FilterEntityList(cmd.entities, player, controlAllUnits);
+
+            for each (var ent in entities)
                 if (!cmpGarrisonHolder || !cmpGarrisonHolder.Unload(ent))
                     notUngarrisoned++;
 
@@ -355 +360 @@
         break;
 
     case "unload-template":
+        var index = cmd.template.indexOf("&");  // Templates for garrisoned units are extended
+        if (index == -1)
+            break;
+        var selected = FilterEntityListWithAllies(cmd.garrisonHolders, player, controlAllUnits);
+        for each (var garrisonHolder in selected)
+        {
+            var cmpGarrisonHolder = Engine.QueryInterface(garrisonHolder, IID_GarrisonHolder);
+            if (cmpGarrisonHolder)
+            {
+                // Only the owner of the garrisonHolder may unload entities from any owners
+                if (!IsOwnedByPlayer(player, garrisonHolder) && !controlAllUnits)
+                {
+                    if (player != +(cmd.template.slice(1,index)))
+                        continue;
+                }
+                if (!cmpGarrisonHolder.UnloadTemplate(cmd.template, cmd.all))
+                    notifyUnloadFailure(player, garrisonHolder);
+            }
+        }
+        break;
+
+    case "unload-all-own":
         var selected = FilterEntityList(cmd.garrisonHolders, player, controlAllUnits);
         for each (var garrisonHolder in selected)
         {
             var cmpGarrisonHolder = Engine.QueryInterface(garrisonHolder, IID_GarrisonHolder);
-            if (!cmpGarrisonHolder || !cmpGarrisonHolder.UnloadTemplate(cmd.template, cmd.all))
+            if (!cmpGarrisonHolder || !cmpGarrisonHolder.UnloadAllOwn())
                 notifyUnloadFailure(player, garrisonHolder)
         }
         break;
@@ -1272 +1299 @@
 
 /**
  * Check if player can control this entity
- * returns: true if the entity is valid and owned by the player if
- *      or control all units is activated for the player, else false
+ * returns: true if the entity is valid and owned by the player
+ *      or control all units is activated, else false
  */
 function CanControlUnit(entity, player, controlAll)
 {
@@ -1281 +1308 @@
 }
 
 /**
+ * Check if player can control this entity
+ * returns: true if the entity is valid and owned by the player
+ *              or  the entity is owned by an mutualAlly
+ *      or control all units is activated, else false
+ */
+function CanControlUnitOrIsAlly(entity, player, controlAll)
+{
+    return (IsOwnedByPlayer(player, entity) || IsOwnedByMutualAllyOfPlayer(player, entity) || controlAll);
+}
+
+/**
  * Filter entities which the player can control
  */
 function FilterEntityList(entities, player, controlAll)
@@ -1289 +1327 @@
 }
 
 /**
+ * Filter entities which the player can control or are mutualAlly
+ */
+function FilterEntityListWithAllies(entities, player, controlAll)
+{
+    return entities.filter(function(ent) { return CanControlUnitOrIsAlly(ent, player, controlAll);} );
+}
+
+/**
  * Try to transform a wall to a gate 
  */
 function TryTransformWallToGate(ent, cmpPlayer, template)

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

@@ -64 +64 @@
         
         // store player ally/neutral/enemy data as arrays
         var allies = [];
+        var mutualAllies = [];
         var neutrals = [];
         var enemies = [];
         for (var j = 0; j < n; ++j)
         {
             allies[j] = cmpPlayer.IsAlly(j);
+            mutualAllies[j] = cmpPlayer.IsMutualAlly(j);
             neutrals[j] = cmpPlayer.IsNeutral(j);
             enemies[j] = cmpPlayer.IsEnemy(j);
         }
@@ -86 +88 @@
             "teamsLocked": cmpPlayer.GetLockTeams(),
             "phase": phase,
             "isAlly": allies,
+            "isMutualAlly": mutualAllies,
             "isNeutral": neutrals,
             "isEnemy": enemies,
             "entityLimits": cmpPlayerEntityLimits.GetLimits(),
@@ -313 +316 @@
             "state": cmpUnitAI.GetCurrentState(),
             "orders": cmpUnitAI.GetOrders(),
         };
+        // Special extended template for garrisoned units
+        if (cmpUnitAI.isGarrisoned && ret.player)
+            ret.template = "p" + ret.player + "&" + ret.template;
     }
     
     var cmpGate = Engine.QueryInterface(ent, IID_Gate);
@@ -344 +350 @@
     return ret;
 };
 
-GuiInterface.prototype.GetTemplateData = function(player, name)
+GuiInterface.prototype.GetTemplateData = function(player, extendedName)
 {
+    var name = extendedName;
+    // Special case for garrisoned units which have a extended template
+    if (extendedName.indexOf("&") != -1)
+        name = extendedName.slice(extendedName.indexOf("&")+1);
+
     var cmpTemplateManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_TemplateManager);
     var template = cmpTemplateManager.GetTemplate(name);
 
@@ -522 +533 @@
     return ret;
 };
 
-GuiInterface.prototype.GetTechnologyData = function(player, name)
+GuiInterface.prototype.GetTechnologyData = function(player, extendedName)
 {
+    var name = extendedName;
+    // Special case for garrisoned units which have an extended template
+    // (does not need technology for now, but we never know)
+    if (extendedName.indexOf("&") != -1)
+        name = extendedName.slice(extendedName.indexOf("&")+1);
+
     var cmpTechTempMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_TechnologyTemplateManager);
     var template = cmpTechTempMan.GetTemplate(name);
     

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

@@ -4247 +4247 @@
     if (!cmpGarrisonHolder)
         return false;
 
-    // Verify that the target is owned by this entity's player
+    // Verify that the target is owned by this entity's player or is mutual allied
     var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
-    if (!cmpOwnership || !IsOwnedByPlayer(cmpOwnership.GetOwner(), target))
+    if (!cmpOwnership || !(IsOwnedByPlayer(cmpOwnership.GetOwner(), target) || IsOwnedByMutualAllyOfPlayer(cmpOwnership.GetOwner(), target)))
         return false;
 
     // Don't let animals garrison for now

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

@@ -351 +351 @@
 
     var sharedLos = [];
     for (var i = 0; i < cmpPlayerManager.GetNumPlayers(); ++i)
-        if (this.IsAlly(i))
-        {
-            var cmpPlayer = Engine.QueryInterface(cmpPlayerManager.GetPlayerByID(i), IID_Player);
-            if (cmpPlayer && cmpPlayer.IsAlly(this.playerID))
-                sharedLos.push(i);
-        }
+        if (this.IsMutualAlly(i))
+            sharedLos.push(i);
 
     cmpRangeManager.SetSharedLos(this.playerID, sharedLos);
 };
@@ -424 +420 @@
     return this.diplomacy[id] > 0;
 };
 
+/**
+ * Check if given player is our ally, and we are its ally
+ */
+Player.prototype.IsMutualAlly = function(id)
+{
+    var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+    if (!cmpPlayerManager)
+        return false;
+    var cmpPlayer = Engine.QueryInterface(cmpPlayerManager.GetPlayerByID(id), IID_Player);
+    return this.IsAlly(id) && cmpPlayer && cmpPlayer.IsAlly(this.playerID);
+};
+
 Player.prototype.SetEnemy = function(id)
 {
     this.SetDiplomacyIndex(id, -1);

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

@@ -220 +220 @@
 };
 
 /**
+ * Perform Eject on the selected entities
+ */
+GarrisonHolder.prototype.PerformEject = function(entities, forced)
+{
+    var ejectedEntities = [];
+    var success = true;
+    for each (var entity in entities)
+    {
+        if (this.Eject(entity, forced))
+        {
+            ejectedEntities.push(entity);
+        }
+        else
+        {
+            success = false;
+        }
+    }
+    
+    this.OrderWalkToRallyPoint(ejectedEntities);
+    this.UpdateGarrisonFlag();
+    
+    return success;
+};
+
+/**
  * Unload units from the garrisoning entity and order them
  * to move to the Rally Point
  * Returns true if successful, false if not
  */
 GarrisonHolder.prototype.Unload = function(entity, forced)
 {
-    if (this.Eject(entity, forced))
-    {
-        this.OrderWalkToRallyPoint([entity]);
-        this.UpdateGarrisonFlag();
-        return true;
-    }
-    
-    return false;
+    return this.PerformEject([entity], forced);
 };
 
 /**
- * Unload one or all units that match a template from the
+ * Unload one or all units that match a template/owner from the
  * garrisoning entity and order them to move to the Rally Point
  * Returns true if successful, false if not
  */
-GarrisonHolder.prototype.UnloadTemplate = function(template, all, forced)
+GarrisonHolder.prototype.UnloadTemplate = function(extendedTemplate, all, forced)
 {
-    var ejectedEntities = [];
-    var success = true;
+    var index = extendedTemplate.indexOf("&");
+    if (index == -1)
+        return false;
+    var owner = extendedTemplate.slice(1,index);
+    var template = extendedTemplate.slice(index+1);
+
+    var entities = [];
     for (var i = 0; i < this.entities.length; ++i)
     {
         var entity = this.entities[i];
@@ -260 +283 @@
         
         if (name != template)
             continue;
+        if (owner != Engine.QueryInterface(entity, IID_Ownership).GetOwner())
+            continue;
 
-        if (this.Eject(entity, forced))
-        {
-            --i; // Decrement 'i' as Eject() shortens the array.
-            ejectedEntities.push(entity);
+        entities.push(entity);
 
-            // If 'all' is false, only ungarrison the first matched unit.
-            if (!all)
-                break;
-        }
-        else
-            success = false;
+        // If 'all' is false, only ungarrison the first matched unit.
+        if (!all)
+            break;
     }
 
-    this.OrderWalkToRallyPoint(ejectedEntities);
-    this.UpdateGarrisonFlag();
-
-    return success;
+    return this.PerformEject(entities, forced);
 };
 
 /**
- * Unload all units from the entity
+ * Unload all units with same owner than the entity
  * Returns true if all successful, false if not
  */
-GarrisonHolder.prototype.UnloadAll = function(forced)
+GarrisonHolder.prototype.UnloadAllOwn = function(forced)
 {
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (!cmpOwnership)
+        return false;
+    var owner = cmpOwnership.GetOwner();
+
     // Make copy of entity list
     var entities = [];
     for each (var entity in this.entities)
     {
-        entities.push(entity);
+        var cmpOwnership = Engine.QueryInterface(entity, IID_Ownership);
+        if (cmpOwnership && cmpOwnership.GetOwner() == owner)
+            entities.push(entity);
     }
     
-    var ejectedEntities = [];
-    var success = true;
-    for each (var entity in entities)
-    {
-        if (this.Eject(entity, forced))
-        {
-            ejectedEntities.push(entity);
-        }
-        else
-        {
-            success = false;
-        }
-    }
-    
-    this.OrderWalkToRallyPoint(ejectedEntities);
-    this.UpdateGarrisonFlag();
-    
-    return success;
+    return this.PerformEject(entities, forced);
 };
 
 /**
+ * Unload all units from the entity
+ * Returns true if all successful, false if not
+ */
+GarrisonHolder.prototype.UnloadAll = function(forced)
+{
+    var entities = this.entities.slice(0);
+    return this.PerformEject(entities, forced);
+};
+
+/**
  * Used to check if the garrisoning entity's health has fallen below
  * a certain limit after which all garrisoned units are unloaded
  */
@@ -469 +485 @@
     }
 };
 
+
+/**
+ * Eject all foreign garrisoned entities which are no more allied
+ */
+GarrisonHolder.prototype.OnDiplomacyChanged = function()
+{
+    for (var i = this.entities.length; i > 0; --i)
+    {
+        if (!IsOwnedByMutualAllyOfEntity(this.entity, this.entities[i-1]))
+            this.Eject(this.entities[i-1], true);
+    }
+    this.UpdateGarrisonFlag();
+};
+
 Engine.RegisterComponentType(IID_GarrisonHolder, "GarrisonHolder", GarrisonHolder);