Changeset 25235

Timestamp:

Apr 12, 2021, 8:51:39 AM (3 years ago)

Author:

Freagarach

Message:

Attack using cmpAttack instead of UnitAI.

Keep responsibilities separated, allow easier modding of attacking behaviour.
Ideally the BuildingAI attacking routine would be merged in here as well, but not done for now.

Part of #5810
Differential revision: D3816
Comments by: @smiley, @Stan

Location:

ps/trunk/binaries/data/mods/public/simulation/components

Files:

• Attack.js (modified) (3 diffs)
• Builder.js (modified) (2 diffs)
• Heal.js (modified) (3 diffs)
• ResourceGatherer.js (modified) (2 diffs)
• TreasureCollecter.js (modified) (2 diffs)
• UnitAI.js (modified) (7 diffs)
• tests/test_UnitAI.js (modified) (3 diffs)

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

@@ -192 +192 @@
 };
 
-Attack.prototype.Serialize = null; // we have no dynamic state to save
-
 Attack.prototype.GetAttackTypes = function(wantedTypes)
 {
@@ -441 +439 @@
 
     return { "max": max, "min": min, "elevationBonus": elevationBonus };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 };
 
@@ -583 +705 @@
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 Attack.prototype.OnValueModification = function(msg)
 {

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

@@ -118 +118 @@
 Builder.prototype.StopRepairing = function(reason)
 {
-    if (this.timer)
-    {
-        let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-        cmpTimer.CancelTimer(this.timer);
-        delete this.timer;
-    }
-
-    if (this.target)
-    {
-        let cmpBuilderList = QueryBuilderListInterface(this.target);
-        if (cmpBuilderList)
-            cmpBuilderList.RemoveBuilder(this.entity);
-
-        delete this.target;
-    }
+    if (!this.target)
+        return;
+
+    let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    cmpTimer.CancelTimer(this.timer);
+    delete this.timer;
+
+    let cmpBuilderList = QueryBuilderListInterface(this.target);
+    if (cmpBuilderList)
+        cmpBuilderList.RemoveBuilder(this.entity);
+
+    delete this.target;
 
     let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
@@ -138 +135 @@
         cmpVisual.SelectAnimation("idle", false, 1.0);
 
-    // The callerIID component may start repairing again,
+    // The callerIID component may start again,
     // replacing the callerIID, hence save that.
     let callerIID = this.callerIID;

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

@@ -167 +167 @@
 
 /**
- * @param {string} reason - The reason why we stopped healing. Currently implemented are:
- *  "outOfRange", "targetInvalidated".
+ * @param {string} reason - The reason why we stopped healing.
  */
 Heal.prototype.StopHealing = function(reason)
 {
-    if (this.timer)
-    {
-        let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-        cmpTimer.CancelTimer(this.timer);
-        delete this.timer;
-    }
+    if (!this.target)
+        return;
+
+    let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    cmpTimer.CancelTimer(this.timer);
+    delete this.timer;
+
+    delete this.target;
 
     let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
@@ -183 +184 @@
         cmpVisual.SelectAnimation("idle", false, 1.0);
 
-    delete this.target;
-
-    // The callerIID component may start healing again,
+    // The callerIID component may start again,
     // replacing the callerIID, hence save that.
     let callerIID = this.callerIID;
@@ -200 +199 @@
 /**
  * Heal our target entity.
- * @params - data and lateness are unused.
+ * @param data - Unused.
+ * @param {number} lateness - The offset of the actual call and when it was expected.
  */
 Heal.prototype.PerformHeal = function(data, lateness)

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

@@ -218 +218 @@
 ResourceGatherer.prototype.StopGathering = function(reason)
 {
-    if (this.timer)
-    {
-        let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-        cmpTimer.CancelTimer(this.timer);
-        delete this.timer;
-    }
-
-    if (this.target)
-    {
-        let cmpResourceSupply = Engine.QueryInterface(this.target, IID_ResourceSupply);
-        if (cmpResourceSupply)
-            cmpResourceSupply.RemoveGatherer(this.entity);
-        this.RemoveFromPlayerCounter();
-        delete this.target;
-    }
+    if (!this.target)
+        return;
+
+    let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    cmpTimer.CancelTimer(this.timer);
+    delete this.timer;
+
+    let cmpResourceSupply = Engine.QueryInterface(this.target, IID_ResourceSupply);
+    if (cmpResourceSupply)
+        cmpResourceSupply.RemoveGatherer(this.entity);
+��   this.RemoveFromPlayerCounter();
+
+    delete this.target;
 
     let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
@@ -238 +236 @@
         cmpVisual.SelectAnimation("idle", false, 1.0);
 
-    // The callerIID component may start gathering again,
+    // The callerIID component may start again,
     // replacing the callerIID, hence save that.
     let callerIID = this.callerIID;

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

@@ -66 +66 @@
 TreasureCollecter.prototype.StopCollecting = function(reason)
 {
-    if (this.timer)
-    {
-        let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-        cmpTimer.CancelTimer(this.timer);
-        delete this.timer;
-    }
+    if (!this.target)
+        return;
+
+    let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+    cmpTimer.CancelTimer(this.timer);
+    delete this.timer;
+
     delete this.target;
 
@@ -78 +79 @@
         cmpVisual.SelectAnimation("idle", false, 1.0);
 
-    // The callerIID component may start collecting again,
+    // The callerIID component may start again,
     // replacing the callerIID, hence save that.
     let callerIID = this.callerIID;

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

@@ -2090 +2090 @@
 
                     this.shouldCheer = false;
-                    if (!this.CanAttack(target))
-                    {
-                        this.SetNextState("COMBAT.FINDINGNEWTARGET");
+
+                    let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+                    if (!cmpAttack)
+                    {
+                        this.FinishOrder();
                         return true;
                     }
@@ -2104 +2106 @@
                         }
 
-                        this.SetNextState("COMBAT.APPROACHING");
+                        this.");
                         return true;
-                    }
-
-                    let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
-                    this.attackTimers = cmpAttack.GetTimers(this.order.data.attackType);
-
-                    // If the repeat time since the last attack hasn't elapsed,
-                    // delay this attack to avoid attacking too fast.
-                    let prepare = this.attackTimers.prepare;
-                    if (this.lastAttacked)
-                    {
-                        let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-                        let repeatLeft = this.lastAttacked + this.attackTimers.repeat - cmpTimer.GetTime();
-                        prepare = Math.max(prepare, repeatLeft);
                     }
 
@@ -2124 +2113 @@
                         this.SetAnimationVariant("combat");
 
-                    this.oldAttackType = this.order.data.attackType;
-                    this.SelectAnimation("attack_" + this.order.data.attackType.toLowerCase());
-                    this.SetAnimationSync(prepare, this.attackTimers.repeat);
-                    this.StartTimer(prepare, this.attackTimers.repeat);
-                    // TODO: we should probably only bother syncing projectile attacks, not melee
-
-                    // If using a non-default prepare time, re-sync the animation when the timer runs.
-                    this.resyncAnimation = prepare != this.attackTimers.prepare;
-
                     this.FaceTowardsTarget(this.order.data.target);
+
+
+
+
+
+
+
+
+
+
 
                     let cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);
@@ -2154 +2144 @@
                     if (cmpBuildingAI)
                         cmpBuildingAI.SetUnitAITarget(0);
-                    this.StopTimer();
-                    this.ResetAnimation();
-                },
-
-                "Timer": function(msg) {
-                    let target = this.order.data.target;
-                    let attackType = this.order.data.attackType;
-
-                    if (!this.CanAttack(target))
-                    {
-                        this.SetNextState("COMBAT.FINDINGNEWTARGET");
-                        return;
-                    }
-
-                    this.RememberTargetPosition();
-                    if (this.order.data.hunting && this.orderQueue.length > 1 && this.orderQueue[1].type === "Gather")
-                        this.RememberTargetPosition(this.orderQueue[1].data);
-
-                    let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
-                    this.lastAttacked = cmpTimer.GetTime() - msg.lateness;
-
-                    this.FaceTowardsTarget(target);
-
-                    // BuildingAI has it's own attack-routine
-                    let cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);
-                    if (!cmpBuildingAI)
-                    {
-                        let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
-                        cmpAttack.PerformAttack(attackType, target);
-                    }
-
-                    // PerformAttack might have triggered messages that moved us to another state.
-                    // (use 'ends with' to handle formation members copying our state).
-                    if (!this.GetCurrentState().endsWith("COMBAT.ATTACKING"))
-                        return;
-
-
-                    // Check we can still reach the target for the next attack
-                    if (this.CheckTargetAttackRange(target, attackType))
-                    {
-                        if (this.resyncAnimation)
-                        {
-                            this.SetAnimationSync(this.attackTimers.repeat, this.attackTimers.repeat);
-                            this.resyncAnimation = false;
-                        }
-                        return;
-                    }
-
-                    if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
+                    let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+                    if (cmpAttack)
+                        cmpAttack.StopAttacking();
+                },
+
+                "OutOfRange": function() {
+                    if (this.ShouldChaseTargetedEntity(this.order.data.target, this.order.data.force))
                     {
                         if (this.CanPack())
@@ -2209 +2157 @@
                             return;
                         }
-                        this.SetNextState("COMBAT.CHASING");
+                        this.SetNextState("CHASING");
                         return;
                     }
-
+                    this.SetNextState("FINDINGNEWTARGET");
+                },
+
+                "TargetInvalidated": function() {
                     this.SetNextState("FINDINGNEWTARGET");
                 },
