Differential D3289 Diff 14978 binaries/data/mods/public/simulation/components/UnitAI.js

Changeset View

Standalone View

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

Show First 20 Lines • Show All 260 Lines • ▼ Show 20 Lines	if (cmpFormation)
cmpFormation.SetRearrange(false);		cmpFormation.SetRearrange(false);
// Calls FinishOrder();		// Calls FinishOrder();
cmpFormation.RemoveMembers([this.entity]);		cmpFormation.RemoveMembers([this.entity]);
cmpFormation.SetRearrange(true);		cmpFormation.SetRearrange(true);
}		}
},		},

"Order.Stop": function(msg) {		"Order.Stop": function(msg) {
this.StopMoving();
this.FinishOrder();		this.FinishOrder();

if (this.IsAnimal())		if (this.IsAnimal())
this.SetNextState("ANIMAL.IDLE");		this.SetNextState("ANIMAL.IDLE");
else if (this.IsFormationMember())		else if (this.IsFormationMember())
this.SetNextState("FORMATIONMEMBER.IDLE");		this.SetNextState("FORMATIONMEMBER.IDLE");
else		else
this.SetNextState("INDIVIDUAL.IDLE");		this.SetNextState("INDIVIDUAL.IDLE");
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 Lines	if (this.CanPack())
return;		return;
}		}


if (this.CheckRange(this.order.data))		if (this.CheckRange(this.order.data))
{		{
// We are already at the target, or can't move at all		// We are already at the target, or can't move at all
this.FinishOrder();		this.FinishOrder();
return true;		return true;
		Lint: ESLintBear (consistent-return) Inline Actions `Method 'Order.WalkToTarget' expected no return value.` Lint: ESLintBear (consistent-return): `Method 'Order.WalkToTarget' expected no return value.`
}		}

this.order.data.relaxed = true;		this.order.data.relaxed = true;

if (this.IsAnimal())		if (this.IsAnimal())
this.SetNextState("ANIMAL.WALKING");		this.SetNextState("ANIMAL.WALKING");
else		else
this.SetNextState("INDIVIDUAL.WALKING");		this.SetNextState("INDIVIDUAL.WALKING");
▲ Show 20 Lines • Show All 380 Lines • ▼ Show 20 Lines	"Order.Guard": function(msg) {
cmpFormation.Disband();		cmpFormation.Disband();
},		},

"Order.Stop": function(msg) {		"Order.Stop": function(msg) {
let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);		let cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
cmpFormation.ResetOrderVariant();		cmpFormation.ResetOrderVariant();
if (!this.IsAttackingAsFormation())		if (!this.IsAttackingAsFormation())
this.CallMemberFunction("Stop", [false]);		this.CallMemberFunction("Stop", [false]);
this.StopMoving();
this.FinishOrder();		this.FinishOrder();
// Don't move the members back into formation,		// Don't move the members back into formation,
// as the formation then resets and it looks odd when walk-stopping.		// as the formation then resets and it looks odd when walk-stopping.
// TODO: this should be improved in the formation reshaping code.		// TODO: this should be improved in the formation reshaping code.
},		},

"Order.Attack": function(msg) {		"Order.Attack": function(msg) {
let target = msg.data.target;		let target = msg.data.target;
Show All 29 Lines	"Order.Garrison": function(msg) {
if (!this.CheckGarrisonRange(msg.data.target))		if (!this.CheckGarrisonRange(msg.data.target))
{		{
if (!this.CheckTargetVisible(msg.data.target))		if (!this.CheckTargetVisible(msg.data.target))
{		{
this.FinishOrder();		this.FinishOrder();
return;		return;
}		}
else		else
{		{
		Lint: ESLintBear (no-else-return) Inline Actions `Unnecessary 'else' after 'return'.` Lint: ESLintBear (no-else-return): `Unnecessary 'else' after 'return'.`
this.SetNextState("GARRISON.APPROACHING");		this.SetNextState("GARRISON.APPROACHING");
return;		return;
}		}
}		}

this.SetNextState("GARRISON.GARRISONING");		this.SetNextState("GARRISON.GARRISONING");
},		},

▲ Show 20 Lines • Show All 462 Lines • ▼ Show 20 Lines	"MEMBER": {
if (cmpFormation)		if (cmpFormation)
cmpFormation.SetRearrange(false);		cmpFormation.SetRearrange(false);
// While waiting on members, the formation is more like		// While waiting on members, the formation is more like
// a group of unit and does not have a well-defined position,		// a group of unit and does not have a well-defined position,
// so move the controller out of the world to enforce that.		// so move the controller out of the world to enforce that.
let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);		let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
if (cmpPosition && cmpPosition.IsInWorld())		if (cmpPosition && cmpPosition.IsInWorld())
{		{
this.StopMoving();		this.StopMoving();
wraitiiUnsubmitted Done Inline Actions Please double-check this one. wraitii: Please double-check this one.
cmpPosition.MoveOutOfWorld();		cmpPosition.MoveOutOfWorld();
}		}

this.StartTimer(1000, 1000);		this.StartTimer(1000, 1000);
return false;		return false;
},		},

"Timer": function(msg) {		"Timer": function(msg) {
▲ Show 20 Lines • Show All 143 Lines • ▼ Show 20 Lines	"WALKINGTOPOINT": {
if (!this.MoveTo(this.order.data))		if (!this.MoveTo(this.order.data))
{		{
this.FinishOrder();		this.FinishOrder();
return true;		return true;
}		}
return false;		return false;
},		},

		"leave": function() {
		this.StopMoving();
		},

"MovementUpdate": function() {		"MovementUpdate": function() {
if (!this.CheckRange(this.order.data))		if (!this.CheckRange(this.order.data))
return;		return;
this.StopMoving();
this.FinishOrder();		this.FinishOrder();
},		},
},		},
},		},


// States for entities not part of a formation:		// States for entities not part of a formation:
"INDIVIDUAL": {		"INDIVIDUAL": {
▲ Show 20 Lines • Show All 303 Lines • ▼ Show 20 Lines	"PATROL": {
this.FindWalkAndFightTargets();		this.FindWalkAndFightTargets();
++this.stopSurveying;		++this.stopSurveying;
}		}
}		}
},		},

