Ticket #2577: 2577 Atlas Todo.patch

binaries/data/mods/public/art/actors/units/celts/boudicca_chariot.xml

@@ -12 +12 @@
       <props>
         <prop actor="units/celts/boudicca_chariot_h1.xml" attachpoint="horseright"/>
         <prop actor="units/celts/boudicca_chariot_h2.xml" attachpoint="horseleft"/>
-        <prop actor="units/celts/boudicca_r2.xml" attachpoint="rider"/>
         <prop actor="units/celts/champion_unit_4_d.xml" attachpoint="driver"/>
       </props>
       <textures><texture file="structural/celt_chariot_b.dds" name="baseTex"/></textures>

binaries/data/mods/public/art/actors/units/persians/cavalry_archer_a.xml

@@ -14 +14 @@
         <prop actor="units/persians/pers_chariot_archer_a_h2.xml" attachpoint="horse2"/>
         <prop actor="units/persians/pers_chariot_archer_a_h3.xml" attachpoint="horse3"/>
         <prop actor="units/persians/pers_chariot_archer_a_h4.xml" attachpoint="horse4"/>
-        <prop actor="units/persians/cavalry_archer_a_r.xml" attachpoint="rider1"/>
         <prop actor="units/persians/cavalry_archer_a_d.xml" attachpoint="rider2"/>
       </props>
       <textures><texture file="structural/pers_chariot_a.png" name="baseTex"/></textures>

binaries/data/mods/public/art/actors/units/persians/cavalry_archer_e.xml

@@ -15 +15 @@
         <prop actor="units/persians/pers_chariot_archer_e_h2.xml" attachpoint="horse2"/>
         <prop actor="units/persians/pers_chariot_archer_e_h3.xml" attachpoint="horse3"/>
         <prop actor="units/persians/pers_chariot_archer_e_h4.xml" attachpoint="horse4"/>
-        <prop actor="units/persians/cavalry_archer_e_r.xml" attachpoint="rider1"/>
         <prop actor="units/persians/cavalry_archer_e_d.xml" attachpoint="rider2"/>
       </props>
       <textures><texture file="structural/pers_chariot_e.png" name="baseTex"/></textures>

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

@@ -155 +155 @@
                         "</interleave>" +
                     "</element>" +
                 "</optional>" +
+                "<optional>"+
+                    "<element name='TurretsOnly' a:help='When set to \"true\", will only accept attacks coming from turrets.'><text/></element>" +
+                "</optional>" +
             "</interleave>" +
         "</element>" +
     "</optional>" +
@@ -202 +205 @@
 
 Attack.prototype.Init = function()
 {
+    this.latestTarget = INVALID_ENTITY;
 };
 
