I'm always finding new ways to be an idiot.
Details
Details
- Reviewers
- None
- Group Reviewers
Restricted Owners Package (Owns No Changed Paths) - Commits
- rP22421: Fix rP22414: s/target/this.gatheringTarget
Hunt the starting sheep in Alpine Valleys
Diff Detail
Diff Detail
- Repository
- rP 0 A.D. Public Repository
- Lint
Automatic diff as part of commit; lint not applicable. - Unit
Automatic diff as part of commit; unit tests not applicable.
Event Timeline
Comment Actions
Successful build - Chance fights ever on the side of the prudent.
Linter detected issues:
Executing section Source...
Executing section JS...
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| 352| 352| var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
| 353| 353| if (this.lastShorelinePosition && cmpPosition && (this.lastShorelinePosition.x == cmpPosition.GetPosition().x)
| 354| 354| && (this.lastShorelinePosition.z == cmpPosition.GetPosition().z))
| 355| |- {
| | 355|+
| 356| 356| // we were already on the shoreline, and have not moved since
| 357| 357| if (DistanceBetweenEntities(this.entity, this.order.data.target) < 50)
| 358| 358| needToMove = false;
| 359| |- }
| | 359|+
| 360| 360|
| 361| 361| if (needToMove)
| 362| 362| this.SetNextState("INDIVIDUAL.PICKUP.APPROACHING");
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| 350| 350| // Check if we need to move TODO implement a better way to know if we are on the shoreline
| 351| 351| var needToMove = true;
| 352| 352| var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
| 353| |- if (this.lastShorelinePosition && cmpPosition && (this.lastShorelinePosition.x == cmpPosition.GetPosition().x)
| 354| |- && (this.lastShorelinePosition.z == cmpPosition.GetPosition().z))
| | 353|+ if (this.lastShorelinePosition && cmpPosition && (this.lastShorelinePosition.x == cmpPosition.GetPosition().x) &&
| | 354|+ (this.lastShorelinePosition.z == cmpPosition.GetPosition().z))
| 355| 355| {
| 356| 356| // we were already on the shoreline, and have not moved since
| 357| 357| if (DistanceBetweenEntities(this.entity, this.order.data.target) < 50)
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'else'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| 515| 515| this.PushOrderFront("Walk", this.order.data.lastPos);
| 516| 516| }
| 517| 517| else
| 518| |- {
| | 518|+
| 519| 519| // We couldn't move there, or the target moved away
| 520| 520| this.FinishOrder();
| 521| |- }
| | 521|+
| 522| 522| return;
| 523| 523| }
| 524| 524|
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| 730| 730| }
| 731| 731| // Check if we are already in range, otherwise walk there
| 732| 732| if (!this.CheckGarrisonRange(msg.data.target))
| 733| |- {
| | 733|+
| 734| 734| if (!this.CheckTargetVisible(msg.data.target))
| 735| 735| {
| 736| 736| this.FinishOrder();
| 741| 741| this.SetNextState("GARRISON.APPROACHING");
| 742| 742| return;
| 743| 743| }
| 744| |- }
| | 744|+
| 745| 745|
| 746| 746| this.SetNextState("GARRISON.GARRISONING");
| 747| 747| },
| | [NORMAL] ESLintBear (no-else-return):
| | Unnecessary 'else' after 'return'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| 736| 736| this.FinishOrder();
| 737| 737| return;
| 738| 738| }
| 739| |- else
| 740| |- {
| | 739|+
| 741| 740| this.SetNextState("GARRISON.APPROACHING");
| 742| 741| return;
| 743| |- }
| | 742|+
| 744| 743| }
| 745| 744|
| 746| 745| this.SetNextState("GARRISON.GARRISONING");
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'else'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| 759| 759| this.PushOrderFront("Walk", msg.data.lastPos);
| 760| 760| }
| 761| 761| else
| 762| |- {
| | 762|+
| 763| 763| // We couldn't move there, or the target moved away
| 764| 764| this.FinishOrder();
| 765| |- }
| | 765|+
| 766| 766| return;
| 767| 767| }
| 768| 768|
| | [NORMAL] ESLintBear (key-spacing):
| | Missing space before value for key 'GARRISON'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| 992| 992| },
| 993| 993| },
| 994| 994|
| 995| |- "GARRISON":{
| | 995|+ "GARRISON": {
| 996| 996| "enter": function() {
| 997| 997| // If the garrisonholder should pickup, warn it so it can take needed action
| 998| 998| var cmpGarrisonHolder = Engine.QueryInterface(this.order.data.target, IID_GarrisonHolder);
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1205|1205| // If the controller handled an order but some members rejected it,
|1206|1206| // they will have no orders and be in the FORMATIONMEMBER.IDLE state.
|1207|1207| if (this.orderQueue.length)
|1208| |- {
| |1208|+
|1209|1209| // We're leaving the formation, so stop our FormationWalk order
|1210|1210| if (this.FinishOrder())
|1211|1211| return;
|1212| |- }
| |1212|+
|1213|1213|
|1214|1214| // No orders left, we're an individual now
|1215|1215| if (this.IsAnimal())
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1233|1233| // Move a tile outside the building
|1234|1234| let range = 4;
|1235|1235| if (this.CheckTargetRangeExplicit(msg.data.target, range, -1))
|1236| |- {
| |1236|+
|1237|1237| // We are already at the target, or can't move at all
|1238|1238| this.FinishOrder();
|1239| |- }
| |1239|+
|1240|1240| else
|1241|1241| {
|1242|1242| this.order.data.min = range;
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1454|1454|
|1455|1455| "LosRangeUpdate": function(msg) {
|1456|1456| if (this.GetStance().targetVisibleEnemies)
|1457| |- {
| |1457|+
|1458|1458| // Start attacking one of the newly-seen enemy (if any)
|1459|1459| this.AttackEntitiesByPreference(msg.data.added);
|1460| |- }
| |1460|+
|1461|1461| },
|1462|1462|
|1463|1463| "LosHealRangeUpdate": function(msg) {
| | [NORMAL] ESLintBear (space-before-function-paren):
| | Unexpected space before function parentheses.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1487|1487| this.SelectAnimation("move");
|1488|1488| },
|1489|1489|
|1490| |- "leave": function () {
| |1490|+ "leave": function() {
|1491|1491| this.SelectAnimation("idle");
|1492|1492| this.StopMoving();
|1493|1493| },
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1667|1667| // if nothing better to do, check if the guarded needs to be healed or repaired
|1668|1668| var cmpHealth = Engine.QueryInterface(this.isGuardOf, IID_Health);
|1669|1669| if (cmpHealth && cmpHealth.IsInjured())
|1670| |- {
| |1670|+
|1671|1671| if (this.CanHeal(this.isGuardOf))
|1672|1672| this.PushOrderFront("Heal", { "target": this.isGuardOf, "force": false });
|1673|1673| else if (this.CanRepair(this.isGuardOf))
|1674|1674| this.PushOrderFront("Repair", { "target": this.isGuardOf, "autocontinue": false, "force": false });
|1675| |- }
| |1675|+
|1676|1676| }
|1677|1677| },
|1678|1678|
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1794|1794| }
|1795|1795| // Check the target is still alive and attackable
|1796|1796| if (this.CanAttack(target) && !this.CheckTargetAttackRange(target, this.order.data.attackType))
|1797| |- {
| |1797|+
|1798|1798| // Can't reach it - try to chase after it
|1799|1799| if (this.ShouldChaseTargetedEntity(target, this.order.data.force))
|1800|1800| {
|1807|1807| this.SetNextState("COMBAT.CHASING");
|1808|1808| return true;
|1809|1809| }
|1810| |- }
| |1810|+
|1811|1811|
|1812|1812| this.StopMoving();
|1813|1813|
| | [NORMAL] ESLintBear (no-unneeded-ternary):
| | Unnecessary use of boolean literals in conditional expression.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1840|1840| // TODO: we should probably only bother syncing projectile attacks, not melee
|1841|1841|
|1842|1842| // If using a non-default prepare time, re-sync the animation when the timer runs.
|1843| |- this.resyncAnimation = (prepare != this.attackTimers.prepare) ? true : false;
| |1843|+ this.resyncAnimation = (prepare != this.attackTimers.prepare);
|1844|1844|
|1845|1845| this.FaceTowardsTarget(this.order.data.target);
|1846|1846|
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1966|1966|
|1967|1967| "Attacked": function(msg) {
|1968|1968| // If we are capturing and are attacked by something that we would not capture, attack that entity instead
|1969| |- if (this.order.data.attackType == "Capture" && (this.GetStance().targetAttackersAlways || !this.order.data.force)
|1970| |- && this.order.data.target != msg.data.attacker && this.GetBestAttackAgainst(msg.data.attacker, true) != "Capture")
| |1969|+ if (this.order.data.attackType == "Capture" && (this.GetStance().targetAttackersAlways || !this.order.data.force) &&
| |1970|+ this.order.data.target != msg.data.attacker && this.GetBestAttackAgainst(msg.data.attacker, true) != "Capture")
|1971|1971| this.RespondToTargetedEntities([msg.data.attacker]);
|1972|1972| },
|1973|1973| },
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|1986|1986| this.SelectAnimation("move");
|1987|1987| var cmpUnitAI = Engine.QueryInterface(this.order.data.target, IID_UnitAI);
|1988|1988| if (cmpUnitAI && cmpUnitAI.IsFleeing())
|1989| |- {
| |1989|+
|1990|1990| // Run after a fleeing target
|1991|1991| this.SetSpeedMultiplier(this.GetRunMultiplier());
|1992| |- }
| |1992|+
|1993|1993| this.StartTimer(1000, 1000);
|1994|1994| },
|1995|1995|
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2168|2168|
|2169|2169| var cmpSupply = Engine.QueryInterface(this.gatheringTarget, IID_ResourceSupply);
|2170|2170| if (cmpSupply && cmpSupply.IsAvailable(cmpOwnership.GetOwner(), this.entity))
|2171| |- {
| |2171|+
|2172|2172| // Check we can still reach and gather from the target
|2173|2173| if (this.CheckTargetRange(this.gatheringTarget, IID_ResourceGatherer) && this.CanGather(this.gatheringTarget))
|2174|2174| {
|2231|2231| return;
|2232|2232| }
|2233|2233| }
|2234| |- }
| |2234|+
|2235|2235|
|2236|2236| // We're already in range, can't get anywhere near it or the target is exhausted.
|2237|2237|
| | [NORMAL] ESLintBear (operator-linebreak):
| | '||' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2257|2257| // Also don't switch to a different type of huntable animal
|2258|2258| var nearby = this.FindNearbyResource(function(ent, type, template) {
|2259|2259| return (
|2260| |- (type.generic == "treasure" && resourceType.generic == "treasure")
|2261| |- || (type.specific == resourceType.specific
| |2260|+ (type.generic == "treasure" && resourceType.generic == "treasure") ||
| |2261|+ (type.specific == resourceType.specific
|2262|2262| && (type.specific != "meat" || resourceTemplate == template))
|2263|2263| );
|2264|2264| });
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2258|2258| var nearby = this.FindNearbyResource(function(ent, type, template) {
|2259|2259| return (
|2260|2260| (type.generic == "treasure" && resourceType.generic == "treasure")
|2261| |- || (type.specific == resourceType.specific
|2262| |- && (type.specific != "meat" || resourceTemplate == template))
| |2261|+ || (type.specific == resourceType.specific &&
| |2262|+ (type.specific != "meat" || resourceTemplate == template))
|2263|2263| );
|2264|2264| });
|2265|2265| if (nearby)
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2323|2323|
|2324|2324| "Timer": function(msg) {
|2325|2325| if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Heal, null))
|2326| |- {
| |2326|+
|2327|2327| // Return to our original position unless we have a better order.
|2328|2328| if (!this.FinishOrder() && this.GetStance().respondHoldGround)
|2329|2329| this.WalkToHeldPosition();
|2330| |- }
| |2330|+
|2331|2331| },
|2332|2332|
|2333|2333| "MovementUpdate": function() {
| | [NORMAL] ESLintBear (no-unneeded-ternary):
| | Unnecessary use of boolean literals in conditional expression.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2357|2357| this.StartTimer(prepare, this.healTimers.repeat);
|2358|2358|
|2359|2359| // If using a non-default prepare time, re-sync the animation when the timer runs.
|2360| |- this.resyncAnimation = (prepare != this.healTimers.prepare) ? true : false;
| |2360|+ this.resyncAnimation = (prepare != this.healTimers.prepare);
|2361|2361|
|2362|2362| this.FaceTowardsTarget(this.order.data.target);
|2363|2363| },
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2570|2570| {
|2571|2571| // The building was already finished/fully repaired before we arrived;
|2572|2572| // let the ConstructionFinished handler handle this.
|2573| |- this.OnGlobalConstructionFinished({"entity": this.repairTarget, "newentity": this.repairTarget});
| |2573|+ this.OnGlobalConstructionFinished({ "entity": this.repairTarget, "newentity": this.repairTarget});
|2574|2574| return true;
|2575|2575| }
|2576|2576|
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2570|2570| {
|2571|2571| // The building was already finished/fully repaired before we arrived;
|2572|2572| // let the ConstructionFinished handler handle this.
|2573| |- this.OnGlobalConstructionFinished({"entity": this.repairTarget, "newentity": this.repairTarget});
| |2573|+ this.OnGlobalConstructionFinished({"entity": this.repairTarget, "newentity": this.repairTarget });
|2574|2574| return true;
|2575|2575| }
|2576|2576|
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2697|2697|
|2698|2698| // Unit was approaching and there's nothing to do now, so switch to walking
|2699|2699| if (oldState === "INDIVIDUAL.REPAIR.APPROACHING")
|2700| |- {
| |2700|+
|2701|2701| // We're already walking to the given point, so add this as a order.
|2702|2702| this.WalkToTarget(msg.data.newentity, true);
|2703| |- }
| |2703|+
|2704|2704| },
|2705|2705| },
|2706|2706|
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2760|2760|
|2761|2761| // Check that we can garrison here
|2762|2762| if (this.CanGarrison(target))
|2763| |- {
| |2763|+
|2764|2764| // Check that we're in range of the garrison target
|2765|2765| if (this.CheckGarrisonRange(target))
|2766|2766| {
|2836|2836| return false;
|2837|2837| }
|2838|2838| }
|2839| |- }
| |2839|+
|2840|2840| // Garrisoning failed for some reason, so finish the order
|2841|2841| this.FinishOrder();
|2842|2842| return true;
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2958|2958| "Attacked": function(msg) {
|2959|2959| if (this.template.NaturalBehaviour == "skittish" ||
|2960|2960| this.template.NaturalBehaviour == "passive")
|2961| |- {
| |2961|+
|2962|2962| this.Flee(msg.data.attacker, false);
|2963| |- }
| |2963|+
|2964|2964| else if (this.IsDangerousAnimal() || this.template.NaturalBehaviour == "defensive")
|2965|2965| {
|2966|2966| if (this.CanAttack(msg.data.attacker))
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|2967|2967| this.Attack(msg.data.attacker, false);
|2968|2968| }
|2969|2969| else if (this.template.NaturalBehaviour == "domestic")
|2970| |- {
| |2970|+
|2971|2971| // Never flee, stop what we were doing
|2972|2972| this.SetNextState("IDLE");
|2973| |- }
| |2973|+
|2974|2974| },
|2975|2975|
|2976|2976| "Order.LeaveFoundation": function(msg) {
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3022|3022| }
|3023|3023| // Start attacking one of the newly-seen enemy (if any)
|3024|3024| else if (this.IsDangerousAnimal())
|3025| |- {
| |3025|+
|3026|3026| this.AttackVisibleEntity(msg.data.added);
|3027| |- }
| |3027|+
|3028|3028|
|3029|3029| // TODO: if two units enter our range together, we'll attack the
|3030|3030| // first and then the second won't trigger another LosRangeUpdate
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3065|3065| }
|3066|3066| // Start attacking one of the newly-seen enemy (if any)
|3067|3067| else if (this.template.NaturalBehaviour == "violent")
|3068| |- {
| |3068|+
|3069|3069| this.AttackVisibleEntity(msg.data.added);
|3070| |- }
| |3070|+
|3071|3071| },
|3072|3072|
|3073|3073| "Timer": function(msg) {
| | [NORMAL] ESLintBear (indent):
| | Expected indentation of 2 tabs but found 7.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3080|3080| "COMBAT": "INDIVIDUAL.COMBAT", // reuse the same combat behaviour for animals
|3081|3081|
|3082|3082| "WALKING": "INDIVIDUAL.WALKING", // reuse the same walking behaviour for animals
|3083| |- // only used for domestic animals
| |3083|+ // only used for domestic animals
|3084|3084| },
|3085|3085| };
|3086|3086|
| | [NORMAL] ESLintBear (no-unneeded-ternary):
| | Unnecessary use of boolean literals in conditional expression.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3137|3137|
|3138|3138| UnitAI.prototype.IsAnimal = function()
|3139|3139| {
|3140| |- return (this.template.NaturalBehaviour ? true : false);
| |3140|+ return (!!this.template.NaturalBehaviour);
|3141|3141| };
|3142|3142|
|3143|3143| UnitAI.prototype.IsDangerousAnimal = function()
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3175|3175| UnitAI.prototype.GetGarrisonHolder = function()
|3176|3176| {
|3177|3177| if (this.IsGarrisoned())
|3178| |- {
| |3178|+
|3179|3179| for (let order of this.orderQueue)
|3180|3180| if (order.type == "Garrison")
|3181|3181| return order.data.target;
|3182| |- }
| |3182|+
|3183|3183| return INVALID_ENTITY;
|3184|3184| };
|3185|3185|
| | [NORMAL] ESLintBear (comma-spacing):
| | A space is required after ','.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3253|3253| {
|3254|3254| let index = this.GetCurrentState().indexOf(".");
|3255|3255| if (index != -1)
|3256| |- this.UnitFsm.SwitchToNextState(this, this.GetCurrentState().slice(0,index));
| |3256|+ this.UnitFsm.SwitchToNextState(this, this.GetCurrentState().slice(0, index));
|3257|3257| this.Stop(false);
|3258|3258| }
|3259|3259|
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3309|3309| if (this.orderQueue[i].type != "PickupUnit" || this.orderQueue[i].data.target != msg.entity)
|3310|3310| continue;
|3311|3311| if (i == 0)
|3312| |- this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg});
| |3312|+ this.UnitFsm.ProcessMessage(this, { "type": "PickupCanceled", "data": msg});
|3313|3313| else
|3314|3314| this.orderQueue.splice(i, 1);
|3315|3315| Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3309|3309| if (this.orderQueue[i].type != "PickupUnit" || this.orderQueue[i].data.target != msg.entity)
|3310|3310| continue;
|3311|3311| if (i == 0)
|3312| |- this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg});
| |3312|+ this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg });
|3313|3313| else
|3314|3314| this.orderQueue.splice(i, 1);
|3315|3315| Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
| | [NORMAL] ESLintBear (spaced-comment):
| | Expected space or tab after '//' in comment.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3393|3393| };
|3394|3394|
|3395|3395|
|3396| |-//// FSM linkage functions ////
| |3396|+// // FSM linkage functions ////
|3397|3397|
|3398|3398| // Setting the next state to the current state will leave/re-enter the top-most substate.
|3399|3399| UnitAI.prototype.SetNextState = function(state)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3565|3565| continue;
|3566|3566| if (this.orderQueue[i].type == type)
|3567|3567| continue;
|3568| |- this.orderQueue.splice(i, 0, {"type": type, "data": data});
| |3568|+ this.orderQueue.splice(i, 0, { "type": type, "data": data});
|3569|3569| Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
|3570|3570| return;
|3571|3571| }
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3565|3565| continue;
|3566|3566| if (this.orderQueue[i].type == type)
|3567|3567| continue;
|3568| |- this.orderQueue.splice(i, 0, {"type": type, "data": data});
| |3568|+ this.orderQueue.splice(i, 0, {"type": type, "data": data });
|3569|3569| Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
|3570|3570| return;
|3571|3571| }
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3579|3579| {
|3580|3580| // Remember the previous work orders to be able to go back to them later if required
|3581|3581| if (data && data.force)
|3582| |- {
| |3582|+
|3583|3583| if (this.IsFormationController())
|3584|3584| this.CallMemberFunction("UpdateWorkOrders", [type]);
|3585|3585| else
|3586|3586| this.UpdateWorkOrders(type);
|3587| |- }
| |3587|+
|3588|3588|
|3589|3589| let garrisonHolder = this.IsGarrisoned() && type != "Ungarrison" ? this.GetGarrisonHolder() : null;
|3590|3590|
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3656|3656| {
|3657|3657| var cmpUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
|3658|3658| if (cmpUnitAI)
|3659| |- {
| |3659|+
|3660|3660| for (var i = 0; i < cmpUnitAI.orderQueue.length; ++i)
|3661|3661| {
|3662|3662| if (isWorkType(cmpUnitAI.orderQueue[i].type))
|3665|3665| return;
|3666|3666| }
|3667|3667| }
|3668| |- }
| |3668|+
|3669|3669| }
|3670|3670|
|3671|3671| // If nothing found, take the unit orders
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'for' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3658|3658| if (cmpUnitAI)
|3659|3659| {
|3660|3660| for (var i = 0; i < cmpUnitAI.orderQueue.length; ++i)
|3661| |- {
| |3661|+
|3662|3662| if (isWorkType(cmpUnitAI.orderQueue[i].type))
|3663|3663| {
|3664|3664| this.workOrders = cmpUnitAI.orderQueue.slice(i);
|3665|3665| return;
|3666|3666| }
|3667| |- }
| |3667|+
|3668|3668| }
|3669|3669| }
|3670|3670|
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'for' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3670|3670|
|3671|3671| // If nothing found, take the unit orders
|3672|3672| for (var i = 0; i < this.orderQueue.length; ++i)
|3673| |- {
| |3673|+
|3674|3674| if (isWorkType(this.orderQueue[i].type))
|3675|3675| {
|3676|3676| this.workOrders = this.orderQueue.slice(i);
|3677|3677| return;
|3678|3678| }
|3679| |- }
| |3679|+
|3680|3680| };
|3681|3681|
|3682|3682| UnitAI.prototype.BackToWork = function()
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3736|3736| if (data.timerRepeat === undefined)
|3737|3737| this.timer = undefined;
|3738|3738|
|3739| |- this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
| |3739|+ this.UnitFsm.ProcessMessage(this, { "type": "Timer", "data": data, "lateness": lateness});
|3740|3740| };
|3741|3741|
|3742|3742| /**
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3736|3736| if (data.timerRepeat === undefined)
|3737|3737| this.timer = undefined;
|3738|3738|
|3739| |- this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
| |3739|+ this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness });
|3740|3740| };
|3741|3741|
|3742|3742| /**
| | [NORMAL] ESLintBear (spaced-comment):
| | Expected space or tab after '//' in comment.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3771|3771| this.timer = undefined;
|3772|3772| };
|3773|3773|
|3774| |-//// Message handlers /////
| |3774|+// // Message handlers /////
|3775|3775|
|3776|3776| UnitAI.prototype.OnMotionChanged = function(msg)
|3777|3777| {
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3783|3783| // TODO: This is a bit inefficient since every unit listens to every
|3784|3784| // construction message - ideally we could scope it to only the one we're building
|3785|3785|
|3786| |- this.UnitFsm.ProcessMessage(this, {"type": "ConstructionFinished", "data": msg});
| |3786|+ this.UnitFsm.ProcessMessage(this, { "type": "ConstructionFinished", "data": msg});
|3787|3787| };
|3788|3788|
|3789|3789| UnitAI.prototype.OnGlobalEntityRenamed = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3783|3783| // TODO: This is a bit inefficient since every unit listens to every
|3784|3784| // construction message - ideally we could scope it to only the one we're building
|3785|3785|
|3786| |- this.UnitFsm.ProcessMessage(this, {"type": "ConstructionFinished", "data": msg});
| |3786|+ this.UnitFsm.ProcessMessage(this, {"type": "ConstructionFinished", "data": msg });
|3787|3787| };
|3788|3788|
|3789|3789| UnitAI.prototype.OnGlobalEntityRenamed = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3808|3808|
|3809|3809| UnitAI.prototype.OnAttacked = function(msg)
|3810|3810| {
|3811| |- this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});
| |3811|+ this.UnitFsm.ProcessMessage(this, { "type": "Attacked", "data": msg});
|3812|3812| };
|3813|3813|
|3814|3814| UnitAI.prototype.OnGuardedAttacked = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3808|3808|
|3809|3809| UnitAI.prototype.OnAttacked = function(msg)
|3810|3810| {
|3811| |- this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});
| |3811|+ this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg });
|3812|3812| };
|3813|3813|
|3814|3814| UnitAI.prototype.OnGuardedAttacked = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3813|3813|
|3814|3814| UnitAI.prototype.OnGuardedAttacked = function(msg)
|3815|3815| {
|3816| |- this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data});
| |3816|+ this.UnitFsm.ProcessMessage(this, { "type": "GuardedAttacked", "data": msg.data});
|3817|3817| };
|3818|3818|
|3819|3819| UnitAI.prototype.OnHealthChanged = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3813|3813|
|3814|3814| UnitAI.prototype.OnGuardedAttacked = function(msg)
|3815|3815| {
|3816| |- this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data});
| |3816|+ this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data });
|3817|3817| };
|3818|3818|
|3819|3819| UnitAI.prototype.OnHealthChanged = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3818|3818|
|3819|3819| UnitAI.prototype.OnHealthChanged = function(msg)
|3820|3820| {
|3821| |- this.UnitFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to});
| |3821|+ this.UnitFsm.ProcessMessage(this, { "type": "HealthChanged", "from": msg.from, "to": msg.to});
|3822|3822| };
|3823|3823|
|3824|3824| UnitAI.prototype.OnRangeUpdate = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3818|3818|
|3819|3819| UnitAI.prototype.OnHealthChanged = function(msg)
|3820|3820| {
|3821| |- this.UnitFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to});
| |3821|+ this.UnitFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to });
|3822|3822| };
|3823|3823|
|3824|3824| UnitAI.prototype.OnRangeUpdate = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3824|3824| UnitAI.prototype.OnRangeUpdate = function(msg)
|3825|3825| {
|3826|3826| if (msg.tag == this.losRangeQuery)
|3827| |- this.UnitFsm.ProcessMessage(this, {"type": "LosRangeUpdate", "data": msg});
| |3827|+ this.UnitFsm.ProcessMessage(this, { "type": "LosRangeUpdate", "data": msg});
|3828|3828| else if (msg.tag == this.losHealRangeQuery)
|3829|3829| this.UnitFsm.ProcessMessage(this, {"type": "LosHealRangeUpdate", "data": msg});
|3830|3830| };
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3824|3824| UnitAI.prototype.OnRangeUpdate = function(msg)
|3825|3825| {
|3826|3826| if (msg.tag == this.losRangeQuery)
|3827| |- this.UnitFsm.ProcessMessage(this, {"type": "LosRangeUpdate", "data": msg});
| |3827|+ this.UnitFsm.ProcessMessage(this, {"type": "LosRangeUpdate", "data": msg });
|3828|3828| else if (msg.tag == this.losHealRangeQuery)
|3829|3829| this.UnitFsm.ProcessMessage(this, {"type": "LosHealRangeUpdate", "data": msg});
|3830|3830| };
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3826|3826| if (msg.tag == this.losRangeQuery)
|3827|3827| this.UnitFsm.ProcessMessage(this, {"type": "LosRangeUpdate", "data": msg});
|3828|3828| else if (msg.tag == this.losHealRangeQuery)
|3829| |- this.UnitFsm.ProcessMessage(this, {"type": "LosHealRangeUpdate", "data": msg});
| |3829|+ this.UnitFsm.ProcessMessage(this, { "type": "LosHealRangeUpdate", "data": msg});
|3830|3830| };
|3831|3831|
|3832|3832| UnitAI.prototype.OnPackFinished = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3826|3826| if (msg.tag == this.losRangeQuery)
|3827|3827| this.UnitFsm.ProcessMessage(this, {"type": "LosRangeUpdate", "data": msg});
|3828|3828| else if (msg.tag == this.losHealRangeQuery)
|3829| |- this.UnitFsm.ProcessMessage(this, {"type": "LosHealRangeUpdate", "data": msg});
| |3829|+ this.UnitFsm.ProcessMessage(this, {"type": "LosHealRangeUpdate", "data": msg });
|3830|3830| };
|3831|3831|
|3832|3832| UnitAI.prototype.OnPackFinished = function(msg)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3831|3831|
|3832|3832| UnitAI.prototype.OnPackFinished = function(msg)
|3833|3833| {
|3834| |- this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
| |3834|+ this.UnitFsm.ProcessMessage(this, { "type": "PackFinished", "packed": msg.packed});
|3835|3835| };
|3836|3836|
|3837|3837| //// Helper functions to be called by the FSM ////
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3831|3831|
|3832|3832| UnitAI.prototype.OnPackFinished = function(msg)
|3833|3833| {
|3834| |- this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
| |3834|+ this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed });
|3835|3835| };
|3836|3836|
|3837|3837| //// Helper functions to be called by the FSM ////
| | [NORMAL] ESLintBear (spaced-comment):
| | Expected space or tab after '//' in comment.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|3834|3834| this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
|3835|3835| };
|3836|3836|
|3837| |-//// Helper functions to be called by the FSM ////
| |3837|+// // Helper functions to be called by the FSM ////
|3838|3838|
|3839|3839| UnitAI.prototype.GetWalkSpeed = function()
|3840|3840| {
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'else'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4021|4021| PlaySound(name, member);
|4022|4022| }
|4023|4023| else
|4024| |- {
| |4024|+
|4025|4025| // Otherwise use our own sounds
|4026|4026| PlaySound(name, this.entity);
|4027| |- }
| |4027|+
|4028|4028| };
|4029|4029|
|4030|4030| /*
| | [NORMAL] ESLintBear (spaced-comment):
| | Expected space or tab after '//' in comment.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4213|4213| else
|4214|4214| // return false? Or hope you come close enough?
|4215|4215| var parabolicMaxRange = 0;
|4216| |- //return false;
| |4216|+ // return false;
|4217|4217|
|4218|4218| // the parabole changes while walking, take something in the middle
|4219|4219| var guessedMaxRange = (range.max + parabolicMaxRange)/2;
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4300|4300| if (this.IsFormationMember())
|4301|4301| {
|4302|4302| var cmpFormationUnitAI = Engine.QueryInterface(this.formationController, IID_UnitAI);
|4303| |- if (cmpFormationUnitAI && cmpFormationUnitAI.IsAttackingAsFormation()
|4304| |- && cmpFormationUnitAI.order.data.target == target)
| |4303|+ if (cmpFormationUnitAI && cmpFormationUnitAI.IsAttackingAsFormation() &&
| |4304|+ cmpFormationUnitAI.order.data.target == target)
|4305|4305| return true;
|4306|4306| }
|4307|4307|
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4473|4473| UnitAI.prototype.AttackEntityInZone = function(ents)
|4474|4474| {
|4475|4475| var target = ents.find(target =>
|4476| |- this.CanAttack(target)
|4477| |- && this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
| |4476|+ this.CanAttack(target) &&
| |4477|+ this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
|4478|4478| && (this.GetStance().respondChaseBeyondVision || this.CheckTargetIsInVisionRange(target))
|4479|4479| );
|4480|4480| if (!target)
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4474|4474| {
|4475|4475| var target = ents.find(target =>
|4476|4476| this.CanAttack(target)
|4477| |- && this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
|4478| |- && (this.GetStance().respondChaseBeyondVision || this.CheckTargetIsInVisionRange(target))
| |4477|+ && this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true)) &&
| |4478|+ (this.GetStance().respondChaseBeyondVision || this.CheckTargetIsInVisionRange(target))
|4479|4479| );
|4480|4480| if (!target)
|4481|4481| return false;
| | [NORMAL] ESLintBear (no-multi-spaces):
| | Multiple spaces found before 'Engine'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4538|4538| // If we are guarding/escorting, don't abandon as long as the guarded unit is in target range of the attacker
|4539|4539| if (this.isGuardOf)
|4540|4540| {
|4541| |- var cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
| |4541|+ var cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
|4542|4542| var cmpAttack = Engine.QueryInterface(target, IID_Attack);
|4543|4543| if (cmpUnitAI && cmpAttack &&
|4544|4544| cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
| | [NORMAL] ESLintBear (indent):
| | Expected indentation of 3 tabs but found 4.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4542|4542| var cmpAttack = Engine.QueryInterface(target, IID_Attack);
|4543|4543| if (cmpUnitAI && cmpAttack &&
|4544|4544| cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
|4545| |- return false;
| |4545|+ return false;
|4546|4546| }
|4547|4547|
|4548|4548| // Stop if we're in hold-ground mode and it's too far from the holding point
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4547|4547|
|4548|4548| // Stop if we're in hold-ground mode and it's too far from the holding point
|4549|4549| if (this.GetStance().respondHoldGround)
|4550| |- {
| |4550|+
|4551|4551| if (!this.CheckTargetDistanceFromHeldPosition(target, iid, type))
|4552|4552| return true;
|4553| |- }
| |4553|+
|4554|4554|
|4555|4555| // Stop if it's left our vision range, unless we're especially persistent
|4556|4556| if (!this.GetStance().respondChaseBeyondVision)
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4554|4554|
|4555|4555| // Stop if it's left our vision range, unless we're especially persistent
|4556|4556| if (!this.GetStance().respondChaseBeyondVision)
|4557| |- {
| |4557|+
|4558|4558| if (!this.CheckTargetIsInVisionRange(target))
|4559|4559| return true;
|4560| |- }
| |4560|+
|4561|4561|
|4562|4562| // (Note that CCmpUnitMotion will detect if the target is lost in FoW,
|4563|4563| // and will continue moving to its last seen position and then stop)
| | [NORMAL] ESLintBear (no-multi-spaces):
| | Multiple spaces found before 'Engine'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4580|4580| // If we are guarding/escorting, chase at least as long as the guarded unit is in target range of the attacker
|4581|4581| if (this.isGuardOf)
|4582|4582| {
|4583| |- let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
| |4583|+ let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
|4584|4584| let cmpAttack = Engine.QueryInterface(target, IID_Attack);
|4585|4585| if (cmpUnitAI && cmpAttack &&
|4586|4586| cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
| | [NORMAL] ESLintBear (spaced-comment):
| | Expected space or tab after '//' in comment.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4593|4593| return false;
|4594|4594| };
|4595|4595|
|4596| |-//// External interface functions ////
| |4596|+// // External interface functions ////
|4597|4597|
|4598|4598| UnitAI.prototype.SetFormationController = function(ent)
|4599|4599| {
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4603|4603| // of our own formation (or ourself if not in formation)
|4604|4604| var cmpObstruction = Engine.QueryInterface(this.entity, IID_Obstruction);
|4605|4605| if (cmpObstruction)
|4606| |- {
| |4606|+
|4607|4607| if (ent == INVALID_ENTITY)
|4608|4608| cmpObstruction.SetControlGroup(this.entity);
|4609|4609| else
|4610|4610| cmpObstruction.SetControlGroup(ent);
|4611| |- }
| |4611|+
|4612|4612|
|4613|4613| // If we were removed from a formation, let the FSM switch back to INDIVIDUAL
|4614|4614| if (ent == INVALID_ENTITY)
| | [NORMAL] ESLintBear (curly):
| | Unnecessary { after 'if' condition.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4746|4746| // if we already had an old guard order, do nothing if the target is the same
|4747|4747| // and the order is running, otherwise remove the previous order
|4748|4748| if (this.isGuardOf)
|4749| |- {
| |4749|+
|4750|4750| if (this.isGuardOf == target && this.order && this.order.type == "Guard")
|4751|4751| return;
|4752|4752| else
|4753|4753| this.RemoveGuard();
|4754| |- }
| |4754|+
|4755|4755|
|4756|4756| this.AddOrder("Guard", { "target": target, "force": false }, queued);
|4757|4757| };
| | [NORMAL] ESLintBear (no-else-return):
| | Unnecessary 'else' after 'return'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4749|4749| {
|4750|4750| if (this.isGuardOf == target && this.order && this.order.type == "Guard")
|4751|4751| return;
|4752| |- else
|4753| |- this.RemoveGuard();
| |4752|+ this.RemoveGuard();
|4754|4753| }
|4755|4754|
|4756|4755| this.AddOrder("Guard", { "target": target, "force": false }, queued);
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|4920|4920| this.WalkToTarget(target, queued);
|4921|4921| return;
|4922|4922| }
|4923| |- this.AddOrder("Attack", { "target": target, "force": true, "allowCapture": allowCapture}, queued);
| |4923|+ this.AddOrder("Attack", { "target": target, "force": true, "allowCapture": allowCapture }, queued);
|4924|4924| };
|4925|4925|
|4926|4926| /**
| | [NORMAL] ESLintBear (no-trailing-spaces):
| | Trailing spaces not allowed.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5069|5069| this.workOrders.length && this.workOrders[0].type == "Trade")
|5070|5070| {
|5071|5071| let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
|5072| |- if (cmpTrader.HasBothMarkets() &&
| |5072|+ if (cmpTrader.HasBothMarkets() &&
|5073|5073| (cmpTrader.GetFirstMarket() == target && cmpTrader.GetSecondMarket() == source ||
|5074|5074| cmpTrader.GetFirstMarket() == source && cmpTrader.GetSecondMarket() == target))
|5075|5075| {
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5350|5350| {
|5351|5351| var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);
|5352|5352| var targetClasses = this.order.data.targetClasses;
|5353| |- if (targetClasses.attack && cmpIdentity
|5354| |- && !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
| |5353|+ if (targetClasses.attack && cmpIdentity &&
| |5354|+ !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|5355|5355| continue;
|5356|5356| if (targetClasses.avoid && cmpIdentity
|5357|5357| && MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5353|5353| if (targetClasses.attack && cmpIdentity
|5354|5354| && !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|5355|5355| continue;
|5356| |- if (targetClasses.avoid && cmpIdentity
|5357| |- && MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
| |5356|+ if (targetClasses.avoid && cmpIdentity &&
| |5357|+ MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
|5358|5358| continue;
|5359|5359| // Only used by the AIs to prevent some choices of targets
|5360|5360| if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5376|5376| {
|5377|5377| var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);
|5378|5378| var targetClasses = this.order.data.targetClasses;
|5379| |- if (cmpIdentity && targetClasses.attack
|5380| |- && !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
| |5379|+ if (cmpIdentity && targetClasses.attack &&
| |5380|+ !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|5381|5381| continue;
|5382|5382| if (cmpIdentity && targetClasses.avoid
|5383|5383| && MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5379|5379| if (cmpIdentity && targetClasses.attack
|5380|5380| && !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|5381|5381| continue;
|5382| |- if (cmpIdentity && targetClasses.avoid
|5383| |- && MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
| |5382|+ if (cmpIdentity && targetClasses.avoid &&
| |5383|+ MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
|5384|5384| continue;
|5385|5385| // Only used by the AIs to prevent some choices of targets
|5386|5386| if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required after '{'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5522|5522|
|5523|5523| UnitAI.prototype.SetHeldPosition = function(x, z)
|5524|5524| {
|5525| |- this.heldPosition = {"x": x, "z": z};
| |5525|+ this.heldPosition = { "x": x, "z": z};
|5526|5526| };
|5527|5527|
|5528|5528| UnitAI.prototype.SetHeldPositionOnEntity = function(entity)
| | [NORMAL] ESLintBear (object-curly-spacing):
| | A space is required before '}'.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5522|5522|
|5523|5523| UnitAI.prototype.SetHeldPosition = function(x, z)
|5524|5524| {
|5525| |- this.heldPosition = {"x": x, "z": z};
| |5525|+ this.heldPosition = {"x": x, "z": z };
|5526|5526| };
|5527|5527|
|5528|5528| UnitAI.prototype.SetHeldPositionOnEntity = function(entity)
| | [NORMAL] ESLintBear (spaced-comment):
| | Expected space or tab after '//' in comment.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5549|5549| return false;
|5550|5550| };
|5551|5551|
|5552| |-//// Helper functions ////
| |5552|+// // Helper functions ////
|5553|5553|
|5554|5554| UnitAI.prototype.CanAttack = function(target)
|5555|5555| {
| | [NORMAL] ESLintBear (spaced-comment):
| | Expected space or tab after '//' in comment.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5753|5753| return cmpPack && cmpPack.IsPacking();
|5754|5754| };
|5755|5755|
|5756| |-//// Formation specific functions ////
| |5756|+// // Formation specific functions ////
|5757|5757|
|5758|5758| UnitAI.prototype.IsAttackingAsFormation = function()
|5759|5759| {
| | [NORMAL] ESLintBear (operator-linebreak):
| | '&&' should be placed at the end of the line.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5758|5758| UnitAI.prototype.IsAttackingAsFormation = function()
|5759|5759| {
|5760|5760| var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
|5761| |- return cmpAttack && cmpAttack.CanAttackAsFormation()
|5762| |- && this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";
| |5761|+ return cmpAttack && cmpAttack.CanAttackAsFormation() &&
| |5762|+ this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";
|5763|5763| };
|5764|5764|
|5765|5765| //// Animal specific functions ////
| | [NORMAL] ESLintBear (spaced-comment):
| | Expected space or tab after '//' in comment.
|----| | /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
| |++++| /mnt/data/jenkins-phabricator/workspace/differential/binaries/data/mods/public/simulation/components/UnitAI.js
|5762|5762| && this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";
|5763|5763| };
|5764|5764|
|5765| |-//// Animal specific functions ////
| |5765|+// // Animal specific functions ////
|5766|5766|
|5767|5767| UnitAI.prototype.MoveRandomly = function(distance)
|5768|5768| {
binaries/data/mods/public/simulation/components/UnitAI.js
| 327| » » » return·true;
| | [NORMAL] ESLintBear (consistent-return):
| | Method 'Order.WalkToTarget' expected no return value.
binaries/data/mods/public/simulation/components/UnitAI.js
| 885| » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
| 907| » » » "enter":·function(msg)·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
| 954| » » » » » return·true;
| | [NORMAL] ESLintBear (consistent-return):
| | Method 'enter' expected no return value.
binaries/data/mods/public/simulation/components/UnitAI.js
|1017| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1052| » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1084| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1298| » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1481| » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1502| » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1532| » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1687| » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1738| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|1808| » » » » » » » return·true;
| | [NORMAL] ESLintBear (consistent-return):
| | Method 'enter' expected no return value.
binaries/data/mods/public/simulation/components/UnitAI.js
|1976| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|2066| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|2247| » » » » » » let·nearby·=·this.FindNearestDropsite(resourceType.generic);
| | [NORMAL] ESLintBear (no-shadow):
| | 'nearby' is already declared in the upper scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2302| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|2420| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|2485| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|2525| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|2729| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|2913| » » » » "enter":·function()·{
| | [NORMAL] ESLintBear (consistent-return):
| | Expected to return a value at the end of method 'enter'.
binaries/data/mods/public/simulation/components/UnitAI.js
|3641| » var·isWorkType·=·type·=>·type·==·"Gather"·||·type·==·"Trade"·||·type·==·"Repair"·||·type·==·"ReturnResource";
| | [NORMAL] ESLintBear (no-shadow):
| | 'type' is already declared in the upper scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|4460| » var·target·=·ents.find(target·=>·this.CanAttack(target));
| | [NORMAL] ESLintBear (no-shadow):
| | 'target' is already declared in the upper scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|4475| » var·target·=·ents.find(target·=>
| | [NORMAL] ESLintBear (no-shadow):
| | 'target' is already declared in the upper scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|4521| » var·ent·=·ents.find(ent·=>·this.CanHeal(ent));
| | [NORMAL] ESLintBear (no-shadow):
| | 'ent' is already declared in the upper scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|4544| » » ····cmpAttack.GetAttackTypes().some(type·=>·cmpUnitAI.CheckTargetAttackRange(this.isGuardOf,·type)))
| | [NORMAL] ESLintBear (no-shadow):
| | 'type' is already declared in the upper scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|5000| » var·lastPos·=·undefined;
| | [NORMAL] ESLintBear (no-undef-init):
| | It's not necessary to initialize 'lastPos' to undefined.
binaries/data/mods/public/simulation/components/UnitAI.js
| 354| » » ····&&·(this.lastShorelinePosition.z·==·cmpPosition.GetPosition().z))
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|1832| » » » » » » var·cmpFormation·=·Engine.QueryInterface(this.formationController,·IID_Formation);
| | [NORMAL] JSHintBear:
| | 'cmpFormation' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|1970| » » » » » » &&·this.order.data.target·!=·msg.data.attacker·&&·this.GetBestAttackAgainst(msg.data.attacker,·true)·!=·"Capture")
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|2242| » » » » » var·cmpResourceGatherer·=·Engine.QueryInterface(this.entity,·IID_ResourceGatherer);
| | [NORMAL] JSHintBear:
| | 'cmpResourceGatherer' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|2258| » » » » » var·nearby·=·this.FindNearbyResource(function(ent,·type,·template)·{
| | [NORMAL] JSHintBear:
| | 'nearby' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|2261| » » » » » » » ||·(type.specific·==·resourceType.specific
| | [NORMAL] JSHintBear:
| | Misleading line break before '||'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|2262| » » » » » » » &&·(type.specific·!=·"meat"·||·resourceTemplate·==·template))
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|2282| » » » » » var·nearby·=·this.FindNearestDropsite(resourceType.generic);
| | [NORMAL] JSHintBear:
| | 'nearby' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|2462| » » » » » var·cmpResourceGatherer·=·Engine.QueryInterface(this.entity,·IID_ResourceGatherer);
| | [NORMAL] JSHintBear:
| | 'cmpResourceGatherer' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|2676| » » » » » var·cmpResourceDropsite·=·Engine.QueryInterface(msg.data.newentity,·IID_ResourceDropsite);
| | [NORMAL] JSHintBear:
| | 'cmpResourceDropsite' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|2762| » » » » » if·(this.CanGarrison(target))
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2765| » » » » » » if·(this.CheckGarrisonRange(target))
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2767| » » » » » » » var·cmpGarrisonHolder·=·Engine.QueryInterface(target,·IID_GarrisonHolder);
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2789| » » » » » » » » var·cmpResourceDropsite·=·Engine.QueryInterface(target,·IID_ResourceDropsite);
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2790| » » » » » » » » if·(cmpResourceDropsite·&&·this.CanReturnResource(target,·true))
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2805| » » » » » » » » » var·cmpHolderPosition·=·Engine.QueryInterface(target,·IID_Position);
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2806| » » » » » » » » » var·cmpHolderUnitAI·=·Engine.QueryInterface(target,·IID_UnitAI);
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2833| » » » » » » » if·(!this.CheckTargetRangeExplicit(target,·0,·0)·&&·this.MoveToTarget(target))
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|2833| » » » » » » » if·(!this.CheckTargetRangeExplicit(target,·0,·0)·&&·this.MoveToTarget(target))
| | [NORMAL] JSHintBear:
| | 'target' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|3603| » » var·order·=·{·"type":·type,·"data":·data·};
| | [NORMAL] JSHintBear:
| | 'order' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|3672| » for·(var·i·=·0;·i·<·this.orderQueue.length;·++i)
| | [NORMAL] JSHintBear:
| | 'i' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|4215| » » var·parabolicMaxRange·=·0;
| | [NORMAL] JSHintBear:
| | 'parabolicMaxRange' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|4219| » var·guessedMaxRange·=·(range.max·+·parabolicMaxRange)/2;
| | [NORMAL] JSHintBear:
| | 'parabolicMaxRange' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|4226| » return·cmpUnitMotion.MoveToTargetRange(target,·range.min,·Math.min(range.max,·parabolicMaxRange));
| | [NORMAL] JSHintBear:
| | 'parabolicMaxRange' used out of scope.
binaries/data/mods/public/simulation/components/UnitAI.js
|4304| » » » &&·cmpFormationUnitAI.order.data.target·==·target)
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|4477| » » &&·this.CheckTargetDistanceFromHeldPosition(target,·IID_Attack,·this.GetBestAttackAgainst(target,·true))
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|4478| » » &&·(this.GetStance().respondChaseBeyondVision·||·this.CheckTargetIsInVisionRange(target))
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|5000| » var·lastPos·=·undefined;
| | [NORMAL] JSHintBear:
| | It's not necessary to initialize 'lastPos' to 'undefined'.
binaries/data/mods/public/simulation/components/UnitAI.js
|5354| » » » » » » &&·!MatchesClassList(cmpIdentity.GetClassesList(),·targetClasses.attack))
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|5357| » » » » » » &&·MatchesClassList(cmpIdentity.GetClassesList(),·targetClasses.avoid))
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|5370| » var·targets·=·this.GetTargetsFromUnit();
| | [NORMAL] JSHintBear:
| | 'targets' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5371| » for·(var·targ·of·targets)
| | [NORMAL] JSHintBear:
| | 'targ' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5377| » » » var·cmpIdentity·=·Engine.QueryInterface(targ,·IID_Identity);
| | [NORMAL] JSHintBear:
| | 'cmpIdentity' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5378| » » » var·targetClasses·=·this.order.data.targetClasses;
| | [NORMAL] JSHintBear:
| | 'targetClasses' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5380| » » » » &&·!MatchesClassList(cmpIdentity.GetClassesList(),·targetClasses.attack))
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|5383| » » » » &&·MatchesClassList(cmpIdentity.GetClassesList(),·targetClasses.avoid))
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
binaries/data/mods/public/simulation/components/UnitAI.js
|5458| » » var·cmpVision·=·Engine.QueryInterface(this.entity,·IID_Vision);
| | [NORMAL] JSHintBear:
| | 'cmpVision' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5461| » » var·range·=·cmpVision.GetRange();
| | [NORMAL] JSHintBear:
| | 'range' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5466| » » var·cmpRanged·=·Engine.QueryInterface(this.entity,·iid);
| | [NORMAL] JSHintBear:
| | 'cmpRanged' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5469| » » var·range·=·iid·!==·IID_Attack·?·cmpRanged.GetRange()·:·cmpRanged.GetFullAttackRange();
| | [NORMAL] JSHintBear:
| | 'range' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5470| » » var·cmpVision·=·Engine.QueryInterface(this.entity,·IID_Vision);
| | [NORMAL] JSHintBear:
| | 'cmpVision' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5480| » » var·cmpVision·=·Engine.QueryInterface(this.entity,·IID_Vision);
| | [NORMAL] JSHintBear:
| | 'cmpVision' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5483| » » var·range·=·cmpVision.GetRange();
| | [NORMAL] JSHintBear:
| | 'range' is already defined.
binaries/data/mods/public/simulation/components/UnitAI.js
|5762| » » &&·this.GetCurrentState()·==·"FORMATIONCONTROLLER.COMBAT.ATTACKING";
| | [NORMAL] JSHintBear:
| | Misleading line break before '&&'; readers may interpret this as an expression boundary.
Executing section cli...Link to build: https://jenkins.wildfiregames.com/job/differential/1864/display/redirect