Changeset 25192

Timestamp:

Apr 5, 2021, 7:22:25 AM (3 years ago)

Author:

Freagarach

Message:

Allow to specify subunits on creation.

This basically does two things:

• Allow turrets on moving entities (fixes serialisation in cmpPos).
• Allow an entity to be present on another when the other is created.

That makes it basically a boiled down version of a prior patch, omitting the part where orders could be passed on.
This does allow e.g. ranged units on chariots that fire while the chariot moves.

Original diff by: @sanderd17
Redone by: @Stan
Differential revision: D1958
Comments by: @Alexandermb, @Angen, @bb, @Langbart, @Nescio, @Stan, @wraitii
Refs. #2577 by implementing the entity on platform case.

Location:

ps/trunk

Files:

• binaries/data/mods/public/gui/session/unit_actions.js (modified) (3 diffs)
• binaries/data/mods/public/simulation/components/GuiInterface.js (modified) (1 diff)
• binaries/data/mods/public/simulation/components/Health.js (modified) (1 diff)
• binaries/data/mods/public/simulation/components/TurretHolder.js (modified) (16 diffs)
• binaries/data/mods/public/simulation/components/Turretable.js (modified) (8 diffs)
• binaries/data/mods/public/simulation/components/UnitAI.js (modified) (1 diff)
• binaries/data/mods/public/simulation/components/tests/test_TurretHolder.js (modified) (1 diff)
• binaries/data/mods/public/simulation/components/tests/test_Turrets.js (modified) (2 diffs)
• binaries/data/mods/public/simulation/helpers/Transform.js (modified) (4 diffs)
• source/graphics/MapReader.cpp (modified) (3 diffs)
• source/simulation2/components/CCmpPosition.cpp (modified) (4 diffs)
• source/simulation2/components/ICmpTurretHolder.cpp (modified) (1 diff)

ps/trunk/binaries/data/mods/public/gui/session/unit_actions.js

@@ -1322 +1322 @@
 
                 if (allowedPlayersCheck([entState], ["Player"]))
-                    count += entState.turretHolder.turretPoints.filter(turretPoint => turretPoint.entity).length;
+                    count += entState.turretHolder.turretPoints.filter(turretPoint => turretPoint.entity).length;
                 else
                     for (let turretPoint of entState.turretHolder.turretPoints)
@@ -1444 +1444 @@
         {
             if (entStates.every(entState => !entState.turretable ||
-                entState.turretable.holder == INVALID_ENTITY))
+                entState.turretable.holder == INVALID_ENTITY ||
+                !entState.turretable.ejectable))
                 return false;
 
@@ -1461 +1462 @@
                 "type": "leave-turret",
                 "entities": entStates.filter(entState => entState.turretable &&
-                    entState.turretable.holder != INVALID_ENTITY).map(entState => entState.id)
+                    entState.turretable.holder != INVALID_ENTITY ||
+                    !entState.turretable.ejectable).map(entState => entState.id)
             });
         },

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

@@ -392 +392 @@
     if (cmpTurretable)
         ret.turretable = {
+
             "holder": cmpTurretable.HolderID()
         };

ps/trunk/binaries/data/mods/public/simulation/components/Health.js

@@ -135 +135 @@
     {
         let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
-        if (cmpUnitAI && (cmpUnitAI.IsIdle() ||
-            cmpUnitAI.GetGarrisonHolder() != INVALID_ENTITY && !cmpUnitAI.IsTurret()))
+        if (cmpUnitAI && cmpUnitAI.IsIdle())
             regen += this.GetIdleRegenRate();
     }

ps/trunk/binaries/data/mods/public/simulation/components/TurretHolder.js

@@ -20 +20 @@
                 "allowedClasses": points[point].AllowedClasses?._string,
                 "angle": points[point].Angle ? +points[point].Angle * Math.PI / 180 : null,
-                "entity": null
+                "entity": null,
+                "template": points[point].Template,
+                "ejectable": "Ejectable" in points[point] ? points[point].Ejectable == "true" : true
             });
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     }
 
@@ -38 +79 @@
      * @return {boolean} - Whether the entity is allowed to occupy the specified turret point.
      */