-Attack.prototype.Serialize = null; // we have no dynamic state to save
+Attack.prototype.Serialize = null; // we have no dynamic state to save 
 
 Attack.prototype.GetAttackTypes = function()
 {
@@ -502 +506 @@
  * and should only be called after GetTimers().repeat msec has passed since the last
  * call to PerformAttack.
  */
-Attack.prototype.PerformAttack = function(type, target)
+Attack.prototype.PerformAttack = function(type, target, turretId)
 {
+    if(this.template[type].TurretsOnly)
+        if (!turretId && this.template[type].TurretsOnly == "true")
+            return;
+
     // If this is a ranged attack, then launch a projectile
     if (type == "Ranged")
     {
@@ -571 +579 @@
         var graphicalPosition = Vector3D.mult(missileDirection, 2).add(realTargetPosition);
         // Launch the graphical projectile
         var cmpProjectileManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ProjectileManager);
-        var id = cmpProjectileManager.LaunchProjectileAtPoint(this.entity, realTargetPosition, horizSpeed, gravity);
+        var id = cmpProjectileManager.LaunchProjectileAtPoint(turretId || this.entity, realTargetPosition, horizSpeed, gravity);
 
         var playerId = Engine.QueryInterface(this.entity, IID_Ownership).GetOwner();
         var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);

binaries/data/mods/public/simulation/components/interfaces/TurretAI.js

@@ +1 @@
+Engine.RegisterInterface("TurretAI");

binaries/data/mods/public/simulation/components/interfaces/TurretHolder.js

@@ +1 @@
+Engine.RegisterInterface("TurretHolder");
+

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

@@ +1 @@
+function TurretAI() {}
+TurretAI.prototype.Schema = 
+    "<empty/>";
+
+TurretAI.prototype.g_MaxPreferenceBonus = 2;
+TurretAI.prototype.g_LatestTarget = 0   ;
+
+/**
+ * Initialize TurretAI Component.
+ */
+TurretAI.prototype.Init = function()
+{
+};
+
+/**
+ * Get the turrent parent.
+ */
+TurretAI.prototype.GetTurretParent = function()
+{
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition)
+        return INVALID_ENTITY;
+    return cmpPosition.GetTurretParent();
+};
+
+/**
+ * Get the attack component
+ */
+TurretAI.prototype.GetCmpAttack = function()
+{
+    // use own attack, or turretHolder's attack
+    var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+    if (cmpAttack)
+        return cmpAttack;
+    return Engine.QueryInterface(this.GetTurretParent(), IID_Attack);
+};
+
+/**
+ * Sends the message to change ownership
+ */
+TurretAI.prototype.OnOwnershipChanged = function(msg)
+{
+    var cmpAttack = this.GetCmpAttack();
+    if (!cmpAttack)
+        return;
+    //Return the first possible Attack Type, Capturing being the last.
+    this.bestAttack = cmpAttack.GetAttackTypes()[0];
+    
+    // Remove current targets, to prevent them from being added twice
+    this.targetUnits = [];
+
+    if (msg.to != -1)
+        this.SetupRangeQuery(msg.to);
+
+    // Non-Gaia buildings should attack certain Gaia units.
+    if (msg.to != 0 || this.gaiaUnitsQuery)
+        this.SetupGaiaRangeQuery(msg.to);
+};
+
+/**
+ * Change Diplomacy State
+ */
+TurretAI.prototype.OnDiplomacyChanged = function(msg)
+{
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (cmpOwnership && cmpOwnership.GetOwner() == msg.player)
+    {
+        // Remove now allied/neutral units
+        this.targetUnits = [];
+        this.SetupRangeQuery(msg.player);
+    }
+};
+
+/**
+ * Cleanup on destroy
+ */
+TurretAI.prototype.OnDestroy = function()
+{
+    if (this.timer)
+    {
+        let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+        cmpTimer.CancelTimer(this.timer);
+        this.timer = undefined;
+    }
+
+    // Clean up range queries
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    if (this.enemyUnitsQuery)
+        cmpRangeManager.DestroyActiveQuery(this.enemyUnitsQuery);
+    if (this.gaiaUnitsQuery)
+        cmpRangeManager.DestroyActiveQuery(this.gaiaUnitsQuery);
+};
+
+/**
+ * Setup the Range Query to detect units coming in & out of range
+ */
+TurretAI.prototype.SetupRangeQuery = function(owner)
+{
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    var cmpPlayerManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+    var cmpAttack = this.GetCmpAttack();
+    if (!cmpAttack)
+        return;
+
+    if (this.enemyUnitsQuery)
+    {
+        cmpRangeManager.DestroyActiveQuery(this.enemyUnitsQuery);
+        this.enemyUnitsQuery = undefined;
+    }
+    
+    var players = [];
+    var cmpPlayer = Engine.QueryInterface(cmpPlayerManager.GetPlayerByID(owner), IID_Player);
+    var numPlayers = cmpPlayerManager.GetNumPlayers();
+
+    for (let i = 1; i < numPlayers; ++i)
+    {
+        // TODO: How to handle neutral players - Special query to attack military only?
+        if (cmpPlayer.IsEnemy(i))
+            players.push(i);
+    }
+
+    var range = cmpAttack.GetRange(this.bestAttack);
+    this.enemyUnitsQuery = cmpRangeManager.CreateActiveParabolicQuery(this.entity, range.min, range.max, range.elevationBonus, players, IID_DamageReceiver, cmpRangeManager.GetEntityFlagMask("normal"));
+    cmpRangeManager.EnableActiveQuery(this.enemyUnitsQuery);
+};
+
+/** 
+ *Set up a range query for Gaia units within LOS range which can be attacked.
+ * This should be called whenever our ownership changes.
+ */
+TurretAI.prototype.SetupGaiaRangeQuery = function()
+{
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    var owner = cmpOwnership.GetOwner();
+
+    var cmpRangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
+    var playerMan = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager);
+    var cmpAttack = this.GetCmpAttack();
+    if (!cmpAttack)
+        return;
+
+    if (this.gaiaUnitsQuery)
+    {
+        cmpRangeManager.DestroyActiveQuery(this.gaiaUnitsQuery);
+        this.gaiaUnitsQuery = undefined;
+    }
+
+    if (owner == -1)
+        return;
+
+    var cmpPlayer = Engine.QueryInterface(playerMan.GetPlayerByID(owner), IID_Player);
+    if (!cmpPlayer.IsEnemy(0))
+        return;
+
+    var range = cmpAttack.GetRange(this.bestAttack);
+
+    // This query is only interested in Gaia entities that can attack.
+    this.gaiaUnitsQuery = cmpRangeManager.CreateActiveParabolicQuery(this.entity, range.min, range.max, range.elevationBonus, [0], IID_Attack, cmpRangeManager.GetEntityFlagMask("normal"));
+    cmpRangeManager.EnableActiveQuery(this.gaiaUnitsQuery);
+};
+
+/**
+ * Called when units enter or leave range
+ */
+TurretAI.prototype.OnRangeUpdate = function(msg)
+{
+    var cmpAttack = this.GetCmpAttack();
+    if (!cmpAttack)
+        return;
+
+    if (msg.tag == this.gaiaUnitsQuery)
+    {
+        const filter = function(e) {
+            let cmpUnitAI = Engine.QueryInterface(e, IID_UnitAI);
+            return (cmpUnitAI && (!cmpUnitAI.IsAnimal() || cmpUnitAI.IsDangerousAnimal()));
+        };
+
+        if (msg.added.length)
+            msg.added = msg.added.filter(filter);
+
+        // Removed entities may not have cmpUnitAI.
+        for (let i = 0; i < msg.removed.length; ++i)
+            if (this.targetUnits.indexOf(msg.removed[i]) == -1)
+                msg.removed.splice(i--, 1);
+    }
+    else if (msg.tag != this.enemyUnitsQuery)
+        return;
+
+    if (msg.added.length > 0)
+        for (let entity of msg.added)
+            if (cmpAttack.CanAttack(entity))
+                this.targetUnits.push(entity);
+            
+    if (msg.removed.length > 0)
+        for (let entity of msg.removed)
+        {   
+            let index = this.targetUnits.indexOf(entity);
+            if (index > -1)
+                this.targetUnits.splice(index, 1);
+        }
+
+    if (!this.targetUnits.length || this.timer)
+        return;
+
+    var attackTimers = cmpAttack.GetTimers(this.bestAttack);
+    this.SelectAnimation("attack_" + this.bestAttack.toLowerCase(), false, 1.0, "attack");
+    this.SetAnimationSync(attackTimers.prepare, attackTimers.repeat);
+    // units entered the range, prepare to shoot
+    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    this.timer = cmpTimer.SetInterval(this.entity, IID_TurretAI, "Attack", attackTimers.prepare, attackTimers.repeat, null);
+};
+
+/**
+ * Get Previous Target
+ */
+TurretAI.prototype.GetPreviousTarget = function()
+{
+    var cmpAttack = this.GetCmpAttack();
+    if (!cmpAttack)
+        return INVALID_ENTITY;
+    var previousTarget = this.g_LatestTarget;
+    var cmpUnitAI = Engine.QueryInterface(this.GetTurretParent(), IID_UnitAI);
+    // if a unit ai, use that to overcome the difference between rangeManager range and unitMotion range
+    if (cmpUnitAI)
+    {
+        if (cmpUnitAI.CheckTargetAttackRange(previousTarget, this.bestAttack))
+            return previousTarget;
+        return INVALID_ENTITY;
+    }
+    // else just use the range manager (which gives us the list of possible targets);
+    if (this.targetUnits.indexOf(previousTarget) != -1)
+        return previousTarget;
+    return INVALID_ENTITY;
+};
+
+/**
+ * Attack other entities
+ */
+TurretAI.prototype.Attack = function()
+{
+    if (!this.targetUnits.length)
+    {
+        if (this.timer)
+        {
+            // stop the timer
+            let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+            cmpTimer.CancelTimer(this.timer);
+            this.timer = undefined;
+        }
+        this.SelectAnimation("idle");
+        return;
+    }
+    
+    var cmpAttack = this.GetCmpAttack();
+    if (!cmpAttack)
+        return;
+    var target = this.GetPreviousTarget();
+    // if no target, select a random one
+    if (target == INVALID_ENTITY)
+    {
+        var selectedIndex = -1;
+        var targets = new WeightedList();
+        for (let i = 0; i < this.targetUnits.length; i++)
+        {
+            let target = this.targetUnits[i];
+            let preference = cmpAttack.GetPreference(target);
+            let weight = 1;
+            if (preference !== null && preference !== undefined)
+            {
+                // Lower preference scores indicate a higher preference so they should result in a higher weight.
+                weight = 1 + this.g_MaxPreferenceBonus / (1 + preference);
+            }
+            targets.push(target, weight);
+        }
+        selectedIndex = targets.randomIndex()
+        target = targets.itemAt(selectedIndex);
+    }
+    // now we hope there's a target
+    if (target != INVALID_ENTITY)
+    {
+        // TODO : It should only turn if the parent has more than one turret.
+        this.TurnTowardsTarget(target); 
+        cmpAttack.PerformAttack(this.bestAttack, target, this.entity);
+        this.g_LatestTarget = target;
+    }
+};
+
+/**
+ * Selection the animations for the  turret
+ */
+TurretAI.prototype.SelectAnimation = function(name, once = false, speed = 1.0, sound)
+{
+    var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+    if (!cmpVisual)
+        return;
+
+    var soundgroup;
+    if (sound)
+    {
+        let cmpSound = Engine.QueryInterface(this.entity, IID_Sound);
+        if (cmpSound)
+            soundgroup = cmpSound.GetSoundGroup(sound);
+    }
+    cmpVisual.SelectAnimation(name, once, speed, soundgroup || "");
+};
+
+/**
+ * Synchronise Animations
+ */
+TurretAI.prototype.SetAnimationSync = function(actiontime, repeattime)
+{
+    var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+    if (!cmpVisual)
+        return;
+
+    cmpVisual.SetAnimationSyncRepeat(repeattime);
+    cmpVisual.SetAnimationSyncOffset(actiontime);
+};
+
+/**
+ * Orient the turret toward his foe.
+ */
+TurretAI.prototype.TurnTowardsTarget = function(target)
+{
+    var cmpThisPosition = Engine.QueryInterface(this.entity, IID_Position);
+    var cmpTargetPosition = Engine.QueryInterface(target, IID_Position);
+    if (!cmpThisPosition || !cmpTargetPosition || !cmpThisPosition.IsInWorld() || !cmpTargetPosition.IsInWorld())
+        return;
+
+    var pos = cmpTargetPosition.GetPosition2D().sub(cmpThisPosition.GetPosition2D());
+    cmpThisPosition.TurnTo(Math.atan2(pos.x, pos.y));
+};
+
+Engine.RegisterComponentType(IID_TurretAI, "TurretAI", TurretAI);

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