"GUARD": {		"GUARD": {
"RemoveGuard": function() {		"RemoveGuard": function() {
this.StopMoving();
this.FinishOrder();		this.FinishOrder();
},		},

"ESCORTING": {		"ESCORTING": {
"enter": function() {		"enter": function() {
if (!this.MoveToTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))		if (!this.MoveToTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
{		{
this.FinishOrder();		this.FinishOrder();
Show All 32 Lines	"GUARD": {
"MovementUpdate": function(msg) {		"MovementUpdate": function(msg) {
if (msg.likelyFailure \|\| this.CheckTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))		if (msg.likelyFailure \|\| this.CheckTargetRangeExplicit(this.isGuardOf, 0, this.guardRange))
this.SetNextState("GUARDING");		this.SetNextState("GUARDING");
},		},
},		},

"GUARDING": {		"GUARDING": {
"enter": function() {		"enter": function() {
this.StopMoving();
this.StartTimer(1000, 1000);		this.StartTimer(1000, 1000);
this.SetHeldPositionOnEntity(this.entity);		this.SetHeldPositionOnEntity(this.entity);
this.SetAnimationVariant("combat");		this.SetAnimationVariant("combat");
this.FaceTowardsTarget(this.order.data.target);		this.FaceTowardsTarget(this.order.data.target);
return false;		return false;
},		},

"LosAttackRangeUpdate": function(msg) {		"LosAttackRangeUpdate": function(msg) {
▲ Show 20 Lines • Show All 118 Lines • ▼ Show 20 Lines	"COMBAT": {
"leave": function() {		"leave": function() {
this.StopMoving();		this.StopMoving();
this.StopTimer();		this.StopTimer();
},		},

"Timer": function(msg) {		"Timer": function(msg) {
if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Attack, this.order.data.attackType))		if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Attack, this.order.data.attackType))
{		{
this.StopMoving();
this.FinishOrder();		this.FinishOrder();

if (this.GetStance().respondHoldGround)		if (this.GetStance().respondHoldGround)
this.WalkToHeldPosition();		this.WalkToHeldPosition();
}		}
else		else
{		{
this.RememberTargetPosition();		this.RememberTargetPosition();
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 Lines	"COMBAT": {
this.PushOrderFront("Pack", { "force": true });		this.PushOrderFront("Pack", { "force": true });
return true;		return true;
}		}

this.SetNextState("COMBAT.APPROACHING");		this.SetNextState("COMBAT.APPROACHING");
return true;		return true;
}		}

this.StopMoving();

let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);		let cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
this.attackTimers = cmpAttack.GetTimers(this.order.data.attackType);		this.attackTimers = cmpAttack.GetTimers(this.order.data.attackType);

// If the repeat time since the last attack hasn't elapsed,		// If the repeat time since the last attack hasn't elapsed,
// delay this attack to avoid attacking too fast.		// delay this attack to avoid attacking too fast.
let prepare = this.attackTimers.prepare;		let prepare = this.attackTimers.prepare;
if (this.lastAttacked)		if (this.lastAttacked)
{		{
▲ Show 20 Lines • Show All 97 Lines • ▼ Show 20 Lines	"COMBAT": {
this.SetNextState("FINDINGNEWTARGET");		this.SetNextState("FINDINGNEWTARGET");
},		},

// TODO: respond to target deaths immediately, rather than waiting		// TODO: respond to target deaths immediately, rather than waiting
// until the next Timer event		// until the next Timer event

"Attacked": function(msg) {		"Attacked": function(msg) {
if (this.order.data.attackType == "Capture" && (this.GetStance().targetAttackersAlways \|\| !this.order.data.force)		if (this.order.data.attackType == "Capture" && (this.GetStance().targetAttackersAlways \|\| !this.order.data.force)
&& this.order.data.target != msg.data.attacker && this.GetBestAttackAgainst(msg.data.attacker, true) != "Capture")		&& this.order.data.target != msg.data.attacker && this.GetBestAttackAgainst(msg.data.attacker, true) != "Capture")
		Lint: JSHintBear Inline Actions `Misleading line break before '&&'; readers may interpret this as an expression boundary.` Lint: JSHintBear: `Misleading line break before '&&'; readers may interpret this as an expression boundary.`
		Lint: ESLintBear (operator-linebreak) Inline Actions `'&&' should be placed at the end of the line.` Lint: ESLintBear (operator-linebreak): `'&&' should be placed at the end of the line.`
this.RespondToTargetedEntities([msg.data.attacker]);		this.RespondToTargetedEntities([msg.data.attacker]);
},		},
},		},

"FINDINGNEWTARGET": {		"FINDINGNEWTARGET": {
"Order.Cheer": function() {		"Order.Cheer": function() {
if (!this.cheeringTime)		if (!this.cheeringTime)
return { "discardOrder": true };		return { "discardOrder": true };
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines	"COMBAT": {
return true;		return true;
},		},
},		},

"CHASING": {		"CHASING": {
"Order.MoveToChasingPoint": function(msg) {		"Order.MoveToChasingPoint": function(msg) {
if (this.CheckPointRangeExplicit(msg.data.x, msg.data.z, 0, msg.data.max))		if (this.CheckPointRangeExplicit(msg.data.x, msg.data.z, 0, msg.data.max))
{		{
this.StopMoving();
this.FinishOrder();		this.FinishOrder();
return;		return;
}		}
this.order.data.relaxed = true;		this.order.data.relaxed = true;
this.StopTimer();		this.StopTimer();
this.SetNextState("MOVINGTOPOINT");		this.SetNextState("MOVINGTOPOINT");
},		},
"enter": function() {		"enter": function() {
Show All 19 Lines	"COMBAT": {

this.StopMoving();		this.StopMoving();
this.StopTimer();		this.StopTimer();
},		},

"Timer": function(msg) {		"Timer": function(msg) {
if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Attack, this.order.data.attackType))		if (this.ShouldAbandonChase(this.order.data.target, this.order.data.force, IID_Attack, this.order.data.attackType))
{		{
this.StopMoving();
this.FinishOrder();		this.FinishOrder();

if (this.GetStance().respondHoldGround)		if (this.GetStance().respondHoldGround)
this.WalkToHeldPosition();		this.WalkToHeldPosition();
}		}
else		else
{		{
this.RememberTargetPosition();		this.RememberTargetPosition();
▲ Show 20 Lines • Show All 202 Lines • ▼ Show 20 Lines	"GATHER": {

// We want to start the gather animation as soon as possible,		// We want to start the gather animation as soon as possible,
// but only if we're actually at the target and it's still alive		// but only if we're actually at the target and it's still alive
// (else it'll look like we're chopping empty air).		// (else it'll look like we're chopping empty air).
// (If it's not alive, the Timer handler will deal with sending us		// (If it's not alive, the Timer handler will deal with sending us
// off to a different target.)		// off to a different target.)
if (this.CheckTargetRange(this.gatheringTarget, IID_ResourceGatherer))		if (this.CheckTargetRange(this.gatheringTarget, IID_ResourceGatherer))
{		{
this.StopMoving();
this.SetDefaultAnimationVariant();		this.SetDefaultAnimationVariant();
this.FaceTowardsTarget(this.order.data.target);		this.FaceTowardsTarget(this.order.data.target);
this.SelectAnimation("gather_" + this.order.data.type.specific);		this.SelectAnimation("gather_" + this.order.data.type.specific);
cmpResourceGatherer.AddToPlayerCounter(this.order.data.type.generic);		cmpResourceGatherer.AddToPlayerCounter(this.order.data.type.generic);
}		}
return false;		return false;
},		},

▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines	"GATHER": {
if (previousTarget == ent)		if (previousTarget == ent)
return false;		return false;

if (type.generic == "treasure" && resourceType.generic == "treasure")		if (type.generic == "treasure" && resourceType.generic == "treasure")
return true;		return true;

return type.specific == resourceType.specific &&		return type.specific == resourceType.specific &&
(type.specific != "meat" \|\| resourceTemplate == template);		(type.specific != "meat" \|\| resourceTemplate == template);
});		});
		Lint: ESLintBear (indent) Inline Actions `Expected indentation of 6 tabs but found 5.` Lint: ESLintBear (indent): `Expected indentation of 6 tabs but found 5.`

if (nearbyResource)		if (nearbyResource)
{		{
this.PerformGather(nearbyResource, false, false);		this.PerformGather(nearbyResource, false, false);
return true;		return true;
}		}

// Failing that, try to move there and se if we are more lucky: maybe there are resources in FOW.		// Failing that, try to move there and se if we are more lucky: maybe there are resources in FOW.
▲ Show 20 Lines • Show All 309 Lines • ▼ Show 20 Lines	"REPAIR": {
if (cmpHealth && cmpHealth.GetHitpoints() >= cmpHealth.GetMaxHitpoints())		if (cmpHealth && cmpHealth.GetHitpoints() >= cmpHealth.GetMaxHitpoints())
{		{
// The building was already finished/fully repaired before we arrived;		// The building was already finished/fully repaired before we arrived;
// let the ConstructionFinished handler handle this.		// let the ConstructionFinished handler handle this.
this.ConstructionFinished({ "entity": this.repairTarget, "newentity": this.repairTarget });		this.ConstructionFinished({ "entity": this.repairTarget, "newentity": this.repairTarget });
return true;		return true;
}		}

this.StopMoving();

let cmpBuilderList = QueryBuilderListInterface(this.repairTarget);		let cmpBuilderList = QueryBuilderListInterface(this.repairTarget);
if (cmpBuilderList)		if (cmpBuilderList)
cmpBuilderList.AddBuilder(this.entity);		cmpBuilderList.AddBuilder(this.entity);

this.FaceTowardsTarget(this.repairTarget);		this.FaceTowardsTarget(this.repairTarget);

this.SelectAnimation("build");		this.SelectAnimation("build");
this.StartTimer(1000, 1000);		this.StartTimer(1000, 1000);
▲ Show 20 Lines • Show All 268 Lines • ▼ Show 20 Lines	"CHEERING": {

"Timer": function(msg) {		"Timer": function(msg) {
this.FinishOrder();		this.FinishOrder();
},		},
},		},

"PACKING": {		"PACKING": {
"enter": function() {		"enter": function() {
this.StopMoving();		let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);

var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
cmpPack.Pack();		cmpPack.Pack();
return false;		return false;
},		},

"PackFinished": function(msg) {		"PackFinished": function(msg) {
this.FinishOrder();		this.FinishOrder();
},		},

"leave": function() {		"leave": function() {
let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);		let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
cmpPack.CancelPack();		cmpPack.CancelPack();
},		},

"Attacked": function(msg) {		"Attacked": function(msg) {
// Ignore attacks while packing		// Ignore attacks while packing
},		},
},		},

"UNPACKING": {		"UNPACKING": {
"enter": function() {		"enter": function() {
this.StopMoving();		let cmpPack = Engine.QueryInterface(this.entity, IID_Pack);

var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
cmpPack.Unpack();		cmpPack.Unpack();
return false;		return false;
},		},

"PackFinished": function(msg) {		"PackFinished": function(msg) {
this.FinishOrder();		this.FinishOrder();
},		},

Show All 23 Lines	"PICKUP": {
},		},

"MovementUpdate": function(msg) {		"MovementUpdate": function(msg) {
if (msg.likelyFailure \|\| msg.likelySuccess)		if (msg.likelyFailure \|\| msg.likelySuccess)
this.SetNextState("LOADING");		this.SetNextState("LOADING");
},		},

"PickupCanceled": function() {		"PickupCanceled": function() {
this.StopMoving();
this.FinishOrder();		this.FinishOrder();
},		},
},		},

"LOADING": {		"LOADING": {
"enter": function() {		"enter": function() {
this.StopMoving();		let cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
var cmpGarrisonHolder = Engine.QueryInterface(this.entity, IID_GarrisonHolder);
if (!cmpGarrisonHolder \|\| cmpGarrisonHolder.IsFull())		if (!cmpGarrisonHolder \|\| cmpGarrisonHolder.IsFull())
{		{
this.FinishOrder();		this.FinishOrder();
return true;		return true;
}		}
return false;		return false;
},		},

▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Lines	"ROAMING": {
"MovementUpdate": function() {		"MovementUpdate": function() {
this.MoveRandomly(+this.template.RoamDistance);		this.MoveRandomly(+this.template.RoamDistance);
},		},
},		},

"FEEDING": {		"FEEDING": {
"enter": function() {		"enter": function() {
this.SelectAnimation("feeding");		this.SelectAnimation("feeding");
this.StopMoving();
this.StartTimer(randIntInclusive(+this.template.FeedTimeMin, +this.template.FeedTimeMax));		this.StartTimer(randIntInclusive(+this.template.FeedTimeMin, +this.template.FeedTimeMax));
return false;		return false;
},		},

"leave": function() {		"leave": function() {
this.ResetAnimation();		this.ResetAnimation();
this.StopTimer();		this.StopTimer();
},		},
Show All 13 Lines	"FEEDING": {
},		},
},		},

"FLEEING": "INDIVIDUAL.FLEEING",		"FLEEING": "INDIVIDUAL.FLEEING",

"COMBAT": "INDIVIDUAL.COMBAT",		"COMBAT": "INDIVIDUAL.COMBAT",

"WALKING": "INDIVIDUAL.WALKING", // reuse the same walking behaviour for animals		"WALKING": "INDIVIDUAL.WALKING", // reuse the same walking behaviour for animals
// only used for domestic animals		// only used for domestic animals
		Lint: ESLintBear (indent) Inline Actions `Expected indentation of 2 tabs but found 7.` Lint: ESLintBear (indent): `Expected indentation of 2 tabs but found 7.`

"CHEERING": {		"CHEERING": {
"enter": function() {		"enter": function() {
this.SelectAnimation("promotion");		this.SelectAnimation("promotion");
this.StartTimer(this.cheeringTime);		this.StartTimer(this.cheeringTime);
return false;		return false;
},		},

▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines

UnitAI.prototype.IsFormationMember = function()		UnitAI.prototype.IsFormationMember = function()
{		{
return (this.formationController != INVALID_ENTITY);		return (this.formationController != INVALID_ENTITY);
};		};

UnitAI.prototype.IsAnimal = function()		UnitAI.prototype.IsAnimal = function()
{		{
return (this.template.NaturalBehaviour ? true : false);		return (this.template.NaturalBehaviour ? true : false);
		Lint: ESLintBear (no-unneeded-ternary) Inline Actions `Unnecessary use of boolean literals in conditional expression.` Lint: ESLintBear (no-unneeded-ternary): `Unnecessary use of boolean literals in conditional expression.`
};		};

UnitAI.prototype.IsDangerousAnimal = function()		UnitAI.prototype.IsDangerousAnimal = function()
{		{
return (this.IsAnimal() && (this.template.NaturalBehaviour == "violent" \|\|		return (this.IsAnimal() && (this.template.NaturalBehaviour == "violent" \|\|
this.template.NaturalBehaviour == "aggressive"));		this.template.NaturalBehaviour == "aggressive"));
};		};

▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines	if (msg.to != INVALID_PLAYER && msg.from != INVALID_PLAYER)
{		{
this.orderQueue.length = Math.min(this.orderQueue.length, 1);		this.orderQueue.length = Math.min(this.orderQueue.length, 1);
Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
}		}
else		else
{		{
let index = this.GetCurrentState().indexOf(".");		let index = this.GetCurrentState().indexOf(".");
if (index != -1)		if (index != -1)
this.UnitFsm.SwitchToNextState(this, this.GetCurrentState().slice(0,index));		this.UnitFsm.SwitchToNextState(this, this.GetCurrentState().slice(0,index));
		Lint: ESLintBear (comma-spacing) Inline Actions `A space is required after ','.` Lint: ESLintBear (comma-spacing): `A space is required after ','.`
this.Stop(false);		this.Stop(false);
}		}

this.workOrders = [];		this.workOrders = [];
let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);		let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
if (cmpTrader)		if (cmpTrader)
cmpTrader.StopTrading();		cmpTrader.StopTrading();

Show All 37 Lines

UnitAI.prototype.OnPickupCanceled = function(msg)		UnitAI.prototype.OnPickupCanceled = function(msg)
{		{
for (let i = 0; i < this.orderQueue.length; ++i)		for (let i = 0; i < this.orderQueue.length; ++i)
{		{
if (this.orderQueue[i].type != "PickupUnit" \|\| this.orderQueue[i].data.target != msg.entity)		if (this.orderQueue[i].type != "PickupUnit" \|\| this.orderQueue[i].data.target != msg.entity)
continue;		continue;
if (i == 0)		if (i == 0)
this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg});		this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg});
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required after '{'.` Lint: ESLintBear (object-curly-spacing): `A space is required after '{'.`
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required before '}'.` Lint: ESLintBear (object-curly-spacing): `A space is required before '}'.`
else		else
this.orderQueue.splice(i, 1);		this.orderQueue.splice(i, 1);
Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
break;		break;
}		}
};		};

/**		/**
▲ Show 20 Lines • Show All 112 Lines • ▼ Show 20 Lines	UnitAI.prototype.SetupAttackRangeQuery = function(enable = true)
let range = this.GetQueryRange(IID_Attack);		let range = this.GetQueryRange(IID_Attack);
this.losAttackRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity, range.min, range.max, players, IID_Resistance, cmpRangeManager.GetEntityFlagMask("normal"));		this.losAttackRangeQuery = cmpRangeManager.CreateActiveQuery(this.entity, range.min, range.max, players, IID_Resistance, cmpRangeManager.GetEntityFlagMask("normal"));

if (enable)		if (enable)
cmpRangeManager.EnableActiveQuery(this.losAttackRangeQuery);		cmpRangeManager.EnableActiveQuery(this.losAttackRangeQuery);
};		};


//// FSM linkage functions ////		//// FSM linkage functions ////
		Lint: ESLintBear (spaced-comment) Inline Actions `Expected space or tab after '//' in comment.` Lint: ESLintBear (spaced-comment): `Expected space or tab after '//' in comment.`

// Setting the next state to the current state will leave/re-enter the top-most substate.		// Setting the next state to the current state will leave/re-enter the top-most substate.
UnitAI.prototype.SetNextState = function(state)		UnitAI.prototype.SetNextState = function(state)
{		{
this.UnitFsm.SetNextState(this, state);		this.UnitFsm.SetNextState(this, state);
};		};

UnitAI.prototype.DeferMessage = function(msg)		UnitAI.prototype.DeferMessage = function(msg)
▲ Show 20 Lines • Show All 149 Lines • ▼ Show 20 Lines	UnitAI.prototype.PushOrderAfterForced = function(type, data)
else		else
{		{
for (let i = 1; i < this.orderQueue.length; ++i)		for (let i = 1; i < this.orderQueue.length; ++i)
{		{
if (this.orderQueue[i].data && this.orderQueue[i].data.force)		if (this.orderQueue[i].data && this.orderQueue[i].data.force)
continue;		continue;
if (this.orderQueue[i].type == type)		if (this.orderQueue[i].type == type)
continue;		continue;
this.orderQueue.splice(i, 0, {"type": type, "data": data});		this.orderQueue.splice(i, 0, {"type": type, "data": data});
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required after '{'.` Lint: ESLintBear (object-curly-spacing): `A space is required after '{'.`
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required before '}'.` Lint: ESLintBear (object-curly-spacing): `A space is required before '}'.`
Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
return;		return;
}		}
this.PushOrder(type, data);		this.PushOrder(type, data);
}		}

Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
};		};
▲ Show 20 Lines • Show All 115 Lines • ▼ Show 20 Lines	for (let order of this.orderQueue)
if (order.data)		if (order.data)
orders.push(clone(order.data));		orders.push(clone(order.data));

return orders;		return orders;
};		};

UnitAI.prototype.UpdateWorkOrders = function(type)		UnitAI.prototype.UpdateWorkOrders = function(type)
{		{
var isWorkType = type => type == "Gather" \|\| type == "Trade" \|\| type == "Repair" \|\| type == "ReturnResource";		var isWorkType = type => type == "Gather" \|\| type == "Trade" \|\| type == "Repair" \|\| type == "ReturnResource";
		Lint: ESLintBear (no-shadow) Inline Actions `'type' is already declared in the upper scope.` Lint: ESLintBear (no-shadow): `'type' is already declared in the upper scope.`
if (isWorkType(type))		if (isWorkType(type))
{		{
this.workOrders = [];		this.workOrders = [];
return;		return;
}		}

if (this.workOrders.length)		if (this.workOrders.length)
return;		return;
Show All 10 Lines	if (cmpUnitAI)
this.workOrders = cmpUnitAI.orderQueue.slice(i);		this.workOrders = cmpUnitAI.orderQueue.slice(i);
return;		return;
}		}
}		}
}		}
}		}

// If nothing found, take the unit orders		// If nothing found, take the unit orders
for (var i = 0; i < this.orderQueue.length; ++i)		for (var i = 0; i < this.orderQueue.length; ++i)
		Lint: JSHintBear Inline Actions `'i' is already defined.` Lint: JSHintBear: `'i' is already defined.`
{		{
if (isWorkType(this.orderQueue[i].type))		if (isWorkType(this.orderQueue[i].type))
{		{
this.workOrders = this.orderQueue.slice(i);		this.workOrders = this.orderQueue.slice(i);
return;		return;
}		}
}		}
};		};
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
};		};

UnitAI.prototype.TimerHandler = function(data, lateness)		UnitAI.prototype.TimerHandler = function(data, lateness)
{		{
// Reset the timer		// Reset the timer
if (data.timerRepeat === undefined)		if (data.timerRepeat === undefined)
this.timer = undefined;		this.timer = undefined;

this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});		this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required before '}'.` Lint: ESLintBear (object-curly-spacing): `A space is required before '}'.`
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required after '{'.` Lint: ESLintBear (object-curly-spacing): `A space is required after '{'.`
};		};

/**		/**
* Set up the UnitAI timer to run after 'offset' msecs, and then		* Set up the UnitAI timer to run after 'offset' msecs, and then
* every 'repeat' msecs until StopTimer is called. A "Timer" message		* every 'repeat' msecs until StopTimer is called. A "Timer" message
* will be sent each time the timer runs.		* will be sent each time the timer runs.
*/		*/
UnitAI.prototype.StartTimer = function(offset, repeat)		UnitAI.prototype.StartTimer = function(offset, repeat)
▲ Show 20 Lines • Show All 69 Lines • ▼ Show 20 Lines	UnitAI.prototype.OnGlobalEntityRenamed = function(msg)
Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
};		};

