Index: ps/trunk/binaries/data/mods/public/simulation/components/Attack.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Attack.js	(revision 23591)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Attack.js	(revision 23592)
@@ -1,617 +1,624 @@
 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>" +
 			"<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>" +
 			"<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>" +
 				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>" +
 				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>" +
 				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>" +
 				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)
 		{
 			let pref = preferredClasses.indexOf(targetClass);
 			if (pref === 0)
 				return pref;
 			if (pref != -1 && (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.GetTimers = function(type)
+Attack.prototype.GetRepeatTime = function(type)
 {
-	let prepare = +(this.template[type].PrepareTime || 0);
-	prepare = ApplyValueModificationsToEntity("Attack/" + type + "/PrepareTime", prepare, this.entity);
+	let repeatTime = 1000;
+
+	if (this.template[type] && this.template[type].RepeatTime)
+		repeatTime = +this.template[type].RepeatTime;
 
-	let repeat = +(this.template[type].RepeatTime || 1000);
-	repeat = ApplyValueModificationsToEntity("Attack/" + type + "/RepeatTime", repeat, this.entity);
+	return ApplyValueModificationsToEntity("Attack/" + type + "/RepeatTime", repeatTime, this.entity);
+};
 
-	return { "prepare": prepare, "repeat": repeat };
+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
 
 		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 previousTargetPosition = Engine.QueryInterface(target, IID_Position).GetPreviousPosition();
 		let targetVelocity = Vector3D.sub(targetPosition, previousTargetPosition).div(turnLength);
 
 		let timeToTarget = this.PredictTimeToTarget(selfPosition, horizSpeed, targetPosition, targetVelocity);
 		let predictedPosition = (timeToTarget !== false) ? Vector3D.mult(targetVelocity, timeToTarget).add(targetPosition) : 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(type, this.GetAttackEffectsData(type), target, this.entity, attackerOwner);
 };
 
 /**
  * Get the predicted time of collision between a projectile (or a chaser)
  * and its target, assuming they both move in straight line at a constant speed.
  * Vertical component of movement is ignored.
  * @param {Vector3D} selfPosition - the 3D position of the projectile (or chaser).
  * @param {number} horizSpeed - the horizontal speed of the projectile (or chaser).
  * @param {Vector3D} targetPosition - the 3D position of the target.
  * @param {Vector3D} targetVelocity - the 3D velocity vector of the target.
  * @return {Vector3D|boolean} - the 3D predicted position or false if the collision will not happen.
  */
 Attack.prototype.PredictTimeToTarget = function(selfPosition, horizSpeed, targetPosition, targetVelocity)
 {
 	let relativePosition = new Vector3D.sub(targetPosition, selfPosition);
 	let a = targetVelocity.x * targetVelocity.x + targetVelocity.z * targetVelocity.z - horizSpeed * horizSpeed;
 	let b = relativePosition.x * targetVelocity.x + relativePosition.z * targetVelocity.z;
 	let c = relativePosition.x * relativePosition.x + relativePosition.z * relativePosition.z;
 	// The predicted time to reach the target is the smallest non negative solution
 	// (when it exists) of the equation a t^2 + 2 b t + c = 0.
 	// Using c>=0, we can straightly compute the right solution.
 
 	if (c == 0)
 		return 0;
 
 	let disc = b * b - a * c;
 	if (a < 0 || b < 0 && disc >= 0)
 		return c / (Math.sqrt(disc) - b);
 
 	return false;
 };
 
 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/interfaces/Attack.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/interfaces/Attack.js	(revision 23591)
+++ ps/trunk/binaries/data/mods/public/simulation/components/interfaces/Attack.js	(revision 23592)
@@ -1,7 +1,5 @@
-Engine.RegisterInterface("Attack");
-
 /**
  * Message of the form { "attacker": number, "target": number, "type": string, "damage": number, "attackerOwner": number }
  * sent from Attack component and by Damage component to the target entity, each time the target is attacked or damaged.
  */
 Engine.RegisterMessageType("Attacked");
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 23591)
+++ ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Attack.js	(revision 23592)
@@ -1,325 +1,330 @@
 Engine.LoadHelperScript("DamageBonus.js");
 Engine.LoadHelperScript("Attacking.js");
 Engine.LoadHelperScript("Player.js");
 Engine.LoadHelperScript("ValueModification.js");
 Engine.LoadComponentScript("interfaces/Attack.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)
 {
 	ResetState();
 
 	{
 		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": {}
 	});
 
 	let defender = ++entityID;
 
 	AddMock(defender, IID_Identity, {
 		"GetClassesList": () => [defenderClass],
 		"HasClass": className => className == defenderClass
 	});
 
 	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.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) => 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 testPredictTimeToTarget(selfPosition, horizSpeed, targetPosition, targetVelocity)
 {
 	ResetState();
 	let cmpAttack = ConstructComponent(1, "Attack", {});
 	let timeToTarget = cmpAttack.PredictTimeToTarget(selfPosition, horizSpeed, targetPosition, targetVelocity);
 	if (timeToTarget === false)
 		return;
 	// Position of the target after that time.
 	let targetPos = Vector3D.mult(targetVelocity, timeToTarget).add(targetPosition);
 	// Time that the projectile need to reach it.
 	let time = targetPos.horizDistanceTo(selfPosition) / horizSpeed;
 	TS_ASSERT_EQUALS(timeToTarget.toFixed(1), time.toFixed(1));
 }
 
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(0, 0, 0), new Vector3D(0, 0, 0));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(0, 0, 0));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(1, 0, 0));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(4, 0, 0));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(16, 0, 0));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(-1, 0, 0));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(-4, 0, 0));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(-16, 0, 0));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(0, 0, 1));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(0, 0, 4));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(0, 0, 16));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(1, 0, 1));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(2, 0, 2));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(8, 0, 8));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(-1, 0, 1));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(-2, 0, 2));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(-8, 0, 8));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(4, 0, 2));
 testPredictTimeToTarget(new Vector3D(0, 0, 0), 4, new Vector3D(20, 0, 0), new Vector3D(-4, 0, 2));