@@ +1 @@
+function TurretHolder() {}
+
+TurretHolder.prototype.Schema =
+    "<element name='TurretPoints'>" +
+        "<zeroOrMore>" +
+            "<element a:help='Element containing the offset coordinates and the template'>" +
+                "<anyName/>" +
+                "<interleave>" +
+                    "<element name='Template'>" +
+                        "<text/>" +
+                    "</element>" +
+                    "<element name='X'>" +
+                        "<data type='decimal'/>" +
+                    "</element>" +
+                    "<element name='Y'>" +
+                        "<data type='decimal'/>" +
+                    "</element>" +
+                    "<element name='Z'>" +
+                        "<data type='decimal'/>" +
+                    "</element>" +
+                "</interleave>" +
+            "</element>" +
+        "</zeroOrMore>" +
+    "</element>";
+
+/**
+ * Initialize TurretHolder Component.
+ */
+TurretHolder.prototype.Init = function()
+{
+    this.turrets = [];
+    var cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    // hack for atlas, don't create the turrets in Atlas, as the references get lost
+    // TODO implement some sort of tag for the turrets so they never get saved by Atlas
+/*  if (cmpTimer.GetTime() == 0)
+        cmpTimer.SetTimeout(this.entity, IID_TurretHolder, "CreateTurrets", 100, null);
+    else*/
+        this.CreateTurrets();
+};
+
+/**
+ * Create the Turrets.
+ */
+TurretHolder.prototype.CreateTurrets = function()
+{
+    for each (let turretPoint in this.template.TurretPoints)
+    {
+        var ent = Engine.AddEntity(turretPoint.Template);
+        var offset = new Vector3D(+turretPoint.X, +turretPoint.Y, +turretPoint.Z);
+        var cmpPosition = Engine.QueryInterface(ent, IID_Position);
+        if (cmpPosition)
+            cmpPosition.SetTurretParent(this.entity, offset);
+        this.turrets.push(ent);
+    }
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (cmpOwnership && cmpOwnership.GetOwner() != -1)
+        this.ChangeTurretOwnership(cmpOwnership.GetOwner());
+};
+
+/**
+ * Return the list of entities garrisoned inside.
+ */
+TurretHolder.prototype.GetTurrets = function()
+{
+    return this.turrets;
+};
+
+/**
+ * Destroys the entities.
+ */
+TurretHolder.prototype.OnDestroy = function()
+{
+    for (let ent of this.turrets)
+        Engine.DestroyEntity(ent);
+};
+
+/**
+ * Change the ownership of the turret.
+ */
+TurretHolder.prototype.OnOwnershipChanged = function(msg)
+{
+    this.ChangeTurretOwnership(msg.to);
+};
+
+/**
+ * Set the ownership of all present turrets to the same owner.
+ */
+TurretHolder.prototype.ChangeTurretOwnership = function(owner)
+{
+    for (let ent of this.turrets)
+    {
+        var cmpOwnership = Engine.QueryInterface(ent, IID_Ownership);
+        if (cmpOwnership)
+            cmpOwnership.SetOwner(owner);
+    }
+};
+
+Engine.RegisterComponentType(IID_TurretHolder, "TurretHolder", TurretHolder);
+

