Differential D781 Diff 15727 binaries/data/mods/public/simulation/helpers/Attacking.js

Changeset View

Standalone View

binaries/data/mods/public/simulation/helpers/Attacking.js

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines
* @param {number} target - The target of the attack.		* @param {number} target - The target of the attack.
* @param {Object} effectData - The effects calculate the effect for.		* @param {Object} effectData - The effects calculate the effect for.
* @param {string} effectType - The type of effect to apply (e.g. Damage, Capture or ApplyStatus).		* @param {string} effectType - The type of effect to apply (e.g. Damage, Capture or ApplyStatus).
* @param {number} bonusMultiplier - The factor to multiply the total effect with.		* @param {number} bonusMultiplier - The factor to multiply the total effect with.
* @param {Object} cmpResistance - Optionally the resistance component of the target.		* @param {Object} cmpResistance - Optionally the resistance component of the target.
*		*
* @return {number} - The total value of the effect.		* @return {number} - The total value of the effect.
*/		*/
Attacking.prototype.GetTotalAttackEffects = function(target, effectData, effectType, bonusMultiplier, cmpResistance)		Attacking.prototype.GetTotalAttackEffects = function(target, attackerPosition, attackHeightOffset, effectData, effectType, bonusMultiplier, cmpResistance)
{		{
let total = 0;		let total = 0;
if (!cmpResistance)		if (!cmpResistance)
cmpResistance = Engine.QueryInterface(target, IID_Resistance);		cmpResistance = Engine.QueryInterface(target, IID_Resistance);

let resistanceStrengths = cmpResistance ? cmpResistance.GetEffectiveResistanceAgainst(effectType) : {};		let resistanceStrengths = cmpResistance ? cmpResistance.GetEffectiveResistanceAgainst(effectType) : {};

if (effectType == "Damage")		if (effectType == "Damage")
		{
		bonusMultiplier *= this.GetElevationDamageMultiplier(target, attackerPosition, attackHeightOffset);
for (let type in effectData.Damage)		for (let type in effectData.Damage)
total += effectData.Damage[type] * Math.pow(0.9, resistanceStrengths.Damage ? resistanceStrengths.Damage[type] \|\| 0 : 0);		total += effectData.Damage[type] * Math.pow(0.9, resistanceStrengths.Damage ? resistanceStrengths.Damage[type] \|\| 0 : 0);
		}
else if (effectType == "Capture")		else if (effectType == "Capture")
{		{
total = effectData.Capture * Math.pow(0.9, resistanceStrengths.Capture \|\| 0);		total = effectData.Capture * Math.pow(0.9, resistanceStrengths.Capture \|\| 0);

// If Health is lower we are more susceptible to capture attacks.		// If Health is lower we are more susceptible to capture attacks.
let cmpHealth = Engine.QueryInterface(target, IID_Health);		let cmpHealth = Engine.QueryInterface(target, IID_Health);
if (cmpHealth)		if (cmpHealth)
total /= 0.1 + 0.9 * cmpHealth.GetHitpoints() / cmpHealth.GetMaxHitpoints();		total /= 0.1 + 0.9 * cmpHealth.GetHitpoints() / cmpHealth.GetMaxHitpoints();
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines	for (let ent of nearEnts)
else // In case someone calls this function with an invalid shape.		else // In case someone calls this function with an invalid shape.
{		{
warn("The " + data.shape + " splash damage shape is not implemented!");		warn("The " + data.shape + " splash damage shape is not implemented!");
}		}
// The RangeManager can return units that are too far away (due to approximations there)		// The RangeManager can return units that are too far away (due to approximations there)
// so the multiplier can end up below 0.		// so the multiplier can end up below 0.
damageMultiplier = Math.max(0, damageMultiplier);		damageMultiplier = Math.max(0, damageMultiplier);

this.HandleAttackEffects(ent, data.type + ".Splash", data.attackData, data.attacker, data.attackerOwner, damageMultiplier);		this.HandleAttackEffects(ent, data.type + ".Splash", data.attackData, data.attacker, data.attackerOwner, data.attackerPosition, data.attackHeightOffset, damageMultiplier);
}		}
};		};
/**		/**
* Handle an attack peformed on an entity.		* Handle an attack peformed on an entity.
*		*
* @param {number} target - The targetted entityID.		* @param {number} target - The targetted entityID.
* @param {string} attackType - The type of attack that was performed (e.g. "Melee" or "Capture").		* @param {string} attackType - The type of attack that was performed (e.g. "Melee" or "Capture").
* @param {Object} effectData - The effects use.		* @param {Object} effectData - The effects use.
* @param {number} attacker - The entityID that attacked us.		* @param {number} attacker - The entityID that attacked us.
* @param {number} attackerOwner - The playerID that owned the attacker when the attack was performed.		* @param {number} attackerOwner - The playerID that owned the attacker when the attack was performed.
		* @param {Vector3D} attackerPosition - The position of the attacker when they performed the attack, used for elevation damage bonus.
		* @param {number} attackHeightOffset - The vertical offset of the attack of the attacker.
* @param {number} bonusMultiplier - The factor to multiply the total effect with, defaults to 1.		* @param {number} bonusMultiplier - The factor to multiply the total effect with, defaults to 1.
*		*
* @return {boolean} - Whether we handled the attack.		* @return {boolean} - Whether we handled the attack.
*/		*/
Attacking.prototype.HandleAttackEffects = function(target, attackType, attackData, attacker, attackerOwner, bonusMultiplier = 1)		Attacking.prototype.HandleAttackEffects = function(target, attackType, attackData, attacker, attackerOwner, attackerPosition, attackHeightOffset, bonusMultiplier = 1)
{		{
let cmpResistance = Engine.QueryInterface(target, IID_Resistance);		let cmpResistance = Engine.QueryInterface(target, IID_Resistance);
if (cmpResistance && cmpResistance.IsInvulnerable())		if (cmpResistance && cmpResistance.IsInvulnerable())
return false;		return false;

bonusMultiplier *= !attackData.Bonuses ? 1 : this.GetAttackBonus(attacker, target, attackType, attackData.Bonuses);		bonusMultiplier *= !attackData.Bonuses ? 1 : this.GetAttackBonus(attacker, target, attackType, attackData.Bonuses);

let targetState = {};		let targetState = {};
for (let receiver of g_AttackEffects.Receivers())		for (let receiver of g_AttackEffects.Receivers())
{		{
if (!attackData[receiver.type])		if (!attackData[receiver.type])
continue;		continue;

let cmpReceiver = Engine.QueryInterface(target, global[receiver.IID]);		let cmpReceiver = Engine.QueryInterface(target, global[receiver.IID]);
if (!cmpReceiver)		if (!cmpReceiver)
continue;		continue;

Object.assign(targetState, cmpReceiver[receiver.method](this.GetTotalAttackEffects(target, attackData, receiver.type, bonusMultiplier, cmpResistance), attacker, attackerOwner));		Object.assign(targetState, cmpReceiver[receiver.method](this.GetTotalAttackEffects(target, attackerPosition, attackHeightOffset, attackData, receiver.type, bonusMultiplier, cmpResistance), attacker, attackerOwner));
}		}

if (!Object.keys(targetState).length)		if (!Object.keys(targetState).length)
return false;		return false;

Engine.PostMessage(target, MT_Attacked, {		Engine.PostMessage(target, MT_Attacked, {
"type": attackType,		"type": attackType,
"target": target,		"target": target,
Show All 18 Lines

/**		/**
* Calculates the attack damage multiplier against a target.		* Calculates the attack damage multiplier against a target.
* @param {number} source - The source entity's id.		* @param {number} source - The source entity's id.
* @param {number} target - The target entity's id.		* @param {number} target - The target entity's id.
* @param {string} type - The type of attack.		* @param {string} type - The type of attack.
* @param {Object} template - The bonus' template.		* @param {Object} template - The bonus' template.
* @return {number} - The source entity's attack bonus against the specified target.		* @return {number} - The source entity's attack bonus against the specified target.
*/		*/
		StanUnsubmitted Done Inline Actions Multiplier instead of Bonus ?No strong feeling. Stan: Multiplier instead of Bonus ?No strong feeling.
Attacking.prototype.GetAttackBonus = function(source, target, type, template)		Attacking.prototype.GetAttackBonus = function(source, target, type, template)
{		{
let cmpIdentity = Engine.QueryInterface(target, IID_Identity);		let cmpIdentity = Engine.QueryInterface(target, IID_Identity);
if (!cmpIdentity)		if (!cmpIdentity)
return 1;		return 1;

let attackBonus = 1;		let attackBonus = 1;
let targetClasses = cmpIdentity.GetClassesList();		let targetClasses = cmpIdentity.GetClassesList();
let targetCiv = cmpIdentity.GetCiv();		let targetCiv = cmpIdentity.GetCiv();

// Multiply the bonuses for all matching classes.		// Multiply the bonuses for all matching classes.
for (let key in template)		for (let key in template)
{		{
let bonus = template[key];		let bonus = template[key];
if (bonus.Civ && bonus.Civ !== targetCiv)		if (bonus.Civ && bonus.Civ !== targetCiv)
continue;		continue;
if (!bonus.Classes \|\| MatchesClassList(targetClasses, bonus.Classes))		if (!bonus.Classes \|\| MatchesClassList(targetClasses, bonus.Classes))
attackBonus *= ApplyValueModificationsToEntity("Attack/" + type + "/Bonuses/" + key + "/Multiplier", +bonus.Multiplier, source);		attackBonus *= ApplyValueModificationsToEntity("Attack/" + type + "/Bonuses/" + key + "/Multiplier", +bonus.Multiplier, source);
}		}

return attackBonus;		return attackBonus;
};		};

		/**
		* Calculate the damage bonus for entities with a height difference.
		* For an explanation of the numbers, see D781.
		*
		* @param {number} target - The entity ID of the target.
		* @param {Vector3D} attackerPosition - The original position of the attacker.
		* @param {number} attackHeightOffset - The attack height offset of the attacker.
		*
		* @return {number} - The factor that the damage will be multiplied with.
		*/
		Attacking.prototype.GetElevationDamageMultiplier = function(target, attackerPosition, attackHeightOffset)
		{
		let cmpTargetPosition = Engine.QueryInterface(target, IID_Position);
		if (!cmpTargetPosition \|\| !cmpTargetPosition.IsInWorld())
		return 1;
		let targetPosition = cmpTargetPosition.GetPosition();
		let elevationDifference = attackerPosition.y + attackHeightOffset - targetPosition.y;

		return Math.max(0.1, 1 + 0.01 * elevationDifference);
		};

var AttackingInstance = new Attacking();		var AttackingInstance = new Attacking();
Engine.RegisterGlobal("Attacking", AttackingInstance);		Engine.RegisterGlobal("Attacking", AttackingInstance);

Engine.RegisterGlobal("g_AttackEffects", new AttackEffects());		Engine.RegisterGlobal("g_AttackEffects", new AttackEffects());