Index: ps/trunk/binaries/data/mods/public/simulation/components/Attack.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Attack.js	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Attack.js	(revision 24751)
@@ -1,664 +1,666 @@
 function Attack() {}
 
 var g_AttackTypes = ["Melee", "Ranged", "Capture"];
 
 Attack.prototype.preferredClassesSchema =
 	"<optional>" +
 		"<element name='PreferredClasses' a:help='Space delimited list of classes preferred for attacking. If an entity has any of theses classes, it is preferred. The classes are in decending order of preference'>" +
 			"<attribute name='datatype'>" +
 				"<value>tokens</value>" +
 			"</attribute>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>";
 
 Attack.prototype.restrictedClassesSchema =
 	"<optional>" +
 		"<element name='RestrictedClasses' a:help='Space delimited list of classes that cannot be attacked by this entity. If target entity has any of these classes, it cannot be attacked'>" +
 			"<attribute name='datatype'>" +
 				"<value>tokens</value>" +
 			"</attribute>" +
 			"<text/>" +
 		"</element>" +
 	"</optional>";
 
 Attack.prototype.Schema =
 	"<a:help>Controls the attack abilities and strengths of the unit.</a:help>" +
 	"<a:example>" +
 		"<Melee>" +
 			"<AttackName>Spear</AttackName>" +
 			"<Damage>" +
 				"<Hack>10.0</Hack>" +
 				"<Pierce>0.0</Pierce>" +
 				"<Crush>5.0</Crush>" +
 			"</Damage>" +
 			"<MaxRange>4.0</MaxRange>" +
 			"<RepeatTime>1000</RepeatTime>" +
 			"<Bonuses>" +
 				"<Bonus1>" +
 					"<Civ>pers</Civ>" +
 					"<Classes>Infantry</Classes>" +
 					"<Multiplier>1.5</Multiplier>" +
 				"</Bonus1>" +
 				"<BonusCavMelee>" +
 					"<Classes>Cavalry Melee</Classes>" +
 					"<Multiplier>1.5</Multiplier>" +
 				"</BonusCavMelee>" +
 			"</Bonuses>" +
 			"<RestrictedClasses datatype=\"tokens\">Champion</RestrictedClasses>" +
 			"<PreferredClasses datatype=\"tokens\">Cavalry Infantry</PreferredClasses>" +
 		"</Melee>" +
 		"<Ranged>" +
 			"<AttackName>Bow</AttackName>" +
 			"<Damage>" +
 				"<Hack>0.0</Hack>" +
 				"<Pierce>10.0</Pierce>" +
 				"<Crush>0.0</Crush>" +
 			"</Damage>" +
 			"<MaxRange>44.0</MaxRange>" +
 			"<MinRange>20.0</MinRange>" +
 			"<ElevationBonus>15.0</ElevationBonus>" +
 			"<PrepareTime>800</PrepareTime>" +
 			"<RepeatTime>1600</RepeatTime>" +
 			"<Delay>1000</Delay>" +
 			"<Bonuses>" +
 				"<Bonus1>" +
 					"<Classes>Cavalry</Classes>" +
 					"<Multiplier>2</Multiplier>" +
 				"</Bonus1>" +
 			"</Bonuses>" +
 			"<Projectile>" +
 				"<Speed>50.0</Speed>" +
 				"<Spread>2.5</Spread>" +
 				"<ActorName>props/units/weapons/rock_flaming.xml</ActorName>" +
 				"<ImpactActorName>props/units/weapons/rock_explosion.xml</ImpactActorName>" +
 				"<ImpactAnimationLifetime>0.1</ImpactAnimationLifetime>" +
 				"<FriendlyFire>false</FriendlyFire>" +
 			"</Projectile>" +
 			"<RestrictedClasses datatype=\"tokens\">Champion</RestrictedClasses>" +
 			"<Splash>" +
 				"<Shape>Circular</Shape>" +
 				"<Range>20</Range>" +
 				"<FriendlyFire>false</FriendlyFire>" +
 				"<Damage>" +
 					"<Hack>0.0</Hack>" +
 					"<Pierce>10.0</Pierce>" +
 					"<Crush>0.0</Crush>" +
 				"</Damage>" +
 			"</Splash>" +
 		"</Ranged>" +
 		"<Slaughter>" +
 			"<Damage>" +
 				"<Hack>1000.0</Hack>" +
 				"<Pierce>0.0</Pierce>" +
 				"<Crush>0.0</Crush>" +
 			"</Damage>" +
 			"<MaxRange>4.0</MaxRange>" +
 		"</Slaughter>" +
 	"</a:example>" +
 	"<optional>" +
 		"<element name='Melee'>" +
 			"<interleave>" +
 				"<element name='AttackName' a:help='Name of the attack, to be displayed in the GUI. Optionally includes a translate context attribute.'>" +
 					"<optional>" +
 						"<attribute name='context'>" +
 							"<text/>" +
 						"</attribute>" +
 					"</optional>" +
 					"<text/>" +
 				"</element>" +
 				Attacking.BuildAttackEffectsSchema() +
 				"<element name='MaxRange' a:help='Maximum attack range (in metres)'><ref name='nonNegativeDecimal'/></element>" +
 				"<element name='PrepareTime' a:help='Time from the start of the attack command until the attack actually occurs (in milliseconds). This value relative to RepeatTime should closely match the \"event\" point in the actor&apos;s attack animation'>" +
 					"<data type='nonNegativeInteger'/>" +
 				"</element>" +
 				"<element name='RepeatTime' a:help='Time between attacks (in milliseconds). The attack animation will be stretched to match this time'>" + // TODO: it shouldn't be stretched
 					"<data type='positiveInteger'/>" +
 				"</element>" +
 				Attack.prototype.preferredClassesSchema +
 				Attack.prototype.restrictedClassesSchema +
 			"</interleave>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Ranged'>" +
 			"<interleave>" +
 				"<element name='AttackName' a:help='Name of the attack, to be displayed in the GUI. Optionally includes a translate context attribute.'>" +
 					"<optional>" +
 						"<attribute name='context'>" +
 							"<text/>" +
 						"</attribute>" +
 					"</optional>" +
 					"<text/>" +
 				"</element>" +
 				Attacking.BuildAttackEffectsSchema() +
 				"<element name='MaxRange' a:help='Maximum attack range (in metres)'><ref name='nonNegativeDecimal'/></element>" +
 				"<element name='MinRange' a:help='Minimum attack range (in metres)'><ref name='nonNegativeDecimal'/></element>" +
 				"<optional>"+
 					"<element name='ElevationBonus' a:help='give an elevation advantage (in meters)'><ref name='nonNegativeDecimal'/></element>" +
 				"</optional>" +
 				"<optional>" +
 					"<element name='RangeOverlay'>" +
 						"<interleave>" +
 							"<element name='LineTexture'><text/></element>" +
 							"<element name='LineTextureMask'><text/></element>" +
 							"<element name='LineThickness'><ref name='nonNegativeDecimal'/></element>" +
 						"</interleave>" +
 					"</element>" +
 				"</optional>" +
 				"<element name='PrepareTime' a:help='Time from the start of the attack command until the attack actually occurs (in milliseconds). This value relative to RepeatTime should closely match the \"event\" point in the actor&apos;s attack animation'>" +
 					"<data type='nonNegativeInteger'/>" +
 				"</element>" +
 				"<element name='RepeatTime' a:help='Time between attacks (in milliseconds). The attack animation will be stretched to match this time'>" +
 					"<data type='positiveInteger'/>" +
 				"</element>" +
 				"<element name='Delay' a:help='Delay of the damage in milliseconds'><ref name='nonNegativeDecimal'/></element>" +
 				"<optional>" +
 					"<element name='Splash'>" +
 						"<interleave>" +
 							"<element name='Shape' a:help='Shape of the splash damage, can be circular or linear'><text/></element>" +
 							"<element name='Range' a:help='Size of the area affected by the splash'><ref name='nonNegativeDecimal'/></element>" +
 							"<element name='FriendlyFire' a:help='Whether the splash damage can hurt non enemy units'><data type='boolean'/></element>" +
 							Attacking.BuildAttackEffectsSchema() +
 						"</interleave>" +
 					"</element>" +
 				"</optional>" +
 				"<element name='Projectile'>" +
 					"<interleave>" +
 						"<element name='Speed' a:help='Speed of projectiles (in meters per second).'>" +
 							"<ref name='positiveDecimal'/>" +
 						"</element>" +
 						"<element name='Spread' a:help='Standard deviation of the bivariate normal distribution of hits at 100 meters. A disk at 100 meters from the attacker with this radius (2x this radius, 3x this radius) is expected to include the landing points of 39.3% (86.5%, 98.9%) of the rounds.'><ref name='nonNegativeDecimal'/></element>" +
 						"<element name='Gravity' a:help='The gravity affecting the projectile. This affects the shape of the flight curve.'>" +
 							"<ref name='nonNegativeDecimal'/>" +
 						"</element>" +
 						"<element name='FriendlyFire' a:help='Whether stray missiles can hurt non enemy units.'><data type='boolean'/></element>" +
 						"<optional>" +
 							"<element name='LaunchPoint' a:help='Delta from the unit position where to launch the projectile.'>" +
 								"<attribute name='y'>" +
 									"<data type='decimal'/>" +
 								"</attribute>" +
 							"</element>" +
 						"</optional>" +
 						"<optional>" +
 							"<element name='ActorName' a:help='actor of the projectile animation.'>" +
 								"<text/>" +
 							"</element>" +
 						"</optional>" +
 						"<optional>" +
 							"<element name='ImpactActorName' a:help='actor of the projectile impact animation'>" +
 								"<text/>" +
 							"</element>" +
 							"<element name='ImpactAnimationLifetime' a:help='length of the projectile impact animation.'>" +
 								"<ref name='positiveDecimal'/>" +
 							"</element>" +
 						"</optional>" +
 					"</interleave>" +
 				"</element>" +
 				Attack.prototype.preferredClassesSchema +
 				Attack.prototype.restrictedClassesSchema +
 			"</interleave>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Capture'>" +
 			"<interleave>" +
 				"<element name='AttackName' a:help='Name of the attack, to be displayed in the GUI. Optionally includes a translate context attribute.'>" +
 					"<optional>" +
 						"<attribute name='context'>" +
 							"<text/>" +
 						"</attribute>" +
 					"</optional>" +
 					"<text/>" +
 				"</element>" +
 				Attacking.BuildAttackEffectsSchema() +
 				"<element name='MaxRange' a:help='Maximum attack range (in meters)'><ref name='nonNegativeDecimal'/></element>" +
 				"<element name='RepeatTime' a:help='Time between attacks (in milliseconds). The attack animation will be stretched to match this time'>" + // TODO: it shouldn't be stretched
 					"<data type='positiveInteger'/>" +
 				"</element>" +
 				Attack.prototype.preferredClassesSchema +
 				Attack.prototype.restrictedClassesSchema +
 			"</interleave>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Slaughter' a:help='A special attack to kill domestic animals'>" +
 			"<interleave>" +
 				"<element name='AttackName' a:help='Name of the attack, to be displayed in the GUI. Optionally includes a translate context attribute.'>" +
 					"<optional>" +
 						"<attribute name='context'>" +
 							"<text/>" +
 						"</attribute>" +
 					"</optional>" +
 					"<text/>" +
 				"</element>" +
 				Attacking.BuildAttackEffectsSchema() +
 				"<element name='MaxRange'><ref name='nonNegativeDecimal'/></element>" + // TODO: how do these work?
 				Attack.prototype.preferredClassesSchema +
 				Attack.prototype.restrictedClassesSchema +
 			"</interleave>" +
 		"</element>" +
 	"</optional>";
 
 Attack.prototype.Init = function()
 {
 };
 
 Attack.prototype.Serialize = null; // we have no dynamic state to save
 
 Attack.prototype.GetAttackTypes = function(wantedTypes)
 {
 	let types = g_AttackTypes.filter(type => !!this.template[type]);
 	if (!wantedTypes)
 		return types;
 
 	let wantedTypesReal = wantedTypes.filter(wtype => wtype.indexOf("!") != 0);
 	return types.filter(type => wantedTypes.indexOf("!" + type) == -1 &&
 	      (!wantedTypesReal || !wantedTypesReal.length || wantedTypesReal.indexOf(type) != -1));
 };
 
 Attack.prototype.GetPreferredClasses = function(type)
 {
 	if (this.template[type] && this.template[type].PreferredClasses &&
 	    this.template[type].PreferredClasses._string)
 		return this.template[type].PreferredClasses._string.split(/\s+/);
 
 	return [];
 };
 
 Attack.prototype.GetRestrictedClasses = function(type)
 {
 	if (this.template[type] && this.template[type].RestrictedClasses &&
 	    this.template[type].RestrictedClasses._string)
 		return this.template[type].RestrictedClasses._string.split(/\s+/);
 
 	return [];
 };
 
 Attack.prototype.CanAttack = function(target, wantedTypes)
 {
 	let cmpFormation = Engine.QueryInterface(target, IID_Formation);
 	if (cmpFormation)
 		return true;
 
 	let cmpThisPosition = Engine.QueryInterface(this.entity, IID_Position);
 	let cmpTargetPosition = Engine.QueryInterface(target, IID_Position);
 	if (!cmpThisPosition || !cmpTargetPosition || !cmpThisPosition.IsInWorld() || !cmpTargetPosition.IsInWorld())
 		return false;
 
 	let cmpIdentity = QueryMiragedInterface(target, IID_Identity);
 	if (!cmpIdentity)
 		return false;
 
 	let cmpHealth = QueryMiragedInterface(target, IID_Health);
 	let targetClasses = cmpIdentity.GetClassesList();
 	if (targetClasses.indexOf("Domestic") != -1 && this.template.Slaughter && cmpHealth && cmpHealth.GetHitpoints() &&
 	   (!wantedTypes || !wantedTypes.filter(wType => wType.indexOf("!") != 0).length))
 		return true;
 
 	let cmpEntityPlayer = QueryOwnerInterface(this.entity);
 	let cmpTargetPlayer = QueryOwnerInterface(target);
 	if (!cmpTargetPlayer || !cmpEntityPlayer)
 		return false;
 
 	let types = this.GetAttackTypes(wantedTypes);
 	let entityOwner = cmpEntityPlayer.GetPlayerID();
 	let targetOwner = cmpTargetPlayer.GetPlayerID();
 	let cmpCapturable = QueryMiragedInterface(target, IID_Capturable);
 
 	// Check if the relative height difference is larger than the attack range
 	// If the relative height is bigger, it means they will never be able to
 	// reach each other, no matter how close they come.
 	let heightDiff = Math.abs(cmpThisPosition.GetHeightOffset() - cmpTargetPosition.GetHeightOffset());
 
 	for (let type of types)
 	{
 		if (type != "Capture" && (!cmpEntityPlayer.IsEnemy(targetOwner) || !cmpHealth || !cmpHealth.GetHitpoints()))
 			continue;
 
 		if (type == "Capture" && (!cmpCapturable || !cmpCapturable.CanCapture(entityOwner)))
 			continue;
 
 		if (heightDiff > this.GetRange(type).max)
 			continue;
 
 		let restrictedClasses = this.GetRestrictedClasses(type);
 		if (!restrictedClasses.length)
 			return true;
 
 		if (!MatchesClassList(targetClasses, restrictedClasses))
 			return true;
 	}
 
 	return false;
 };
 
 /**
  * Returns null if we have no preference or the lowest index of a preferred class.
  */
 Attack.prototype.GetPreference = function(target)
 {
 	let cmpIdentity = Engine.QueryInterface(target, IID_Identity);
 	if (!cmpIdentity)
 		return undefined;
 
 	let targetClasses = cmpIdentity.GetClassesList();
 
 	let minPref = null;
 	for (let type of this.GetAttackTypes())
 	{
 		let preferredClasses = this.GetPreferredClasses(type);
-		for (let targetClass of targetClasses)
+		for (let pref = 0; pref < preferredClasses.length; ++pref)
 		{
-			let pref = preferredClasses.indexOf(targetClass);
-			if (pref === 0)
-				return pref;
-			if (pref != -1 && (minPref === null || minPref > pref))
-				minPref = pref;
+			if (MatchesClassList(targetClasses, preferredClasses[pref]))
+			{
+				if (pref === 0)
+					return pref;
+				if ((minPref === null || minPref > pref))
+					minPref = pref;
+			}
 		}
 	}
 	return minPref;
 };
 
 /**
  * Get the full range of attack using all available attack types.
  */
 Attack.prototype.GetFullAttackRange = function()
 {
 	let ret = { "min": Infinity, "max": 0 };
 	for (let type of this.GetAttackTypes())
 	{
 		let range = this.GetRange(type);
 		ret.min = Math.min(ret.min, range.min);
 		ret.max = Math.max(ret.max, range.max);
 	}
 	return ret;
 };
 
 Attack.prototype.GetAttackEffectsData = function(type, splash)
 {
 	let template = this.template[type];
 	if (splash)
 		template = template.Splash;
 	return Attacking.GetAttackEffectsData("Attack/" + type + (splash ? "/Splash" : ""), template, this.entity);
 };
 
 /**
  * Find the best attack against a target.
  * @param {number} target - The entity-ID of the target.
  * @param {boolean} allowCapture - Whether capturing is allowed.
  * @return {string} - The preferred attack type.
  */
 Attack.prototype.GetBestAttackAgainst = function(target, allowCapture)
 {
 	let cmpFormation = Engine.QueryInterface(target, IID_Formation);
 	if (cmpFormation)
 	{
 		// TODO: Formation against formation needs review
 		let types = this.GetAttackTypes();
 		return g_AttackTypes.find(attack => types.indexOf(attack) != -1);
 	}
 
 	let cmpIdentity = Engine.QueryInterface(target, IID_Identity);
 	if (!cmpIdentity)
 		return undefined;
 
 	// Always slaughter domestic animals instead of using a normal attack
 	if (this.template.Slaughter && cmpIdentity.HasClass("Domestic"))
 		return "Slaughter";
 
 	let types = this.GetAttackTypes().filter(type => this.CanAttack(target, [type]));
 
 	// Check whether the target is capturable and prefer that when it is allowed.
 	let captureIndex = types.indexOf("Capture");
 	if (captureIndex != -1)
 	{
 		if (allowCapture)
 			return "Capture";
 		types.splice(captureIndex, 1);
 	}
 
 	let targetClasses = cmpIdentity.GetClassesList();
 	let isPreferred = attackType => MatchesClassList(targetClasses, this.GetPreferredClasses(attackType));
 
 	return types.sort((a, b) =>
 		(types.indexOf(a) + (isPreferred(a) ? types.length : 0)) -
 		(types.indexOf(b) + (isPreferred(b) ? types.length : 0))).pop();
 };
 
 Attack.prototype.CompareEntitiesByPreference = function(a, b)
 {
 	let aPreference = this.GetPreference(a);
 	let bPreference = this.GetPreference(b);
 
 	if (aPreference === null && bPreference === null) return 0;
 	if (aPreference === null) return 1;
 	if (bPreference === null) return -1;
 	return aPreference - bPreference;
 };
 
 Attack.prototype.GetAttackName = function(type)
 {
 	return {
 		"name": this.template[type].AttackName._string || this.template[type].AttackName,
 		"context": this.template[type].AttackName["@context"]
 	};
 };
 
 Attack.prototype.GetRepeatTime = function(type)
 {
 	let repeatTime = 1000;
 
 	if (this.template[type] && this.template[type].RepeatTime)
 		repeatTime = +this.template[type].RepeatTime;
 
 	return ApplyValueModificationsToEntity("Attack/" + type + "/RepeatTime", repeatTime, this.entity);
 };
 
 Attack.prototype.GetTimers = function(type)
 {
 	return {
 		"prepare": ApplyValueModificationsToEntity("Attack/" + type + "/PrepareTime", +(this.template[type].PrepareTime || 0), this.entity),
 		"repeat": this.GetRepeatTime(type)
 	};
 };
 
 Attack.prototype.GetSplashData = function(type)
 {
 	if (!this.template[type].Splash)
 		return undefined;
 
 	return {
 		"attackData": this.GetAttackEffectsData(type, true),
 		"friendlyFire": this.template[type].Splash.FriendlyFire == "true",
 		"radius": ApplyValueModificationsToEntity("Attack/" + type + "/Splash/Range", +this.template[type].Splash.Range, this.entity),
 		"shape": this.template[type].Splash.Shape,
 	};
 };
 
 Attack.prototype.GetRange = function(type)
 {
 	if (!type)
 		return this.GetFullAttackRange();
 
 	let max = +this.template[type].MaxRange;
 	max = ApplyValueModificationsToEntity("Attack/" + type + "/MaxRange", max, this.entity);
 
 	let min = +(this.template[type].MinRange || 0);
 	min = ApplyValueModificationsToEntity("Attack/" + type + "/MinRange", min, this.entity);
 
 	let elevationBonus = +(this.template[type].ElevationBonus || 0);
 	elevationBonus = ApplyValueModificationsToEntity("Attack/" + type + "/ElevationBonus", elevationBonus, this.entity);
 
 	return { "max": max, "min": min, "elevationBonus": elevationBonus };
 };
 
 /**
  * Attack the target entity. This should only be called after a successful range check,
  * and should only be called after GetTimers().repeat msec has passed since the last
  * call to PerformAttack.
  */
 Attack.prototype.PerformAttack = function(type, target)
 {
 	let attackerOwner = Engine.QueryInterface(this.entity, IID_Ownership).GetOwner();
 
 	// If this is a ranged attack, then launch a projectile
 	if (type == "Ranged")
 	{
 		let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 		let turnLength = cmpTimer.GetLatestTurnLength()/1000;
 		// In the future this could be extended:
 		//  * Obstacles like trees could reduce the probability of the target being hit
 		//  * Obstacles like walls should block projectiles entirely
 
 		let horizSpeed = +this.template[type].Projectile.Speed;
 		let gravity = +this.template[type].Projectile.Gravity;
 		// horizSpeed /= 2; gravity /= 2; // slow it down for testing
 
 		// We will try to estimate the position of the target, where we can hit it.
 		// We first estimate the time-till-hit by extrapolating linearly the movement
 		// of the last turn. We compute the time till an arrow will intersect the target.
 		let cmpPosition = Engine.QueryInterface(this.entity, IID_Position);
 		if (!cmpPosition || !cmpPosition.IsInWorld())
 			return;
 		let selfPosition = cmpPosition.GetPosition();
 		let cmpTargetPosition = Engine.QueryInterface(target, IID_Position);
 		if (!cmpTargetPosition || !cmpTargetPosition.IsInWorld())
 			return;
 		let targetPosition = cmpTargetPosition.GetPosition();
 
 		let targetVelocity = Vector3D.sub(targetPosition, cmpTargetPosition.GetPreviousPosition()).div(turnLength);
 
 		let timeToTarget = PositionHelper.PredictTimeToTarget(selfPosition, horizSpeed, targetPosition, targetVelocity);
 
 		// 'Cheat' and use UnitMotion to predict the position in the near-future.
 		// This avoids 'dancing' issues with units zigzagging over very short distances.
 		// However, this could fail if the player gives several short move orders, so
 		// occasionally fall back to basic interpolation.
 		let predictedPosition = targetPosition;
 		if (timeToTarget !== false)
 		{
 			// Don't predict too far in the future, but avoid threshold effects.
 			// After 1 second, always use the 'dumb' interpolated past-motion prediction.
 			let useUnitMotion = randBool(Math.max(0, 0.75 - timeToTarget / 1.333));
 			if (useUnitMotion)
 			{
 				let cmpTargetUnitMotion = Engine.QueryInterface(target, IID_UnitMotion);
 				let cmpTargetUnitAI = Engine.QueryInterface(target, IID_UnitAI);
 				if (cmpTargetUnitMotion && (!cmpTargetUnitAI || !cmpTargetUnitAI.IsFormationMember()))
 				{
 					let pos2D = cmpTargetUnitMotion.EstimateFuturePosition(timeToTarget);
 					predictedPosition.x = pos2D.x;
 					predictedPosition.z = pos2D.y;
 				}
 				else
 					predictedPosition = Vector3D.mult(targetVelocity, timeToTarget).add(targetPosition);
 			}
 			else
 				predictedPosition = Vector3D.mult(targetVelocity, timeToTarget).add(targetPosition);
 		}
 
 		// Add inaccuracy based on spread.
 		let distanceModifiedSpread = ApplyValueModificationsToEntity("Attack/Ranged/Spread", +this.template[type].Projectile.Spread, this.entity) *
 			predictedPosition.horizDistanceTo(selfPosition) / 100;
 
 		let randNorm = randomNormal2D();
 		let offsetX = randNorm[0] * distanceModifiedSpread;
 		let offsetZ = randNorm[1] * distanceModifiedSpread;
 
 		let realTargetPosition = new Vector3D(predictedPosition.x + offsetX, targetPosition.y, predictedPosition.z + offsetZ);
 
 		// Recalculate when the missile will hit the target position.
 		let realHorizDistance = realTargetPosition.horizDistanceTo(selfPosition);
 		timeToTarget = realHorizDistance / horizSpeed;
 
 		let missileDirection = Vector3D.sub(realTargetPosition, selfPosition).div(realHorizDistance);
 
 		// Launch the graphical projectile.
 		let cmpProjectileManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ProjectileManager);
 
 		let actorName = "";
 		let impactActorName = "";
 		let impactAnimationLifetime = 0;
 
 		actorName = this.template[type].Projectile.ActorName || "";
 		impactActorName = this.template[type].Projectile.ImpactActorName || "";
 		impactAnimationLifetime = this.template[type].Projectile.ImpactAnimationLifetime || 0;
 
 		// TODO: Use unit rotation to implement x/z offsets.
 		let deltaLaunchPoint = new Vector3D(0, +this.template[type].Projectile.LaunchPoint["@y"], 0);
 		let launchPoint = Vector3D.add(selfPosition, deltaLaunchPoint);
 
 		let cmpVisual = Engine.QueryInterface(this.entity, IID_Visual);
 		if (cmpVisual)
 		{
 			// if the projectile definition is missing from the template
 			// then fallback to the projectile name and launchpoint in the visual actor
 			if (!actorName)
 				actorName = cmpVisual.GetProjectileActor();
 
 			let visualActorLaunchPoint = cmpVisual.GetProjectileLaunchPoint();
 			if (visualActorLaunchPoint.length() > 0)
 				launchPoint = visualActorLaunchPoint;
 		}
 
 		let id = cmpProjectileManager.LaunchProjectileAtPoint(launchPoint, realTargetPosition, horizSpeed, gravity, actorName, impactActorName, impactAnimationLifetime);
 
 		let attackImpactSound = "";
 		let cmpSound = Engine.QueryInterface(this.entity, IID_Sound);
 		if (cmpSound)
 			attackImpactSound = cmpSound.GetSoundGroup("attack_impact_" + type.toLowerCase());
 
 		let data = {
 			"type": type,
 			"attackData": this.GetAttackEffectsData(type),
 			"target": target,
 			"attacker": this.entity,
 			"attackerOwner": attackerOwner,
 			"position": realTargetPosition,
 			"direction": missileDirection,
 			"projectileId": id,
 			"attackImpactSound": attackImpactSound,
 			"splash": this.GetSplashData(type),
 			"friendlyFire": this.template[type].Projectile.FriendlyFire == "true",
 		};
 
 		cmpTimer.SetTimeout(SYSTEM_ENTITY, IID_DelayedDamage, "MissileHit", +this.template[type].Delay + timeToTarget * 1000, data);
 	}
 	else
 		Attacking.HandleAttackEffects(target, type, this.GetAttackEffectsData(type), this.entity, attackerOwner);
 };
 
 Attack.prototype.OnValueModification = function(msg)
 {
 	if (msg.component != "Attack")
 		return;
 
 	let cmpUnitAI = Engine.QueryInterface(this.entity, IID_UnitAI);
 	if (!cmpUnitAI)
 		return;
 
 	if (this.GetAttackTypes().some(type =>
 	      msg.valueNames.indexOf("Attack/" + type + "/MaxRange") != -1))
 		cmpUnitAI.UpdateRangeQueries();
 };
 
 Attack.prototype.GetRangeOverlays = function()
 {
 	if (!this.template.Ranged || !this.template.Ranged.RangeOverlay)
 		return [];
 
 	let range = this.GetRange("Ranged");
 	let rangeOverlays = [];
 	for (let i in range)
 		if ((i == "min" || i == "max") && range[i])
 			rangeOverlays.push({
 				"radius": range[i],
 				"texture": this.template.Ranged.RangeOverlay.LineTexture,
 				"textureMask": this.template.Ranged.RangeOverlay.LineTextureMask,
 				"thickness": +this.template.Ranged.RangeOverlay.LineThickness,
 			});
 	return rangeOverlays;
 };
 
 Engine.RegisterComponentType(IID_Attack, "Attack", Attack);
