Differential D1977 Diff 8503 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 126 Lines • ▼ Show 20 Lines	"none": {
"respondChase": false,		"respondChase": false,
"respondChaseBeyondVision": false,		"respondChaseBeyondVision": false,
"respondStandGround": false,		"respondStandGround": false,
"respondHoldGround": false,		"respondHoldGround": false,
"selectable": false		"selectable": false
}		}
};		};

// See ../helpers/FSM.js for some documentation of this FSM specification syntax		// See ../helpers/FSM.js for some documentation of this FSM specification syntax
		FreagarachUnsubmitted Not Done Inline Actions Capital `n`? Freagarach: Capital `n`?
		SilierAuthorUnsubmitted Done Inline Actions rather no, it is variable and not function. Silier: rather no, it is variable and not function.
UnitAI.prototype.UnitFsmSpec = {		UnitAI.prototype.UnitFsmSpec = {

// Default event handlers:		// Default event handlers:

"MovementUpdate": function(msg) {		"MovementUpdate": function(msg) {
// ignore spurious movement messages		// ignore spurious movement messages
// (these can happen when stopping moving at the same time		// (these can happen when stopping moving at the same time
// as switching states)		// as switching states)
▲ Show 20 Lines • Show All 462 Lines • ▼ Show 20 Lines	UnitAI.prototype.UnitFsmSpec = {
},		},

"Order.Ungarrison": function() {		"Order.Ungarrison": function() {
this.FinishOrder();		this.FinishOrder();
this.isGarrisoned = false;		this.isGarrisoned = false;
},		},

"Order.Cheering": function(msg) {		"Order.Cheering": function(msg) {
this.SetNextState("INDIVIDUAL.CHEERING");		this.SetNextState("INDIVIDUAL.CHEERING");
		FreagarachUnsubmitted Not Done Inline Actions - Freagarach: -` `
},		},

"Order.Pack": function(msg) {		"Order.Pack": function(msg) {
if (this.CanPack())		if (this.CanPack())
this.SetNextState("INDIVIDUAL.PACKING");		this.SetNextState("INDIVIDUAL.PACKING");
},		},

"Order.Unpack": function(msg) {		"Order.Unpack": function(msg) {
▲ Show 20 Lines • Show All 758 Lines • ▼ Show 20 Lines	"GuardedAttacked": function(msg) {
{		{
this.orderQueue.splice(1, 1);		this.orderQueue.splice(1, 1);
Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
}		}
}		}
},		},

"IDLE": {		"IDLE": {
"enter": function() {		"enter": function() {
		FreagarachUnsubmitted Not Done Inline Actions + Freagarach: +` `
// Switch back to idle animation to guarantee we won't		// Switch back to idle animation to guarantee we won't
		FreagarachUnsubmitted Not Done Inline Actions Perhaps also check if we're really idle? Freagarach: Perhaps also check if we're really idle?
		SilierAuthorUnsubmitted Done Inline Actions No order does that Silier: No order does that
		FreagarachUnsubmitted Not Done Inline Actions Example: Unit calls finishOrder and enters this idle state, with enemy nearby. The rangeQuery won't be reset until the timer expires, but we can be put in cheering state when that order arrives at the same turn. Freagarach: Example: Unit calls finishOrder and enters this idle state, with enemy nearby. The rangeQuery…
		SilierAuthorUnsubmitted Done Inline Actions Description of idle says: `If we entered the idle state we must have nothing better to do`. There is no command given by the player. If unit would be in combat before it would not end up here with attackable enemies around. And I do not think this is an issue. Unit will react back when being attacked and it just does not initiate attack right away, but after ends up cheering. Setting that on if will have in result missed orders. Silier: Description of idle says: ` If we entered the idle state we must have nothing better to do`.
		FreagarachUnsubmitted Not Done Inline Actions Unit will react back when being attacked and it just does not initiate attack right away Which would mean always having reveiced one blow before being able to strike back. That being said, missed cheers is also not nice indeed. We'll see how this unfolds. Freagarach: > Unit will react back when being attacked and it just does not initiate attack right away…
// get stuck with an incorrect animation		// get stuck with an incorrect animation
		SilierAuthorUnsubmitted Not Done Inline Actions comma Silier: comma
var animationName = "idle";		var animationName = "idle";
		FreagarachUnsubmitted Not Done Inline Actions +`\n` Freagarach: +`\n`
if (this.IsFormationMember())		if (this.IsFormationMember())
{		{
var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);		var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
if (cmpFormation)		if (cmpFormation)
animationName = cmpFormation.GetFormationAnimation(this.entity, animationName);		animationName = cmpFormation.GetFormationAnimation(this.entity, animationName);
}		}
this.SelectAnimation(animationName);		this.SelectAnimation(animationName);

▲ Show 20 Lines • Show All 439 Lines • ▼ Show 20 Lines	"COMBAT": {
// TODO: we should probably only bother syncing projectile attacks, not melee		// TODO: we should probably only bother syncing projectile attacks, not melee

// If using a non-default prepare time, re-sync the animation when the timer runs.		// If using a non-default prepare time, re-sync the animation when the timer runs.
this.resyncAnimation = (prepare != this.attackTimers.prepare) ? true : false;		this.resyncAnimation = (prepare != this.attackTimers.prepare) ? true : false;

this.FaceTowardsTarget(this.order.data.target);		this.FaceTowardsTarget(this.order.data.target);

var cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);		var cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);
if (cmpBuildingAI)		if (cmpBuildingAI)
		FreagarachUnsubmitted Not Done Inline Actions +`/n` Freagarach: +`/n`
		StanUnsubmitted Not Done Inline Actions Early return to drop the else ? Stan: Early return to drop the else ?
cmpBuildingAI.SetUnitAITarget(this.order.data.target);		cmpBuildingAI.SetUnitAITarget(this.order.data.target);
},		},
		FreagarachUnsubmitted Not Done Inline Actions Isn't it still false here? Freagarach: Isn't it still false here?

		FreagarachUnsubmitted Not Done Inline Actions Idem. Freagarach: Idem.
"leave": function() {		"leave": function() {
var cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);		var cmpBuildingAI = Engine.QueryInterface(this.entity, IID_BuildingAI);
		FreagarachUnsubmitted Not Done Inline Actions (This is probably because of hunting? But just to mention it: we won't cheer after killing a lion as well.) Freagarach: (This is probably because of hunting? But just to mention it: we won't cheer after killing a…
		FreagarachUnsubmitted Not Done Inline Actions Don't we want to cheer also whenever we've destroyed a structure? Freagarach: Don't we want to cheer also whenever we've destroyed a structure?
		SilierAuthorUnsubmitted Done Inline Actions good question. I do not have clear answer for that. As structures are entities in los, they will cause units to not cheer, but cheering after capturing lonely house might not be wanted. What do you think ? Silier: good question. I do not have clear answer for that. As structures are entities in los, they…
		FreagarachUnsubmitted Not Done Inline Actions I think we'd want to. We can force orders anyway and queued orders also prevent cheering, so it won't disturb gameplay. Freagarach: I think we'd want to. We can force orders anyway and queued orders also prevent cheering, so it…
		SilierAuthorUnsubmitted Done Inline Actions another thought, maybe it would be good to put that to identity component? cmpIdentity.cheerAfterDestroyed? so if one does not want units to cheer after killing basic soldier one would set that in citizensoldier template to false? Silier: another thought, maybe it would be good to put that to identity component? cmpIdentity.
		FreagarachUnsubmitted Not Done Inline Actions I would say just cheer always, even when killing an animal. Hunting won't be affected since there is an order afterwards. And I guess people will be generally delighted when coming out of combat state ;) But it seems a bit strange to have in the attacked template that one may not cheer. E.g. if a support women kills some basic soldier, she would be thrilled, I guess. But for some hero women it's just daily work. Freagarach: I would say just cheer always, even when killing an animal. Hunting won't be affected since…
		StanUnsubmitted Not Done Inline Actions What about having cheering classes? MatchClassList(happywhenhavingkilled, this.target.classes) Stan: What about having cheering classes? MatchClassList(happywhenhavingkilled, this.target.classes)
		FreagarachUnsubmitted Not Done Inline Actions And no "happywhenhavingkilled" means not cheering (e.g. rams etc.). Freagarach: And no "happywhenhavingkilled" means not cheering (e.g. rams etc.).
		SilierAuthorUnsubmitted Done Inline Actions What about having cheering classes? MatchClassList(happywhenhavingkilled, this.target.classes) Thought about that, but in my opinion that would add too big overhead compared to that we want to add just fancy animation. Silier: >What about having cheering classes? >MatchClassList(happywhenhavingkilled, this.target.
		FreagarachUnsubmitted Not Done Inline Actions So we can just cheer always and when user find it strange we can react on that? Freagarach: So we can just cheer always and when user find it strange we can react on that?
		SilierAuthorUnsubmitted Done Inline Actions not always, cheering after killing chickens/sheep/deer is weird enough already since non dangerous animals does not end up in range queries. Silier: not always, cheering after killing chickens/sheep/deer is weird enough already since non…
		FreagarachUnsubmitted Not Done Inline Actions `cmpUnitAI && (!cmpUnitAI.IsAnimal() \|\| cmpUnitAI.IsDangerousAnimal());`? Freagarach: `cmpUnitAI && (!cmpUnitAI.IsAnimal() \|\| cmpUnitAI.IsDangerousAnimal());`?
if (cmpBuildingAI)		if (cmpBuildingAI)
cmpBuildingAI.SetUnitAITarget(0);		cmpBuildingAI.SetUnitAITarget(0);
this.StopTimer();		this.StopTimer();
this.SetDefaultAnimationVariant();		this.SetDefaultAnimationVariant();
},		},

"Timer": function(msg) {		"Timer": function(msg) {
var target = this.order.data.target;		var target = this.order.data.target;
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines	"COMBAT": {
}		}
this.SetNextState("COMBAT.CHASING");		this.SetNextState("COMBAT.CHASING");
return;		return;
}		}
}		}

