Ticket #2577: turrets_scripted.2.diff

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>" +
@@ -188 +191 @@
 
 Attack.prototype.Init = function()
 {
+    this.latestTarget = INVALID_ENTITY;
 };
 
-Attack.prototype.Serialize = null; // we have no dynamic state to save
+Attack.prototype.GetLatestTarget = function()
+{
+    return this.latestTarget;
+};
 
 Attack.prototype.GetAttackTypes = function()
 {
@@ -443 +450 @@
  * 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 == "true" && !turretId)
+        return;
     // If this is a ranged attack, then launch a projectile
     if (type == "Ranged")
     {
@@ -512 +521 @@
         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/TurretAI.js

@@ +1 @@
+function TurretAI() {}
+
+TurretAI.prototype.Schema = 
+    "<empty/>";
+
+TurretAI.prototype.MAX_PREFERENCE_BONUS = 2;
+
+/**
+ * Initialize TurretAI Component
+ */
+TurretAI.prototype.Init = function()
+{
+};
+
+TurretAI.prototype.GetTurretParent = function()
+{
+    var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
+    if (!cmpPosition)
+        return INVALID_ENTITY;
+    return cmpPosition.GetTurretParent();
+};
+
+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);
+};
+
+TurretAI.prototype.OnOwnershipChanged = function(msg)
+{
+    var cmpAttack = this.GetCmpAttack();
+    if (!cmpAttack)
+        return;
+    this.bestAttack = cmpAttack.GetBestAttack();
+    // 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);
+};
+
+TurretAI.prototype.OnDiplomacyChanged = function(msg)
+{
+    var cmpOwnership = Engine.QueryInterface(this.entity, IID_Ownership);
+    if (cmpOwnership && cmpOwnership.GetOwner() == msg.player)
+    {
+        // Remove maybe now allied/neutral units
+        this.targetUnits = [];
+        this.SetupRangeQuery(msg.player);
+    }
+};
+
+/**
+ * Cleanup on destroy
+ */
+TurretAI.prototype.OnDestroy = function()
+{
+    if (this.timer)
+    {
+        var 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 (var i = 1; i < numPlayers; ++i)
+    {   // Exclude gaia, allies, and self
+        // 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) {
+            var 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 (var 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 each (var entity in msg.added)
+        {
+            if (cmpAttack.CanAttack(entity))
+                this.targetUnits.push(entity);
+        }
+    }
+    if (msg.removed.length > 0)
+    {
+        for each (var entity in msg.removed)
+        {   
+            var 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);
+};
+
+TurretAI.prototype.GetPreviousTarget = function()
+{
+    var cmpAttack = this.GetCmpAttack();
+    if (!cmpAttack)
+        return INVALID_ENTITY;
+    var previousTarget = cmpAttack.GetLatestTarget();
+    var turretParent = this.GetTurretParent();
+    var cmpUnitAI = Engine.QueryInterface(turretParent, 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;
+};
+
+TurretAI.prototype.Attack = function()
+{
+    if (!this.targetUnits.length)
+    {
+        if (this.timer)
+        {
+            // stop the timer
+            var 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 (var i = 0; i < this.targetUnits.length; i++)
+        {
+            var target = this.targetUnits[i];
+            var preference = cmpAttack.GetPreference(target);
+            var 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.MAX_PREFERENCE_BONUS / (1 + preference);
+            }
+            targets.push(target, weight);
+        }
+        selectedIndex = targets.randomIndex()
+        target = targets.itemAt(selectedIndex);
+    }
+    // now we hope there's a target
+    if (target != INVALID_ENTITY)
+    {
+        this.TurnTowardsTarget(target);
+        cmpAttack.PerformAttack(this.bestAttack, target, this.entity);
+    }
+};
+
+TurretAI.prototype.SelectAnimation = function(name, once, speed, sound)
+{
+    var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+    if (!cmpVisual)
+        return;
+
+    var soundgroup;
+    if (sound)
+    {
+        var cmpSound = Engine.QueryInterface(this.entity, IID_Sound);
+        if (cmpSound)
+            soundgroup = cmpSound.GetSoundGroup(sound);
+    }
+    cmpVisual.SelectAnimation(name, once || false, speed || 1.0, soundgroup || "");
+};
+
+TurretAI.prototype.SetAnimationSync = function(actiontime, repeattime)
+{
+    var cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
+    if (!cmpVisual)
+        return;
+
+    cmpVisual.SetAnimationSyncRepeat(repeattime);
+    cmpVisual.SetAnimationSyncOffset(actiontime);
+};
+
+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();
+};
+
+TurretHolder.prototype.CreateTurrets = function()
+{
+    for each (var 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;
+};
+
+TurretHolder.prototype.OnDestroy = function()
+{
+    for (var ent of this.turrets)
+        Engine.DestroyEntity(ent);
+};
+
+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 (var 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/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/templates/template_turret.xml

@@ +1 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Entity parent="template_entity_full">
+  <Decay>
+    <Inactive/>
+    <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/>
+  <VisualActor>
+    <SilhouetteDisplay>true</SilhouetteDisplay>
+    <SilhouetteOccluder>false</SilhouetteOccluder>
+    <VisibleInAtlasOnly>false</VisibleInAtlasOnly>
+  </VisualActor>
+</Entity>

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

@@ -10 +10 @@
       <Spread>1.3</Spread>
       <MaxRange>60.0</MaxRange>
       <MinRange>16.0</MinRange>
+      <TurretsOnly>true</TurretsOnly>
     </Ranged>
   </Attack>
   <Footprint replace="">
@@ -28 +29 @@
   <ResourceGatherer>
     <BaseSpeed>0.75</BaseSpeed>
   </ResourceGatherer>
+  <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

@@ -22 +22 @@
   <ResourceGatherer>
     <BaseSpeed>0.5</BaseSpeed>
   </ResourceGatherer>
+  <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>