Index: ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Attack.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Attack.js	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Attack.js	(revision 24751)
@@ -1,359 +1,403 @@
 AttackEffects = class AttackEffects
 {
 	constructor() {}
 	Receivers()
 	{
 		return [{
 			"type": "Damage",
 			"IID": "IID_Health",
 			"method": "TakeDamage"
 		},
 		{
 			"type": "Capture",
 			"IID": "IID_Capturable",
 			"method": "Capture"
 		},
 		{
 			"type": "ApplyStatus",
 			"IID": "IID_StatusEffectsReceiver",
 			"method": "ApplyStatus"
 		}];
 	}
 };
 
 Engine.LoadHelperScript("Attacking.js");
 Engine.LoadHelperScript("Player.js");
 Engine.LoadHelperScript("ValueModification.js");
 Engine.LoadComponentScript("interfaces/Auras.js");
 Engine.LoadComponentScript("interfaces/Capturable.js");
 Engine.LoadComponentScript("interfaces/ModifiersManager.js");
 Engine.LoadComponentScript("interfaces/Formation.js");
 Engine.LoadComponentScript("interfaces/Health.js");
 Engine.LoadComponentScript("interfaces/TechnologyManager.js");
 Engine.LoadComponentScript("Attack.js");
 
 let entityID = 903;
 
 function attackComponentTest(defenderClass, isEnemy, test_function)
 {
 	let playerEnt1 = 5;
 
 	AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
 		"GetPlayerByID": () => playerEnt1
 	});
 
 	AddMock(playerEnt1, IID_Player, {
 		"GetPlayerID": () => 1,
 		"IsEnemy": () => isEnemy
 	});
 
 	let attacker = entityID;
 
 	AddMock(attacker, IID_Position, {
 		"IsInWorld": () => true,
 		"GetHeightOffset": () => 5,
 		"GetPosition2D": () => new Vector2D(1, 2)
 	});
 
 	AddMock(attacker, IID_Ownership, {
 		"GetOwner": () => 1
 	});
 
 	let cmpAttack = ConstructComponent(attacker, "Attack", {
 		"Melee": {
 			"Damage": {
 				"Hack": 11,
 				"Pierce": 5,
 				"Crush": 0
 			},
 			"MinRange": 3,
 			"MaxRange": 5,
 			"PreferredClasses": {
 				"_string": "FemaleCitizen"
 			},
 			"RestrictedClasses": {
 				"_string": "Elephant Archer"
 			},
 			"Bonuses":
 			{
 				"BonusCav": {
 					"Classes": "Cavalry",
 					"Multiplier": 2
 				}
 			}
 		},
 		"Ranged": {
 			"Damage": {
 				"Hack": 0,
 				"Pierce": 10,
 				"Crush": 0
 			},
 			"MinRange": 10,
 			"MaxRange": 80,
 			"PrepareTime": 300,
 			"RepeatTime": 500,
 			"Projectile": {
 				"Speed": 10,
 				"Spread": 2,
 				"Gravity": 1,
 				"FriendlyFire": "false"
 			},
 			"PreferredClasses": {
 				"_string": "Archer"
 			},
 			"RestrictedClasses": {
 				"_string": "Elephant"
 			},
 			"Splash": {
 				"Shape": "Circular",
 				"Range": 10,
 				"FriendlyFire": "false",
 				"Damage": {
 					"Hack": 0.0,
 					"Pierce": 15.0,
 					"Crush": 35.0
 				},
 				"Bonuses": {
 					"BonusCav": {
 						"Classes": "Cavalry",
 						"Multiplier": 3
 					}
 				}
 			}
 		},
 		"Capture": {
 			"Capture": 8,
 			"MaxRange": 10,
 		},
 		"Slaughter": {},
 		"StatusEffect": {
 			"ApplyStatus": {
 				"StatusInternalName": {
 					"StatusName": "StatusShownName",
 					"ApplierTooltip": "ApplierTooltip",
 					"ReceiverTooltip": "ReceiverTooltip",
 					"Duration": 5000,
 					"Stackability": "Stacks",
 					"Modifiers": {
 						"SE": {
 							"Paths": {
 								"_string": "Health/Max"
 							},
 							"Affects": {
 								"_string": "Unit"
 							},
 							"Add": 10
 						}
 					}
 				}
 			},
 			"MinRange": "10",
 			"MaxRange": "80"
 		}
 	});
 
 	let defender = ++entityID;
 
 	AddMock(defender, IID_Identity, {
 		"GetClassesList": () => [defenderClass],
 		"HasClass": className => className == defenderClass,
 		"GetCiv": () => "civ"
 	});
 
 	AddMock(defender, IID_Ownership, {
 		"GetOwner": () => 1
 	});
 
 	AddMock(defender, IID_Position, {
 		"IsInWorld": () => true,
 		"GetHeightOffset": () => 0
 	});
 
 	AddMock(defender, IID_Health, {
 		"GetHitpoints": () => 100
 	});
 
 	test_function(attacker, cmpAttack, defender);
 }
 
 // Validate template getter functions
 attackComponentTest(undefined, true, (attacker, cmpAttack, defender) => {
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(), ["Melee", "Ranged", "Capture"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes([]), ["Melee", "Ranged", "Capture"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(["Melee", "Ranged", "Capture"]), ["Melee", "Ranged", "Capture"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(["Melee", "Ranged"]), ["Melee", "Ranged"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(["Capture"]), ["Capture"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(["Melee", "!Melee"]), []);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(["!Melee"]), ["Ranged", "Capture"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(["!Melee", "!Ranged"]), ["Capture"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(["Capture", "!Ranged"]), ["Capture"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackTypes(["Capture", "Melee", "!Ranged"]), ["Melee", "Capture"]);
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetPreferredClasses("Melee"), ["FemaleCitizen"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetRestrictedClasses("Melee"), ["Elephant", "Archer"]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetFullAttackRange(), { "min": 0, "max": 80 });
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackEffectsData("Capture"), { "Capture": 8 });
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackEffectsData("Ranged"), {
 		"Damage": {
 			"Hack": 0,
 			"Pierce": 10,
 			"Crush": 0
 		}
 	});
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackEffectsData("Ranged", true), {
 		"Damage": {
 			"Hack": 0.0,
 			"Pierce": 15.0,
 			"Crush": 35.0
 		},
 		"Bonuses": {
 			"BonusCav": {
 				"Classes": "Cavalry",
 				"Multiplier": 3
 			}
 		}
 	});
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetAttackEffectsData("StatusEffect"), {
 		"ApplyStatus": {
 			"StatusInternalName": {
 				"Duration": 5000,
 				"Interval": 0,
 				"Stackability": "Stacks",
 				"Modifiers": {
 					"SE": {
 						"Paths": {
 							"_string": "Health/Max"
 						},
 						"Affects": {
 							"_string": "Unit"
 						},
 						"Add": 10
 					}
 				}
 			}
 		}
 	});
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetTimers("Ranged"), {
 		"prepare": 300,
 		"repeat": 500
 	});
 
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetRepeatTime("Ranged"), 500);
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetTimers("Capture"), {
 		"prepare": 0,
 		"repeat": 1000
 	});
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetRepeatTime("Capture"), 1000);
 
 	TS_ASSERT_UNEVAL_EQUALS(cmpAttack.GetSplashData("Ranged"), {
 		"attackData": {
 			"Damage": {
 				"Hack": 0,
 				"Pierce": 15,
 				"Crush": 35,
 			},
 			"Bonuses": {
 				"BonusCav": {
 					"Classes": "Cavalry",
 					"Multiplier": 3
 				}
 			}
 		},
 		"friendlyFire": false,
 		"radius": 10,
 		"shape": "Circular"
 	});
 });
 
 for (let className of ["Infantry", "Cavalry"])
 	attackComponentTest(className, true, (attacker, cmpAttack, defender) => {
 
 		TS_ASSERT_EQUALS(cmpAttack.GetAttackEffectsData("Melee").Bonuses.BonusCav.Multiplier, 2);
 
 		TS_ASSERT_EQUALS(cmpAttack.GetAttackEffectsData("Capture").Bonuses || null, null);
 
 		let getAttackBonus = (s, t, e, splash) => Attacking.GetAttackBonus(s, e, t, cmpAttack.GetAttackEffectsData(t, splash).Bonuses || null);
 		TS_ASSERT_UNEVAL_EQUALS(getAttackBonus(attacker, "Melee", defender), className == "Cavalry" ? 2 : 1);
 		TS_ASSERT_UNEVAL_EQUALS(getAttackBonus(attacker, "Ranged", defender), 1);
 		TS_ASSERT_UNEVAL_EQUALS(getAttackBonus(attacker, "Ranged", defender, true), className == "Cavalry" ? 3 : 1);
 		TS_ASSERT_UNEVAL_EQUALS(getAttackBonus(attacker, "Capture", defender), 1);
 		TS_ASSERT_UNEVAL_EQUALS(getAttackBonus(attacker, "Slaughter", defender), 1);
 	});
 
 // CanAttack rejects elephant attack due to RestrictedClasses
 attackComponentTest("Elephant", true, (attacker, cmpAttack, defender) => {
 	TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender), false);
 });
 
 function testGetBestAttackAgainst(defenderClass, bestAttack, bestAllyAttack, isBuilding = false)
 {
 	attackComponentTest(defenderClass, true, (attacker, cmpAttack, defender) => {
 
 		if (isBuilding)
 			AddMock(defender, IID_Capturable, {
 				"CanCapture": playerID => {
 					TS_ASSERT_EQUALS(playerID, 1);
 					return true;
 				}
 			});
 
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender), true);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, []), true);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Ranged"]), true);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["!Melee"]), true);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Capture"]), isBuilding);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Melee", "Capture"]), defenderClass != "Archer");
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Ranged", "Capture"]), true);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["!Ranged", "!Melee"]), isBuilding || defenderClass == "Domestic");
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Melee", "!Melee"]), false);
 
 		let allowCapturing = [true];
 		if (!isBuilding)
 			allowCapturing.push(false);
 
 		for (let ac of allowCapturing)
 			TS_ASSERT_EQUALS(cmpAttack.GetBestAttackAgainst(defender, ac), bestAttack);
 	});
 
 	attackComponentTest(defenderClass, false, (attacker, cmpAttack, defender) => {
 
 		if (isBuilding)
 			AddMock(defender, IID_Capturable, {
 				"CanCapture": playerID => {
 					TS_ASSERT_EQUALS(playerID, 1);
 					return true;
 				}
 			});
 
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender), isBuilding || defenderClass == "Domestic");
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, []), isBuilding || defenderClass == "Domestic");
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Ranged"]), false);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["!Melee"]), isBuilding || defenderClass == "Domestic");
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Capture"]), isBuilding);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Melee", "Capture"]), isBuilding);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Ranged", "Capture"]), isBuilding);
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["!Ranged", "!Melee"]), isBuilding || defenderClass == "Domestic");
 		TS_ASSERT_EQUALS(cmpAttack.CanAttack(defender, ["Melee", "!Melee"]), false);
 
 		let allowCapturing = [true];
 		if (!isBuilding)
 			allowCapturing.push(false);
 
 		for (let ac of allowCapturing)
 			TS_ASSERT_EQUALS(cmpAttack.GetBestAttackAgainst(defender, ac), bestAllyAttack);
 	});
 }
 
 testGetBestAttackAgainst("FemaleCitizen", "Melee", undefined);
 testGetBestAttackAgainst("Archer", "Ranged", undefined);
 testGetBestAttackAgainst("Domestic", "Slaughter", "Slaughter");
 testGetBestAttackAgainst("Structure", "Capture", "Capture", true);
 testGetBestAttackAgainst("Structure", "Ranged", undefined, false);
