Index: ps/trunk/binaries/data/mods/public/simulation/components/Attack.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Attack.js	(revision 22303)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Attack.js	(revision 22304)
@@ -1,694 +1,712 @@
 function Attack() {}
 
 var g_AttackTypes = ["Melee", "Ranged", "Capture"];
 
+Attack.prototype.statusEffectsSchema =
+	"<optional>" +
+		"<element name='StatusEffects' a:help='Effects like poisioning or burning a unit.'>" +
+			"<oneOrMore>" +
+				"<element>" +
+					"<anyName/>" +
+					"<interleave>" +
+							"<element name='Duration' a:help='The duration of the status while the effect occurs.'><ref name='nonNegativeDecimal'/></element>" +
+							"<element name='Interval' a:help='Interval between the occurances of the effect.'><ref name='nonNegativeDecimal'/></element>" +
+							"<element name='Damage' a:help='Damage caused by the effect.'><ref name='nonNegativeDecimal'/></element>" +
+					"</interleave>" +
+				"</element>" +
+			"</oneOrMore>" +
+		"</element>" +
+	"</optional>";
+
 Attack.prototype.bonusesSchema =
 	"<optional>" +
 		"<element name='Bonuses'>" +
 			"<zeroOrMore>" +
 				"<element>" +
 					"<anyName/>" +
 					"<interleave>" +
 						"<optional>" +
 							"<element name='Civ' a:help='If an entity has this civ then the bonus is applied'><text/></element>" +
 						"</optional>" +
 						"<element name='Classes' a:help='If an entity has all these classes then the bonus is applied'><text/></element>" +
 						"<element name='Multiplier' a:help='The attackers attack strength is multiplied by this'><ref name='nonNegativeDecimal'/></element>" +
 					"</interleave>" +
 				"</element>" +
 			"</zeroOrMore>" +
 		"</element>" +
 	"</optional>";
 
 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>" +
 			"<Hack>10.0</Hack>" +
 			"<Pierce>0.0</Pierce>" +
 			"<Crush>5.0</Crush>" +
 			"<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>" +
 			"<Hack>0.0</Hack>" +
 			"<Pierce>10.0</Pierce>" +
 			"<Crush>0.0</Crush>" +
 			"<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>" +
 			"</Projectile>" +
 			"<RestrictedClasses datatype=\"tokens\">Champion</RestrictedClasses>" +
 			"<Splash>" +
 				"<Shape>Circular</Shape>" +
 				"<Range>20</Range>" +
 				"<FriendlyFire>false</FriendlyFire>" +
 				"<Hack>0.0</Hack>" +
 				"<Pierce>10.0</Pierce>" +
 				"<Crush>0.0</Crush>" +
 			"</Splash>" +
 		"</Ranged>" +
 		"<Slaughter>" +
 			"<Hack>1000.0</Hack>" +
 			"<Pierce>0.0</Pierce>" +
 			"<Crush>0.0</Crush>" +
 			"<MaxRange>4.0</MaxRange>" +
 		"</Slaughter>" +
 	"</a:example>" +
 	"<optional>" +
 		"<element name='Melee'>" +
 			"<interleave>" +
 				DamageTypes.BuildSchema("damage strength") +
 				"<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.bonusesSchema +
 				Attack.prototype.preferredClassesSchema +
 				Attack.prototype.restrictedClassesSchema +
 			"</interleave>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Ranged'>" +
 			"<interleave>" +
 				DamageTypes.BuildSchema("damage strength") +
 				"<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>" +
 							DamageTypes.BuildSchema("damage strength") +
 							Attack.prototype.bonusesSchema +
 						"</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>" +
 						"<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.statusEffectsSchema +
 				Attack.prototype.bonusesSchema +
 				Attack.prototype.preferredClassesSchema +
 				Attack.prototype.restrictedClassesSchema +
 			"</interleave>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Capture'>" +
 			"<interleave>" +
 				"<element name='Value' a:help='Capture points value'><ref name='nonNegativeDecimal'/></element>" +
 				"<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.bonusesSchema +
 				Attack.prototype.preferredClassesSchema +
 				Attack.prototype.restrictedClassesSchema +
 			"</interleave>" +
 		"</element>" +
 	"</optional>" +
 	"<optional>" +
 		"<element name='Slaughter' a:help='A special attack to kill domestic animals'>" +
 			"<interleave>" +
 				DamageTypes.BuildSchema("damage strength") +
 				"<element name='MaxRange'><ref name='nonNegativeDecimal'/></element>" + // TODO: how do these work?
 				Attack.prototype.bonusesSchema +
 				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.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;
 
 	let targetClasses = cmpIdentity.GetClassesList();
 	let isTargetClass = className => targetClasses.indexOf(className) != -1;
 
 	// Always slaughter domestic animals instead of using a normal attack
 	if (isTargetClass("Domestic") && this.template.Slaughter)
 		return "Slaughter";
 
 	let types = this.GetAttackTypes().filter(type => !this.GetRestrictedClasses(type).some(isTargetClass));
 
 	// check if the target is capturable
 	let captureIndex = types.indexOf("Capture");
 	if (captureIndex != -1)
 	{
 		let cmpCapturable = QueryMiragedInterface(target, IID_Capturable);
 
 		let cmpPlayer = QueryOwnerInterface(this.entity);
 		if (allowCapture && cmpPlayer && cmpCapturable && cmpCapturable.CanCapture(cmpPlayer.GetPlayerID()))
 			return "Capture";
 		// not capturable, so remove this attack
 		types.splice(captureIndex, 1);
 	}
 
 	let isPreferred = className => this.GetPreferredClasses(className).some(isTargetClass);
 
 	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)
 {
 	let prepare = +(this.template[type].PrepareTime || 0);
 	prepare = ApplyValueModificationsToEntity("Attack/" + type + "/PrepareTime", prepare, this.entity);
 
 	let repeat = +(this.template[type].RepeatTime || 1000);
 	repeat = ApplyValueModificationsToEntity("Attack/" + type + "/RepeatTime", repeat, this.entity);
 
 	return { "prepare": prepare, "repeat": repeat };
 };
 
 Attack.prototype.GetAttackStrengths = function(type)
 {
 	// Work out the attack values with technology effects
 	let template = this.template[type];
 	let splash = "";
 	if (!template)
 	{
 		template = this.template[type.split(".")[0]].Splash;
 		splash = "/Splash";
 	}
 
 	let applyMods = damageType =>
 		ApplyValueModificationsToEntity("Attack/" + type + splash + "/" + damageType, +(template[damageType] || 0), this.entity);
 
 	if (type == "Capture")
 		return { "value": applyMods("Value") };
 
 	let ret = {};
 	for (let damageType of DamageTypes.GetTypes())
 		ret[damageType] = applyMods(damageType);
 
 	return ret;
 };
 
 Attack.prototype.GetSplashDamage = function(type)
 {
 	if (!this.template[type].Splash)
 		return false;
 
 	let splash = this.GetAttackStrengths(type + ".Splash");
 	splash.friendlyFire = this.template[type].Splash.FriendlyFire != "false";
 	splash.shape = this.template[type].Splash.Shape;
 	return splash;
 };
 
 Attack.prototype.GetRange = function(type)
 {
 	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.prototype.GetBonusTemplate = function(type)
 {
 	let template = this.template[type];
 	if (!template)
 		template = this.template[type.split(".")[0]].Splash;
 
 	return template.Bonuses || null;
 };
 
 /**
  * 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();
  	let cmpDamage = Engine.QueryInterface(SYSTEM_ENTITY, IID_Damage);
 
 	// 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.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,
 			"attacker": this.entity,
 			"target": target,
 			"strengths": this.GetAttackStrengths(type),
 			"position": realTargetPosition,
 			"direction": missileDirection,
 			"projectileId": id,
 			"bonus": this.GetBonusTemplate(type),
 			"isSplash": false,
 			"attackerOwner": attackerOwner,
-			"attackImpactSound": attackImpactSound
+			"attackImpactSound": attackImpactSound,
+			"statusEffects": this.template[type].StatusEffects
 		};
 		if (this.template[type].Splash)
 		{
 			data.friendlyFire = this.template[type].Splash.FriendlyFire != "false";
 			data.radius = +this.template[type].Splash.Range;
 			data.shape = this.template[type].Splash.Shape;
 			data.isSplash = true;
 			data.splashStrengths = this.GetAttackStrengths(type + ".Splash");
 			data.splashBonus = this.GetBonusTemplate(type + ".Splash");
 		}
 		cmpTimer.SetTimeout(SYSTEM_ENTITY, IID_Damage, "MissileHit", timeToTarget * 1000 + +this.template[type].Delay, data);
 	}
 	else if (type == "Capture")
 	{
 		if (attackerOwner == INVALID_PLAYER)
 			return;
 
 		let multiplier = GetDamageBonus(target, this.GetBonusTemplate(type));
 		let cmpHealth = Engine.QueryInterface(target, IID_Health);
 		if (!cmpHealth || cmpHealth.GetHitpoints() == 0)
 			return;
 		multiplier *= cmpHealth.GetMaxHitpoints() / (0.1 * cmpHealth.GetMaxHitpoints() + 0.9 * cmpHealth.GetHitpoints());
 
 		let cmpCapturable = Engine.QueryInterface(target, IID_Capturable);
 		if (!cmpCapturable || !cmpCapturable.CanCapture(attackerOwner))
 			return;
 
 		let strength = this.GetAttackStrengths("Capture").value * multiplier;
 		if (cmpCapturable.Reduce(strength, attackerOwner) && IsOwnedByEnemyOfPlayer(attackerOwner, target))
 			Engine.PostMessage(target, MT_Attacked, {
 				"attacker": this.entity,
 				"target": target,
 				"type": type,
 				"damage": strength,
 				"attackerOwner": attackerOwner
 			});
 	}
 	else
 	{
 		// Melee attack - hurt the target immediately
 		cmpDamage.CauseDamage({
 			"strengths": this.GetAttackStrengths(type),
 			"target": target,
 			"attacker": this.entity,
 			"multiplier": GetDamageBonus(target, this.GetBonusTemplate(type)),
 			"type": type,
 			"attackerOwner": 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/Damage.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/Damage.js	(revision 22303)
+++ ps/trunk/binaries/data/mods/public/simulation/components/Damage.js	(revision 22304)
@@ -1,306 +1,312 @@
 function Damage() {}
 
 Damage.prototype.Schema =
 	"<a:component type='system'/><empty/>";
 
 Damage.prototype.Init = function()
 {
 };
 
 /**
  * Gives the position of the given entity, taking the lateness into account.
  * @param {number} ent - entity id of the entity we are finding the location for.
  * @param {number} lateness - the time passed since the expected time to fire the function.
  * @return {Vector3D} - the location of the entity.
  */
 Damage.prototype.InterpolatedLocation = function(ent, lateness)
 {
 	let cmpTargetPosition = Engine.QueryInterface(ent, IID_Position);
 	if (!cmpTargetPosition || !cmpTargetPosition.IsInWorld()) // TODO: handle dead target properly
 		return undefined;
 	let curPos = cmpTargetPosition.GetPosition();
 	let prevPos = cmpTargetPosition.GetPreviousPosition();
 	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
 	let turnLength = cmpTimer.GetLatestTurnLength();
 	return new Vector3D(
 			(curPos.x * (turnLength - lateness) + prevPos.x * lateness) / turnLength,
 			0,
 			(curPos.z * (turnLength - lateness) + prevPos.z * lateness) / turnLength);
 };
 
 /**
  * Test if a point is inside of an entity's footprint.
  * @param {number}   ent - id of the entity we are checking with.
  * @param {Vector3D} point - the point we are checking with.
  * @param {number}   lateness - the time passed since the expected time to fire the function.
  * @return {boolean} - true if the point is inside of the entity's footprint.
  */
 Damage.prototype.TestCollision = function(ent, point, lateness)
 {
 	let targetPosition = this.InterpolatedLocation(ent, lateness);
 	if (!targetPosition)
 		return false;
 
 	let cmpFootprint = Engine.QueryInterface(ent, IID_Footprint);
 	if (!cmpFootprint)
 		return false;
 
 	let targetShape = cmpFootprint.GetShape();
 
 	if (!targetShape)
 		return false;
 
 	if (targetShape.type == "circle")
 		return targetPosition.horizDistanceToSquared(point) < targetShape.radius * targetShape.radius;
 
 	if (targetShape.type == "square")
 	{
 		let angle = Engine.QueryInterface(ent, IID_Position).GetRotation().y;
 		let distance = Vector2D.from3D(Vector3D.sub(point, targetPosition)).rotate(-angle);
 		return Math.abs(distance.x) < targetShape.width / 2 && Math.abs(distance.y) < targetShape.depth / 2;
 	}
 
 	warn("TestCollision called with an invalid footprint shape");
 	return false;
 };
 
 /**
  * Get the list of players affected by the damage.
  * @param {number}  attackerOwner - the player id of the attacker.
  * @param {boolean} friendlyFire - a flag indicating if allied entities are also damaged.
  * @return {number[]} - the ids of players need to be damaged
  */
 Damage.prototype.GetPlayersToDamage = function(attackerOwner, friendlyFire)
 {
 	if (!friendlyFire)
 		return QueryPlayerIDInterface(attackerOwner).GetEnemies();
 
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetAllPlayers();
 };
 
 /**
  * Handles hit logic after the projectile travel time has passed.
  * @param {Object}   data - the data sent by the caller.
  * @param {number}   data.attacker - the entity id of the attacker.
  * @param {number}   data.target - the entity id of the target.
  * @param {Vector2D} data.origin - the origin of the projectile hit.
  * @param {Object}   data.strengths - data of the form { 'hack': number, 'pierce': number, 'crush': number }.
  * @param {string}   data.type - the type of damage.
  * @param {number}   data.attackerOwner - the player id of the owner of the attacker.
  * @param {boolean}  data.isSplash - a flag indicating if it's splash damage.
  * @param {Vector3D} data.position - the expected position of the target.
  * @param {number}   data.projectileId - the id of the projectile.
  * @param {Vector3D} data.direction - the unit vector defining the direction.
  * @param {Object}   data.bonus - the attack bonus template from the attacker.
  * @param {string}   data.attackImpactSound - the name of the sound emited on impact.
+ * @param {Object}   data.statusEffects - status effects eg. poisoning, burning etc.
  * ***When splash damage***
  * @param {boolean}  data.friendlyFire - a flag indicating if allied entities are also damaged.
  * @param {number}   data.radius - the radius of the splash damage.
  * @param {string}   data.shape - the shape of the splash range.
  * @param {Object}   data.splashBonus - the attack bonus template from the attacker.
  * @param {Object}   data.splashStrengths - data of the form { 'hack': number, 'pierce': number, 'crush': number }.
  */
 Damage.prototype.MissileHit = function(data, lateness)
 {
 	if (!data.position)
 		return;
 
 	let cmpSoundManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_SoundManager);
 	if (cmpSoundManager && data.attackImpactSound)
 		cmpSoundManager.PlaySoundGroupAtPosition(data.attackImpactSound, data.position);
 
 	// Do this first in case the direct hit kills the target
 	if (data.isSplash)
 	{
 		this.CauseSplashDamage({
 			"attacker": data.attacker,
 			"origin": Vector2D.from3D(data.position),
 			"radius": data.radius,
 			"shape": data.shape,
 			"strengths": data.splashStrengths,
 			"splashBonus": data.splashBonus,
 			"direction": data.direction,
 			"playersToDamage": this.GetPlayersToDamage(data.attackerOwner, data.friendlyFire),
 			"type": data.type,
 			"attackerOwner": data.attackerOwner
 		});
 	}
 
 	let cmpProjectileManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_ProjectileManager);
 
 	// Deal direct damage if we hit the main target
 	// and if the target has DamageReceiver (not the case for a mirage for example)
 	let cmpDamageReceiver = Engine.QueryInterface(data.target, IID_DamageReceiver);
 	if (cmpDamageReceiver && this.TestCollision(data.target, data.position, lateness))
 	{
 		data.multiplier = GetDamageBonus(data.target, data.bonus);
 		this.CauseDamage(data);
 		cmpProjectileManager.RemoveProjectile(data.projectileId);
+
+		let cmpStatusReceiver = Engine.QueryInterface(data.target, IID_StatusEffectsReceiver);
+		if (cmpStatusReceiver && data.statusEffects)
+			cmpStatusReceiver.InflictEffects(data.statusEffects);
+
 		return;
 	}
 
 	let targetPosition = this.InterpolatedLocation(data.target, lateness);
 	if (!targetPosition)
 		return;
 
 	// If we didn't hit the main target look for nearby units
 	let cmpPlayer = QueryPlayerIDInterface(data.attackerOwner);
 	let ents = this.EntitiesNearPoint(Vector2D.from3D(data.position), targetPosition.horizDistanceTo(data.position) * 2, cmpPlayer.GetEnemies());
 	for (let ent of ents)
 	{
 		if (!this.TestCollision(ent, data.position, lateness))
 			continue;
 
 		this.CauseDamage({
 			"strengths": data.strengths,
 			"target": ent,
 			"attacker": data.attacker,
 			"multiplier": GetDamageBonus(ent, data.bonus),
 			"type": data.type,
 			"attackerOwner": data.attackerOwner
 		});
 		cmpProjectileManager.RemoveProjectile(data.projectileId);
 		break;
 	}
 };
 
 /**
  * Damages units around a given origin.
  * @param {Object}   data - the data sent by the caller.
  * @param {number}   data.attacker - the entity id of the attacker.
  * @param {Vector2D} data.origin - the origin of the projectile hit.
  * @param {number}   data.radius - the radius of the splash damage.
  * @param {string}   data.shape - the shape of the radius.
  * @param {Object}   data.strengths - data of the form { 'hack': number, 'pierce': number, 'crush': number }.
  * @param {string}   data.type - the type of damage.
  * @param {number}   data.attackerOwner - the player id of the attacker.
  * @param {Vector3D} [data.direction] - the unit vector defining the direction. Needed for linear splash damage.
  * @param {Object}   data.splashBonus - the attack bonus template from the attacker.
  * @param {number[]} data.playersToDamage - the array of player id's to damage.
  */
 Damage.prototype.CauseSplashDamage = function(data)
 {
 	// Get nearby entities and define variables
 	let nearEnts = this.EntitiesNearPoint(data.origin, data.radius, data.playersToDamage);
 	let damageMultiplier = 1;
 
 	// Cycle through all the nearby entities and damage it appropriately based on its distance from the origin.
 	for (let ent of nearEnts)
 	{
 		let entityPosition = Engine.QueryInterface(ent, IID_Position).GetPosition2D();
 		if (data.shape == 'Circular') // circular effect with quadratic falloff in every direction
 			damageMultiplier = 1 - data.origin.distanceToSquared(entityPosition) / (data.radius * data.radius);
 		else if (data.shape == 'Linear') // linear effect with quadratic falloff in two directions (only used for certain missiles)
 		{
 			// Get position of entity relative to splash origin.
 			let relativePos = entityPosition.sub(data.origin);
 
 			// Get the position relative to the missile direction.
 			let direction = Vector2D.from3D(data.direction);
 			let parallelPos = relativePos.dot(direction);
 			let perpPos = relativePos.cross(direction);
 
 			// The width of linear splash is one fifth of the normal splash radius.
 			let width = data.radius / 5;
 
 			// Check that the unit is within the distance splash width of the line starting at the missile's
 			// landing point which extends in the direction of the missile for length splash radius.
 			if (parallelPos >= 0 && Math.abs(perpPos) < width) // If in radius, quadratic falloff in both directions
 				damageMultiplier = (1 - parallelPos * parallelPos / (data.radius * data.radius)) *
 					(1 - perpPos * perpPos / (width * width));
 			else
 				damageMultiplier = 0;
 		}
 		else // In case someone calls this function with an invalid shape.
 		{
 			warn("The " + data.shape + " splash damage shape is not implemented!");
 		}
 
 		if (data.splashBonus)
 			damageMultiplier *= GetDamageBonus(ent, data.splashBonus);
 
 		// Call CauseDamage which reduces the hitpoints, posts network command, plays sounds....
 		this.CauseDamage({
 			"strengths": data.strengths,
 			"target": ent,
 			"attacker": data.attacker,
 			"multiplier": damageMultiplier,
 			"type": data.type + ".Splash",
 			"attackerOwner": data.attackerOwner
 		});
 	}
 };
 
 /**
  * Causes damage on a given unit.
  * @param {Object} data - the data passed by the caller.
  * @param {Object} data.strengths - data in the form of { 'hack': number, 'pierce': number, 'crush': number }.
  * @param {number} data.target - the entity id of the target.
- * @param {number} data.attacker - the entity id og the attacker.
+ * @param {number} data.attacker - the entity id of the attacker.
  * @param {number} data.multiplier - the damage multiplier.
  * @param {string} data.type - the type of damage.
  * @param {number} data.attackerOwner - the player id of the attacker.
  */
 Damage.prototype.CauseDamage = function(data)
 {
 	let cmpDamageReceiver = Engine.QueryInterface(data.target, IID_DamageReceiver);
 	if (!cmpDamageReceiver)
 		return;
 
 	let targetState = cmpDamageReceiver.TakeDamage(data.strengths, data.multiplier);
 
 	let cmpPromotion = Engine.QueryInterface(data.attacker, IID_Promotion);
 	let cmpLoot = Engine.QueryInterface(data.target, IID_Loot);
 	let cmpHealth = Engine.QueryInterface(data.target, IID_Health);
 	if (cmpPromotion && cmpLoot && cmpLoot.GetXp() > 0)
 		cmpPromotion.IncreaseXp(cmpLoot.GetXp() * -targetState.change / cmpHealth.GetMaxHitpoints());
 
 	if (targetState.killed)
 		this.TargetKilled(data.attacker, data.target, data.attackerOwner);
 
 	Engine.PostMessage(data.target, MT_Attacked, { "attacker": data.attacker, "target": data.target, "type": data.type, "damage": -targetState.change, "attackerOwner": data.attackerOwner });
 };
 
 /**
  * Gets entities near a give point for given players.
  * @param {Vector2D} origin - the point to check around.
  * @param {number}   radius - the radius around the point to check.
  * @param {number[]} players - the players of which we need to check entities.
  * @return {number[]} - the id's of the entities in range of the given point.
  */
 Damage.prototype.EntitiesNearPoint = function(origin, radius, players)
 {
 	// If there is insufficient data return an empty array.
 	if (!origin || !radius || !players)
 		return [];
 
 	return Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager).ExecuteQueryAroundPos(origin, 0, radius, players, IID_DamageReceiver);
 };
 
 /**
  * Called when a unit kills something (another unit, building, animal etc)
  * @param {number} attacker - the entity id of the killer.
  * @param {number} target - the entity id of the target.
  * @param {number} attackerOwner - the player id of the attacker.
  */
 Damage.prototype.TargetKilled = function(attacker, target, attackerOwner)
 {
 	let cmpAttackerOwnership = Engine.QueryInterface(attacker, IID_Ownership);
 	let atkOwner = cmpAttackerOwnership && cmpAttackerOwnership.GetOwner() != INVALID_PLAYER ? cmpAttackerOwnership.GetOwner() : attackerOwner;
 
 	// Add to killer statistics.
 	let cmpKillerPlayerStatisticsTracker = QueryPlayerIDInterface(atkOwner, IID_StatisticsTracker);
 	if (cmpKillerPlayerStatisticsTracker)
 		cmpKillerPlayerStatisticsTracker.KilledEntity(target);
 	// Add to loser statistics.
 	let cmpTargetPlayerStatisticsTracker = QueryOwnerInterface(target, IID_StatisticsTracker);
 	if (cmpTargetPlayerStatisticsTracker)
 		cmpTargetPlayerStatisticsTracker.LostEntity(target);
 
 	// If killer can collect loot, let's try to collect it.
 	let cmpLooter = Engine.QueryInterface(attacker, IID_Looter);
 	if (cmpLooter)
 		cmpLooter.Collect(target);
 };
 
 Engine.RegisterSystemComponentType(IID_Damage, "Damage", Damage);