// if we're targetting a formation, find a new member of that formation		// if we're targetting a formation, find a new member of that formation
var cmpTargetFormation = Engine.QueryInterface(this.order.data.formationTarget \|\| INVALID_ENTITY, IID_Formation);		var cmpTargetFormation = Engine.QueryInterface(this.order.data.formationTarget \|\| INVALID_ENTITY, IID_Formation);
// if there is no target, it means previously searching for the target inside the target formation failed, so don't repeat the search		// if there is no target, it means previously searching for the target inside the target formation failed, so don't repeat the search
		FreagarachUnsubmitted Not Done Inline Actions +`\n`. Freagarach: +`\n`.
if (target && cmpTargetFormation)		if (target && cmpTargetFormation)
{		{
this.order.data.target = this.order.data.formationTarget;		this.order.data.target = this.order.data.formationTarget;
this.TimerHandler(msg.data, msg.lateness);		this.TimerHandler(msg.data, msg.lateness);
return;		return;
}		}

// Can't reach it, no longer owned by enemy, or it doesn't exist any more - give up		// Can't reach it, no longer owned by enemy, or it doesn't exist any more - give up
Show All 12 Lines	"COMBAT": {
// Packable units may have switched to PACKING state, thus canceling the timer and having order.data.attackType undefined.		// Packable units may have switched to PACKING state, thus canceling the timer and having order.data.attackType undefined.
if (this.orderQueue.length > 0 && this.orderQueue[0].data && this.orderQueue[0].data.attackType &&		if (this.orderQueue.length > 0 && this.orderQueue[0].data && this.orderQueue[0].data.attackType &&
this.orderQueue[0].data.attackType == this.oldAttackType)		this.orderQueue[0].data.attackType == this.oldAttackType)
this.TimerHandler(msg.data, msg.lateness);		this.TimerHandler(msg.data, msg.lateness);
return;		return;
}		}