@@ -3400 +3351 @@
     this.isGuardOf = undefined;
 
-    // For preventing increased action rate due to Stop orders or target death.
-    this.lastAttacked = undefined;
-
     this.formationAnimationVariant = undefined;
     this.cheeringTime = +(this.template.CheeringTime || 0);
@@ -4790 +4738 @@
         target = cmpFormation.GetClosestMember(this.entity);
 
-    if (type != "Ranged")
-        return this.CheckTargetRange(target, IID_Attack, type);
-
-    let targetCmpPosition = Engine.QueryInterface(target, IID_Position);
-    if (!targetCmpPosition || !targetCmpPosition.IsInWorld())
-        return false;
-
-    let range = this.GetRange(IID_Attack, type, target);
-    if (!range)
-        return false;
-
-    let thisCmpPosition = Engine.QueryInterface(this.entity, IID_Position);
-    if (!thisCmpPosition.IsInWorld())
-        return false;
-
-    let s = thisCmpPosition.GetPosition();
-
-    let t = targetCmpPosition.GetPosition();
-
-    let h = s.y - t.y + range.elevationBonus;
-    let maxRange = Math.sqrt(Math.square(range.max) + 2 * range.max * h);
-
-    if (maxRange < 0)
-        return false;
-
-    let cmpObstructionManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ObstructionManager);
-    return cmpObstructionManager.IsInTargetRange(this.entity, target, range.min, maxRange, false);
+    let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
+    return cmpAttack && cmpAttack.IsTargetInRange(target, type);
 };
 

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

@@ -150 +150 @@
     });
 
-    AddMock(SYSTEM_ENTITY, IID_ObstructionManager, {
-        "IsInTargetRange": () => true,
-        "IsInPointRange": () => true
-    });
-
     var unitAI = ConstructComponent(unit, "UnitAI", { "FormationController": "false", "DefaultStance": "aggressive" });
 
@@ -195 +190 @@
         "CanAttack": function(v) { return true; },
         "CompareEntitiesByPreference": function(a, b) { return 0; },
+
+
     });
 
@@ -371 +368 @@
             "CanAttack": function(v) { return true; },
             "CompareEntitiesByPreference": function(a, b) { return 0; },
+
+
+
         });