-    AllowedToOccupyTurret(entity, turretPoint)
+    AllowedToOccupyTurret(entity, turretPoint)
     {
         if (!turretPoint || turretPoint.entity)
@@ -59 +100 @@
     CanOccupy(entity)
     {
-        return !!this.turretPoints.find(turretPoint => this.AllowedToOccupyTurret(entity, turretPoint));
+        return !!this.turretPoints.find(turretPoint => this.AllowedToOccupyTurret(entity, turretPoint));
     }
 
@@ -69 +110 @@
      * @return {boolean} - Whether the occupation was successful.
      */
-    OccupyTurret(entity, requestedTurretPoint)
+    OccupyTurret(entity, requestedTurretPoint)
     {
         let cmpPositionOccupant = Engine.QueryInterface(entity, IID_Position);
@@ -79 +120 @@
             return false;
 
-        if (this.OccupiesTurret(entity))
+        if (this.OccupiesTurret(entity))
             return false;
 
@@ -85 +126 @@
         if (requestedTurretPoint)
         {
-            if (this.AllowedToOccupyTurret(entity, requestedTurretPoint))
+            if (this.AllowedToOccupyTurret(entity, requestedTurretPoint))
                 turretPoint = requestedTurretPoint;
         }
         else
-            turretPoint = this.turretPoints.find(turret => !turret.entity && this.AllowedToOccupyTurret(entity, turret));
+            turretPoint = this.turretPoints.find(turret => !turret.entity && this.AllowedToOccupyTurret(entity, turret));
 
         if (!turretPoint)
@@ -122 +163 @@
      * @return {boolean} - Whether the occupation has succeeded.
      */
-    OccupyNamedTurret(entity, turretName)
-    {
-        return this.OccupyTurret(entity, this.turretPoints.find(turret => turret.name == turretName));
+    OccupyNamedTurretPoint(entity, turretName)
+    {
+        return this.OccupyTurretPoint(entity, this.TurretPointByName(turretName));
+    }
+
+    /**
+     * @param {string} turretPointName - The name of the requested turret point.
+     * @return {Object} - The requested turret point.
+     */
+    TurretPointByName(turretPointName)
+    {
+        return this.turretPoints.find(turret => turret.name == turretPointName);
     }
 
@@ -130 +180 @@
      * Remove the entity from a turret.
      * @param {number} entity - The specific entity to eject.
+
      * @param {Object} turret - Optionally the turret to abandon.
      *
-     * @return {boolean} - Whether the entity was occupying a/the turret before.
-     */
-    LeaveTurret(entity, requestedTurretPoint)
+     * @return {boolean} - Whether the entity .
+     */
+    LeaveTurret, requestedTurretPoint)
     {
         let turretPoint;
@@ -143 +194 @@
         }
         else
-            turretPoint = this.turretPoints.find(turret => turret.entity == entity);
-
-        if (!turretPoint)
+            turretPoint = this.entity);
+
+        if (!turretPoint)
             return false;
 
         turretPoint.entity = null;
-
-        let cmpPositionEntity = Engine.QueryInterface(entity, IID_Position);
-        if (cmpPositionEntity)
-            cmpPositionEntity.SetTurretParent(INVALID_ENTITY, new Vector3D());
 
         Engine.PostMessage(this.entity, MT_TurretsChanged, {
@@ -168 +215 @@
      * @return {boolean} - Whether the entity is positioned on a turret of this entity.
      */
-    OccupiesTurret(entity, requestedTurretPoint)
+    OccupiesTurret(entity, requestedTurretPoint)
     {
         return requestedTurretPoint ? requestedTurretPoint.entity == entity :
-            this.turretPoints.some(turretPoint => turretPoint.entity == entity);
+            entity);
     }
 
@@ -178 +225 @@
      * @return {Object} - The turret this entity is positioned on, if applicable.
      */
-    GetOccupiedTurret(entity)
+    GetOccupiedTurret(entity)
     {
         return this.turretPoints.find(turretPoint => turretPoint.entity == entity);
@@ -187 +234 @@
      * @return {Object} - The turret this entity is positioned on, if applicable.
      */
-    GetOccupiedTurretName(entity)
-    {
-        let turret = this.GetOccupiedTurret(entity);
+    GetOccupiedTurretName(entity)
+    {
+        let turret = this.GetOccupiedTurret(entity);
         return turret ? turret.name : "";
     }
@@ -307 +354 @@
 
         for (let [turretPointName, entity] of this.initTurrets)
-            if (!this.OccupyNamedTurret(entity, turretPointName))
+        {
+            let cmpTurretable = Engine.QueryInterface(entity, IID_Turretable);
+            if (!cmpTurretable || !cmpTurretable.OccupyTurret(this.entity, turretPointName, this.TurretPointByName(turretPointName).ejectable))
                 warn("Entity " + entity + " could not occupy the turret point " +
                     turretPointName + " of turret holder " + this.entity + ".");
+
 
         delete this.initTurrets;
@@ -324 +374 @@
             if (!cmpTurretable)
                 continue;
-            let currentPoint = this.GetOccupiedTurretName(entity);
+            let currentPoint = this.GetOccupiedTurretName(entity);
             cmpTurretable.LeaveTurret(true);
             cmpTurretable.OccupyTurret(msg.newentity, currentPoint);
@@ -335 +385 @@
     OnOwnershipChanged(msg)
     {
-        let entities = this.GetEntities();
-        if (!entities.length)
+        if (msg.to === INVALID_PLAYER)
+        {
+            this.EjectOrKill(this.GetEntities());
             return;
-
-        if (msg.to == INVALID_PLAYER)
-            this.EjectOrKill(entities);
-        else
-            for (let entity of entities.filter(entity => !IsOwnedByMutualAllyOfEntity(entity, this.entity)))
+        }
+        for (let point of this.turretPoints)
+        {
+            // If we were created, create any subunits now.
+            // This has to be done here (instead of on Init)
+            // for Ownership ought to be initialised.
+            if (point.template && msg.from === INVALID_PLAYER)
             {
-                let cmpTurretable = Engine.QueryInterface(entity, IID_Turretable);
+                this.CreateSubunit(point.name);
+                continue;
+            }
+            if (!point.entity)
+                continue;
+            if (!point.ejectable)
+            {
+                let cmpTurretOwnership = Engine.QueryInterface(point.entity, IID_Ownership);
+                if (cmpTurretOwnership)
+                    cmpTurretOwnership.SetOwner(msg.to);
+            }
+            else if (!IsOwnedByMutualAllyOfEntity(point.entity, this.entity))
+            {
+                let cmpTurretable = Engine.QueryInterface(point.entity, IID_Turretable);
                 if (cmpTurretable)
                     cmpTurretable.LeaveTurret();
             }
+
+
     }
 }
@@ -366 +434 @@
                         "<data type='decimal'/>" +
                     "</element>" +
+
+
+
+
+
+
+
+
+
+
                     "<optional>" +
                         "<element name='AllowedClasses' a:help='If specified, only entities matching the given classes will be able to use this turret.'>" +

ps/trunk/binaries/data/mods/public/simulation/components/Turretable.js

@@ -36 +36 @@
 
 /**
+
+
+
+
+
+
+
+
  * @param {number} target - The entity ID to check.
  * @return {boolean} - Whether we can occupy the turret.
@@ -51 +59 @@
  * @param {number} target - The entity ID of the entity this entity is being turreted on.
  * @param {string} turretPointName - Optionally the turret point name to occupy.
+
+
  * @return {boolean} - Whether occupying succeeded.
  */
-Turretable.prototype.OccupyTurret = function(target, turretPointName = "")
+Turretable.prototype.OccupyTurret = function(target, turretPointName = "")
 {
     if (!this.CanOccupy(target))
@@ -59 +69 @@
 
     let cmpTurretHolder = Engine.QueryInterface(target, IID_TurretHolder);
-    if (!cmpTurretHolder || !cmpTurretHolder.OccupyNamedTurret(this.entity, turretPointName))
+    if (!cmpTurretHolder || !cmpTurretHolder.OccupyNamedTurret(this.entity, turretPointName))
         return false;
 
     this.holder = target;
+
 
     let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
@@ -97 +108 @@
         return true;
 
+
+
+
     let pos = PositionHelper.GetSpawnPosition(this.holder, this.entity, forced);
     if (!pos)
@@ -102 +116 @@
 
     let cmpTurretHolder = Engine.QueryInterface(this.holder, IID_TurretHolder);
-    if (!cmpTurretHolder || !cmpTurretHolder.LeaveTurret(this.entity))
+    if (!cmpTurretHolder || !cmpTurretHolder.LeaveTurret))
         return false;
 
@@ -112 +126 @@
     if (cmpPosition)
     {
+
         cmpPosition.JumpTo(pos.x, pos.z);
         cmpPosition.SetHeightOffset(0);
+
+
+
+
     }
-
-    let cmpHolderPosition = Engine.QueryInterface(this.holder, IID_Position);
-    if (cmpHolderPosition)
-        cmpPosition.SetYRotation(cmpHolderPosition.GetPosition().horizAngleTo(pos));
 
     let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
@@ -139 +154 @@
 
     let cmpRallyPoint = Engine.QueryInterface(this.holder, IID_RallyPoint);
+
+
+
+
+
     if (cmpRallyPoint)
         cmpRallyPoint.OrderToRallyPoint(this.entity, ["occupy-turret"]);
 
-    delete this.holder;
+    delete this.;
     return true;
 };
@@ -156 +176 @@
 
     let holder = this.holder;
-    let currentPoint = cmpTurretHolder.GetOccupiedTurretName(this.entity);
+    let currentPoint = cmpTurretHolder.GetOccupiedTurretName(this.entity);
     this.LeaveTurret(true);
     let cmpTurretableNew = Engine.QueryInterface(msg.newentity, IID_Turretable);

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

@@ -3575 +3575 @@
 };
 
-UnitAI.prototype.GetGarrisonHolder = function()
-{
-    if (!this.isGarrisoned)
-        return INVALID_ENTITY;
-
-    let cmpGarrisonable = Engine.QueryInterface(this.entity, IID_Garrisonable);
-    return cmpGarrisonable ? cmpGarrisonable.HolderID() : INVALID_ENTITY;
-};
-
 UnitAI.prototype.ShouldRespondToEndOfAlert = function()
 {

ps/trunk/binaries/data/mods/public/simulation/components/tests/test_TurretHolder.js

@@ -92 +92 @@
 
 // Test visible garrisoning restrictions.
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(siegeEngineID, cmpTurretHolder.turretPoints[0]), true);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(siegeEngineID, cmpTurretHolder.turretPoints[1]), true);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(siegeEngineID, cmpTurretHolder.turretPoints[2]), true);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(archerID, cmpTurretHolder.turretPoints[0]), true);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(archerID, cmpTurretHolder.turretPoints[1]), false);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(archerID, cmpTurretHolder.turretPoints[2]), true);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(cavID, cmpTurretHolder.turretPoints[0]), true);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(cavID, cmpTurretHolder.turretPoints[1]), false);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(cavID, cmpTurretHolder.turretPoints[2]), true);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(infID, cmpTurretHolder.turretPoints[0]), true);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(infID, cmpTurretHolder.turretPoints[1]), false);
-TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(infID, cmpTurretHolder.turretPoints[2]), false);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(siegeEngineID, cmpTurretHolder.turretPoints[0]), true);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(siegeEngineID, cmpTurretHolder.turretPoints[1]), true);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(siegeEngineID, cmpTurretHolder.turretPoints[2]), true);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(archerID, cmpTurretHolder.turretPoints[0]), true);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(archerID, cmpTurretHolder.turretPoints[1]), false);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(archerID, cmpTurretHolder.turretPoints[2]), true);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(cavID, cmpTurretHolder.turretPoints[0]), true);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(cavID, cmpTurretHolder.turretPoints[1]), false);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(cavID, cmpTurretHolder.turretPoints[2]), true);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(infID, cmpTurretHolder.turretPoints[0]), true);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(infID, cmpTurretHolder.turretPoints[1]), false);
+TS_ASSERT_EQUALS(cmpTurretHolder.AllowedToOccupyTurret(infID, cmpTurretHolder.turretPoints[2]), false);
 
 // Test that one cannot leave a turret that is not occupied.