binaries/data/mods/public/simulation/templates/template_turret.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Entity parent="template_entity_full">
+    <Decay>
+        <Active>false</Active> 
+        <SinkingAnim>false</SinkingAnim> 
+        <DelayTime>80.0</DelayTime>
+        <SinkRate>0.01</SinkRate>
+        <SinkAccel>0.0</SinkAccel>
+    </Decay>
+    <Minimap>
+        <Type>unit</Type>
+    </Minimap>
+    <OverlayRenderer/>
+    <Selectable disable=""/>
+    <Sound>
+        <SoundGroups>
+            <attacked>interface/alarm/alarm_attackplayer.xml</attacked>
+        </SoundGroups>
+    </Sound>
+    <TurretAI/>
+    <Visibility>
+        <RetainInFog>false</RetainInFog>
+        <AlwaysVisible>false</AlwaysVisible>
+        <Preview>false</Preview>
+        <Corpse>false</Corpse>
+    </Visibility>
+    <Vision>
+        <Range>92</Range>
+    </Vision>
+    <VisualActor>
+        <SilhouetteDisplay>true</SilhouetteDisplay>
+        <SilhouetteOccluder>false</SilhouetteOccluder>
+        <VisibleInAtlasOnly>false</VisibleInAtlasOnly>
+    </VisualActor>
+</Entity>