UnitAI.prototype.OnAttacked = function(msg)		UnitAI.prototype.OnAttacked = function(msg)
{		{
if (msg.fromStatusEffect)		if (msg.fromStatusEffect)
return;		return;

this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});		this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required after '{'.` Lint: ESLintBear (object-curly-spacing): `A space is required after '{'.`
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required before '}'.` Lint: ESLintBear (object-curly-spacing): `A space is required before '}'.`
};		};

UnitAI.prototype.OnGuardedAttacked = function(msg)		UnitAI.prototype.OnGuardedAttacked = function(msg)
{		{
this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data});		this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data});
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required after '{'.` Lint: ESLintBear (object-curly-spacing): `A space is required after '{'.`
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required before '}'.` Lint: ESLintBear (object-curly-spacing): `A space is required before '}'.`
};		};

UnitAI.prototype.OnRangeUpdate = function(msg)		UnitAI.prototype.OnRangeUpdate = function(msg)
{		{
if (msg.tag == this.losRangeQuery)		if (msg.tag == this.losRangeQuery)
this.UnitFsm.ProcessMessage(this, { "type": "LosRangeUpdate", "data": msg });		this.UnitFsm.ProcessMessage(this, { "type": "LosRangeUpdate", "data": msg });
else if (msg.tag == this.losHealRangeQuery)		else if (msg.tag == this.losHealRangeQuery)
this.UnitFsm.ProcessMessage(this, { "type": "LosHealRangeUpdate", "data": msg });		this.UnitFsm.ProcessMessage(this, { "type": "LosHealRangeUpdate", "data": msg });
else if (msg.tag == this.losAttackRangeQuery)		else if (msg.tag == this.losAttackRangeQuery)
this.UnitFsm.ProcessMessage(this, { "type": "LosAttackRangeUpdate", "data": msg });		this.UnitFsm.ProcessMessage(this, { "type": "LosAttackRangeUpdate", "data": msg });
};		};