+
+
+function testAttackPreference()
+{
+	const attacker = 5;
+
+	let cmpAttack = ConstructComponent(attacker, "Attack", {
+		"Melee": {
+			"Damage": {
+				"Crush": 0
+			},
+			"MinRange": 3,
+			"MaxRange": 5,
+			"PreferredClasses": {
+				"_string": "FemaleCitizen Unit+!Ship"
+			},
+			"RestrictedClasses": {
+				"_string": "Elephant Archer"
+			},
+		}
+	});
+
+	AddMock(attacker+1, IID_Identity, {
+		"GetClassesList": () => ["FemaleCitizen", "Unit"]
+	});
+
+	AddMock(attacker+2, IID_Identity, {
+		"GetClassesList": () => ["Unit"]
+	});
+
+	AddMock(attacker+3, IID_Identity, {
+		"GetClassesList": () => ["Unit", "Ship"]
+	});
+
+	AddMock(attacker+4, IID_Identity, {
+		"GetClassesList": () => ["SomethingElse"]
+	});
+
+	TS_ASSERT_EQUALS(cmpAttack.GetPreference(attacker+1), 0);
+	TS_ASSERT_EQUALS(cmpAttack.GetPreference(attacker+2), 1);
+	TS_ASSERT_EQUALS(cmpAttack.GetPreference(attacker+3), null);
+	TS_ASSERT_EQUALS(cmpAttack.GetPreference(attacker+4), null);
+}
+testAttackPreference();
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_cavalry_melee_maceman.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_cavalry_melee_maceman.xml	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_cavalry_melee_maceman.xml	(revision 24751)
@@ -1,44 +1,45 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_cavalry_melee">
   <Attack>
     <Melee>
       <AttackName>Mace</AttackName>
       <Damage>
         <Hack>0</Hack>
         <Pierce>0</Pierce>
         <Crush>8</Crush>
       </Damage>
       <MaxRange>4</MaxRange>
       <PrepareTime>500</PrepareTime>
       <RepeatTime>1000</RepeatTime>