Index: ps/trunk/binaries/data/mods/public/simulation/components/StatusEffectsReceiver.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/StatusEffectsReceiver.js	(nonexistent)
+++ ps/trunk/binaries/data/mods/public/simulation/components/StatusEffectsReceiver.js	(revision 22304)
@@ -0,0 +1,69 @@
+function StatusEffectsReceiver() {}
+
+StatusEffectsReceiver.prototype.Init = function()
+{
+	this.activeStatusEffects = {};
+};
+
+StatusEffectsReceiver.prototype.InflictEffects = function(statusEffects)
+{
+	for (let effect in statusEffects)
+		this.InflictEffect(effect, statusEffects[effect]);
+};
+
+StatusEffectsReceiver.prototype.InflictEffect = function(statusName, data)
+{
+	if (this.activeStatusEffects[statusName])
+		return;
+
+	this.activeStatusEffects[statusName] = {};
+	let status = this.activeStatusEffects[statusName];
+	status.duration = +data.Duration;
+	status.interval = +data.Interval;
+	status.damage = +data.Damage;
+	status.timeElapsed = 0;
+	status.firstTime = true;
+
+	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+	status.timer = cmpTimer.SetInterval(this.entity, IID_StatusEffectsReceiver, "ExecuteEffect", 0, +status.interval, statusName);
+};
+
+StatusEffectsReceiver.prototype.RemoveEffect = function(statusName) {
+	if (!this.activeStatusEffects[statusName])
+		return;
+
+	let cmpTimer = Engine.QueryInterface(SYSTEM_ENTITY, IID_Timer);
+	cmpTimer.CancelTimer(this.activeStatusEffects[statusName].timer);
+	this.activeStatusEffects[statusName] = undefined;
+};
+
+StatusEffectsReceiver.prototype.ExecuteEffect = function(statusName, lateness)
+{
+	let status = this.activeStatusEffects[statusName];
+	if (!status)
+		return;
+
+	if (status.firstTime)
+	{
+		status.firstTime = false;
+		status.timeElapsed += lateness;
+	}
+	else
+		status.timeElapsed += status.interval + lateness;
+
+	let cmpDamage = Engine.QueryInterface(SYSTEM_ENTITY, IID_Damage);
+
+	cmpDamage.CauseDamage({
+		"strengths": { [statusName]: status.damage },
+		"target": this.entity,
+		"attacker": -1,
+		"multiplier": 1,
+		"type": statusName,
+		"attackerOwner": -1
+	});
+
+	if (status.timeElapsed >= status.duration)
+		this.RemoveEffect(statusName);
+};
+
+Engine.RegisterComponentType(IID_StatusEffectsReceiver, "StatusEffectsReceiver", StatusEffectsReceiver);