-TS_ASSERT(!cmpTurretHolder.LeaveTurret(archerID));
+TS_ASSERT(!cmpTurretHolder.LeaveTurret(archerID));
 
 // Test occupying a turret.
-TS_ASSERT(!cmpTurretHolder.OccupiesTurret(archerID));
-TS_ASSERT(cmpTurretHolder.OccupyTurret(archerID));
-TS_ASSERT(cmpTurretHolder.OccupiesTurret(archerID));
+TS_ASSERT(!cmpTurretHolder.OccupiesTurret(archerID));
+TS_ASSERT(cmpTurretHolder.OccupyTurret(archerID));
+TS_ASSERT(cmpTurretHolder.OccupiesTurret(archerID));
 
 // We're not occupying a turret that we can't occupy.
-TS_ASSERT(!cmpTurretHolder.OccupiesTurret(archerID, cmpTurretHolder.turretPoints[1]));
-TS_ASSERT(!cmpTurretHolder.OccupyTurret(cavID, cmpTurretHolder.turretPoints[1]));
-TS_ASSERT(!cmpTurretHolder.OccupyTurret(cavID, cmpTurretHolder.turretPoints[0]));
-TS_ASSERT(cmpTurretHolder.OccupyTurret(cavID, cmpTurretHolder.turretPoints[2]));
+TS_ASSERT(!cmpTurretHolder.OccupiesTurret(archerID, cmpTurretHolder.turretPoints[1]));
+TS_ASSERT(!cmpTurretHolder.OccupyTurret(cavID, cmpTurretHolder.turretPoints[1]));
+TS_ASSERT(!cmpTurretHolder.OccupyTurret(cavID, cmpTurretHolder.turretPoints[0]));
+TS_ASSERT(cmpTurretHolder.OccupyTurret(cavID, cmpTurretHolder.turretPoints[2]));
 
 // Leave turrets.