+      <PreferredClasses datatype="tokens">!Ship</PreferredClasses>
     </Melee>
   </Attack>
   <Cost>
     <Resources>
       <wood>50</wood>
     </Resources>
   </Cost>
   <Identity>
     <GenericName>Cavalry Maceman</GenericName>
     <VisibleClasses datatype="tokens">Maceman</VisibleClasses>
   </Identity>
   <Loot>
     <wood>5</wood>
   </Loot>
   <Resistance>
     <Entity>
       <Damage>
         <Hack>4</Hack>
         <Pierce>2</Pierce>
       </Damage>
     </Entity>
   </Resistance>
   <Sound>
     <SoundGroups>
       <attack_melee>attack/weapon/sword_attack.xml</attack_melee>
     </SoundGroups>
   </Sound>
   <UnitMotion>
     <WalkSpeed op="mul">1.1</WalkSpeed>
   </UnitMotion>
 </Entity>
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_cavalry_maceman.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_cavalry_maceman.xml	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_cavalry_maceman.xml	(revision 24751)
@@ -1,38 +1,39 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_champion_cavalry">
   <Attack>
     <Melee>
       <AttackName>Mace</AttackName>
       <Damage>
         <Hack>0</Hack>
         <Pierce>0</Pierce>
         <Crush>16</Crush>
       </Damage>
       <MaxRange>4</MaxRange>
       <PrepareTime>500</PrepareTime>
       <RepeatTime>1000</RepeatTime>