UnitAI.prototype.OnPackFinished = function(msg)		UnitAI.prototype.OnPackFinished = function(msg)
{		{
this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});		this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required after '{'.` Lint: ESLintBear (object-curly-spacing): `A space is required after '{'.`
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required before '}'.` Lint: ESLintBear (object-curly-spacing): `A space is required before '}'.`
};		};

//// Helper functions to be called by the FSM ////		//// Helper functions to be called by the FSM ////
		Lint: ESLintBear (spaced-comment) Inline Actions `Expected space or tab after '//' in comment.` Lint: ESLintBear (spaced-comment): `Expected space or tab after '//' in comment.`

UnitAI.prototype.GetWalkSpeed = function()		UnitAI.prototype.GetWalkSpeed = function()
{		{
let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);		let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
if (!cmpUnitMotion)		if (!cmpUnitMotion)
return 0;		return 0;
return cmpUnitMotion.GetWalkSpeed();		return cmpUnitMotion.GetWalkSpeed();
};		};
▲ Show 20 Lines • Show All 682 Lines • ▼ Show 20 Lines

/**		/**
* Try to find one of the given entities which can be attacked,		* Try to find one of the given entities which can be attacked,
* and start attacking it.		* and start attacking it.
* Returns true if it found something to attack.		* Returns true if it found something to attack.
*/		*/
UnitAI.prototype.AttackVisibleEntity = function(ents)		UnitAI.prototype.AttackVisibleEntity = function(ents)
{		{
var target = ents.find(target => this.CanAttack(target));		var target = ents.find(target => this.CanAttack(target));
		Lint: ESLintBear (no-shadow) Inline Actions `'target' is already declared in the upper scope.` Lint: ESLintBear (no-shadow): `'target' is already declared in the upper scope.`
if (!target)		if (!target)
return false;		return false;

this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": true });		this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": true });
return true;		return true;
};		};