-TS_ASSERT(cmpTurretHolder.LeaveTurret(archerID));
-TS_ASSERT(!cmpTurretHolder.LeaveTurret(cavID, cmpTurretHolder.turretPoints[1]));
-TS_ASSERT(cmpTurretHolder.LeaveTurret(cavID, cmpTurretHolder.turretPoints[2]));
+TS_ASSERT(cmpTurretHolder.LeaveTurret(archerID));
+TS_ASSERT(!cmpTurretHolder.LeaveTurret, cmpTurretHolder.turretPoints[1]));
+TS_ASSERT(cmpTurretHolder.LeaveTurret, cmpTurretHolder.turretPoints[2]));

ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Turrets.js

@@ -88 +88 @@
 TS_ASSERT(cmpTurretable.OccupyTurret(holder));
 TS_ASSERT_UNEVAL_EQUALS(cmpTurretHolder.GetEntities(), [turret]);
-TS_ASSERT(cmpTurretHolder.OccupiesTurret(turret));
+TS_ASSERT(cmpTurretHolder.OccupiesTurret(turret));
 TS_ASSERT(cmpTurretable.LeaveTurret());
 TS_ASSERT_UNEVAL_EQUALS(cmpTurretHolder.GetEntities(), []);
@@ -99 +99 @@
 TS_ASSERT(cmpTurretable.OccupyTurret(holder));
 TS_ASSERT(cmpTurretableNew.LeaveTurret());