+      <PreferredClasses datatype="tokens">!Ship</PreferredClasses>
     </Melee>
   </Attack>
   <Health>
     <Max>300</Max>
   </Health>
   <Identity>
     <GenericName>Champion Cavalry Maceman</GenericName>
     <VisibleClasses datatype="tokens">Melee Maceman</VisibleClasses>
   </Identity>
   <Resistance>
     <Entity>
       <Damage>
         <Pierce op="add">1</Pierce>
       </Damage>
     </Entity>
   </Resistance>
   <Sound>
     <SoundGroups>
       <attack_melee>attack/weapon/sword_attack.xml</attack_melee>
     </SoundGroups>
   </Sound>
   <UnitMotion>
     <WalkSpeed op="mul">1.1</WalkSpeed>
   </UnitMotion>
 </Entity>
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_elephant_melee.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_elephant_melee.xml	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_elephant_melee.xml	(revision 24751)
@@ -1,20 +1,21 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_champion_elephant">
   <Attack>
     <Capture disable=""/>
     <Melee>
       <AttackName>Trunk</AttackName>
       <Damage>
         <Hack>30</Hack>
         <Pierce>0</Pierce>
         <Crush>120</Crush>
       </Damage>
       <MaxRange>5.0</MaxRange>
       <PrepareTime>750</PrepareTime>
       <RepeatTime>1500</RepeatTime>