Property changes on: ps/trunk/binaries/data/mods/public/simulation/components/StatusEffectsReceiver.js
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/public/simulation/components/interfaces/StatusEffectsReceiver.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/interfaces/StatusEffectsReceiver.js	(nonexistent)
+++ ps/trunk/binaries/data/mods/public/simulation/components/interfaces/StatusEffectsReceiver.js	(revision 22304)
@@ -0,0 +1 @@
+Engine.RegisterInterface("StatusEffectsReceiver");

Property changes on: ps/trunk/binaries/data/mods/public/simulation/components/interfaces/StatusEffectsReceiver.js
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Damage.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Damage.js	(revision 22303)
+++ ps/trunk/binaries/data/mods/public/simulation/components/tests/test_Damage.js	(revision 22304)
@@ -1,550 +1,551 @@
 Engine.LoadHelperScript("DamageBonus.js");
 Engine.LoadHelperScript("DamageTypes.js");
 Engine.LoadHelperScript("Player.js");
 Engine.LoadHelperScript("Sound.js");
 Engine.LoadHelperScript("ValueModification.js");
 Engine.LoadComponentScript("interfaces/Attack.js");
 Engine.LoadComponentScript("interfaces/AttackDetection.js");
 Engine.LoadComponentScript("interfaces/AuraManager.js");
 Engine.LoadComponentScript("interfaces/Damage.js");
 Engine.LoadComponentScript("interfaces/DamageReceiver.js");
 Engine.LoadComponentScript("interfaces/Health.js");
 Engine.LoadComponentScript("interfaces/Loot.js");
 Engine.LoadComponentScript("interfaces/Player.js");
 Engine.LoadComponentScript("interfaces/Promotion.js");