binaries/data/mods/public/simulation/templates/units/brit_hero_bouddica_r.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Entity parent="template_turret">
+  <VisualActor>
+    <Actor>units/celts/boudicca_r2.xml</Actor>
+  </VisualActor>
+</Entity>

binaries/data/mods/public/simulation/templates/units/brit_hero_boudicca.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_hero_cavalry_javelinist">
+  <Attack>
+    <Ranged>
+      <TurretsOnly>true</TurretsOnly>
+    </Ranged>
+  </Attack>
   <Auras>
     <Aura1>
       <Type>global</Type>
@@ -26 +31 @@
     <History>Ammianus Marcellinus described how difficult it would be for a band of foreigners to deal with a Celt if he called in the help of his wife. For she was stronger than he was and could rain blows and kicks upon the assailants equal in force to the shots of a catapult. Boudicca, queen of the Iceni, was said to be 'very tall and terrifying in appearance; her voice was very harsh and a great mass of red hair fell over her shoulders. She wore a tunic of many colors over which a thick cloak was fastened by a brooch.</History>
     <Icon>units/celt_hero_boudicca.png</Icon>
   </Identity>
+    <TurretHolder>
+        <TurretPoints>
+            <Archer>
+                <Template>units/brit_hero_bouddica_r</Template>
+                    <X>0</X>
+                    <Y>1.4</Y>
+                    <Z>-2.5</Z>
+            </Archer>
+        </TurretPoints>
+    </TurretHolder>
   <VisualActor>
     <Actor>units/celts/boudicca_chariot.xml</Actor>
   </VisualActor>