+      <PreferredClasses datatype="tokens">!Ship</PreferredClasses>
     </Melee>
   </Attack>
   <Identity>
     <VisibleClasses datatype="tokens">Melee</VisibleClasses>
   </Identity>
 </Entity>
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_infantry_maceman.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_infantry_maceman.xml	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_champion_infantry_maceman.xml	(revision 24751)
@@ -1,36 +1,37 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_champion_infantry">
   <Attack>
     <Melee>
       <AttackName>Mace</AttackName>
       <Damage>
         <Hack>0</Hack>
         <Pierce>0</Pierce>
         <Crush>14</Crush>
       </Damage>
       <MaxRange>3</MaxRange>
       <PrepareTime>500</PrepareTime>
       <RepeatTime>1000</RepeatTime>
+      <PreferredClasses datatype="tokens">!Ship</PreferredClasses>
     </Melee>
   </Attack>
   <Health>
     <Max>200</Max>
   </Health>
   <Identity>
     <GenericName>Champion Infantry Maceman</GenericName>
     <VisibleClasses datatype="tokens">Melee Maceman</VisibleClasses>
   </Identity>
   <Resistance>
     <Entity>
       <Damage>
         <Hack op="add">1</Hack>
         <Pierce op="add">1</Pierce>
       </Damage>
     </Entity>
   </Resistance>
   <Sound>
     <SoundGroups>
       <attack_melee>attack/weapon/sword_attack.xml</attack_melee>
     </SoundGroups>
   </Sound>
 </Entity>
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_cavalry_maceman.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_cavalry_maceman.xml	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_cavalry_maceman.xml	(revision 24751)
@@ -1,28 +1,29 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_hero_cavalry">
   <Attack>
     <Melee>
       <AttackName>Mace</AttackName>
       <Damage>
         <Hack>0</Hack>
         <Pierce>0</Pierce>
         <Crush>32</Crush>
       </Damage>
       <MaxRange>4</MaxRange>
       <PrepareTime>500</PrepareTime>
       <RepeatTime>1000</RepeatTime>
