In D2911#126234, @borg- wrote:

@wraitii need remove "They are also capable of constructing defense towers and palisades" on spart.json.
Slave also needs to be updated too.

In D2911#126760, @Itms wrote:

I am not sure I understood you, I 100% agree with Justus that the current "female citizens" should just be "citizens" with two kinds of models/voices, using the phenotype system. Those citizens with various phenotypes would be better at gathering food, would have a boosting aura, couldn't fight, etc. I don't see how that conflicts with citizen soldiers, which are different units?

I think I remember that in DE, workers aren't "citizen soldiers" but either pure citizen or pure soldier. That I don't think we're considering at the moment -> hence my "no"?

Maybe the confusion arises from the word "citizens" which wouldn't be clear anymore if all units are citizens (workers or soldiers). Maybe call them farmers, or maybe do the naming depending on the civ. For instance, in Athens I believe all citizens go to war whereas the ones who always stay in the country do not have citizen rights.

Indeed, . I don't actually mind having a "worker" class instead of just women, which has always seemed kind of odd, but it's somewhat accurate for Greek society that citizens were both workers & soldiers, and that non-citizens weren't soldiers. We chose to not really represent slaves iirc, which would be the obvious choice.
In other culture of the time, things _would_ be different, but that's a bit of a different issue.

I like how 0ad works now, women with different attributes than men. I really don't see a problem with that. Add another male unit to the game so soldiers couldn’t collect resources. Anyway Its for another discussion in the future, now this patch is good and fix current balancing issues.

Successful build - Chance fights ever on the side of the prudent.

• rebased and updated

Successful build - Chance fights ever on the side of the prudent.

• rebased

Yes, calling workers (i.e. gatherers + builders) in 0 A.D. “citizens” is a really unfortunate choice of words. Citizenship implies legal and political rights, and is limited to only a subset of the population (the French revolution had not yet happened in our timeframe).

If you make women build everything, even military buildings and fortresses and stuff

Actually female citizens can already build everything, they just can't initiate all foundations (that's not a problem for the AI).

then you should go the DE route and change "Female Citizens" to just Citizens (male and female) using the phenotype system.

I would welcome having male non-soldier “citizen” workers, but that requires someone to create the actors, and is outside the scope of this patch.

In D2911#126651, @wraitii wrote:

At the moment I don't think we plan on stopping citizen soldiers from being soldiers, so that's a likely no for now.

Successful build - Chance fights ever on the side of the prudent.

Rebase. Add note that this is only a workaround

Build failure - The Moirai have given mortals hearts that can endure.

Update with the version from the SM52 git migration branch.

I checked for completeness.

Successful build - Chance fights ever on the side of the prudent.

In D665#126639, @Vulcan wrote:

Build failure - The Moirai have given mortals hearts that can endure.

Linter detected issues:
Executing section Source...