/**		/**
* Try to find one of the given entities which can be attacked		* Try to find one of the given entities which can be attacked
* and which is close to the hold position, and start attacking it.		* and which is close to the hold position, and start attacking it.
* Returns true if it found something to attack.		* Returns true if it found something to attack.
*/		*/
UnitAI.prototype.AttackEntityInZone = function(ents)		UnitAI.prototype.AttackEntityInZone = function(ents)
{		{
var target = ents.find(target =>		var target = ents.find(target =>
		Lint: ESLintBear (no-shadow) Inline Actions `'target' is already declared in the upper scope.` Lint: ESLintBear (no-shadow): `'target' is already declared in the upper scope.`
this.CanAttack(target)		this.CanAttack(target)
&& this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))		&& this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
		Lint: JSHintBear Inline Actions `Misleading line break before '&&'; readers may interpret this as an expression boundary.` Lint: JSHintBear: `Misleading line break before '&&'; readers may interpret this as an expression boundary.`
		Lint: ESLintBear (operator-linebreak) Inline Actions `'&&' should be placed at the end of the line.` Lint: ESLintBear (operator-linebreak): `'&&' should be placed at the end of the line.`
&& (this.GetStance().respondChaseBeyondVision \|\| this.CheckTargetIsInVisionRange(target))		&& (this.GetStance().respondChaseBeyondVision \|\| this.CheckTargetIsInVisionRange(target))
		Lint: JSHintBear Inline Actions `Misleading line break before '&&'; readers may interpret this as an expression boundary.` Lint: JSHintBear: `Misleading line break before '&&'; readers may interpret this as an expression boundary.`
		Lint: ESLintBear (operator-linebreak) Inline Actions `'&&' should be placed at the end of the line.` Lint: ESLintBear (operator-linebreak): `'&&' should be placed at the end of the line.`
);		);
if (!target)		if (!target)
return false;		return false;