+      <PreferredClasses datatype="tokens">!Ship</PreferredClasses>
     </Melee>
   </Attack>
   <Identity>
     <GenericName>Hero Cavalry Maceman</GenericName>
     <VisibleClasses datatype="tokens">Melee Maceman</VisibleClasses>
   </Identity>
   <Sound>
     <SoundGroups>
       <attack_melee>attack/weapon/sword_attack.xml</attack_melee>
     </SoundGroups>
   </Sound>
   <UnitMotion>
     <WalkSpeed op="mul">1.1</WalkSpeed>
   </UnitMotion>
 </Entity>
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_elephant_melee.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_elephant_melee.xml	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_elephant_melee.xml	(revision 24751)
@@ -1,77 +1,78 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_hero">
   <Attack>
     <Capture disable=""/>
     <Melee>
       <AttackName>Trunk</AttackName>
       <Damage>
         <Hack>60</Hack>
         <Pierce>0</Pierce>
         <Crush>240</Crush>
       </Damage>
       <MaxRange>5.0</MaxRange>
       <PrepareTime>750</PrepareTime>
       <RepeatTime>1500</RepeatTime>
+     <PreferredClasses datatype="tokens">!Ship</PreferredClasses>
     </Melee>
   </Attack>
   <Cost>
     <Resources>
       <food>600</food>
       <metal>400</metal>
     </Resources>
   </Cost>
   <Footprint replace="">
     <Square width="4.5" depth="9.0"/>
     <Height>9.0</Height>
   </Footprint>
   <Health>
     <Max>1500</Max>
   </Health>
   <Identity>
     <GenericName>Hero Elephant</GenericName>
     <VisibleClasses datatype="tokens">Elephant Melee</VisibleClasses>
   </Identity>
   <Loot>
     <food>60</food>
     <metal>40</metal>
   </Loot>
   <Position>
     <TurnRate>3</TurnRate>
   </Position>
   <Resistance>
     <Entity>
       <Damage>
         <Hack>10</Hack>
         <Pierce>10</Pierce>
         <Crush>25</Crush>
       </Damage>
     </Entity>
   </Resistance>
   <Selectable>
     <Overlay>
       <Shape>
         <Circle radius="5.0"/>
       </Shape>
     </Overlay>
   </Selectable>
   <Sound>
     <SoundGroups>
       <select>actor/fauna/animal/elephant_select.xml</select>
       <order_walk>actor/fauna/animal/elephant_order.xml</order_walk>
       <order_attack>actor/fauna/animal/elephant_attack_order.xml</order_attack>
       <order_gather>actor/fauna/animal/elephant_order.xml</order_gather>
       <order_garrison>actor/fauna/animal/elephant_order.xml</order_garrison>
       <attack_melee>actor/fauna/animal/elephant_attack.xml</attack_melee>
       <walk>actor/mounted/movement/walk.xml</walk>
       <run>actor/mounted/movement/walk.xml</run>
       <death>actor/fauna/animal/elephant_death.xml</death>
       <trained>actor/fauna/animal/elephant_trained.xml</trained>
     </SoundGroups>
   </Sound>
   <StatusBars>
     <HeightOffset>10.0</HeightOffset>
   </StatusBars>
   <UnitMotion>
     <PassabilityClass>large</PassabilityClass>
   </UnitMotion>
 </Entity>
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_infantry_maceman.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_infantry_maceman.xml	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_hero_infantry_maceman.xml	(revision 24751)
@@ -1,33 +1,34 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_hero_infantry">
   <Attack>
     <Melee>
       <AttackName>Mace</AttackName>
       <Damage>
         <Hack>0</Hack>
         <Pierce>0</Pierce>
         <Crush>28</Crush>
       </Damage>
       <MaxRange>3</MaxRange>
       <PrepareTime>500</PrepareTime>
       <RepeatTime>1000</RepeatTime>