Index: ps/trunk/source/simulation2/TypeList.h
===================================================================
--- ps/trunk/source/simulation2/TypeList.h	(revision 23591)
+++ ps/trunk/source/simulation2/TypeList.h	(revision 23592)
@@ -1,208 +1,211 @@
 /* Copyright (C) 2020 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 // MESSAGE: message types
 // INTERFACE: component interface types
 // COMPONENT: component types
 
 // Components intended only for use in test cases:
 // (The tests rely on the enum IDs, so don't change the order of these)
 INTERFACE(Test1)
 COMPONENT(Test1A)
 COMPONENT(Test1B)
 COMPONENT(Test1Scripted)
 INTERFACE(Test2)
 COMPONENT(Test2A)
 COMPONENT(Test2Scripted)
 
 // Message types:
 MESSAGE(TurnStart)
 MESSAGE(Update)
 MESSAGE(Update_MotionFormation)
 MESSAGE(Update_MotionUnit)
 MESSAGE(Update_Final)
 MESSAGE(Interpolate) // non-deterministic (use with caution)
 MESSAGE(RenderSubmit) // non-deterministic (use with caution)
 MESSAGE(ProgressiveLoad) // non-deterministic (use with caution)
 MESSAGE(Deserialized) // non-deterministic (use with caution)
 MESSAGE(Create)
 MESSAGE(Destroy)
 MESSAGE(OwnershipChanged)
 MESSAGE(PositionChanged)
 MESSAGE(InterpolatedPositionChanged)
 MESSAGE(TerritoryPositionChanged)
 MESSAGE(MotionUpdate)
 MESSAGE(RangeUpdate)
 MESSAGE(TerrainChanged)
 MESSAGE(VisibilityChanged)
 MESSAGE(WaterChanged)
 MESSAGE(ObstructionMapShapeChanged)
 MESSAGE(TerritoriesChanged)
 MESSAGE(PathResult)
 MESSAGE(ValueModification)
 MESSAGE(TemplateModification)
 MESSAGE(VisionRangeChanged)
 MESSAGE(VisionSharingChanged)
 MESSAGE(MinimapPing)
 MESSAGE(CinemaPathEnded)
 MESSAGE(CinemaQueueEnded)
 MESSAGE(PlayerColorChanged)
 
 // TemplateManager must come before all other (non-test) components,
 // so that it is the first to be (de)serialized
 INTERFACE(TemplateManager)
 COMPONENT(TemplateManager)
 
 // Special component for script component types with no native interface
 INTERFACE(UnknownScript)
 COMPONENT(UnknownScript)
 
 // In alphabetical order:
 
 INTERFACE(AIInterface)
 COMPONENT(AIInterfaceScripted)
 
 INTERFACE(AIManager)
 COMPONENT(AIManager)
 
+INTERFACE(Attack)
+COMPONENT(AttackScripted)
+
 INTERFACE(CinemaManager)
 COMPONENT(CinemaManager)
 
 INTERFACE(CommandQueue)
 COMPONENT(CommandQueue)
 
 INTERFACE(Decay)
 COMPONENT(Decay)
 
 INTERFACE(Fogging)
 COMPONENT(FoggingScripted)
 
 // Note: The VisualActor component relies on this component being initialized before itself, in order to support using
 // an entity's footprint shape for the selection boxes. This dependency is not strictly necessary, but it does avoid
 // some extra plumbing code to set up on-demand initialization. If you find yourself forced to break this dependency,
 // see VisualActor's Init method for a description of how you can avoid it.
 INTERFACE(Footprint)
 COMPONENT(Footprint)
 
 INTERFACE(GarrisonHolder)
 COMPONENT(GarrisonHolderScripted)
 
 INTERFACE(GuiInterface)
 COMPONENT(GuiInterfaceScripted)
 
 INTERFACE(Identity)
 COMPONENT(IdentityScripted)
 
 INTERFACE(Minimap)
 COMPONENT(Minimap)
 
 INTERFACE(Mirage)
 COMPONENT(MirageScripted)
 
 INTERFACE(Motion)
 COMPONENT(MotionBall)
 COMPONENT(MotionScripted)
 
 INTERFACE(Obstruction)
 COMPONENT(Obstruction)
 
 INTERFACE(ObstructionManager)
 COMPONENT(ObstructionManager)
 
 INTERFACE(OverlayRenderer)
 COMPONENT(OverlayRenderer)
 
 INTERFACE(Ownership)
 COMPONENT(Ownership)
 
 INTERFACE(ParticleManager)
 COMPONENT(ParticleManager)
 
 INTERFACE(Pathfinder)
 COMPONENT(Pathfinder)
 
 INTERFACE(Player)
 COMPONENT(PlayerScripted)
 
 INTERFACE(PlayerManager)
 COMPONENT(PlayerManagerScripted)
 
 INTERFACE(Position)
 COMPONENT(Position) // must be before VisualActor
 
 INTERFACE(ProjectileManager)
 COMPONENT(ProjectileManager)
 
 INTERFACE(RallyPoint)
 COMPONENT(RallyPointScripted)
 
 INTERFACE(RallyPointRenderer)
 COMPONENT(RallyPointRenderer)
 
 INTERFACE(RangeManager)
 COMPONENT(RangeManager)
 
 INTERFACE(RangeOverlayRenderer)
 COMPONENT(RangeOverlayRenderer)
 
 INTERFACE(Selectable)
 COMPONENT(Selectable)
 
 INTERFACE(Settlement)
 COMPONENT(SettlementScripted)
 
 INTERFACE(Sound)
 COMPONENT(SoundScripted)
 
 INTERFACE(SoundManager)
 COMPONENT(SoundManager)
 
 INTERFACE(ValueModificationManager)
 COMPONENT(ValueModificationManagerScripted)
 
 INTERFACE(Terrain)
 COMPONENT(Terrain)
 
 INTERFACE(TerritoryDecayManager)
 COMPONENT(TerritoryDecayManagerScripted)
 
 INTERFACE(TerritoryInfluence)
 COMPONENT(TerritoryInfluence)
 
 INTERFACE(TerritoryManager)
 COMPONENT(TerritoryManager)
 
 INTERFACE(UnitMotion)
 COMPONENT(UnitMotion) // must be after Obstruction
 COMPONENT(UnitMotionScripted)
 
 INTERFACE(UnitRenderer)
 COMPONENT(UnitRenderer)
 
 INTERFACE(Visibility)
 COMPONENT(VisibilityScripted)
 
 INTERFACE(Vision)
 COMPONENT(Vision)
 
 // Note: this component relies on the Footprint component being initialized before itself. See the comments above for
 // the Footprint component to find out why.
 INTERFACE(Visual)
 COMPONENT(VisualActor) // must be after Ownership (dependency in Deserialize) and Vision (dependency in Init)
 
 INTERFACE(WaterManager)
 COMPONENT(WaterManager)
Index: ps/trunk/source/simulation2/components/ICmpAttack.cpp
===================================================================
--- ps/trunk/source/simulation2/components/ICmpAttack.cpp	(nonexistent)
+++ ps/trunk/source/simulation2/components/ICmpAttack.cpp	(revision 23592)
@@ -0,0 +1,40 @@
+/* Copyright (C) 2020 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "ICmpAttack.h"
+
+#include "simulation2/system/InterfaceScripted.h"
+#include "simulation2/scripting/ScriptComponent.h"
+
+
+BEGIN_INTERFACE_WRAPPER(Attack)
+END_INTERFACE_WRAPPER(Attack)
+
+class CCmpAttackScripted : public ICmpAttack
+{
+public:
+	DEFAULT_SCRIPT_WRAPPER(AttackScripted)
+
+    virtual float GetRepeatTime(const std::string& type) const
+    {
+        return m_Script.Call<float, const std::string&>("GetRepeatTime", type);
+    }
+};
+
+REGISTER_COMPONENT_SCRIPT_WRAPPER(AttackScripted)

Property changes on: ps/trunk/source/simulation2/components/ICmpAttack.cpp
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/simulation2/components/ICmpAttack.h
===================================================================
--- ps/trunk/source/simulation2/components/ICmpAttack.h	(nonexistent)
+++ ps/trunk/source/simulation2/components/ICmpAttack.h	(revision 23592)
@@ -0,0 +1,30 @@
+/* Copyright (C) 2020 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_ICMPATTACK
+#define INCLUDED_ICMPATTACK
+
+#include "simulation2/system/Interface.h"
+
+class ICmpAttack : public IComponent
+{
+public:
+    virtual float GetRepeatTime(const std::string& type) const = 0;
+    DECLARE_INTERFACE_TYPE(Attack)
+};
+
+#endif // INCLUDED_ICMPATTACK

Property changes on: ps/trunk/source/simulation2/components/ICmpAttack.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: ps/trunk/source/tools/atlas/GameInterface/ActorViewer.cpp
===================================================================
--- ps/trunk/source/tools/atlas/GameInterface/ActorViewer.cpp	(revision 23591)
+++ ps/trunk/source/tools/atlas/GameInterface/ActorViewer.cpp	(revision 23592)
@@ -1,558 +1,553 @@
-/* Copyright (C) 2019 Wildfire Games.
+/* Copyright (C) 2020 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "precompiled.h"
 
 #include "ActorViewer.h"
 
 #include "View.h"
 
 #include "graphics/ColladaManager.h"
 #include "graphics/LOSTexture.h"
 #include "graphics/Unit.h"
 #include "graphics/Model.h"
 #include "graphics/ModelDef.h"
 #include "graphics/ObjectManager.h"
 #include "graphics/ParticleManager.h"
 #include "graphics/Patch.h"
 #include "graphics/SkeletonAnimManager.h"
 #include "graphics/Terrain.h"
 #include "graphics/TerrainTextureEntry.h"
 #include "graphics/TerrainTextureManager.h"
 #include "graphics/TerritoryTexture.h"
 #include "graphics/UnitManager.h"
 #include "graphics/Overlay.h"
 #include "maths/MathUtil.h"
 #include "ps/Filesystem.h"
 #include "ps/CLogger.h"
 #include "ps/GameSetup/Config.h"
 #include "ps/ProfileViewer.h"
 #include "renderer/Renderer.h"
 #include "renderer/RenderingOptions.h"
 #include "renderer/Scene.h"
 #include "renderer/SkyManager.h"
 #include "renderer/WaterManager.h"
 #include "scriptinterface/ScriptInterface.h"
 #include "simulation2/Simulation2.h"
+#include "simulation2/components/ICmpAttack.h"
 #include "simulation2/components/ICmpOwnership.h"
 #include "simulation2/components/ICmpPosition.h"
 #include "simulation2/components/ICmpRangeManager.h"
 #include "simulation2/components/ICmpTerrain.h"
 #include "simulation2/components/ICmpUnitMotion.h"
 #include "simulation2/components/ICmpVisual.h"
 #include "simulation2/components/ICmpWaterManager.h"
 #include "simulation2/helpers/Render.h"
 
 struct ActorViewerImpl : public Scene
 {
 	NONCOPYABLE(ActorViewerImpl);
 public:
 	ActorViewerImpl() :
 		Entity(INVALID_ENTITY),
 		Terrain(),
 		ColladaManager(g_VFS),
 		MeshManager(ColladaManager),
 		SkeletonAnimManager(ColladaManager),
 		UnitManager(),
 		Simulation2(&UnitManager, g_ScriptRuntime, &Terrain),
 		ObjectManager(MeshManager, SkeletonAnimManager, Simulation2),
 		LOSTexture(Simulation2),
 		TerritoryTexture(Simulation2)
 	{
 		UnitManager.SetObjectManager(ObjectManager);
 	}
 
 	entity_id_t Entity;
 	CStrW CurrentUnitID;
 	CStr CurrentUnitAnim;
 	float CurrentSpeed;
 	bool WalkEnabled;
 	bool GroundEnabled;
 	bool WaterEnabled;
 	bool ShadowsEnabled;
 
 	// Whether shadows, sky and water are enabled outside of the actor viewer.
 	bool OldShadows;
 	bool OldSky;
 	bool OldWater;
 
 	bool SelectionBoxEnabled;
 	bool AxesMarkerEnabled;
 	int PropPointsMode; // 0 disabled, 1 for point markers, 2 for point markers + axes
 
 	SColor4ub Background;
 
 	CTerrain Terrain;
 
 	CColladaManager ColladaManager;
 	CMeshManager MeshManager;
 	CSkeletonAnimManager SkeletonAnimManager;
 	CObjectManager ObjectManager;
 	CUnitManager UnitManager;
 	CSimulation2 Simulation2;
 	CLOSTexture LOSTexture;
 	CTerritoryTexture TerritoryTexture;
 
 	SOverlayLine SelectionBoxOverlay;
 	SOverlayLine AxesMarkerOverlays[3];
 	std::vector<CModel::Prop> Props;
 	std::vector<SOverlayLine> PropPointOverlays;
 
 	// Simplistic implementation of the Scene interface
 	virtual void EnumerateObjects(const CFrustum& frustum, SceneCollector* c)
 	{
 		if (GroundEnabled)
 		{
 			for (ssize_t pj = 0; pj < Terrain.GetPatchesPerSide(); ++pj)
 				for (ssize_t pi = 0; pi < Terrain.GetPatchesPerSide(); ++pi)
 					c->Submit(Terrain.GetPatch(pi, pj));
 		}
 
 		CmpPtr<ICmpVisual> cmpVisual(Simulation2, Entity);
 		if (cmpVisual)
 		{
 			// add selection box outlines manually
 			if (SelectionBoxEnabled)
 			{
 				SelectionBoxOverlay.m_Color = CColor(35/255.f, 86/255.f, 188/255.f, .75f); // pretty blue
 				SelectionBoxOverlay.m_Thickness = 2;
 
 				SimRender::ConstructBoxOutline(cmpVisual->GetSelectionBox(), SelectionBoxOverlay);
 				c->Submit(&SelectionBoxOverlay);
 			}
 
 			// add origin axis thingy
 			if (AxesMarkerEnabled)
 			{
 				CMatrix3D worldSpaceAxes;
 				// offset from the ground a little bit to prevent fighting with the floor texture (also note: SetTranslation
 				// sets the identity 3x3 transformation matrix, which are the world axes)
 				worldSpaceAxes.SetTranslation(cmpVisual->GetPosition() + CVector3D(0, 0.02f, 0));
 				SimRender::ConstructAxesMarker(worldSpaceAxes, AxesMarkerOverlays[0], AxesMarkerOverlays[1], AxesMarkerOverlays[2]);
 
 				c->Submit(&AxesMarkerOverlays[0]);
 				c->Submit(&AxesMarkerOverlays[1]);
 				c->Submit(&AxesMarkerOverlays[2]);
 			}
 
 			// add prop point overlays
 			if (PropPointsMode > 0 && Props.size() > 0)
 			{
 				PropPointOverlays.clear(); // doesn't clear capacity, but should be ok since the number of prop points is usually pretty limited
 				for (size_t i = 0; i < Props.size(); ++i)
 				{
 					CModel::Prop& prop = Props[i];
 					if (prop.m_Model) // should always be the case
 					{
 						// prop point positions are automatically updated during animations etc. by CModel::ValidatePosition
 						const CMatrix3D& propCoordSystem = prop.m_Model->GetTransform();
 
 						SOverlayLine pointGimbal;
 						pointGimbal.m_Color = CColor(1.f, 0.f, 1.f, 1.f);
 						SimRender::ConstructGimbal(propCoordSystem.GetTranslation(), 0.05f, pointGimbal);
 						PropPointOverlays.push_back(pointGimbal);
 
 						if (PropPointsMode > 1)
 						{
 							// scale the prop axes coord system down a bit to distinguish them from the main world-space axes markers
 							CMatrix3D displayCoordSystem = propCoordSystem;
 							displayCoordSystem.Scale(0.5f, 0.5f, 0.5f);
 							// revert translation scaling
 							displayCoordSystem._14 = propCoordSystem._14;
 							displayCoordSystem._24 = propCoordSystem._24;
 							displayCoordSystem._34 = propCoordSystem._34;
 
 							// construct an XYZ axes marker for the prop's coordinate system
 							SOverlayLine xAxis, yAxis, zAxis;
 							SimRender::ConstructAxesMarker(displayCoordSystem, xAxis, yAxis, zAxis);
 							PropPointOverlays.push_back(xAxis);
 							PropPointOverlays.push_back(yAxis);
 							PropPointOverlays.push_back(zAxis);
 						}
 					}
 				}
 
 				for (size_t i = 0; i < PropPointOverlays.size(); ++i)
 				{
 					c->Submit(&PropPointOverlays[i]);
 				}
 			}
 		}
 
 		// send a RenderSubmit message so the components can submit their visuals to the renderer
 		Simulation2.RenderSubmit(*c, frustum, false);
 	}
 
 	virtual CLOSTexture& GetLOSTexture()
 	{
 		return LOSTexture;
 	}
 
 	virtual CTerritoryTexture& GetTerritoryTexture()
 	{
 		return TerritoryTexture;
 	}
 
 	/**
 	 * Recursively fetches the props of the currently displayed entity model and its submodels, and stores them for rendering.
 	 */
 	void UpdatePropList();
 	void UpdatePropListRecursive(CModelAbstract* model);
 
 };
 
 void ActorViewerImpl::UpdatePropList()
 {
 	Props.clear();
 
 	CmpPtr<ICmpVisual> cmpVisual(Simulation2, Entity);
 	if (cmpVisual)
 	{
 		CUnit* unit = cmpVisual->GetUnit();
 		if (unit)
 		{
 			CModelAbstract& modelAbstract = unit->GetModel();
 			UpdatePropListRecursive(&modelAbstract);
 		}
 	}
 }
 
 void ActorViewerImpl::UpdatePropListRecursive(CModelAbstract* modelAbstract)
 {
 	ENSURE(modelAbstract);
 
 	CModel* model = modelAbstract->ToCModel();
 	if (model)
 	{
 		std::vector<CModel::Prop>& modelProps = model->GetProps();
 		for (CModel::Prop& modelProp : modelProps)
 		{
 			Props.push_back(modelProp);
 			if (modelProp.m_Model)
 				UpdatePropListRecursive(modelProp.m_Model);
 		}
 	}
 }
 
 ActorViewer::ActorViewer()
 	: m(*new ActorViewerImpl())
 {
 	m.WalkEnabled = false;
 	m.GroundEnabled = true;
 	m.WaterEnabled = false;
 	m.ShadowsEnabled = g_RenderingOptions.GetShadows();
 	m.SelectionBoxEnabled = false;
 	m.AxesMarkerEnabled = false;
 	m.PropPointsMode = 0;
 	m.Background = SColor4ub(0, 0, 0, 255);
 
 	// Create a tiny empty piece of terrain, just so we can put shadows
 	// on it without having to think too hard
 	m.Terrain.Initialize(2, NULL);
 	CTerrainTextureEntry* tex = g_TexMan.FindTexture("whiteness");
 	if (tex)
 	{
 		for (ssize_t pi = 0; pi < m.Terrain.GetPatchesPerSide(); ++pi)
 		{
 			for (ssize_t pj = 0; pj < m.Terrain.GetPatchesPerSide(); ++pj)
 			{
 				CPatch* patch = m.Terrain.GetPatch(pi, pj);
 				for (ssize_t i = 0; i < PATCH_SIZE; ++i)
 				{
 					for (ssize_t j = 0; j < PATCH_SIZE; ++j)
 					{
 						CMiniPatch& mp = patch->m_MiniPatches[i][j];
 						mp.Tex = tex;
 						mp.Priority = 0;
 					}
 				}
 			}
 		}
 	}
 	else
 	{
 		debug_warn(L"Failed to load whiteness texture");
 	}
 
 	// Prepare the simulation
 	m.Simulation2.LoadDefaultScripts();
 	m.Simulation2.ResetState();
 
 	// Set player data
 	m.Simulation2.SetMapSettings(m.Simulation2.GetPlayerDefaults());
 	m.Simulation2.LoadPlayerSettings(true);
 
 	// Tell the simulation we've already loaded the terrain
 	CmpPtr<ICmpTerrain> cmpTerrain(m.Simulation2, SYSTEM_ENTITY);
 	if (cmpTerrain)
 		cmpTerrain->ReloadTerrain(false);
 
 	// Remove FOW since we're in Atlas
 	CmpPtr<ICmpRangeManager> cmpRangeManager(m.Simulation2, SYSTEM_ENTITY);
 	if (cmpRangeManager)
 		cmpRangeManager->SetLosRevealAll(-1, true);
 
 	m.Simulation2.InitGame();
 }
 
 ActorViewer::~ActorViewer()
 {
 	delete &m;
 }
 
 CSimulation2* ActorViewer::GetSimulation2()
 {
 	return &m.Simulation2;
 }
 
 entity_id_t ActorViewer::GetEntity()
 {
 	return m.Entity;
 }
 
 void ActorViewer::UnloadObjects()
 {
 	m.ObjectManager.UnloadObjects();
 }
 
 void ActorViewer::SetActor(const CStrW& name, const CStr& animation, player_id_t playerID)
 {
 	bool needsAnimReload = false;
 
 	CStrW id = name;
 
 	// Recreate the entity, if we don't have one or if the new one is different
 	if (m.Entity == INVALID_ENTITY || id != m.CurrentUnitID)
 	{
 		// Delete the old entity (if any)
 		if (m.Entity != INVALID_ENTITY)
 		{
 			m.Simulation2.DestroyEntity(m.Entity);
 			m.Simulation2.FlushDestroyedEntities();
 			m.Entity = INVALID_ENTITY;
 		}
 
 		// Clear particles associated with deleted entity
 		g_Renderer.GetParticleManager().ClearUnattachedEmitters();
 
 		// If there's no actor to display, return with nothing loaded
 		if (id.empty())
 			return;
 
 		m.Entity = m.Simulation2.AddEntity(L"preview|" + id);
 		if (m.Entity == INVALID_ENTITY)
 			return;
 
 		CmpPtr<ICmpPosition> cmpPosition(m.Simulation2, m.Entity);
 		if (cmpPosition)
 		{
 			ssize_t c = TERRAIN_TILE_SIZE * m.Terrain.GetPatchesPerSide()*PATCH_SIZE/2;
 			cmpPosition->JumpTo(entity_pos_t::FromInt(c), entity_pos_t::FromInt(c));
 			cmpPosition->SetYRotation(entity_angle_t::Pi());
 		}
 
 		CmpPtr<ICmpOwnership> cmpOwnership(m.Simulation2, m.Entity);
 		if (cmpOwnership)
 			cmpOwnership->SetOwner(playerID);
 
 		needsAnimReload = true;
 	}
 
 	if (animation != m.CurrentUnitAnim)
 		needsAnimReload = true;
 
 	if (needsAnimReload)
 	{
+		// Emulate the typical simulation animation behaviour.
 		CStr anim = animation.LowerCase();
-
-		// Emulate the typical simulation animation behaviour
-		float speed;
-		float repeattime = 0.f;
+		float speed = 1.0f;
+		// Speed will be ignored if we have a repeat time.
+		float repeattime = 0.0f;
+		m.CurrentSpeed = 0.0f;
 		if (anim == "walk")
 		{
 			CmpPtr<ICmpUnitMotion> cmpUnitMotion(m.Simulation2, m.Entity);
 			if (cmpUnitMotion)
-				speed = cmpUnitMotion->GetWalkSpeed().ToFloat();
+				speed  = cmpUnitMotion->GetWalkSpeed().ToFloat();
 			else
-				speed = 7.f; // typical unit speed
-
+				speed = 7.f; // Typical unit walk speed.
 			m.CurrentSpeed = speed;
 		}
 		else if (anim == "run")
 		{
 			CmpPtr<ICmpUnitMotion> cmpUnitMotion(m.Simulation2, m.Entity);
 			if (cmpUnitMotion)
 				speed = cmpUnitMotion->GetWalkSpeed().ToFloat() * cmpUnitMotion->GetRunMultiplier().ToFloat();
 			else
-				speed = 12.f; // typical unit speed
+				speed = 12.f; // Typical unit run speed.
 
 			m.CurrentSpeed = speed;
 		}
-		else if (anim == "melee")
-		{
-			speed = 1.f; // speed will be ignored if we have a repeattime
-			m.CurrentSpeed = 0.f;
-
-			CStr code = "var cmp = Engine.QueryInterface("+CStr::FromUInt(m.Entity)+", IID_Attack); " +
-				"if (cmp) cmp.GetTimers(cmp.GetBestAttack()).repeat; else 0;";
-			m.Simulation2.GetScriptInterface().Eval(code.c_str(), repeattime);
-		}
-		else
-		{
-			// Play the animation at normal speed, but movement speed is zero
-			speed = 1.f;
-			m.CurrentSpeed = 0.f;
-		}
-
-		CStr sound;
-		if (anim == "melee")
-			sound = "attack";
-		else if (anim == "build")
-			sound = "build";
-		else if (anim.Find("gather_") == 0)
-			sound = anim;
+		else if (anim == "attack_melee")
+			repeattime = GetRepeatTimeByAttackType("Melee");
+		else if (anim == "attack_ranged")
+			repeattime = GetRepeatTimeByAttackType("Ranged");
+		else if (anim == "attack_slaughter")
+			repeattime = GetRepeatTimeByAttackType("Slaughter");
+		else if (anim == "attack_capture")
+			repeattime = GetRepeatTimeByAttackType("Capture");
 
 		CmpPtr<ICmpVisual> cmpVisual(m.Simulation2, m.Entity);
 		if (cmpVisual)
 		{
 			// TODO: SetEntitySelection(anim)
 			cmpVisual->SelectAnimation(anim, false, fixed::FromFloat(speed));
 			if (repeattime)
 				cmpVisual->SetAnimationSyncRepeat(fixed::FromFloat(repeattime));
 		}
 
 		// update prop list for new entity/animation (relies on needsAnimReload also getting called for entire entity changes)
 		m.UpdatePropList();
 	}
 
 	m.CurrentUnitID = id;
 	m.CurrentUnitAnim = animation;
 }
 
 void ActorViewer::SetEnabled(bool enabled)
 {
 	if (enabled)
 	{
 		// Set shadows, sky and water.
 		m.OldShadows = g_RenderingOptions.GetShadows();
 		g_RenderingOptions.SetShadows(m.ShadowsEnabled);
 
 		m.OldSky = g_Renderer.GetSkyManager()->GetRenderSky();
 		g_Renderer.GetSkyManager()->SetRenderSky(false);
 
 		m.OldWater = g_Renderer.GetWaterManager()->m_RenderWater;
 		g_Renderer.GetWaterManager()->m_RenderWater = m.WaterEnabled;
 	}
 	else
 	{
 		// Restore the old renderer state
 		g_RenderingOptions.SetShadows(m.OldShadows);
 		g_Renderer.GetSkyManager()->SetRenderSky(m.OldSky);
 		g_Renderer.GetWaterManager()->m_RenderWater = m.OldWater;
 	}
 }
 
 void ActorViewer::SetBackgroundColor(const SColor4ub& color)
 {
 	m.Background = color;
 	m.Terrain.SetBaseColor(color);
 }
 
 void ActorViewer::SetWalkEnabled(bool enabled)    { m.WalkEnabled = enabled; }
 void ActorViewer::SetGroundEnabled(bool enabled)  { m.GroundEnabled = enabled; }
 void ActorViewer::SetWaterEnabled(bool enabled)
 {
 	m.WaterEnabled = enabled;
 	// Adjust water level
 	entity_pos_t waterLevel = entity_pos_t::FromFloat(enabled ? 10.f : 0.f);
 	CmpPtr<ICmpWaterManager> cmpWaterManager(m.Simulation2, SYSTEM_ENTITY);
 	if (cmpWaterManager)
 		cmpWaterManager->SetWaterLevel(waterLevel);
 }
 void ActorViewer::SetShadowsEnabled(bool enabled) { m.ShadowsEnabled = enabled; }
 void ActorViewer::SetBoundingBoxesEnabled(bool enabled) { m.SelectionBoxEnabled = enabled; }
 void ActorViewer::SetAxesMarkerEnabled(bool enabled)    { m.AxesMarkerEnabled = enabled; }
 void ActorViewer::SetPropPointsMode(int mode)           { m.PropPointsMode = mode; }
 
 void ActorViewer::SetStatsEnabled(bool enabled)
 {
 	if (enabled)
 		g_ProfileViewer.ShowTable("renderer");
 	else
 		g_ProfileViewer.ShowTable("");
 }
 
