diff --git a/binaries/data/mods/public/simulation/components/Looter.js b/binaries/data/mods/public/simulation/components/Looter.js
index 87577e9..fe98468 100644
--- a/binaries/data/mods/public/simulation/components/Looter.js
+++ b/binaries/data/mods/public/simulation/components/Looter.js
@@ -44,6 +44,140 @@ Looter.prototype.Collect = function(targetEntity)
 			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 targetCarriedEntities_index = -1;
+			while (freeGarrisonSpotCount > 0 && ++targetCarriedEntities_index < targetNonEjectedCarriedEntities.length)
+			{
+				var targetCarriedEntity = targetNonEjectedCarriedEntities[targetCarriedEntities_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?
+				var carriedEntityClasses = carriedEntity.GetClassesList();
+				if (carriedEntityClasses.length)
+				{	
+					// Is one of the by the target carried entity's classes allowed to garrison inside our looting unit?
+					for each (var carriedEntityClass in carriedEntityClasses)
+					{
+						if (cmpGarrisonHolder.GetAllowedClasses().indexOf(carriedEntityClass) === -1)
+							continue;
+						
+						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);