binaries/data/mods/public/simulation/templates/units/pers_cavalry_archer_a.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="units/pers_cavalry_archer_b">
+  <Attack>
+    <Ranged>
+      <TurretsOnly>true</TurretsOnly>
+    </Ranged>
+  </Attack>
   <Identity>
     <Rank>Advanced</Rank>
   </Identity>
@@ -6 +11 @@
   <Promotion>
     <Entity>units/pers_cavalry_archer_e</Entity>
   </Promotion>
+  <TurretHolder>
+    <TurretPoints>
+      <Archer>
+        <Template>units/pers_cavalry_archer_rider_a</Template>
+        <X>1</X>
+         <Y>2.2</Y>
+         <Z>-4.0</Z>
+      </Archer>
+    </TurretPoints>
+  </TurretHolder>
   <VisualActor>
     <Actor>units/persians/cavalry_archer_a.xml</Actor>
   </VisualActor>

binaries/data/mods/public/simulation/templates/units/pers_cavalry_archer_e.xml

@@ -4 +4 @@
     <Rank>Elite</Rank>
   </Identity>
   <Promotion disable=""/>
+  <TurretHolder>
+    <TurretPoints>
+      <Archer>
+        <Template>units/pers_cavalry_archer_rider_e</Template>
+        <X>1</X>
+         <Y>2.2</Y>
+         <Z>-4.0</Z>
+      </Archer>
+    </TurretPoints>
+  </TurretHolder>
   <VisualActor>
     <Actor>units/persians/cavalry_archer_e.xml</Actor>
   </VisualActor>

binaries/data/mods/public/simulation/templates/units/pers_cavalry_archer_rider_a.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Entity parent="template_turret">
+  <VisualActor>
+    <Actor>units/persians/cavalry_archer_a_r.xml</Actor>
+  </VisualActor>
+</Entity>

binaries/data/mods/public/simulation/templates/units/pers_cavalry_archer_rider_e.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Entity parent="template_turret">
+  <VisualActor>
+    <Actor>units/persians/cavalry_archer_e_r.xml</Actor>
+  </VisualActor>
+</Entity>