-let previousTurret = cmpTurretHolder.GetOccupiedTurretName(turret);
+let previousTurret = cmpTurretHolder.GetOccupiedTurretName(turret);
 cmpTurretable.OnEntityRenamed({
     "entity": turret,
     "newentity": newTurret
 });
-let newTurretPos = cmpTurretHolder.GetOccupiedTurretName(newTurret);
+let newTurretPos = cmpTurretHolder.GetOccupiedTurretName(newTurret);
 TS_ASSERT_UNEVAL_EQUALS(newTurretPos, previousTurret);
 TS_ASSERT(cmpTurretableNew.LeaveTurret());

ps/trunk/binaries/data/mods/public/simulation/helpers/Transform.js

@@ -27 +27 @@
     }
 
+
+
+
+
+
+
+
     var cmpOwnership = Engine.QueryInterface(oldEnt, IID_Ownership);
     var cmpNewOwnership = Engine.QueryInterface(newEnt, IID_Ownership);
@@ -59 +66 @@
         cmpNewBuilderList.AddBuilders(cmpBuilderList.GetBuilders());
 
-    var cmpUnitAI = Engine.QueryInterface(oldEnt, IID_UnitAI);
-    var cmpNewUnitAI = Engine.QueryInterface(newEnt, IID_UnitAI);
-    if (cmpUnitAI && cmpNewUnitAI)
-    {
-        let pos = cmpUnitAI.GetHeldPosition();
-        if (pos)
-            cmpNewUnitAI.SetHeldPosition(pos.x, pos.z);
-        if (cmpUnitAI.GetStanceName())
-            cmpNewUnitAI.SwitchToStance(cmpUnitAI.GetStanceName());
-        if (cmpUnitAI.GetGarrisonHolder() != INVALID_ENTITY)
-            cmpNewUnitAI.SetGarrisoned();
-        cmpNewUnitAI.AddOrders(cmpUnitAI.GetOrders());
-        if (cmpUnitAI.IsGuardOf())
-        {
-            let guarded = cmpUnitAI.IsGuardOf();
-            let cmpGuard = Engine.QueryInterface(guarded, IID_Guard);
-            if (cmpGuard)
-            {
-                cmpGuard.RenameGuard(oldEnt, newEnt);
-                cmpNewUnitAI.SetGuardOf(guarded);
-            }
-        }
-    }
-
     let cmpPromotion = Engine.QueryInterface(oldEnt, IID_Promotion);
     let cmpNewPromotion = Engine.QueryInterface(newEnt, IID_Promotion);