source/simulation2/components/ICmpPathfinder.h
|   1| /*·Copyright·(C)·2019·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2020" year instead of "2019"

source/simulation2/components/ICmpPathfinder.h
|  34| template<typename·T>·class·Grid;
|    | [MAJOR] CPPCheckBear (syntaxError):
|    | Code 'template<...' is invalid C code. Use --std or --language to configure the language.

source/simulation2/components/ICmpUnitMotion.h
|  34| class·ICmpUnitMotion·:·public·IComponent
|    | [MAJOR] CPPCheckBear (syntaxError):
|    | Code 'classICmpUnitMotion:' is invalid C code. Use --std or --language to configure the language.

source/simulation2/helpers/HierarchicalPathfinder.h
|   1| /*·Copyright·(C)·2019·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2020" year instead of "2019"

source/simulation2/helpers/HierarchicalPathfinder.h
|  32| ·*·The·navcell-grid·representation·of·the·map·is·split·into·fixed-size·chunks.
|    | [MAJOR] CPPCheckBear (syntaxError):
|    | Code 'classPathGoal{' is invalid C code. Use --std or --language to configure the language.

source/simulation2/components/CCmpPathfinder_Common.h
|  34| #include·"graphics/Overlay.h"
|    | [MAJOR] CPPCheckBear (syntaxError):
|    | Code 'template<...' is invalid C code. Use --std or --language to configure the language.

source/simulation2/helpers/HierarchicalPathfinder.cpp
|   1| /*·Copyright·(C)·2019·Wildfire·Games.
|    | [NORMAL] LicenseYearBear:
|    | License should have "2020" year instead of "2019"
Executing section JS...
|    | [NORMAL] ESLintBear (no-else-return):
|    | Unnecessary 'else' after 'return'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
| 796| 796| 					this.FinishOrder();
| 797| 797| 					return;
| 798| 798| 				}
| 799|    |-				else
| 800|    |-				{
|    | 799|+				
| 801| 800| 					this.SetNextState("GARRISON.APPROACHING");
| 802| 801| 					return;
| 803|    |-				}
|    | 802|+				
| 804| 803| 			}
| 805| 804| 
| 806| 805| 			this.SetNextState("GARRISON.GARRISONING");
|    | [NORMAL] ESLintBear (key-spacing):
|    | Missing space before value for key 'GARRISON'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|1060|1060| 			},
|1061|1061| 		},
|1062|1062| 
|1063|    |-		"GARRISON":{
|    |1063|+		"GARRISON": {
|1064|1064| 			"APPROACHING": {
|1065|1065| 				"enter": function() {
|1066|1066| 					if (!this.MoveToGarrisonRange(this.order.data.target))
|    | [NORMAL] ESLintBear (operator-linebreak):
|    | '&&' should be placed at the end of the line.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|2064|2064| 
|2065|2065| 				"Attacked": function(msg) {
|2066|2066| 					// If we are capturing and are attacked by something that we would not capture, attack that entity instead
|2067|    |-					if (this.order.data.attackType == "Capture" && (this.GetStance().targetAttackersAlways || !this.order.data.force)
|2068|    |-						&& this.order.data.target != msg.data.attacker && this.GetBestAttackAgainst(msg.data.attacker, true) != "Capture")
|    |2067|+					if (this.order.data.attackType == "Capture" && (this.GetStance().targetAttackersAlways || !this.order.data.force) &&
|    |2068|+						this.order.data.target != msg.data.attacker && this.GetBestAttackAgainst(msg.data.attacker, true) != "Capture")
|2069|2069| 						this.RespondToTargetedEntities([msg.data.attacker]);
|2070|2070| 				},
|2071|2071| 			},
|    | [NORMAL] ESLintBear (no-trailing-spaces):
|    | Trailing spaces not allowed.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|2223|2223| 					"MovementUpdate": function(msg) {
|2224|2224| 						// If it looks like the path is failing, and we are close enough (3 tiles) from wanted range
|2225|2225| 						// stop anyways. This avoids pathing for an unreachable goal and reduces lag considerably.
|2226|    |-						if (msg.likelyFailure || 
|    |2226|+						if (msg.likelyFailure ||
|2227|2227| 							msg.obstructed && this.RelaxedMaxRangeCheck(this.order.data, this.order.data.max + this.DefaultRelaxedMaxRange) ||
|2228|2228| 							!msg.obstructed && this.CheckRange(this.order.data))
|2229|2229| 							this.FinishOrder();
|    | [NORMAL] ESLintBear (indent):
|    | Expected indentation of 7 tabs but found 6.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|2526|2526| 
|2527|2527| 								return type.specific == resourceType.specific &&
|2528|2528| 								    (type.specific != "meat" || resourceTemplate == template);
|2529|    |-						});
|    |2529|+							});
|2530|2530| 
|2531|2531| 						if (nearbyResource)
|2532|2532| 						{
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|2858|2858| 					{
|2859|2859| 						// The building was already finished/fully repaired before we arrived;
|2860|2860| 						// let the ConstructionFinished handler handle this.
|2861|    |-						this.OnGlobalConstructionFinished({"entity": this.repairTarget, "newentity": this.repairTarget});
|    |2861|+						this.OnGlobalConstructionFinished({ "entity": this.repairTarget, "newentity": this.repairTarget});
|2862|2862| 						return true;
|2863|2863| 					}
|2864|2864| 
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|2858|2858| 					{
|2859|2859| 						// The building was already finished/fully repaired before we arrived;
|2860|2860| 						// let the ConstructionFinished handler handle this.
|2861|    |-						this.OnGlobalConstructionFinished({"entity": this.repairTarget, "newentity": this.repairTarget});
|    |2861|+						this.OnGlobalConstructionFinished({"entity": this.repairTarget, "newentity": this.repairTarget });
|2862|2862| 						return true;
|2863|2863| 					}
|2864|2864| 
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3145|3145| 				this.StopTimer();
|3146|3146| 				this.ResetAnimation();
|3147|3147| 				if (this.formationAnimationVariant)
|3148|    |-					this.SetAnimationVariant(this.formationAnimationVariant)
|    |3148|+					this.SetAnimationVariant(this.formationAnimationVariant);
|3149|3149| 				else
|3150|3150| 					this.SetDefaultAnimationVariant();
|3151|3151| 				var cmpResistance = Engine.QueryInterface(this.entity, IID_Resistance);
|    | [NORMAL] ESLintBear (indent):
|    | Expected indentation of 2 tabs but found 7.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3359|3359| 		"COMBAT": "INDIVIDUAL.COMBAT", // reuse the same combat behaviour for animals
|3360|3360| 
|3361|3361| 		"WALKING": "INDIVIDUAL.WALKING",	// reuse the same walking behaviour for animals
|3362|    |-							// only used for domestic animals
|    |3362|+		// only used for domestic animals
|3363|3363| 
|3364|3364| 		// Reuse the same garrison behaviour for animals.
|3365|3365| 		"GARRISON": "INDIVIDUAL.GARRISON",
|    | [NORMAL] ESLintBear (no-unneeded-ternary):
|    | Unnecessary use of boolean literals in conditional expression.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3409|3409| 
|3410|3410| UnitAI.prototype.IsAnimal = function()
|3411|3411| {
|3412|    |-	return (this.template.NaturalBehaviour ? true : false);
|    |3412|+	return (!!this.template.NaturalBehaviour);
|3413|3413| };
|3414|3414| 
|3415|3415| UnitAI.prototype.IsDangerousAnimal = function()
|    | [NORMAL] ESLintBear (comma-spacing):
|    | A space is required after ','.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3549|3549| 		{
|3550|3550| 			let index = this.GetCurrentState().indexOf(".");
|3551|3551| 			if (index != -1)
|3552|    |-				this.UnitFsm.SwitchToNextState(this, this.GetCurrentState().slice(0,index));
|    |3552|+				this.UnitFsm.SwitchToNextState(this, this.GetCurrentState().slice(0, index));
|3553|3553| 			this.Stop(false);
|3554|3554| 		}
|3555|3555| 
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3606|3606| 		if (this.orderQueue[i].type != "PickupUnit" || this.orderQueue[i].data.target != msg.entity)
|3607|3607| 			continue;
|3608|3608| 		if (i == 0)
|3609|    |-			this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg});
|    |3609|+			this.UnitFsm.ProcessMessage(this, { "type": "PickupCanceled", "data": msg});
|3610|3610| 		else
|3611|3611| 			this.orderQueue.splice(i, 1);
|3612|3612| 		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3606|3606| 		if (this.orderQueue[i].type != "PickupUnit" || this.orderQueue[i].data.target != msg.entity)
|3607|3607| 			continue;
|3608|3608| 		if (i == 0)
|3609|    |-			this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg});
|    |3609|+			this.UnitFsm.ProcessMessage(this, {"type": "PickupCanceled", "data": msg });
|3610|3610| 		else
|3611|3611| 			this.orderQueue.splice(i, 1);
|3612|3612| 		Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
|    | [NORMAL] ESLintBear (spaced-comment):
|    | Expected space or tab after '//' in comment.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3735|3735| };
|3736|3736| 
|3737|3737| 
|3738|    |-//// FSM linkage functions ////
|    |3738|+// // FSM linkage functions ////
|3739|3739| 
|3740|3740| // Setting the next state to the current state will leave/re-enter the top-most substate.
|3741|3741| UnitAI.prototype.SetNextState = function(state)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3908|3908| 				continue;
|3909|3909| 			if (this.orderQueue[i].type == type)
|3910|3910| 				continue;
|3911|    |-			this.orderQueue.splice(i, 0, {"type": type, "data": data});
|    |3911|+			this.orderQueue.splice(i, 0, { "type": type, "data": data});
|3912|3912| 			Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
|3913|3913| 			return;
|3914|3914| 		}
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|3908|3908| 				continue;
|3909|3909| 			if (this.orderQueue[i].type == type)
|3910|3910| 				continue;
|3911|    |-			this.orderQueue.splice(i, 0, {"type": type, "data": data});
|    |3911|+			this.orderQueue.splice(i, 0, {"type": type, "data": data });
|3912|3912| 			Engine.PostMessage(this.entity, MT_UnitAIOrderDataChanged, { "to": this.GetOrderData() });
|3913|3913| 			return;
|3914|3914| 		}
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4149|4149| 	if (data.timerRepeat === undefined)
|4150|4150| 		this.timer = undefined;
|4151|4151| 
|4152|    |-	this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
|    |4152|+	this.UnitFsm.ProcessMessage(this, { "type": "Timer", "data": data, "lateness": lateness});
|4153|4153| };
|4154|4154| 
|4155|4155| /**
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4149|4149| 	if (data.timerRepeat === undefined)
|4150|4150| 		this.timer = undefined;
|4151|4151| 
|4152|    |-	this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness});
|    |4152|+	this.UnitFsm.ProcessMessage(this, {"type": "Timer", "data": data, "lateness": lateness });
|4153|4153| };
|4154|4154| 
|4155|4155| /**
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4194|4194| 	// TODO: This is a bit inefficient since every unit listens to every
|4195|4195| 	// construction message - ideally we could scope it to only the one we're building
|4196|4196| 
|4197|    |-	this.UnitFsm.ProcessMessage(this, {"type": "ConstructionFinished", "data": msg});
|    |4197|+	this.UnitFsm.ProcessMessage(this, { "type": "ConstructionFinished", "data": msg});
|4198|4198| };
|4199|4199| 
|4200|4200| UnitAI.prototype.OnGlobalEntityRenamed = function(msg)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4194|4194| 	// TODO: This is a bit inefficient since every unit listens to every
|4195|4195| 	// construction message - ideally we could scope it to only the one we're building
|4196|4196| 
|4197|    |-	this.UnitFsm.ProcessMessage(this, {"type": "ConstructionFinished", "data": msg});
|    |4197|+	this.UnitFsm.ProcessMessage(this, {"type": "ConstructionFinished", "data": msg });
|4198|4198| };
|4199|4199| 
|4200|4200| UnitAI.prototype.OnGlobalEntityRenamed = function(msg)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4233|4233| 	if (msg.fromStatusEffect)
|4234|4234| 		return;
|4235|4235| 
|4236|    |-	this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});
|    |4236|+	this.UnitFsm.ProcessMessage(this, { "type": "Attacked", "data": msg});
|4237|4237| };
|4238|4238| 
|4239|4239| UnitAI.prototype.OnGuardedAttacked = function(msg)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4233|4233| 	if (msg.fromStatusEffect)
|4234|4234| 		return;
|4235|4235| 
|4236|    |-	this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg});
|    |4236|+	this.UnitFsm.ProcessMessage(this, {"type": "Attacked", "data": msg });
|4237|4237| };
|4238|4238| 
|4239|4239| UnitAI.prototype.OnGuardedAttacked = function(msg)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4238|4238| 
|4239|4239| UnitAI.prototype.OnGuardedAttacked = function(msg)
|4240|4240| {
|4241|    |-	this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data});
|    |4241|+	this.UnitFsm.ProcessMessage(this, { "type": "GuardedAttacked", "data": msg.data});
|4242|4242| };
|4243|4243| 
|4244|4244| UnitAI.prototype.OnHealthChanged = function(msg)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4238|4238| 
|4239|4239| UnitAI.prototype.OnGuardedAttacked = function(msg)
|4240|4240| {
|4241|    |-	this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data});
|    |4241|+	this.UnitFsm.ProcessMessage(this, {"type": "GuardedAttacked", "data": msg.data });
|4242|4242| };
|4243|4243| 
|4244|4244| UnitAI.prototype.OnHealthChanged = function(msg)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4243|4243| 
|4244|4244| UnitAI.prototype.OnHealthChanged = function(msg)
|4245|4245| {
|4246|    |-	this.UnitFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to});
|    |4246|+	this.UnitFsm.ProcessMessage(this, { "type": "HealthChanged", "from": msg.from, "to": msg.to});
|4247|4247| };
|4248|4248| 
|4249|4249| UnitAI.prototype.OnRangeUpdate = function(msg)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4243|4243| 
|4244|4244| UnitAI.prototype.OnHealthChanged = function(msg)
|4245|4245| {
|4246|    |-	this.UnitFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to});
|    |4246|+	this.UnitFsm.ProcessMessage(this, {"type": "HealthChanged", "from": msg.from, "to": msg.to });
|4247|4247| };
|4248|4248| 
|4249|4249| UnitAI.prototype.OnRangeUpdate = function(msg)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4258|4258| 
|4259|4259| UnitAI.prototype.OnPackFinished = function(msg)
|4260|4260| {
|4261|    |-	this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
|    |4261|+	this.UnitFsm.ProcessMessage(this, { "type": "PackFinished", "packed": msg.packed});
|4262|4262| };
|4263|4263| 
|4264|4264| //// Helper functions to be called by the FSM ////
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4258|4258| 
|4259|4259| UnitAI.prototype.OnPackFinished = function(msg)
|4260|4260| {
|4261|    |-	this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
|    |4261|+	this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed });
|4262|4262| };
|4263|4263| 
|4264|4264| //// Helper functions to be called by the FSM ////
|    | [NORMAL] ESLintBear (spaced-comment):
|    | Expected space or tab after '//' in comment.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4261|4261| 	this.UnitFsm.ProcessMessage(this, {"type": "PackFinished", "packed": msg.packed});
|4262|4262| };
|4263|4263| 
|4264|    |-//// Helper functions to be called by the FSM ////
|    |4264|+// // Helper functions to be called by the FSM ////
|4265|4265| 
|4266|4266| UnitAI.prototype.GetWalkSpeed = function()
|4267|4267| {
|    | [NORMAL] ESLintBear (operator-linebreak):
|    | '&&' should be placed at the end of the line.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4986|4986| UnitAI.prototype.AttackEntityInZone = function(ents)
|4987|4987| {
|4988|4988| 	var target = ents.find(target =>
|4989|    |-		this.CanAttack(target)
|4990|    |-		&& this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
|    |4989|+		this.CanAttack(target) &&
|    |4990|+		this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
|4991|4991| 		&& (this.GetStance().respondChaseBeyondVision || this.CheckTargetIsInVisionRange(target))
|4992|4992| 	);
|4993|4993| 	if (!target)
|    | [NORMAL] ESLintBear (operator-linebreak):
|    | '&&' should be placed at the end of the line.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|4987|4987| {
|4988|4988| 	var target = ents.find(target =>
|4989|4989| 		this.CanAttack(target)
|4990|    |-		&& this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true))
|4991|    |-		&& (this.GetStance().respondChaseBeyondVision || this.CheckTargetIsInVisionRange(target))
|    |4990|+		&& this.CheckTargetDistanceFromHeldPosition(target, IID_Attack, this.GetBestAttackAgainst(target, true)) &&
|    |4991|+		(this.GetStance().respondChaseBeyondVision || this.CheckTargetIsInVisionRange(target))
|4992|4992| 	);
|4993|4993| 	if (!target)
|4994|4994| 		return false;
|    | [NORMAL] ESLintBear (no-multi-spaces):
|    | Multiple spaces found before 'Engine'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5071|5071| 	// If we are guarding/escorting, don't abandon as long as the guarded unit is in target range of the attacker
|5072|5072| 	if (this.isGuardOf)
|5073|5073| 	{
|5074|    |-		var cmpUnitAI =  Engine.QueryInterface(target, IID_UnitAI);
|    |5074|+		var cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
|5075|5075| 		var cmpAttack = Engine.QueryInterface(target, IID_Attack);
|5076|5076| 		if (cmpUnitAI && cmpAttack &&
|5077|5077| 		    cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
|    | [NORMAL] ESLintBear (indent):
|    | Expected indentation of 3 tabs but found 4.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5075|5075| 		var cmpAttack = Engine.QueryInterface(target, IID_Attack);
|5076|5076| 		if (cmpUnitAI && cmpAttack &&
|5077|5077| 		    cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
|5078|    |-				return false;
|    |5078|+			return false;
|5079|5079| 	}
|5080|5080| 
|5081|5081| 	// Stop if we're in hold-ground mode and it's too far from the holding point
|    | [NORMAL] ESLintBear (no-multi-spaces):
|    | Multiple spaces found before 'Engine'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5113|5113| 	// If we are guarding/escorting, chase at least as long as the guarded unit is in target range of the attacker
|5114|5114| 	if (this.isGuardOf)
|5115|5115| 	{
|5116|    |-		let cmpUnitAI =  Engine.QueryInterface(target, IID_UnitAI);
|    |5116|+		let cmpUnitAI = Engine.QueryInterface(target, IID_UnitAI);
|5117|5117| 		let cmpAttack = Engine.QueryInterface(target, IID_Attack);
|5118|5118| 		if (cmpUnitAI && cmpAttack &&
|5119|5119| 		    cmpAttack.GetAttackTypes().some(type => cmpUnitAI.CheckTargetAttackRange(this.isGuardOf, type)))
|    | [NORMAL] ESLintBear (spaced-comment):
|    | Expected space or tab after '//' in comment.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5126|5126| 	return false;
|5127|5127| };
|5128|5128| 
|5129|    |-//// External interface functions ////
|    |5129|+// // External interface functions ////
|5130|5130| 
|5131|5131| UnitAI.prototype.SetFormationController = function(ent)
|5132|5132| {
|    | [NORMAL] ESLintBear (no-else-return):
|    | Unnecessary 'else' after 'return'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5282|5282| 	{
|5283|5283| 		if (this.isGuardOf == target && this.order && this.order.type == "Guard")
|5284|5284| 			return;
|5285|    |-		else
|5286|    |-			this.RemoveGuard();
|    |5285|+		this.RemoveGuard();
|5287|5286| 	}
|5288|5287| 
|5289|5288| 	this.AddOrder("Guard", { "target": target, "force": false }, queued);
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5616|5616| 
|5617|5617| 	if (this.IsFormationController())
|5618|5618| 		this.CallMemberFunction("CancelSetupTradeRoute", [target]);
|5619|    |-}
|    |5619|+};
|5620|5620| /**
|5621|5621|  * Adds trade order to the queue. Either walk to the first market, or
|5622|5622|  * start a new route. Not forced, so it can be interrupted by attacks.
|    | [NORMAL] ESLintBear (no-trailing-spaces):
|    | Trailing spaces not allowed.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5637|5637| 	    this.workOrders.length && this.workOrders[0].type == "Trade")
|5638|5638| 	{
|5639|5639| 		let cmpTrader = Engine.QueryInterface(this.entity, IID_Trader);
|5640|    |-		if (cmpTrader.HasBothMarkets() && 
|    |5640|+		if (cmpTrader.HasBothMarkets() &&
|5641|5641| 		   (cmpTrader.GetFirstMarket() == target && cmpTrader.GetSecondMarket() == source ||
|5642|5642| 		    cmpTrader.GetFirstMarket() == source && cmpTrader.GetSecondMarket() == target))
|5643|5643| 		{
|    | [NORMAL] ESLintBear (operator-linebreak):
|    | '&&' should be placed at the end of the line.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5944|5944| 				{
|5945|5945| 					var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);
|5946|5946| 					var targetClasses = this.order.data.targetClasses;
|5947|    |-					if (targetClasses.attack && cmpIdentity
|5948|    |-						&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|    |5947|+					if (targetClasses.attack && cmpIdentity &&
|    |5948|+						!MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|5949|5949| 						continue;
|5950|5950| 					if (targetClasses.avoid && cmpIdentity
|5951|5951| 						&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
|    | [NORMAL] ESLintBear (operator-linebreak):
|    | '&&' should be placed at the end of the line.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5947|5947| 					if (targetClasses.attack && cmpIdentity
|5948|5948| 						&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|5949|5949| 						continue;
|5950|    |-					if (targetClasses.avoid && cmpIdentity
|5951|    |-						&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
|    |5950|+					if (targetClasses.avoid && cmpIdentity &&
|    |5951|+						MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
|5952|5952| 						continue;
|5953|5953| 					// Only used by the AIs to prevent some choices of targets
|5954|5954| 					if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
|    | [NORMAL] ESLintBear (operator-linebreak):
|    | '&&' should be placed at the end of the line.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5970|5970| 		{
|5971|5971| 			var cmpIdentity = Engine.QueryInterface(targ, IID_Identity);
|5972|5972| 			var targetClasses = this.order.data.targetClasses;
|5973|    |-			if (cmpIdentity && targetClasses.attack
|5974|    |-				&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|    |5973|+			if (cmpIdentity && targetClasses.attack &&
|    |5974|+				!MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|5975|5975| 				continue;
|5976|5976| 			if (cmpIdentity && targetClasses.avoid
|5977|5977| 				&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
|    | [NORMAL] ESLintBear (operator-linebreak):
|    | '&&' should be placed at the end of the line.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|5973|5973| 			if (cmpIdentity && targetClasses.attack
|5974|5974| 				&& !MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.attack))
|5975|5975| 				continue;
|5976|    |-			if (cmpIdentity && targetClasses.avoid
|5977|    |-				&& MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
|    |5976|+			if (cmpIdentity && targetClasses.avoid &&
|    |5977|+				MatchesClassList(cmpIdentity.GetClassesList(), targetClasses.avoid))
|5978|5978| 				continue;
|5979|5979| 			// Only used by the AIs to prevent some choices of targets
|5980|5980| 			if (targetClasses.vetoEntities && targetClasses.vetoEntities[targ])
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required after '{'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|6126|6126| 
|6127|6127| UnitAI.prototype.SetHeldPosition = function(x, z)
|6128|6128| {
|6129|    |-	this.heldPosition = {"x": x, "z": z};
|    |6129|+	this.heldPosition = { "x": x, "z": z};
|6130|6130| };
|6131|6131| 
|6132|6132| UnitAI.prototype.SetHeldPositionOnEntity = function(entity)
|    | [NORMAL] ESLintBear (object-curly-spacing):
|    | A space is required before '}'.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|6126|6126| 
|6127|6127| UnitAI.prototype.SetHeldPosition = function(x, z)
|6128|6128| {
|6129|    |-	this.heldPosition = {"x": x, "z": z};
|    |6129|+	this.heldPosition = {"x": x, "z": z };
|6130|6130| };
|6131|6131| 
|6132|6132| UnitAI.prototype.SetHeldPositionOnEntity = function(entity)
|    | [NORMAL] ESLintBear (spaced-comment):
|    | Expected space or tab after '//' in comment.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|6153|6153| 	return false;
|6154|6154| };
|6155|6155| 
|6156|    |-//// Helper functions ////
|    |6156|+// // Helper functions ////
|6157|6157| 
|6158|6158| /**
|6159|6159|  * General getter for ranges.
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|6172|6172| 		return undefined;
|6173|6173| 
|6174|6174| 	return component.GetRange(type);
|6175|    |-}
|    |6175|+};
|6176|6176| 
|6177|6177| UnitAI.prototype.CanAttack = function(target)
|6178|6178| {
|    | [NORMAL] ESLintBear (spaced-comment):
|    | Expected space or tab after '//' in comment.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|6348|6348| 	return cmpPack && cmpPack.IsPacking();
|6349|6349| };
|6350|6350| 
|6351|    |-//// Formation specific functions ////
|    |6351|+// // Formation specific functions ////
|6352|6352| 
|6353|6353| UnitAI.prototype.IsAttackingAsFormation = function()
|6354|6354| {
|    | [NORMAL] ESLintBear (operator-linebreak):
|    | '&&' should be placed at the end of the line.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|6353|6353| UnitAI.prototype.IsAttackingAsFormation = function()
|6354|6354| {
|6355|6355| 	var cmpAttack = Engine.QueryInterface(this.entity, IID_Attack);
|6356|    |-	return cmpAttack && cmpAttack.CanAttackAsFormation()
|6357|    |-		&& this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";
|    |6356|+	return cmpAttack && cmpAttack.CanAttackAsFormation() &&
|    |6357|+		this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";
|6358|6358| };
|6359|6359| 
|6360|6360| //// Animal specific functions ////
|    | [NORMAL] ESLintBear (spaced-comment):
|    | Expected space or tab after '//' in comment.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|6357|6357| 		&& this.GetCurrentState() == "FORMATIONCONTROLLER.COMBAT.ATTACKING";
|6358|6358| };
|6359|6359| 
|6360|    |-//// Animal specific functions ////
|    |6360|+// // Animal specific functions ////
|6361|6361| 
|6362|6362| UnitAI.prototype.MoveRandomly = function(distance)
|6363|6363| {
|    | [NORMAL] ESLintBear (semi):
|    | Missing semicolon.
|----|    | /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|    |++++| /zpool0/trunk/binaries/data/mods/public/simulation/components/UnitAI.js
|6408|6408| {
|6409|6409| 	let cmpUnitMotion = Engine.QueryInterface(this.entity, IID_UnitMotion);
|6410|6410| 	return cmpUnitMotion && cmpUnitMotion.GetFacePointAfterMove();
|6411|    |-}
|    |6411|+};
|6412|6412| 
|6413|6413| UnitAI.prototype.AttackEntitiesByPreference = function(ents)
|6414|6414| {

binaries/data/mods/public/simulation/components/UnitAI.js
| 349| »   »   »   return·true;
|    | [NORMAL] ESLintBear (consistent-return):
|    | Method 'Order.WalkToTarget' expected no return value.

binaries/data/mods/public/simulation/components/UnitAI.js
|4054| »   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
|4973| »   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
|4988| »   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
|5054| »   let·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
|5077| »   »   ····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
|2068| »   »   »   »   »   »   &&·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
|3148| »   »   »   »   »   this.SetAnimationVariant(this.formationAnimationVariant)
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/components/UnitAI.js
|4001| »   »   var·order·=·{·"type":·type,·"data":·data·};
|    | [NORMAL] JSHintBear:
|    | 'order' is already defined.

binaries/data/mods/public/simulation/components/UnitAI.js
|4085| »   for·(var·i·=·0;·i·<·this.orderQueue.length;·++i)
|    | [NORMAL] JSHintBear:
|    | 'i' is already defined.

binaries/data/mods/public/simulation/components/UnitAI.js
|4990| »   »   &&·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
|4991| »   »   &&·(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
|5619| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/components/UnitAI.js
|5948| »   »   »   »   »   »   &&·!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
|5951| »   »   »   »   »   »   &&·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
|5964| »   var·targets·=·this.GetTargetsFromUnit();
|    | [NORMAL] JSHintBear:
|    | 'targets' is already defined.

binaries/data/mods/public/simulation/components/UnitAI.js
|5965| »   for·(var·targ·of·targets)
|    | [NORMAL] JSHintBear:
|    | 'targ' is already defined.

binaries/data/mods/public/simulation/components/UnitAI.js
|5971| »   »   »   var·cmpIdentity·=·Engine.QueryInterface(targ,·IID_Identity);
|    | [NORMAL] JSHintBear:
|    | 'cmpIdentity' is already defined.

binaries/data/mods/public/simulation/components/UnitAI.js
|5972| »   »   »   var·targetClasses·=·this.order.data.targetClasses;
|    | [NORMAL] JSHintBear:
|    | 'targetClasses' is already defined.

binaries/data/mods/public/simulation/components/UnitAI.js
|5974| »   »   »   »   &&·!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
|5977| »   »   »   »   &&·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
|6175| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.

binaries/data/mods/public/simulation/components/UnitAI.js
|6357| »   »   &&·this.GetCurrentState()·==·"FORMATIONCONTROLLER.COMBAT.ATTACKING";
|    | [NORMAL] JSHintBear:
|    | Misleading line break before '&&'; readers may interpret this as an expression boundary.

binaries/data/mods/public/simulation/components/UnitAI.js
|6411| }
|    | [NORMAL] JSHintBear:
|    | Missing semicolon.
Executing section cli...

Link to build: https://jenkins.wildfiregames.com/job/docker-differential/2818/display/redirect

1. Without position unit is not in game. Just cant happen so aborting state is ok.
2. We do nothing with original unit when we promote it, so it ends out of world, but it finishes order in unitai and since FSM keeps swtiching states while they are called from enter, we got unit to infinite loop.

Notice gather ordered given are not queued nor pushed so they are processed inside current state.

// If func called SetNextState then switch into the new state,
// and continue switching if the new state's 'enter' called SetNextState again

I am accepting this as fixing the issue, but one should check another states affected by moving promoted unit out of world or one should ensure promoted unit gets deleted all orders and is moved to some trash state.

Rebased & fix compilation errors.

Successful build - Chance fights ever on the side of the prudent.

Broken attempt @wraitii can you help me

In that case, I think this is the best we can do for now.

In D148#125904, @wraitii wrote:

I have one alternate proposition:

• How about you make the FPS counter have a completely transparent background (doesn't matter too much if it's not seen)?
• The in-game time counter could be made a "first-class citizen", since it's specific to in-game.

Then you wouldn't have to hack with the order of things.

Hmm, not that happy about this solution.
With a fully transparent background the white font gets unreadable in some situations. (e.g. main menu)

Will rebase after SM52

You're missing the case where the user-autocompletes a pseudo, or any JS modifying "caption" in fact. You probably need to add a final check in UpdateText() or in HandleMessage.

Build failure - The Moirai have given mortals hearts that can endure.

Build failure - The Moirai have given mortals hearts that can endure.

Build failure - The Moirai have given mortals hearts that can endure.

Much bigger diff.
I went the way of creating a general algorithm for "data file inclusion", which is intended to replace the "transformation" aspect of ParamNode.

Thanks for the fair warning, and the time you took to express it :)

Successful build - Chance fights ever on the side of the prudent.

Include D2691 This way it's sure it won't be forgotten.

Successful build - Chance fights ever on the side of the prudent.

Fix Unix* builds

Successful build - Chance fights ever on the side of the prudent.

Apply my inline comments.

Successful build - Chance fights ever on the side of the prudent.

Much simpler solution, thanks to elexis;

Successful build - Chance fights ever on the side of the prudent.

Rebase

Successful build - Chance fights ever on the side of the prudent.

Successful build - Chance fights ever on the side of the prudent.

Successful build - Chance fights ever on the side of the prudent.

The jenkins error is spurious -> checkrefs passes locally and the map works and has the correct header.

At the moment I don't think we plan on stopping citizen soldiers from being soldiers, so that's a likely no for now.

If you make women build everything, even military buildings and fortresses and stuff, then you should go the DE route and change "Female Citizens" to just Citizens (male and female) using the phenotype system.

Rebased, will commit once lights are green

Build failure - The Moirai have given mortals hearts that can endure.

Build failure - The Moirai have given mortals hearts that can endure.

Build failure - The Moirai have given mortals hearts that can endure.

Build failure - The Moirai have given mortals hearts that can endure.

Build failure - The Moirai have given mortals hearts that can endure.

I agree that these techs make no sense and removing them seems good.

Rebased.

@borg- Did you test this?

In D2852#126596, @borg- wrote:

I'm trying to update the patch but I'm not getting it, am I doing something wrong?

Should compile like this, went a bit overboard with the headers :p .

Build was aborted.

Reupload to try and fix the map... Not sure what's going on there :p

Build failure - The Moirai have given mortals hearts that can endure.

Build failure - The Moirai have given mortals hearts that can endure.

Thanks again for the hard work and keeping up with this :) It's a great addition.

Quick tweaks before merging.

New behavior seems better as the message is correct and the game actually exits anyway even if you press continue

Successful build - Chance fights ever on the side of the prudent.

In D2921#126612, @Stan wrote:

Not sure why you changed the last file.

I removed the unused variable for more clear comparison of ARB and GLSL shaders.

Works fine for me in release and debug, Not sure why you changed the last file. ARB and GLSL show no difference.

Successful build - Chance fights ever on the side of the prudent.

Fixed minor style issues

Thanks again for the great work ?

• Keep <BuildTime>80</BuildTime> <Resources> <wood>225</wood> </Resources>
• Research time 30 --> 40.

In D2852#126548, @Nescio wrote:

Yes. Feel free to update the patch, like I did, or if you intend to make further changes, consider commandeering it.
I actually dislike this patch, but if others really think it's an improvement, I have no real objections, worker elephants are not that important.

Build failure - The Moirai have given mortals hearts that can endure.

Fixed seg fault due to user exiting the game from the UI when the script is using it, too.