Ticket #2732: extend_looter_to_transfer_carried_resources_and_in_the_looted_entity_garrisoned_entities.2.diff

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

@@ -44 +44 @@
             cmpPlayer.AddResources(resourcesToAdd);
         }
     }
+    
+
+    // If target entity has inventory component, add carried goods to loot too:
+    var cmpTargetPlayer = QueryOwnerInterface(targetEntity, IID_Player); // To allow to remove the resources from the looted entity's owning player.
+    var cmpGuiInterface = Engine.QueryInterface(SYSTEM_ENTITY, IID_GuiInterface); // Alternatively see gui/session/session.js GetExtendedEntityState via the C++ Engine.GuiInterfaceCall("GetExtendedEntityState", entId).
+    var entityState = cmpGuiInterface.GetExtendedEntityState(cmpPlayer.playerID, targetEntity);
+    var targetEntityState = cmpGuiInterface.GetExtendedEntityState(cmpTargetPlayer.playerID, targetEntity);
+    // TODO perhaps merge EntityState and ExtendedEntityState like in gui/session/session.js ?
+    // Resource carrying
+    if (targetEntityState.resourceCarrying && targetEntityState.resourceCarrying.length)
+    {
+        var resourcesToAdd = {};
+        // We should only be carrying one resource type at once, nevertheless we should be ready for multiple resources:
+        // => sum up all carried resources, grouped by resource type (as required to be able to add it to our player).
+        for each (var targetCarriedResource in targetEntityState.resourceCarrying)
+        {
+            // The GUI has not to be updated because the to be looted enemy unit won't be selected and even if, then details won't be shown if it's not an ally.
+            //Engine.GetGUIObjectByName("resourceCarryingIcon").hidden = false;
+            //Engine.GetGUIObjectByName("resourceCarryingText").hidden = false;
+            //Engine.GetGUIObjectByName("resourceCarryingIcon").sprite = "stretched:session/icons/resources/"+carriedResource.type+".png";
+            //Engine.GetGUIObjectByName("resourceCarryingText").caption = sprintf(translate("%(amount)s / %(max)s"), { amount: carriedResource.amount, max: carriedResource.max });
+
+            // Move the resource amount:
+            // ---------------------------------------
+            // EITHER (directly add to the player)
+            if (!resourcesToAdd[targetCarriedResource.type])
+                resourceToAdd[targetCarriedResource.type] = 0;
+            if (targetCarriedResource.amount)
+                resourcesToAdd[targetCarriedResource.type] += +targetCarriedResource.amount;
+            // Reset the looted unit's resource carrying:
+            targetCarriedResource.amount = 0;
+            // Note: The player get the resources removed and added respectively after the loop.
+            
+            // ---------------------------------------
+            // OR (make the looting unit carry the resources)
+            // Do we have enough resource capacity?
+            var carriedResourceWithCorrectType = undefined; 
+            // find correct resource type:
+            if (entityState.resourceCarrying && entityState.resourceCarrying.length)
+            {
+                for each (var carriedResource in entityState.resourceCarrying)
+                {
+                    if (carriedResource.type == targetCarriedResource.type)
+                    {
+                        carriedResourceWithCorrectType = carriedResource;
+                        break;
+                    }
+                }
+            }
+            var freeSpaceAmount = 0; // TODO Query template for the maximum resource gather count!
+            if (!carriedResourceWithCorrectType)
+            {
+                var template = GetTemplate(entityState.template);
+                //TODO freeSpaceAmount = template.;
+                //TODO carriedResourceWithCorrectType = ;
+            }
+            else
+                freeSpaceAmount = carriedResourceWithCorrectType.max - carriedResourceWithCorrectType.amount;
+            // Transfer the resource amount:    
+            if (freeSpaceAmount > 0)
+            {
+                carriedResourceWithCorrectType.amount += freeSpaceAmount;
+                targetCarriedResource.amount -= freeSpaceAmount;
+            }
+            //else nothing to add and nothing to substract. => no carrying resource loot.
+
+             
+        }
+        cmpPlayer.AddResources(resourcesToAdd);
+        cmpTargetPlayer.RemoveResources(resourcesToAdd);
+
+    }
+     
+     
+    // TODO generalize GarrisonHolder to EntityHolder/Inventory (renaming is enough, but pick-up garrison (read: entity) option has to be added!).
+    var cmpTargetGarrisonHolder = Engine.QueryInterface(targetEntity, IID_GarrisonHolder);
+    if (cmpTargetGarrisonHolder)
+    {
+        // Is our looting entity allowed to Garrison the carried entity inside itself?
+        var targetNonEjectedCarriedEntities = cmpTargetGarrisonHolder.GetEntities();
+        if (targetNonEjectedCarriedEntities)
+        {
+            // Own capacity is already full?
+            var freeGarrisonSpotCount = cmpGarrisonHolder.GetCapacity() - cmpGarrisonHolder.GetGarrisonedEntitiesCount();
+            var targetNonEjectedCarriedEntities_index = -1;
+            while (freeGarrisonSpotCount > 0 && ++targetNonEjectedCarriedEntities_index < targetNonEjectedCarriedEntities.length)
+            {
+                var targetCarriedEntity = targetNonEjectedCarriedEntities[targetNonEjectedCarriedEntities_index];
+                //if (carriedEntity.amount) TODO allow for grouping of equal entities. (see the GUI where a number is used to show how many entities of the same type are garrisoned.)
+                // Is this entity allowed to carry/garrison the entity class the other unit carried?
+                if (!cmpGarrisonHolder.AllowedToGarrison(targetCarriedEntity))
+                    continue;
+                
+                //else garrison:
+                var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+                if (!cmpOwnership)
+                    break;
+                //warn('New Owner (looting entity): ' + cmpOwnership);
+                var cmpTargetEntityOwnership = Engine.QueryInterface(targetEntity, IID_Ownership);
+                var cmpCarriedEntityOwnership = Engine.QueryInterface(carriedEntity, IID_Ownership);
+                if (!cmpCarriedEntityOwnership)
+                    break;
+                //warn('Old Owner : ' + cmpTargetOwnership);
+                   
+                // 1) eject:
+                var is_forced = true;
+                cmpTargetGarrisonHolder.Eject(carriedEntity, is_forced);
+                
+                // 2) change garrisoned entity's ownership:
+                // Fully convert to a normal unit of your own, the original ethnicity still recognizable.
+                cmpTargetEntityOwnership.SetOwner(cmpOwnership.GetOwner());
+                warn('The looting entity: ' + this.entity + ' (Owner: '+ cmpOwnership +') changed the ownership of the target entity: ' + carriedEntity + ' (Owner: '+ cmpCarriedEntityOwnership +' ).');
+                // Because it might have been an target-entity-allied entity that was garrisoned inside the target entity.
+                var cmpCarriedEntityPlayer = QueryOwnerInterface(targetEntity, IID_Player); // To allow to remove the resources from the looted entity's owning player.
+                Engine.PostMessage(this.entity, MT_OwnershipChanged, { "entity": carriedEntity,
+            "from": cmpCarriedEntityPlayer.playerID, "to": cmpPlayer.playerID });
+                
+                // 3) garrison entity inside our looting entity:
+                cmpGarrisonHolder.Garrison(carriedEntity);
+            }
+        }
+    }
+
+
+
+
+
+
 }
 
 Engine.RegisterComponentType(IID_Looter, "Looter", Looter);