this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": true });		this.PushOrderFront("Attack", { "target": target, "force": false, "allowCapture": true });
return true;		return true;
};		};

▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
};		};

/**		/**
* Try to respond to healable entities.		* Try to respond to healable entities.
* Returns true if it responded.		* Returns true if it responded.
*/		*/
UnitAI.prototype.RespondToHealableEntities = function(ents)		UnitAI.prototype.RespondToHealableEntities = function(ents)
{		{
let ent = ents.find(ent => this.CanHeal(ent));		let ent = ents.find(ent => this.CanHeal(ent));
		Lint: ESLintBear (no-shadow) Inline Actions `'ent' is already declared in the upper scope.` Lint: ESLintBear (no-shadow): `'ent' is already declared in the upper scope.`
if (!ent)		if (!ent)
return false;		return false;

this.PushOrderFront("Heal", { "target": ent, "force": false });		this.PushOrderFront("Heal", { "target": ent, "force": false });
return true;		return true;
};		};

/**		/**
Show All 9 Lines	if (force)
return false;		return false;

// If we are guarding/escorting, don't abandon as long as the guarded unit is in target range of the attacker		// If we are guarding/escorting, don't abandon as long as the guarded unit is in target range of the attacker
if (this.isGuardOf)		if (this.isGuardOf)
{		{
let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);		let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
let cmpAttack = Engine.QueryInterface(target, IID_Attack);		let cmpAttack = Engine.QueryInterface(target, IID_Attack);
if (cmpUnitAI && cmpAttack &&		if (cmpUnitAI && cmpAttack &&
cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))		cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
		Lint: ESLintBear (no-shadow) Inline Actions `'type' is already declared in the upper scope.` Lint: ESLintBear (no-shadow): `'type' is already declared in the upper scope.`
return false;		return false;
		Lint: ESLintBear (indent) Inline Actions `Expected indentation of 3 tabs but found 4.` Lint: ESLintBear (indent): `Expected indentation of 3 tabs but found 4.`
}		}

if (this.GetStance().respondHoldGround)		if (this.GetStance().respondHoldGround)
if (!this.CheckTargetDistanceFromHeldPosition(target, iid, type))		if (!this.CheckTargetDistanceFromHeldPosition(target, iid, type))
return true;		return true;

// Stop if it's left our vision range, unless we're especially persistent.		// Stop if it's left our vision range, unless we're especially persistent.
if (!this.GetStance().respondChaseBeyondVision)		if (!this.GetStance().respondChaseBeyondVision)
Show All 13 Lines	if (!this.AbleToMove())
return false;		return false;

if (this.GetStance().respondChase)		if (this.GetStance().respondChase)
return true;		return true;

// If we are guarding/escorting, chase at least as long as the guarded unit is in target range of the attacker		// If we are guarding/escorting, chase at least as long as the guarded unit is in target range of the attacker
if (this.isGuardOf)		if (this.isGuardOf)
{		{
let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);		let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
		Lint: ESLintBear (no-multi-spaces) Inline Actions `Multiple spaces found before 'Engine'.` Lint: ESLintBear (no-multi-spaces): `Multiple spaces found before 'Engine'.`
let cmpAttack = Engine.QueryInterface(target, IID_Attack);		let cmpAttack = Engine.QueryInterface(target, IID_Attack);
if (cmpUnitAI && cmpAttack &&		if (cmpUnitAI && cmpAttack &&
cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))		cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
return true;		return true;
}		}

return force;		return force;
};		};

//// External interface functions ////		//// External interface functions ////
		Lint: ESLintBear (spaced-comment) Inline Actions `Expected space or tab after '//' in comment.` Lint: ESLintBear (spaced-comment): `Expected space or tab after '//' in comment.`

/**		/**
* Order a unit to leave the formation it is in.		* Order a unit to leave the formation it is in.
* Used to handle queued no-formation orders for units in formation.		* Used to handle queued no-formation orders for units in formation.
*/		*/
UnitAI.prototype.LeaveFormation = function(queued = true)		UnitAI.prototype.LeaveFormation = function(queued = true)
{		{
// If queued, add the order even if we're not in formation,		// If queued, add the order even if we're not in formation,
▲ Show 20 Lines • Show All 154 Lines • ▼ Show 20 Lines	UnitAI.prototype.Guard = function(target, queued)
if (target === this.entity)		if (target === this.entity)
return;		return;

if (this.isGuardOf)		if (this.isGuardOf)
{		{
if (this.isGuardOf == target && this.order && this.order.type == "Guard")		if (this.isGuardOf == target && this.order && this.order.type == "Guard")
return;		return;
else		else
this.RemoveGuard();		this.RemoveGuard();
		Lint: ESLintBear (no-else-return) Inline Actions `Unnecessary 'else' after 'return'.` Lint: ESLintBear (no-else-return): `Unnecessary 'else' after 'return'.`
}		}

this.AddOrder("Guard", { "target": target, "force": false }, queued);		this.AddOrder("Guard", { "target": target, "force": false }, queued);
};		};

/**		/**
* @return {boolean} - Whether it makes sense to guard the given entity.		* @return {boolean} - Whether it makes sense to guard the given entity.
*/		*/
▲ Show 20 Lines • Show All 311 Lines • ▼ Show 20 Lines
{		{
let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);		let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
if (!cmpTrader)		if (!cmpTrader)
return;		return;
cmpTrader.RemoveTargetMarket(target);		cmpTrader.RemoveTargetMarket(target);

if (this.IsFormationController())		if (this.IsFormationController())
this.CallMemberFunction("CancelSetupTradeRoute", [target]);		this.CallMemberFunction("CancelSetupTradeRoute", [target]);
}		}
		Lint: ESLintBear (semi) Inline Actions `Missing semicolon.` Lint: ESLintBear (semi): `Missing semicolon.`
		Lint: JSHintBear Inline Actions `Missing semicolon.` Lint: JSHintBear: `Missing semicolon.`