+float ActorViewer::GetRepeatTimeByAttackType(const std::string& type) const
+{
+	CmpPtr<ICmpAttack> cmpAttack(m.Simulation2, m.Entity);
+	if (cmpAttack)
+		return cmpAttack->GetRepeatTime(type);
+
+	return 0.0f;
+}
+
 void ActorViewer::Render()
 {
 	m.Terrain.MakeDirty(RENDERDATA_UPDATE_COLOR);
 
 	g_Renderer.SetClearColor(m.Background);
 
 	// Set simulation context for rendering purposes
 	g_Renderer.SetSimulation(&m.Simulation2);
 
 	g_Renderer.BeginFrame();
 
 	// Find the centre of the interesting region, in the middle of the patch
 	// and half way up the model (assuming there is one)
 	CVector3D centre;
 	CmpPtr<ICmpVisual> cmpVisual(m.Simulation2, m.Entity);
 	if (cmpVisual)
 		cmpVisual->GetBounds().GetCenter(centre);
 	else
 		centre.Y = 0.f;
 	centre.X = centre.Z = TERRAIN_TILE_SIZE * m.Terrain.GetPatchesPerSide()*PATCH_SIZE/2;
 
 	CCamera camera = AtlasView::GetView_Actor()->GetCamera();
 	camera.m_Orientation.Translate(centre.X, centre.Y, centre.Z);
 	camera.UpdateFrustum();
 
 	g_Renderer.SetSceneCamera(camera, camera);
 
 	g_Renderer.RenderScene(m);
 
 	glDisable(GL_DEPTH_TEST);
 	g_Logger->Render();
 	g_ProfileViewer.RenderProfile();
 	glEnable(GL_DEPTH_TEST);
 
 	g_Renderer.EndFrame();
 
 	ogl_WarnIfError();
 }
 
 void ActorViewer::Update(float simFrameLength, float realFrameLength)
 {
 	m.Simulation2.Update((int)(simFrameLength*1000));
 	m.Simulation2.Interpolate(simFrameLength, 0, realFrameLength);
 
 	if (m.WalkEnabled && m.CurrentSpeed)
 	{
 		CmpPtr<ICmpPosition> cmpPosition(m.Simulation2, m.Entity);
 		if (cmpPosition)
 		{
 			// Move the model by speed*simFrameLength forwards
 			float z = cmpPosition->GetPosition().Z.ToFloat();
 			z -= m.CurrentSpeed*simFrameLength;
 			// Wrap at the edges, so it doesn't run off into the horizon
 			ssize_t c = TERRAIN_TILE_SIZE * m.Terrain.GetPatchesPerSide()*PATCH_SIZE/2;
 			if (z < c - TERRAIN_TILE_SIZE*PATCH_SIZE * 0.1f)
 				z = c + TERRAIN_TILE_SIZE*PATCH_SIZE * 0.1f;
 			cmpPosition->JumpTo(cmpPosition->GetPosition().X, entity_pos_t::FromFloat(z));
 		}
 	}
 }