+      <PreferredClasses datatype="tokens">!Ship</PreferredClasses>
     </Melee>
   </Attack>
   <Identity>
     <GenericName>Hero Infantry Maceman</GenericName>
     <VisibleClasses datatype="tokens">Melee Maceman</VisibleClasses>
   </Identity>
   <Resistance>
     <Entity>
       <Damage>
         <Hack op="add">2</Hack>
         <Pierce op="add">2</Pierce>
       </Damage>
     </Entity>
   </Resistance>
   <Sound>
     <SoundGroups>
       <attack_melee>attack/weapon/sword_attack.xml</attack_melee>
     </SoundGroups>
   </Sound>
 </Entity>
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_infantry_melee_maceman.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_infantry_melee_maceman.xml	(revision 24750)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit_infantry_melee_maceman.xml	(revision 24751)
@@ -1,41 +1,42 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity parent="template_unit_infantry_melee">
   <Attack>
     <Melee>
       <AttackName>Mace</AttackName>
       <Damage>
         <Hack>0</Hack>
         <Pierce>0</Pierce>
         <Crush>7</Crush>
       </Damage>
       <MaxRange>3</MaxRange>
       <PrepareTime>500</PrepareTime>
       <RepeatTime>1000</RepeatTime>
+      <PreferredClasses datatype="tokens">!Ship</PreferredClasses>
     </Melee>
   </Attack>
   <Cost>
     <Resources>
       <wood>50</wood>
     </Resources>
   </Cost>
   <Identity>
     <GenericName>Infantry Maceman</GenericName>
     <VisibleClasses datatype="tokens">Maceman</VisibleClasses>
   </Identity>
   <Loot>
     <wood>5</wood>
   </Loot>
   <Resistance>
     <Entity>
       <Damage>
         <Hack>4</Hack>
         <Pierce>5</Pierce>
       </Damage>
     </Entity>
   </Resistance>
   <Sound>
     <SoundGroups>
       <attack_melee>attack/weapon/sword_attack.xml</attack_melee>
     </SoundGroups>
   </Sound>
 </Entity>