+Engine.LoadComponentScript("interfaces/StatusEffectsReceiver.js");
 Engine.LoadComponentScript("interfaces/TechnologyManager.js");
 Engine.LoadComponentScript("interfaces/Timer.js");
 Engine.LoadComponentScript("Attack.js");
 Engine.LoadComponentScript("Damage.js");
 Engine.LoadComponentScript("Timer.js");
 
 function Test_Generic()
 {
 	ResetState();
 
 	let cmpDamage = ConstructComponent(SYSTEM_ENTITY, "Damage");
 	let cmpTimer = ConstructComponent(SYSTEM_ENTITY, "Timer");
 	cmpTimer.OnUpdate({ turnLength: 1 });
 	let attacker = 11;
 	let atkPlayerEntity = 1;
 	let attackerOwner = 6;
 	let cmpAttack = ConstructComponent(attacker, "Attack",
 		{
 			"Ranged": {
 				"MaxRange": 50,
 				"MinRange": 0,
 				"Delay": 0,
 				"Projectile": {
 					"Speed": 75.0,
 					"Spread": 0.5,
 					"Gravity": 9.81,
 					"LaunchPoint": { "@y": 3 }
 				}
 			}
 		});
 	let damage = 5;
 	let target = 21;
 	let targetOwner = 7;
 	let targetPos = new Vector3D(3, 0, 3);
 
 	let type = "Melee";
 	let damageTaken = false;
 
 	cmpAttack.GetAttackStrengths = attackType => ({ "hack": 0, "pierce": 0, "crush": damage });
 
 	let data = {
 		"attacker": attacker,
 		"target": target,
 		"type": "Melee",
 		"strengths": { "hack": 0, "pierce": 0, "crush": damage },
 		"multiplier": 1.0,
 		"attackerOwner": attackerOwner,
 		"position": targetPos,
 		"isSplash": false,
 		"projectileId": 9,
 		"direction": new Vector3D(1,0,0)
 	};
 
 	AddMock(atkPlayerEntity, IID_Player, {
 		"GetEnemies": () => [targetOwner]
 	});
 
 	AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
 		"GetPlayerByID": id => atkPlayerEntity,
 		"GetAllPlayers": () => [0, 1, 2, 3, 4]
 	});
 
 	AddMock(SYSTEM_ENTITY, IID_ProjectileManager, {
 		"RemoveProjectile": () => {},
 		"LaunchProjectileAtPoint": (ent, pos, speed, gravity) => {},
 	});
 
 	AddMock(target, IID_Position, {
 		"GetPosition": () => targetPos,
 		"GetPreviousPosition": () => targetPos,
 		"GetPosition2D": () => Vector2D.From(targetPos),
 		"IsInWorld": () => true,
 	});
 
 	AddMock(target, IID_Health, {});
 
 	AddMock(target, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => { damageTaken = true; return { "killed": false, "change": -multiplier * strengths.crush }; },
 	});
 
 	Engine.PostMessage = function(ent, iid, message)
 	{
 		TS_ASSERT_UNEVAL_EQUALS({ "attacker": attacker, "target": target, "type": type, "damage": damage, "attackerOwner": attackerOwner }, message);
 	};
 
 	AddMock(target, IID_Footprint, {
 		"GetShape": () => ({ "type": "circle", "radius": 20 }),
 	});
 
 	AddMock(attacker, IID_Ownership, {
 		"GetOwner": () => attackerOwner,
 	});
 
 	AddMock(attacker, IID_Position, {
 		"GetPosition": () => new Vector3D(2, 0, 3),
 		"GetRotation": () => new Vector3D(1, 2, 3),
 		"IsInWorld": () => true,
 	});
 
 	function TestDamage()
 	{
 		cmpTimer.OnUpdate({ turnLength: 1 });
 		TS_ASSERT(damageTaken);
 		damageTaken = false;
 	}
 
 	cmpDamage.CauseDamage(data);
 	TestDamage();
 
 	type = data.type = "Ranged";
 	cmpDamage.CauseDamage(data);
 	TestDamage();
 
 	// Check for damage still being dealt if the attacker dies
 	cmpAttack.PerformAttack("Ranged", target);
 	Engine.DestroyEntity(attacker);
 	TestDamage();
 
 	atkPlayerEntity = 1;
 	AddMock(atkPlayerEntity, IID_Player, {
 		"GetEnemies": () => [2, 3]
 	});
 	TS_ASSERT_UNEVAL_EQUALS(cmpDamage.GetPlayersToDamage(atkPlayerEntity, true), [0, 1, 2, 3, 4]);
 	TS_ASSERT_UNEVAL_EQUALS(cmpDamage.GetPlayersToDamage(atkPlayerEntity, false), [2, 3]);
 }
 
 Test_Generic();
 
 function TestLinearSplashDamage()
 {
 	ResetState();
 	Engine.PostMessage = (ent, iid, message) => {};
 
 	const attacker = 50;
 	const attackerOwner = 1;
 
 	const origin = new Vector2D(0, 0);
 
 	let data = {
 		"attacker": attacker,
 		"origin": origin,
 		"radius": 10,
 		"shape": "Linear",
 		"strengths": { "hack" : 100, "pierce" : 0, "crush": 0 },
 		"direction": new Vector3D(1, 747, 0),
 		"playersToDamage": [2],
 		"type": "Ranged",
 		"attackerOwner": attackerOwner
 	};
 
 	let fallOff = function(x,y)
 	{
 		return (1 - x * x / (data.radius * data.radius)) * (1 - 25 * y * y / (data.radius * data.radius));
 	};
 
 	let hitEnts = new Set();
 
 	let cmpDamage = ConstructComponent(SYSTEM_ENTITY, "Damage");
 
 	AddMock(SYSTEM_ENTITY, IID_RangeManager, {
 		"ExecuteQueryAroundPos": () => [60, 61, 62],
 	});
 
 	AddMock(60, IID_Position, {
 		"GetPosition2D": () => new Vector2D(2.2, -0.4),
 	});
 
 	AddMock(61, IID_Position, {
 		"GetPosition2D": () => new Vector2D(0, 0),
 	});
 
 	AddMock(62, IID_Position, {
 		"GetPosition2D": () => new Vector2D(5, 2),
 	});
 
 	AddMock(60, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			hitEnts.add(60);
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 100 * fallOff(2.2, -0.4));
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(61, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			hitEnts.add(61);
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 100 * fallOff(0, 0));
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(62, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			hitEnts.add(62);
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 0);
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	cmpDamage.CauseSplashDamage(data);
 	TS_ASSERT(hitEnts.has(60));
 	TS_ASSERT(hitEnts.has(61));
 	TS_ASSERT(hitEnts.has(62));
 	hitEnts.clear();
 
 	data.direction = new Vector3D(0.6, 747, 0.8);
 
 	AddMock(60, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			hitEnts.add(60);
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 100 * fallOff(1, 2));
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	cmpDamage.CauseSplashDamage(data);
 	TS_ASSERT(hitEnts.has(60));
 	TS_ASSERT(hitEnts.has(61));
 	TS_ASSERT(hitEnts.has(62));
 	hitEnts.clear();
 }
 
 TestLinearSplashDamage();
 
 function TestCircularSplashDamage()
 {
 	ResetState();
 	Engine.PostMessage = (ent, iid, message) => {};
 
 	const radius = 10;
 
 	let fallOff = function(r)
 	{
 		return 1 - r * r / (radius * radius);
 	};
 
 	let cmpDamage = ConstructComponent(SYSTEM_ENTITY, "Damage");
 
 	AddMock(SYSTEM_ENTITY, IID_RangeManager, {
 		"ExecuteQueryAroundPos": () => [60, 61, 62, 64],
 	});
 
 	AddMock(60, IID_Position, {
 		"GetPosition2D": () => new Vector2D(3, 4),
 	});
 
 	AddMock(61, IID_Position, {
 		"GetPosition2D": () => new Vector2D(0, 0),
 	});
 
 	AddMock(62, IID_Position, {
 		"GetPosition2D": () => new Vector2D(3.6, 3.2),
 	});
 
 	AddMock(63, IID_Position, {
 		"GetPosition2D": () => new Vector2D(10, -10),
 	});
 
 	// Target on the frontier of the shape
 	AddMock(64, IID_Position, {
 		"GetPosition2D": () => new Vector2D(9, -4),
 	});
 
 	AddMock(60, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 100 * fallOff(0));
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(61, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 100 * fallOff(5));
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(62, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 100 * fallOff(1));
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(63, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			TS_ASSERT(false);
 		}
 	});
 
 	AddMock(64, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 0);
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	cmpDamage.CauseSplashDamage({
 		"attacker": 50,
 		"origin": new Vector2D(3, 4),
 		"radius": radius,
 		"shape": "Circular",
 		"strengths": { "hack" : 100, "pierce" : 0, "crush": 0 },
 		"playersToDamage": [2],
 		"type": "Ranged",
 		"attackerOwner": 1
 	});
 }
 
 TestCircularSplashDamage();
 
 function Test_MissileHit()
 {
 	ResetState();
 	Engine.PostMessage = (ent, iid, message) => {};
 
 	let cmpDamage = ConstructComponent(SYSTEM_ENTITY, "Damage");
 
 	let target = 60;
 	let targetOwner = 1;
 	let targetPos = new Vector3D(3, 10, 0);
 	let hitEnts = new Set();
 
 	AddMock(SYSTEM_ENTITY, IID_Timer, {
 		"GetLatestTurnLength": () => 500
 	});
 
 	const radius = 10;
 
 	let data = {
 		"type": "Ranged",
 		"attacker": 70,
 		"target": 60,
 		"strengths": { "hack": 0, "pierce": 100, "crush": 0 },
 		"position": targetPos,
 		"direction": new Vector3D(1, 0, 0),
 		"projectileId": 9,
 		"bonus": undefined,
 		"isSplash": false,
 		"attackerOwner": 1
 	};
 
 	AddMock(SYSTEM_ENTITY, IID_PlayerManager, {
 		"GetPlayerByID": id => id == 1 ? 10 : 11,
 		"GetAllPlayers": () => [0, 1]
 	});
 
 	AddMock(SYSTEM_ENTITY, IID_ProjectileManager, {
 		"RemoveProjectile": () => {},
 		"LaunchProjectileAtPoint": (ent, pos, speed, gravity) => {},
 	});
 
 	AddMock(60, IID_Position, {
 		"GetPosition": () => targetPos,
 		"GetPreviousPosition": () => targetPos,
 		"GetPosition2D": () => Vector2D.From(targetPos),
 		"IsInWorld": () => true,
 	});
 
 	AddMock(60, IID_Health, {});
 
 	AddMock(60, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			hitEnts.add(60);
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 100);
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(60, IID_Footprint, {
 		"GetShape": () => ({ "type": "circle", "radius": 20 }),
 	});
 
 	AddMock(70, IID_Ownership, {
 		"GetOwner": () => 1,
 	});
 
 	AddMock(70, IID_Position, {
 		"GetPosition": () => new Vector3D(0, 0, 0),
 		"GetRotation": () => new Vector3D(0, 0, 0),
 		"IsInWorld": () => true,
 	});
 
 	AddMock(10, IID_Player, {
 		"GetEnemies": () => [2]
 	});
 
 	cmpDamage.MissileHit(data, 0);
 	TS_ASSERT(hitEnts.has(60));
 	hitEnts.clear();
 
 	// The main target is not hit but another one is hit.
 
 	AddMock(60, IID_Position, {
 		"GetPosition": () => new Vector3D(900, 10, 0),
 		"GetPreviousPosition": () => new Vector3D(900, 10, 0),
 		"GetPosition2D": () => new Vector2D(900, 0),
 		"IsInWorld": () => true,
 	});
 
 	AddMock(60, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			TS_ASSERT_EQUALS(false);
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(SYSTEM_ENTITY, IID_RangeManager, {
 		"ExecuteQueryAroundPos": () => [61]
 	});
 
 	AddMock(61, IID_Position, {
 		"GetPosition": () => targetPos,
 		"GetPreviousPosition": () => targetPos,
 		"GetPosition2D": () => Vector2D.from3D(targetPos),
 		"IsInWorld": () => true,
 	});
 
 	AddMock(61, IID_Health, {});
 
 	AddMock(61, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 100);
 			hitEnts.add(61);
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(61, IID_Footprint, {
 		"GetShape": () => ({ "type": "circle", "radius": 20 }),
 	});
 
 	cmpDamage.MissileHit(data, 0);
 	TS_ASSERT(hitEnts.has(61));
 	hitEnts.clear();
 
 	// Add a splash damage.
 
 	data.friendlyFire = false;
 	data.radius = 10;
 	data.shape = "Circular";
 	data.isSplash = true;
 	data.splashStrengths = { "hack": 0, "pierce": 0, "crush": 200 };
 
 	AddMock(SYSTEM_ENTITY, IID_RangeManager, {
 		"ExecuteQueryAroundPos": () => [61, 62]
 	});
 
 	let dealtDamage = 0;
 	AddMock(61, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			dealtDamage += multiplier * (strengths.hack + strengths.pierce + strengths.crush);
 			hitEnts.add(61);
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(62, IID_Position, {
 		"GetPosition": () => new Vector3D(8, 10, 0),
 		"GetPreviousPosition": () => new Vector3D(8, 10, 0),
 		"GetPosition2D": () => new Vector2D(8, 0),
 		"IsInWorld": () => true,
 	});
 
 	AddMock(62, IID_Health, {});
 
 	AddMock(62, IID_DamageReceiver, {
 		"TakeDamage": (strengths, multiplier) => {
 			TS_ASSERT_EQUALS(multiplier * (strengths.hack + strengths.pierce + strengths.crush), 200 * 0.75);
 			hitEnts.add(62);
 			return { "killed": false, "change": -multiplier * (strengths.hack + strengths.pierce + strengths.crush) };
 		}
 	});
 
 	AddMock(62, IID_Footprint, {
 		"GetShape": () => ({ "type": "circle", "radius": 20 }),
 	});
 
 	cmpDamage.MissileHit(data, 0);
 	TS_ASSERT(hitEnts.has(61));
 	TS_ASSERT_EQUALS(dealtDamage, 100 + 200);
 	dealtDamage = 0;
 	TS_ASSERT(hitEnts.has(62));
 	hitEnts.clear();
 
 	// Add some hard counters bonus.
 
 	Engine.DestroyEntity(62);
 	AddMock(SYSTEM_ENTITY, IID_RangeManager, {
 		"ExecuteQueryAroundPos": () => [61]
 	});
 
 	let bonus= { "BonusCav": { "Classes": "Cavalry", "Multiplier": 400 } };
 	let splashBonus = { "BonusCav": { "Classes": "Cavalry", "Multiplier": 10000 } };
 
 	AddMock(61, IID_Identity, {
 		"HasClass": cl => cl == "Cavalry"
 	});
 
 	data.bonus = bonus;
 	cmpDamage.MissileHit(data, 0);
 	TS_ASSERT(hitEnts.has(61));
 	TS_ASSERT_EQUALS(dealtDamage, 400 * 100 + 200);
 	dealtDamage = 0;
 	hitEnts.clear();
 
 	data.splashBonus = splashBonus;
 	cmpDamage.MissileHit(data, 0);
 	TS_ASSERT(hitEnts.has(61));
 	TS_ASSERT_EQUALS(dealtDamage, 400 * 100 + 10000 * 200);
 	dealtDamage = 0;
 	hitEnts.clear();
 
 	data.bonus = undefined;
 	cmpDamage.MissileHit(data, 0);
 	TS_ASSERT(hitEnts.has(61));
 	TS_ASSERT_EQUALS(dealtDamage, 100 + 10000 * 200);
 	dealtDamage = 0;
 	hitEnts.clear();
 
 	data.bonus = null;
 	cmpDamage.MissileHit(data, 0);
 	TS_ASSERT(hitEnts.has(61));
 	TS_ASSERT_EQUALS(dealtDamage, 100 + 10000 * 200);
 	dealtDamage = 0;
 	hitEnts.clear();
 
 	data.bonus = {};
 	cmpDamage.MissileHit(data, 0);
 	TS_ASSERT(hitEnts.has(61));
 	TS_ASSERT_EQUALS(dealtDamage, 100 + 10000 * 200);
 	dealtDamage = 0;
 	hitEnts.clear();
 }
 
 Test_MissileHit();
Index: ps/trunk/binaries/data/mods/public/simulation/components/tests/test_StatusEffectsReceiver.js
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/components/tests/test_StatusEffectsReceiver.js	(nonexistent)
+++ ps/trunk/binaries/data/mods/public/simulation/components/tests/test_StatusEffectsReceiver.js	(revision 22304)
@@ -0,0 +1,119 @@
+Engine.LoadComponentScript("interfaces/Damage.js");
+Engine.LoadComponentScript("interfaces/StatusEffectsReceiver.js");
+Engine.LoadComponentScript("interfaces/Timer.js");
+Engine.LoadComponentScript("StatusEffectsReceiver.js");
+Engine.LoadComponentScript("Timer.js");
+
+var target = 42;
+var cmpStatusReceiver;
+var cmpTimer;
+var dealtDamage;
+
+function setup()
+{
+	cmpStatusReceiver = ConstructComponent(target, "StatusEffectsReceiver");
+	cmpTimer = ConstructComponent(SYSTEM_ENTITY, "Timer");
+	dealtDamage = 0;
+}
+
+function testInflictEffects()
+{
+	setup();
+	let statusName = "Burn";
+	AddMock(SYSTEM_ENTITY, IID_Damage, {
+		"CauseDamage": (data) => { dealtDamage += data.strengths[statusName]; }
+	});
+
+	// damage scheduled: 0, 10, 20 sec
+	cmpStatusReceiver.InflictEffects({
+		[statusName]: {
+			"Duration": 20000,
+			"Interval": 10000,
+			"Damage": 1
+		}
+	});
+
+	cmpTimer.OnUpdate({ "turnLength": 1 });
+	TS_ASSERT_EQUALS(dealtDamage, 1); // 1 sec
+
+	cmpTimer.OnUpdate({ "turnLength": 8 });
+	TS_ASSERT_EQUALS(dealtDamage, 1); // 9 sec
+
+	cmpTimer.OnUpdate({ "turnLength": 1 });
+	TS_ASSERT_EQUALS(dealtDamage, 2); // 10 sec
+
+	cmpTimer.OnUpdate({ "turnLength": 10 });
+	TS_ASSERT_EQUALS(dealtDamage, 3); // 20 sec
+
+	cmpTimer.OnUpdate({ "turnLength": 10 });
+	TS_ASSERT_EQUALS(dealtDamage, 3); // 30 sec
+}
+
+testInflictEffects();
+
+function testMultipleEffects()
+{
+	setup();
+	AddMock(SYSTEM_ENTITY, IID_Damage, {
+		"CauseDamage": (data) => {
+			if (data.strengths.Burn) dealtDamage += data.strengths.Burn;
+			if (data.strengths.Poison) dealtDamage += data.strengths.Poison;
+		}
+	});
+
+	// damage scheduled: 0, 1, 2, 10 sec
+	cmpStatusReceiver.InflictEffects({
+		"Burn": {
+			"Duration": 20000,
+			"Interval": 10000,
+			"Damage": 10
+		},
+		"Poison": {
+			"Duration": 3000,
+			"Interval": 1000,
+			"Damage": 1
+		}
+	});
+
+	cmpTimer.OnUpdate({ "turnLength": 1 });
+	TS_ASSERT_EQUALS(dealtDamage, 12); // 1 sec
+
+	cmpTimer.OnUpdate({ "turnLength": 1 });
+	TS_ASSERT_EQUALS(dealtDamage, 13); // 2 sec
+
+	cmpTimer.OnUpdate({ "turnLength": 1 });
+	TS_ASSERT_EQUALS(dealtDamage, 13); // 3 sec
+
+	cmpTimer.OnUpdate({ "turnLength": 7 });
+	TS_ASSERT_EQUALS(dealtDamage, 23); // 10 sec
+}
+
+testMultipleEffects();
+
+function testRemoveEffect()
+{
+	setup();
+	let statusName = "Poison";
+	AddMock(SYSTEM_ENTITY, IID_Damage, {
+		"CauseDamage": (data) => { dealtDamage += data.strengths[statusName]; }
+	});
+
+	// damage scheduled: 0, 10, 20 sec
+	cmpStatusReceiver.InflictEffects({
+		[statusName]: {
+			"Duration": 20000,
+			"Interval": 10000,
+			"Damage": 1
+		}
+	});
+
+	cmpTimer.OnUpdate({ "turnLength": 1 });
+	TS_ASSERT_EQUALS(dealtDamage, 1); // 1 sec
+
+	cmpStatusReceiver.RemoveEffect(statusName);
+
+	cmpTimer.OnUpdate({ "turnLength": 10 });
+	TS_ASSERT_EQUALS(dealtDamage, 1); // 11 sec
+}
+
+testRemoveEffect();

Property changes on: ps/trunk/binaries/data/mods/public/simulation/components/tests/test_StatusEffectsReceiver.js
___________________________________________________________________
Added: svn:executable
## -0,0 +1 ##
+*
\ No newline at end of property
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_structure.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_structure.xml	(revision 22303)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_structure.xml	(revision 22304)
@@ -1,165 +1,166 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity>
   <AIProxy/>
   <Armour>
     <Hack>1</Hack>
     <Pierce>1</Pierce>
     <Crush>1</Crush>
     <Foundation>
       <Hack>1</Hack>
       <Pierce>1</Pierce>
       <Crush>1</Crush>
     </Foundation>
   </Armour>
   <BuildingAI>
     <DefaultArrowCount>0</DefaultArrowCount>
     <GarrisonArrowMultiplier>0</GarrisonArrowMultiplier>
     <GarrisonArrowClasses>Infantry Cavalry</GarrisonArrowClasses>
   </BuildingAI>
   <BuildRestrictions>
     <PlacementType>land</PlacementType>
     <Territory>own</Territory>
   </BuildRestrictions>
   <Capturable>
     <CapturePoints>500</CapturePoints>
     <RegenRate>0.5</RegenRate>
     <GarrisonRegenRate>5.0</GarrisonRegenRate>
   </Capturable>
   <Cost>
     <Population>0</Population>
     <PopulationBonus>0</PopulationBonus>
     <BuildTime>10</BuildTime>
     <Resources>
       <food>0</food>
       <wood>0</wood>
       <stone>0</stone>
       <metal>0</metal>
     </Resources>
   </Cost>
   <Decay>
     <Active>false</Active>
     <SinkingAnim>false</SinkingAnim>
     <DelayTime>0.0</DelayTime>
     <SinkRate>3.0</SinkRate>
     <SinkAccel>9.8</SinkAccel>
   </Decay>
   <Fogging/>
   <Guard/>
   <Health>
     <DamageVariants>
       <lightdamage>0.85</lightdamage>
       <mediumdamage>0.65</mediumdamage>
       <heavydamage>0.35</heavydamage>
     </DamageVariants>
     <DeathType>corpse</DeathType>
     <RegenRate>0</RegenRate>
     <IdleRegenRate>0</IdleRegenRate>
     <Unhealable>true</Unhealable>
   </Health>
   <Identity>
     <Civ>gaia</Civ>
     <GenericName>Structure</GenericName>
     <Classes datatype="tokens">Structure</Classes>
     <Undeletable>false</Undeletable>
   </Identity>
   <Loot>
     <xp>0</xp>
     <food>0</food>
     <wood>10</wood>
     <stone>0</stone>
     <metal>0</metal>
   </Loot>
   <Looter/>
   <Minimap>
     <Type>structure</Type>
   </Minimap>
   <Obstruction>
     <Active>true</Active>
     <BlockMovement>true</BlockMovement>
     <BlockPathfinding>true</BlockPathfinding>
     <BlockFoundation>true</BlockFoundation>
     <BlockConstruction>false</BlockConstruction>
     <DisableBlockMovement>false</DisableBlockMovement>
     <DisableBlockPathfinding>false</DisableBlockPathfinding>
     <DeleteUponConstruction>false</DeleteUponConstruction>
   </Obstruction>
   <OverlayRenderer/>
   <Ownership/>
   <Position>
     <Altitude>0</Altitude>
     <Anchor>upright</Anchor>
     <Floating>false</Floating>
     <FloatDepth>0.0</FloatDepth>
     <TurnRate>6.0</TurnRate>
   </Position>
   <ProductionQueue>
     <TechCostMultiplier>
       <food>1.0</food>
       <wood>1.0</wood>
       <stone>1.0</stone>
       <metal>1.0</metal>
       <time>1.0</time>
     </TechCostMultiplier>
   </ProductionQueue>
   <RallyPoint/>
   <RallyPointRenderer>
     <MarkerTemplate>special/rallypoint</MarkerTemplate>
     <LineTexture>art/textures/misc/rallypoint_line.png</LineTexture>
     <LineTextureMask>art/textures/misc/rallypoint_line_mask.png</LineTextureMask>
     <LineThickness>0.25</LineThickness>
     <LineDashColor r="158" g="11" b="15"/>
     <LineStartCap>square</LineStartCap>
     <LineEndCap>round</LineEndCap>
     <LinePassabilityClass>default</LinePassabilityClass>
   </RallyPointRenderer>
   <RangeOverlayManager/>
   <RangeOverlayRenderer/>
   <Repairable>
     <RepairTimeRatio>2.0</RepairTimeRatio>
   </Repairable>
   <Selectable>
     <Overlay>
       <Outline>
         <LineTexture>outline_border.png</LineTexture>
         <LineTextureMask>outline_border_mask.png</LineTextureMask>
         <LineThickness>0.4</LineThickness>
       </Outline>
     </Overlay>
   </Selectable>
   <Sound>
     <SoundGroups>
       <select>interface/select/building/sel_universal.xml</select>
       <constructed>interface/complete/building/complete_universal.xml</constructed>
       <death>attack/destruction/building_collapse_large.xml</death>
       <attacked>interface/alarm/alarm_attackplayer.xml</attacked>
       <attack_ranged>attack/weapon/arrowfly.xml</attack_ranged>
       <attack_impact_ranged>attack/impact/arrow_metal.xml</attack_impact_ranged>
     </SoundGroups>
   </Sound>
   <StatusBars>
     <BarWidth>6.0</BarWidth>
     <BarHeight>0.6</BarHeight>
     <HeightOffset>12.0</HeightOffset>
   </StatusBars>
+  <StatusEffectsReceiver/>
   <TerritoryDecay>
     <DecayRate>20</DecayRate>
   </TerritoryDecay>
   <Visibility>
     <RetainInFog>true</RetainInFog>
     <AlwaysVisible>false</AlwaysVisible>
     <Corpse>false</Corpse>
     <Preview>false</Preview>
   </Visibility>
   <Vision>
     <Range>40</Range>
   </Vision>
   <VisionSharing>
     <Bribable>false</Bribable>
   </VisionSharing>
   <VisualActor>
     <ConstructionPreview/>
     <SilhouetteDisplay>false</SilhouetteDisplay>
     <SilhouetteOccluder>true</SilhouetteOccluder>
     <VisibleInAtlasOnly>false</VisibleInAtlasOnly>
   </VisualActor>
 </Entity>
Index: ps/trunk/binaries/data/mods/public/simulation/templates/template_unit.xml
===================================================================
--- ps/trunk/binaries/data/mods/public/simulation/templates/template_unit.xml	(revision 22303)
+++ ps/trunk/binaries/data/mods/public/simulation/templates/template_unit.xml	(revision 22304)
@@ -1,144 +1,145 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Entity>
   <AIProxy/>
   <Armour>
     <Hack>1</Hack>
     <Pierce>1</Pierce>
     <Crush>15</Crush>
   </Armour>
   <Cost>
     <Population>1</Population>
     <PopulationBonus>0</PopulationBonus>
     <BuildTime>1</BuildTime>
     <Resources>
       <food>0</food>
       <wood>0</wood>
       <stone>0</stone>
       <metal>0</metal>
     </Resources>
   </Cost>
   <Decay>
     <Active>false</Active>
     <SinkingAnim>false</SinkingAnim>
     <DelayTime>30.0</DelayTime>
     <SinkRate>0.01</SinkRate>
     <SinkAccel>0.0</SinkAccel>
   </Decay>
   <Footprint>
     <Circle radius="1.5"/>
     <Height>2.5</Height>
   </Footprint>
   <Garrisonable/>
   <Guard/>
   <Health>
     <DeathType>corpse</DeathType>
     <Max>100</Max>
     <RegenRate>0</RegenRate>
     <IdleRegenRate>0</IdleRegenRate>
     <Unhealable>false</Unhealable>
   </Health>
   <Identity>
     <Civ>gaia</Civ>
     <GenericName>Unit</GenericName>
     <Classes datatype="tokens">Unit ConquestCritical</Classes>
     <Formations datatype="tokens">
       special/formations/null
       special/formations/box
       special/formations/column_closed
       special/formations/line_closed
       special/formations/column_open
       special/formations/line_open
       special/formations/flank
       special/formations/battle_line
     </Formations>
     <Undeletable>false</Undeletable>
   </Identity>
   <Looter/>
   <Minimap>
     <Type>unit</Type>
   </Minimap>
   <Obstruction>
     <Unit/>
     <Active>true</Active>
     <BlockMovement>true</BlockMovement>
     <BlockPathfinding>false</BlockPathfinding>
     <BlockFoundation>false</BlockFoundation>
     <BlockConstruction>true</BlockConstruction>
     <DisableBlockMovement>false</DisableBlockMovement>
     <DisableBlockPathfinding>false</DisableBlockPathfinding>
     <DeleteUponConstruction>false</DeleteUponConstruction>
   </Obstruction>
   <OverlayRenderer/>
   <Ownership/>
   <Position>
     <Altitude>0</Altitude>
     <Anchor>upright</Anchor>
     <Floating>false</Floating>
     <FloatDepth>0.0</FloatDepth>
     <TurnRate>6.0</TurnRate>
   </Position>
   <RangeOverlayManager/>
   <RangeOverlayRenderer/>
   <ResourceGatherer>
     <MaxDistance>2.0</MaxDistance>
     <BaseSpeed>1.0</BaseSpeed>
     <Rates>
       <treasure>1</treasure>
     </Rates>
     <Capacities>
       <food>10</food>
       <wood>10</wood>
       <stone>10</stone>
       <metal>10</metal>
     </Capacities>
   </ResourceGatherer>
   <Selectable>
     <Overlay>
       <Texture>
         <MainTexture>circle/128x128.png</MainTexture>
         <MainTextureMask>circle/128x128_mask.png</MainTextureMask>
       </Texture>
     </Overlay>
   </Selectable>
   <Sound>
     <SoundGroups>
       <attacked>interface/alarm/alarm_attackplayer.xml</attacked>
       <attack_slaughter>attack/weapon/sword.xml</attack_slaughter>
     </SoundGroups>
   </Sound>
   <StatusBars>
     <BarWidth>2.0</BarWidth>
     <BarHeight>0.333</BarHeight>
     <HeightOffset>5.0</HeightOffset>
   </StatusBars>
+  <StatusEffectsReceiver/>
   <UnitAI>
     <DefaultStance>aggressive</DefaultStance>
     <FleeDistance>12.0</FleeDistance>
     <FormationController>false</FormationController>
     <CanGuard>true</CanGuard>
     <CanPatrol>true</CanPatrol>
   </UnitAI>
   <UnitMotion>
     <FormationController>false</FormationController>
     <PassabilityClass>default</PassabilityClass>
     <WalkSpeed>9.0</WalkSpeed>
     <RunMultiplier>1.67</RunMultiplier>
   </UnitMotion>
   <Visibility>
     <RetainInFog>false</RetainInFog>
     <AlwaysVisible>false</AlwaysVisible>
     <Corpse>false</Corpse>
     <Preview>false</Preview>
   </Visibility>
   <Vision>
     <Range>12</Range>
   </Vision>
   <VisionSharing>
     <Bribable>false</Bribable>
   </VisionSharing>
   <VisualActor>
     <SilhouetteDisplay>true</SilhouetteDisplay>
     <SilhouetteOccluder>false</SilhouetteOccluder>
     <VisibleInAtlasOnly>false</VisibleInAtlasOnly>
   </VisualActor>
 </Entity>