/**		/**
* Adds trade order to the queue. Either walk to the first market, or		* Adds trade order to the queue. Either walk to the first market, or
* start a new route. Not forced, so it can be interrupted by attacks.		* start a new route. Not forced, so it can be interrupted by attacks.
* The possible route may be given directly as a SetupTradeRoute argument		* The possible route may be given directly as a SetupTradeRoute argument
* if coming from a RallyPoint, or through this.expectedRoute if a user command.		* if coming from a RallyPoint, or through this.expectedRoute if a user command.
*/		*/
UnitAI.prototype.SetupTradeRoute = function(target, source, route, queued)		UnitAI.prototype.SetupTradeRoute = function(target, source, route, queued)
{		{
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Lines
UnitAI.prototype.MarketRemoved = function(market)		UnitAI.prototype.MarketRemoved = function(market)
{		{
if (this.order && this.order.data && this.order.data.target && this.order.data.target == market)		if (this.order && this.order.data && this.order.data.target && this.order.data.target == market)
this.UnitFsm.ProcessMessage(this, { "type": "TradingCanceled", "market": market });		this.UnitFsm.ProcessMessage(this, { "type": "TradingCanceled", "market": market });
};		};

UnitAI.prototype.StopTrading = function()		UnitAI.prototype.StopTrading = function()
{		{
this.StopMoving();
this.FinishOrder();		this.FinishOrder();
var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);		var cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
cmpTrader.StopTrading();		cmpTrader.StopTrading();
};		};

/**		/**
* Adds repair/build order to the queue, forced by the player		* Adds repair/build order to the queue, forced by the player
* until the target is reached		* until the target is reached
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines	if (!cmpPosition \|\| !cmpPosition.IsInWorld())
return;		return;
var pos = cmpPosition.GetPosition();		var pos = cmpPosition.GetPosition();
this.SetHeldPosition(pos.x, pos.z);		this.SetHeldPosition(pos.x, pos.z);

this.SetStance(stance);		this.SetStance(stance);
// Stop moving if switching to stand ground		// Stop moving if switching to stand ground
// TODO: Also stop existing orders in a sensible way		// TODO: Also stop existing orders in a sensible way
if (stance == "standground")		if (stance == "standground")
this.StopMoving();		this.Stop();
		FreagarachAuthorUnsubmitted Done Inline Actions For the record, I dislike this behaviour. Freagarach: For the record, I dislike this behaviour.

// Reset the range queries, since the range depends on stance.		// Reset the range queries, since the range depends on stance.
this.SetupRangeQueries();		this.SetupRangeQueries();
};		};

UnitAI.prototype.SetTurretStance = function()		UnitAI.prototype.SetTurretStance = function()
{		{
this.previousStance = undefined;		this.previousStance = undefined;
▲ Show 20 Lines • Show All 74 Lines • ▼ Show 20 Lines	for (var ent of cmpFormation.members)
{		{
if (!cmpUnitAI.CanAttack(targ))		if (!cmpUnitAI.CanAttack(targ))
continue;		continue;
if (this.order.data.targetClasses)		if (this.order.data.targetClasses)
{		{
var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);		var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);
var targetClasses = this.order.data.targetClasses;		var targetClasses = this.order.data.targetClasses;
if (targetClasses.attack && cmpIdentity		if (targetClasses.attack && cmpIdentity
&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))		&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
		Lint: ESLintBear (operator-linebreak) Inline Actions `'&&' should be placed at the end of the line.` Lint: ESLintBear (operator-linebreak): `'&&' should be placed at the end of the line.`
		Lint: JSHintBear Inline Actions `Misleading line break before '&&'; readers may interpret this as an expression boundary.` Lint: JSHintBear: `Misleading line break before '&&'; readers may interpret this as an expression boundary.`
continue;		continue;
if (targetClasses.avoid && cmpIdentity		if (targetClasses.avoid && cmpIdentity
&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))		&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
		Lint: ESLintBear (operator-linebreak) Inline Actions `'&&' should be placed at the end of the line.` Lint: ESLintBear (operator-linebreak): `'&&' should be placed at the end of the line.`
		Lint: JSHintBear Inline Actions `Misleading line break before '&&'; readers may interpret this as an expression boundary.` Lint: JSHintBear: `Misleading line break before '&&'; readers may interpret this as an expression boundary.`
continue;		continue;
// Only used by the AIs to prevent some choices of targets		// Only used by the AIs to prevent some choices of targets
if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])		if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
continue;		continue;
}		}
this.PushOrderFront("Attack", { "target": targ, "force": false, "allowCapture": this.order.data.allowCapture });		this.PushOrderFront("Attack", { "target": targ, "force": false, "allowCapture": this.order.data.allowCapture });
return true;		return true;
}		}
}		}
return false;		return false;
}		}

var targets = this.GetTargetsFromUnit();		var targets = this.GetTargetsFromUnit();
		Lint: JSHintBear Inline Actions `'targets' is already defined.` Lint: JSHintBear: `'targets' is already defined.`
for (var targ of targets)		for (var targ of targets)
		Lint: JSHintBear Inline Actions `'targ' is already defined.` Lint: JSHintBear: `'targ' is already defined.`
{		{
if (!this.CanAttack(targ))		if (!this.CanAttack(targ))
continue;		continue;
if (this.order.data.targetClasses)		if (this.order.data.targetClasses)
{		{
var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);		var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);
		Lint: JSHintBear Inline Actions `'cmpIdentity' is already defined.` Lint: JSHintBear: `'cmpIdentity' is already defined.`
var targetClasses = this.order.data.targetClasses;		var targetClasses = this.order.data.targetClasses;
		Lint: JSHintBear Inline Actions `'targetClasses' is already defined.` Lint: JSHintBear: `'targetClasses' is already defined.`
if (cmpIdentity && targetClasses.attack		if (cmpIdentity && targetClasses.attack
&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))		&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
		Lint: ESLintBear (operator-linebreak) Inline Actions `'&&' should be placed at the end of the line.` Lint: ESLintBear (operator-linebreak): `'&&' should be placed at the end of the line.`
		Lint: JSHintBear Inline Actions `Misleading line break before '&&'; readers may interpret this as an expression boundary.` Lint: JSHintBear: `Misleading line break before '&&'; readers may interpret this as an expression boundary.`
continue;		continue;
if (cmpIdentity && targetClasses.avoid		if (cmpIdentity && targetClasses.avoid
&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))		&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
		Lint: ESLintBear (operator-linebreak) Inline Actions `'&&' should be placed at the end of the line.` Lint: ESLintBear (operator-linebreak): `'&&' should be placed at the end of the line.`
		Lint: JSHintBear Inline Actions `Misleading line break before '&&'; readers may interpret this as an expression boundary.` Lint: JSHintBear: `Misleading line break before '&&'; readers may interpret this as an expression boundary.`
continue;		continue;
// Only used by the AIs to prevent some choices of targets		// Only used by the AIs to prevent some choices of targets
if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])		if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
continue;		continue;
}		}
this.PushOrderFront("Attack", { "target": targ, "force": false, "allowCapture": this.order.data.allowCapture });		this.PushOrderFront("Attack", { "target": targ, "force": false, "allowCapture": this.order.data.allowCapture });
return true;		return true;
}		}
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Lines	if (!orderData)
orderData = this.order.data;		orderData = this.order.data;
let cmpPosition = Engine.QueryInterface(orderData.target, IID_Position);		let cmpPosition = Engine.QueryInterface(orderData.target, IID_Position);
if (cmpPosition && cmpPosition.IsInWorld())		if (cmpPosition && cmpPosition.IsInWorld())
orderData.lastPos = cmpPosition.GetPosition();		orderData.lastPos = cmpPosition.GetPosition();
};		};

UnitAI.prototype.SetHeldPosition = function(x, z)		UnitAI.prototype.SetHeldPosition = function(x, z)
{		{
this.heldPosition = {"x": x, "z": z};		this.heldPosition = {"x": x, "z": z};
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required after '{'.` Lint: ESLintBear (object-curly-spacing): `A space is required after '{'.`
		Lint: ESLintBear (object-curly-spacing) Inline Actions `A space is required before '}'.` Lint: ESLintBear (object-curly-spacing): `A space is required before '}'.`
};		};

UnitAI.prototype.SetHeldPositionOnEntity = function(entity)		UnitAI.prototype.SetHeldPositionOnEntity = function(entity)
{		{
var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);		var cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
if (!cmpPosition \|\| !cmpPosition.IsInWorld())		if (!cmpPosition \|\| !cmpPosition.IsInWorld())
return;		return;
var pos = cmpPosition.GetPosition();		var pos = cmpPosition.GetPosition();
Show All 10 Lines	UnitAI.prototype.WalkToHeldPosition = function()
if (this.heldPosition)		if (this.heldPosition)
{		{
this.AddOrder("Walk", { "x": this.heldPosition.x, "z": this.heldPosition.z, "force": false }, false);		this.AddOrder("Walk", { "x": this.heldPosition.x, "z": this.heldPosition.z, "force": false }, false);
return true;		return true;
}		}
return false;		return false;
};		};

//// Helper functions ////		//// Helper functions ////
		Lint: ESLintBear (spaced-comment) Inline Actions `Expected space or tab after '//' in comment.` Lint: ESLintBear (spaced-comment): `Expected space or tab after '//' in comment.`

/**		/**
* General getter for ranges.		* General getter for ranges.
*		*
* @param {number} iid		* @param {number} iid
* @param {string} type - [Optional]		* @param {string} type - [Optional]
* @return {Object \| undefined} - The range in the form		* @return {Object \| undefined} - The range in the form
* { "min": number, "max": number }		* { "min": number, "max": number }
* Object."elevationBonus": number may be present when iid == IID_Attack.		* Object."elevationBonus": number may be present when iid == IID_Attack.
* Returns undefined when the entity does not have the requested component.		* Returns undefined when the entity does not have the requested component.
*/		*/
UnitAI.prototype.GetRange = function(iid, type)		UnitAI.prototype.GetRange = function(iid, type)
{		{
let component = Engine.QueryInterface(this.entity, iid);		let component = Engine.QueryInterface(this.entity, iid);
if (!component)		if (!component)
return undefined;		return undefined;

return component.GetRange(type);		return component.GetRange(type);
}		}
		Lint: ESLintBear (semi) Inline Actions `Missing semicolon.` Lint: ESLintBear (semi): `Missing semicolon.`
		Lint: JSHintBear Inline Actions `Missing semicolon.` Lint: JSHintBear: `Missing semicolon.`

UnitAI.prototype.CanAttack = function(target)		UnitAI.prototype.CanAttack = function(target)
{		{
// Formation controllers should always respond to commands		// Formation controllers should always respond to commands
// (then the individual units can make up their own minds)		// (then the individual units can make up their own minds)
if (this.IsFormationController())		if (this.IsFormationController())
return true;		return true;

▲ Show 20 Lines • Show All 148 Lines • ▼ Show 20 Lines
};		};

UnitAI.prototype.IsPacking = function()		UnitAI.prototype.IsPacking = function()
{		{
var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);		var cmpPack = Engine.QueryInterface(this.entity, IID_Pack);
return cmpPack && cmpPack.IsPacking();		return cmpPack && cmpPack.IsPacking();
};		};