// Return to our original position		// Return to our original position
if (this.GetStance().respondHoldGround)		if (this.GetStance().respondHoldGround)
this.WalkToHeldPosition();		this.WalkToHeldPosition();

		this.Cheer();
		wraitiiUnsubmitted Not Done Inline Actions Think you want this to be in the "leave" call, if we don't have a next order or something like that, rather. wraitii: Think you want this to be in the "leave" call, if we don't have a next order or something like…
		SilierAuthorUnsubmitted Done Inline Actions Actually I think this is the best place, If this would be in leave, that would be called even when you would give order to stop or you change order to walk Silier: Actually I think this is the best place, If this would be in leave, that would be called even…
},		},
		FreagarachUnsubmitted Not Done Inline Actions Do we want to cheer before this or after this? Freagarach: Do we want to cheer before this or after this?

// TODO: respond to target deaths immediately, rather than waiting		// TODO: respond to target deaths immediately, rather than waiting
		FreagarachUnsubmitted Not Done Inline Actions +`/n` Freagarach: +`/n`
// until the next Timer event		// until the next Timer event

"Attacked": function(msg) {		"Attacked": function(msg) {
		FreagarachUnsubmitted Not Done Inline Actions Perhaps make the magic `30` part of the prototype? Freagarach: Perhaps make the magic `30` part of the prototype?
		SilierAuthorUnsubmitted Done Inline Actions Still would be magic, but maybe better Silier: Still would be magic, but maybe better
// If we are capturing and are attacked by something that we would not capture, attack that entity instead		// If we are capturing and are attacked by something that we would not capture, attack that entity instead
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")
this.RespondToTargetedEntities([msg.data.attacker]);		this.RespondToTargetedEntities([msg.data.attacker]);
},		},
},		},