Index: ps/trunk/source/tools/atlas/GameInterface/ActorViewer.h
===================================================================
--- ps/trunk/source/tools/atlas/GameInterface/ActorViewer.h	(revision 23591)
+++ ps/trunk/source/tools/atlas/GameInterface/ActorViewer.h	(revision 23592)
@@ -1,57 +1,58 @@
-/* Copyright (C) 2019 Wildfire Games.
+/* Copyright (C) 2020 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 2 of the License, or
  * (at your option) any later version.
  *
  * 0 A.D. is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef INCLUDED_ACTORVIEWER
 #define INCLUDED_ACTORVIEWER
 
 #include "ps/CStr.h"
 #include "simulation2/helpers/Player.h"
 #include "simulation2/system/Entity.h"
 
 struct ActorViewerImpl;
 struct SColor4ub;
 class CSimulation2;
 
 class ActorViewer
 {
 	NONCOPYABLE(ActorViewer);
 public:
 	ActorViewer();
 	~ActorViewer();
 
 	CSimulation2* GetSimulation2();
 	entity_id_t GetEntity();
 	void SetActor(const CStrW& id, const CStr& animation, player_id_t playerID);
 	void SetEnabled(bool enabled);
 	void UnloadObjects();
 	void SetBackgroundColor(const SColor4ub& color);
 	void SetWalkEnabled(bool enabled);
 	void SetGroundEnabled(bool enabled);
 	void SetWaterEnabled(bool enabled);
 	void SetShadowsEnabled(bool enabled);
 	void SetStatsEnabled(bool enabled);
 	void SetBoundingBoxesEnabled(bool enabled);
 	void SetAxesMarkerEnabled(bool enabled);
 	void SetPropPointsMode(int mode);
 	void Render();
 	void Update(float simFrameLength, float realFrameLength);
 
 private:
 	ActorViewerImpl& m;
+	float GetRepeatTimeByAttackType(const std::string& type) const;
 };
 
 #endif // INCLUDED_ACTORVIEWER