//// Formation specific functions ////		//// Formation specific functions ////
		Lint: ESLintBear (spaced-comment) Inline Actions `Expected space or tab after '//' in comment.` Lint: ESLintBear (spaced-comment): `Expected space or tab after '//' in comment.`

UnitAI.prototype.IsAttackingAsFormation = function()		UnitAI.prototype.IsAttackingAsFormation = function()
{		{
var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);		var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
return cmpAttack && cmpAttack.CanAttackAsFormation()		return cmpAttack && cmpAttack.CanAttackAsFormation()
&& this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";		&& this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";
		Lint: ESLintBear (operator-linebreak) Inline Actions `'&&' should be placed at the end of the line.` Lint: ESLintBear (operator-linebreak): `'&&' should be placed at the end of the line.`
		Lint: JSHintBear Inline Actions `Misleading line break before '&&'; readers may interpret this as an expression boundary.` Lint: JSHintBear: `Misleading line break before '&&'; readers may interpret this as an expression boundary.`
};		};

//// Animal specific functions ////		//// Animal specific functions ////
		Lint: ESLintBear (spaced-comment) Inline Actions `Expected space or tab after '//' in comment.` Lint: ESLintBear (spaced-comment): `Expected space or tab after '//' in comment.`

UnitAI.prototype.MoveRandomly = function(distance)		UnitAI.prototype.MoveRandomly = function(distance)
{		{
// To minimize drift all across the map, animals describe circles		// To minimize drift all across the map, animals describe circles
// approximated by polygons.		// approximated by polygons.
// And to avoid getting stuck in obstacles or narrow spaces, each side		// And to avoid getting stuck in obstacles or narrow spaces, each side
// of the polygon is obtained by trying to go away from a point situated		// of the polygon is obtained by trying to go away from a point situated
// half a meter backwards of the current position, after rotation.		// half a meter backwards of the current position, after rotation.
Show All 34 Lines	UnitAI.prototype.SetFacePointAfterMove = function(val)
if (cmpMotion)		if (cmpMotion)
cmpMotion.SetFacePointAfterMove(val);		cmpMotion.SetFacePointAfterMove(val);
};		};

UnitAI.prototype.GetFacePointAfterMove = function()		UnitAI.prototype.GetFacePointAfterMove = function()
{		{
let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);		let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
return cmpUnitMotion && cmpUnitMotion.GetFacePointAfterMove();		return cmpUnitMotion && cmpUnitMotion.GetFacePointAfterMove();
}		}
		Lint: JSHintBear Inline Actions `Missing semicolon.` Lint: JSHintBear: `Missing semicolon.`
		Lint: ESLintBear (semi) Inline Actions `Missing semicolon.` Lint: ESLintBear (semi): `Missing semicolon.`

UnitAI.prototype.AttackEntitiesByPreference = function(ents)		UnitAI.prototype.AttackEntitiesByPreference = function(ents)
{		{
if (!ents.length)		if (!ents.length)
return false;		return false;

var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);		var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
if (!cmpAttack)		if (!cmpAttack)
▲ Show 20 Lines • Show All 99 Lines • Show Last 20 Lines