"CHASING": {		"CHASING": {
▲ Show 20 Lines • Show All 856 Lines • ▼ Show 20 Lines	"GARRISON": {

"leave": function() {		"leave": function() {
}		}
},		},
},		},

"CHEERING": {		"CHEERING": {
"enter": function() {		"enter": function() {
// Unit is invulnerable while cheering
var cmpDamageReceiver = Engine.QueryInterface(this.entity, IID_DamageReceiver);
cmpDamageReceiver.SetInvulnerability(true);
this.SelectAnimation("promotion");		this.SelectAnimation("promotion");
		FreagarachUnsubmitted Not Done Inline Actions Should be renamed in a seperate diff to cheering I guess. Freagarach: Should be renamed in a seperate diff to cheering I guess.
this.StartTimer(2800, 2800);		this.StartTimer(2800);
return false;		return false;
},		},

"leave": function() {		"leave": function() {
this.StopTimer();		this.StopTimer();
var cmpDamageReceiver = Engine.QueryInterface(this.entity, IID_DamageReceiver);
cmpDamageReceiver.SetInvulnerability(false);
},		},

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

"PACKING": {		"PACKING": {
▲ Show 20 Lines • Show All 210 Lines • ▼ Show 20 Lines	"ANIMAL": {

"COMBAT": "INDIVIDUAL.COMBAT", // reuse the same combat behaviour for animals		"COMBAT": "INDIVIDUAL.COMBAT", // reuse the same combat behaviour for animals

"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
},		},
};		};

UnitAI.prototype.Init = function()		UnitAI.prototype.Init = function()
		StanUnsubmitted Not Done Inline Actions Constant? Stan: Constant?
{		{
this.orderQueue = []; // current order is at the front of the list		this.orderQueue = []; // current order is at the front of the list
this.order = undefined; // always == this.orderQueue[0]		this.order = undefined; // always == this.orderQueue[0]
this.formationController = INVALID_ENTITY; // entity with IID_Formation that we belong to		this.formationController = INVALID_ENTITY; // entity with IID_Formation that we belong to
this.isGarrisoned = false;		this.isGarrisoned = false;
this.isIdle = false;		this.isIdle = false;
this.finishedOrder = false; // used to find if all formation members finished the order		this.finishedOrder = false; // used to find if all formation members finished the order

▲ Show 20 Lines • Show All 142 Lines • ▼ Show 20 Lines	UnitAI.prototype.OnOwnershipChanged = function(msg)

if (this.isGuardOf && (msg.to == INVALID_PLAYER \|\| !IsOwnedByMutualAllyOfEntity(this.entity, this.isGuardOf)))		if (this.isGuardOf && (msg.to == INVALID_PLAYER \|\| !IsOwnedByMutualAllyOfEntity(this.entity, this.isGuardOf)))
this.RemoveGuard();		this.RemoveGuard();

// If the unit isn't being created or dying, reset stance and clear orders		// If the unit isn't being created or dying, reset stance and clear orders
if (msg.to != INVALID_PLAYER && msg.from != INVALID_PLAYER)		if (msg.to != INVALID_PLAYER && msg.from != INVALID_PLAYER)
{		{
// Switch to a virgin state to let states execute their leave handlers.		// Switch to a virgin state to let states execute their leave handlers.
// except if garrisoned or cheering or (un)packing, in which case we only clear the order queue		// except if garrisoned or or (un)packing, in which case we only clear the order queue
if (this.isGarrisoned \|\| this.IsPacking() \|\| this.orderQueue[0] && this.orderQueue[0].type == "Cheering")		if (this.isGarrisoned \|\| this.IsPacking() \|\| this.orderQueue[0])
		FreagarachUnsubmitted Not Done Inline Actions +`.` Freagarach: +`.`
		FreagarachUnsubmitted Not Done Inline Actions -`or` Freagarach: -`or`
{		{
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)
▲ Show 20 Lines • Show All 253 Lines • ▼ Show 20 Lines

/**		/**
* Add an order onto the front of the queue,		* Add an order onto the front of the queue,
* and execute it immediately.		* and execute it immediately.
*/		*/
UnitAI.prototype.PushOrderFront = function(type, data)		UnitAI.prototype.PushOrderFront = function(type, data)
{		{
var order = { "type": type, "data": data };		var order = { "type": type, "data": data };
// If current order is cheering then add new order after it		// If current order is packing/unpacking then add new order after it
// same thing if current order if packing/unpacking		if (this.order && this.IsPacking())
		FreagarachUnsubmitted Not Done Inline Actions +`.` Freagarach: +`.`
if (this.order && this.order.type == "Cheering")
{
var cheeringOrder = this.orderQueue.shift();
this.orderQueue.unshift(cheeringOrder, order);
}
else if (this.order && this.IsPacking())
{		{
var packingOrder = this.orderQueue.shift();		var packingOrder = this.orderQueue.shift();
this.orderQueue.unshift(packingOrder, order);		this.orderQueue.unshift(packingOrder, order);
}		}
else		else
{		{
this.orderQueue.unshift(order);		this.orderQueue.unshift(order);
this.order = order;		this.order = order;
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines	if (this.IsFormationController())
this.CallMemberFunction("UpdateWorkOrders", [type]);		this.CallMemberFunction("UpdateWorkOrders", [type]);
else		else
this.UpdateWorkOrders(type);		this.UpdateWorkOrders(type);
}		}

let garrisonHolder = this.IsGarrisoned() && type != "Ungarrison" ? this.GetGarrisonHolder() : null;		let garrisonHolder = this.IsGarrisoned() && type != "Ungarrison" ? this.GetGarrisonHolder() : null;

// Special cases of orders that shouldn't be replaced:		// Special cases of orders that shouldn't be replaced:
// 1. Cheering - we're invulnerable, add order after we finish		// 1. Packing/unpacking - we're immobile, add order after we finish (unless it's cancel)
		wraitiiUnsubmitted Not Done Inline Actions I think you can clear these two comments and just say something like `Packing/Unpacking shouldn't be replaced unless we're explicitly doing that` or something. wraitii: I think you can clear these two comments and just say something like `Packing/Unpacking…
		FreagarachUnsubmitted Not Done Inline Actions `(un)packing`? +`.` Freagarach: `(un)packing`? +`.`
		FreagarachUnsubmitted Not Done Inline Actions `P` -> `p` and the dot. Freagarach: `P` -> `p` and the dot.
// 2. Packing/unpacking - we're immobile, add order after we finish (unless it's cancel)
// TODO: maybe a better way of doing this would be to use priority levels		// TODO: maybe a better way of doing this would be to use priority levels
if (this.order && this.order.type == "Cheering")		if (this.IsPacking() && type != "CancelPack" && type != "CancelUnpack")
{
var order = { "type": type, "data": data };
var cheeringOrder = this.orderQueue.shift();
this.orderQueue = [cheeringOrder, order];
}
else if (this.IsPacking() && type != "CancelPack" && type != "CancelUnpack")
{		{
var order = { "type": type, "data": data };		var order = { "type": type, "data": data };
var packingOrder = this.orderQueue.shift();		var packingOrder = this.orderQueue.shift();
this.orderQueue = [packingOrder, order];		this.orderQueue = [packingOrder, order];
}		}
else		else
{		{
this.orderQueue = [];		this.orderQueue = [];
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines	UnitAI.prototype.BackToWork = function()

if (this.IsGarrisoned())		if (this.IsGarrisoned())
{		{
let cmpGarrisonHolder = Engine.QueryInterface(this.GetGarrisonHolder(), IID_GarrisonHolder);		let cmpGarrisonHolder = Engine.QueryInterface(this.GetGarrisonHolder(), IID_GarrisonHolder);
if (!cmpGarrisonHolder \|\| !cmpGarrisonHolder.PerformEject([this.entity], false))		if (!cmpGarrisonHolder \|\| !cmpGarrisonHolder.PerformEject([this.entity], false))
return false;		return false;
}		}

// Clear the order queue considering special orders not to avoid		// Clear the order queue considering special orders not to avoid
if (this.order && this.order.type == "Cheering")
{
var cheeringOrder = this.orderQueue.shift();
this.orderQueue = [cheeringOrder];
}
else
this.orderQueue = [];		this.orderQueue = [];
		wraitiiUnsubmitted Not Done Inline Actions this comment can be changed too. wraitii: this comment can be changed too.
		FreagarachUnsubmitted Not Done Inline Actions Comment unnecessary now. Freagarach: Comment unnecessary now.

this.AddOrders(this.workOrders);		this.AddOrders(this.workOrders);
Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });

// And if the unit is in a formation, remove it from the formation		// And if the unit is in a formation, remove it from the formation
if (this.IsFormationMember())		if (this.IsFormationMember())
{		{
var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);		var cmpFormation = Engine.QueryInterface(this.formationController, IID_Formation);
▲ Show 20 Lines • Show All 1,508 Lines • ▼ Show 20 Lines
* interrupted by attacks.		* interrupted by attacks.
*/		*/
UnitAI.prototype.Flee = function(target, queued)		UnitAI.prototype.Flee = function(target, queued)
{		{
this.AddOrder("Flee", { "target": target, "force": false }, queued);		this.AddOrder("Flee", { "target": target, "force": false }, queued);
};		};

/**		/**
* Adds cheer order to the queue. Forced so it won't be interrupted by attacks.		* Adds cheer order to the queue. Do not force so it can be interrupted by attacks.
*/		*/
		FreagarachUnsubmitted Not Done Inline Actions This could be made more generic perhaps? (To also allow group behavious such as a pack of wild animals attacking instead of being slaughtered one by one.) Freagarach: This could be made more generic perhaps? (To also allow group behavious such as a pack of wild…
UnitAI.prototype.Cheer = function()		UnitAI.prototype.Cheer = function()
{		{
this.AddOrder("Cheering", { "force": true }, false);		this.AddOrder("Cheering", { "force": false }, false);
};		};
		FreagarachUnsubmitted Not Done Inline Actions `// Keep that range small so units within reasonable distance cheer.`? Freagarach: `// Keep that range small so units within reasonable distance cheer.`?

UnitAI.prototype.Pack = function(queued)		UnitAI.prototype.Pack = function(queued)
		FreagarachUnsubmitted Not Done Inline Actions Inline? Freagarach: Inline?
{		{
// Check that we can pack		// Check that we can pack
if (this.CanPack())		if (this.CanPack())
this.AddOrder("Pack", { "force": true }, queued);		this.AddOrder("Pack", { "force": true }, queued);
		FreagarachUnsubmitted Not Done Inline Actions +`;` Freagarach: +`;`
};		};

UnitAI.prototype.Unpack = function(queued)		UnitAI.prototype.Unpack = function(queued)
{		{
// Check that we can unpack		// Check that we can unpack
if (this.CanUnpack())		if (this.CanUnpack())
this.AddOrder("Unpack", { "force": true }, queued);		this.AddOrder("Unpack", { "force": true }, queued);
};		};
▲ Show 20 Lines • Show All 618 Lines • ▼ Show 20 Lines	cmpFormation.GetMembers().forEach(ent => {
var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);		var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
cmpUnitAI[funcname].apply(cmpUnitAI, args);		cmpUnitAI[funcname].apply(cmpUnitAI, args);
});		});
};		};

/**		/**
* Call obj.functname(args) on UnitAI components of all formation members,		* Call obj.functname(args) on UnitAI components of all formation members,
* and return true if all calls return true.		* and return true if all calls return true.
*/		*/
		FreagarachUnsubmitted Not Done Inline Actions `friendly` Freagarach: `friendly`
UnitAI.prototype.TestAllMemberFunction = function(funcname, args)		UnitAI.prototype.TestAllMemberFunction = function(funcname, args)
{		{
var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);		var cmpFormation = Engine.QueryInterface(this.entity, IID_Formation);
if (!cmpFormation)		if (!cmpFormation)
return false;		return false;

		FreagarachUnsubmitted Not Done Inline Actions Friendly != owned. So either the function ought to be renamed or we should be able to specify which players may be asked to perform the function. (Allies cheering would be nice, IMHO.) Freagarach: Friendly != owned. So either the function ought to be renamed or we should be able to specify…
		StanUnsubmitted Not Done Inline Actions Can owner be INVALID_PLAYER? Stan: Can owner be INVALID_PLAYER?
return cmpFormation.GetMembers().every(ent => {		return cmpFormation.GetMembers().every(ent => {
		FreagarachUnsubmitted Not Done Inline Actions `\n` Freagarach: `\n`
		FreagarachUnsubmitted Not Done Inline Actions ^ Freagarach: ^
		FreagarachUnsubmitted Not Done Inline Actions `for (let ent of nearby)`? Freagarach: `for (let ent of nearby)`?
var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);		var cmpUnitAI = Engine.QueryInterface(ent, IID_UnitAI);
return cmpUnitAI[funcname].apply(cmpUnitAI, args);		return cmpUnitAI[funcname].apply(cmpUnitAI, args);
});		});
};		};

UnitAI.prototype.UnitFsm = new FSM(UnitAI.prototype.UnitFsmSpec);		UnitAI.prototype.UnitFsm = new FSM(UnitAI.prototype.UnitFsmSpec);

Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);		Engine.RegisterComponentType(IID_UnitAI, "UnitAI", UnitAI);