@@ -96 +79 @@
         cmpNewResGatherer.SetLastCarriedType(cmpResGatherer.GetLastCarriedType());
     }
-
 
     // Maintain the list of guards
@@ -134 +116 @@
     Engine.PostMessage(oldEnt, MT_EntityRenamed, { "entity": oldEnt, "newentity": newEnt });
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     if (cmpPosition && cmpPosition.IsInWorld())
         cmpPosition.MoveOutOfWorld();

ps/trunk/source/graphics/MapReader.cpp

@@ -1059 +1059 @@
             }
 
-            CmpPtr<ICmpOwnership> cmpOwnership(sim, ent);
-            if (cmpOwnership)
-                cmpOwnership->SetOwner(PlayerID);
-
             if (!Garrison.empty())
             {
@@ -1072 +1068 @@
             }
 
+
+
             if (!Turrets.empty())
             {
@@ -1080 +1078 @@
                     LOGERROR("CXMLMapReader::ReadEntities() entity '%d' of player '%d' has no TurretHolder component and thus cannot use turrets.", ent, PlayerID);
             }
+
+
+
+
 
             CmpPtr<ICmpObstruction> cmpObstruction(sim, ent);

ps/trunk/source/simulation2/components/CCmpPosition.cpp

@@ -1 @@
-/* Copyright (C) 2020 Wildfire Games.
+/* Copyright (C) 202 Wildfire Games.
  * This file is part of 0 A.D.
  *
@@ -22 +22 @@
 
 #include "simulation2/MessageTypes.h"
+
 
 #include "ICmpTerrain.h"
@@ -229 +230 @@
             serialize.NumberFixed_Unbounded("z", m_TurretPosition.Z);
         }
+
     }
 
@@ -266 +268 @@
             deserialize.NumberFixed_Unbounded("z", m_TurretPosition.Z);
         }
+
 
         if (m_InWorld)

ps/trunk/source/simulation2/components/ICmpTurretHolder.cpp

@@ -41 +41 @@
         for (entity_id_t entity : entities)
             turrets.push_back(std::make_pair(
-                m_Script.Call<std::string>("GetOccupiedTurretName", entity),
+                m_Script.Call<std::string>("GetOccupiedTurretName", entity),
                 entity
             ));