Ticket #1910: Damage.js

function Damage() {}

Damage.prototype.Schema = "<a:component type='system'/><empty/>";

Damage.prototype.Init = function()
{
    // Create dummy entity for EntitiesNearPoint
    this.dummyTargetEntity = Engine.AddEntity('special/dummy');
}

/****************************************
 * Damages units around a given origin.
 * data.attacker = <entity id>
 * data.origin = {'x':<int>, 'z':<int>}
 * data.radius = <int>
 * data.shape = <string>
 * data.strengths = {'hack':<float>, 'pierce':<float>, 'crush':<float>}
 * ***Optional Variables***
 * data.direction = <unit vector>
 * data.playersToDamage = <array of player ids>
 */
Damage.prototype.CauseSplashDamage = function(data)
{
    // Get nearby entities and define variables
    var nearEnts = this.EntitiesNearPoint(data.origin, data.radius, data.playersToDamage);
    var damageMultiplier = 1;
    // Cycle through all the nearby entities and damage it appropriately based on its distance from the origin.
    for each (var entity in nearEnts)
    {
        var entityPosition = Engine.QueryInterface(entity, IID_Position).GetPosition();
        if(data.shape=='circular') // circular effect with quadratic falloff in every direction
        {
            var squaredDistanceFromOrigin = this.VectorDistanceSquared(data.origin, entityPosition);
            damageMultiplier == 1 - ((squaredDistanceFromOrigin) / (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.
            var relativePos = {"x": entityPosition.x - data.origin.x, "z": entityPosition.z - data.origin.z};

            // The width of linear splash is one fifth of the normal splash radius.
            var width = data.radius/5;

            // Effectivly rotate the axis to align with the missile direction.
            var parallelDist = this.VectorDot(relativePos, data.direction);//x axis
            var perpDist = Math.abs(this.VectorCross(relativePos, data.direction));//y axis

            // Check that the unit is within the distance at which it will get damaged.
            if (parallelDist > -width && perpDist < width) // If in radius, quadratic falloff in both directions
                multiplier = (data.radius*data.radius - parallelDist*parallelDist) / (data.radius*data.radius)
                                     * (width*width - perpDist*perpDist) / (width*width);
            else
                multiplier = 0;
        }
        else // In case someone calls this function with an invalid shape.
        {
            warn("The "+data.shape+" splash damage shape is not implemented!");
        }
        // Call CauseDamage which reduces the hitpoints, posts network command, plays sounds....
        this.CauseDamage({"strengths":data.strengths, "target":entity, "attacker":data.attacker, "multiplier":damageMultiplier, "type":"Splash"})
    }
};

/****************************************
 * Causes damage on a given unit
 * data.strengths = {'hack':<float>, 'pierce':<float>, 'crush':<float>}
 * data.target = <entity id>
 * data.attacker = <entity id>
 * data.multiplier = <float between 1 and 0>
 * data.type = <string>
 */
Damage.prototype.CauseDamage = function(data)
{
    // Check the target can be damaged otherwise don't do anything.
    var cmpDamageReceiver = Engine.QueryInterface(data.target, IID_DamageReceiver);
    if (!cmpDamageReceiver)
        return;

    // Damage the target
    var targetState = cmpDamageReceiver.TakeDamage(data.strengths.hack * data.multiplier, data.strengths.pierce * data.multiplier, data.strengths.crush * data.multiplier);

    // If the target was killed run some cleanup
    if (targetState.killed == true)
        this.TargetKilled(data.attacker, data.target);

    // Post the network command (make it work in multiplayer)
    Engine.PostMessage(data.target, MT_Attacked,{ "attacker": data.attacker, "target": data.target, "type": data.type, "damage": -targetState.change });

    // Play attacking sounds
    PlaySound("attack_impact", data.attacker);
};

/****************************************
 * Gets entities near a give point for given players.
 * origin = {'x':<int>, 'z':<int>}
 * radius = <int>
 * players = <array>
 * If players is not included, entities from all players are used.
 */
Damage.prototype.EntitiesNearPoint = function(origin, radius, players)
{
    // If there is insufficient data return an empty array.
    if(!origin || !radius)
        return [];

    // Move the dummy entity to the origin of the query.
    var cmpDummyPosition = Engine.QueryInterface(this.dummyTargetEntity, IID_Position);
    cmpDummyPosition.JumpTo(origin.x, origin.z);

    // If the players parameter is not specified use all players.
    if(!players)
        players = Engine.QueryInterface(SYSTEM_ENTITY, IID_PlayerManager).GetAllPlayers();

    // Call RangeManager with dummy entity and return the result.
    var rangeManager = Engine.QueryInterface(SYSTEM_ENTITY, IID_RangeManager);
    var rangeQuery = rangeManager.ExecuteQuery(this.dummyTargetEntity, 0, radius, players, IID_DamageReceiver);
    return rangeQuery;
};

/****************************************
 * Called when some units kills something (another unit, building, animal etc)
 * killerEntity = <entity id>
 * targetEntity = <entity id>
 */
Damage.prototype.TargetKilled = function(killerEntity, targetEntity)
{
    // Add to killer statistics.
    var cmpKillerPlayerStatisticsTracker = QueryOwnerInterface(killerEntity, IID_StatisticsTracker);
    if (cmpKillerPlayerStatisticsTracker)
        cmpKillerPlayerStatisticsTracker.KilledEntity(targetEntity);
    // Add to loser statistics.
    var cmpTargetPlayerStatisticsTracker = QueryOwnerInterface(targetEntity, IID_StatisticsTracker);
    if (cmpTargetPlayerStatisticsTracker)
        cmpTargetPlayerStatisticsTracker.LostEntity(targetEntity);

    // If killer can collect loot, lets try to collect it.
    var cmpLooter = Engine.QueryInterface(killerEntity, IID_Looter);
    if (cmpLooter)
        cmpLooter.Collect(targetEntity);
};

// Gets the straight line distance between p1 and p2
Damage.prototype.VectorDistanceSquared = function(p1, p2)
{
    return ((p1.x - p2.x)*(p1.x - p2.x) + (p1.z - p2.z)*(p1.z - p2.z));
};

// Gets the dot product of two vectors.
Damage.prototype.VectorDot = function(p1, p2)
{
    return (p1.x * p2.x + p1.z * p2.z);
};

// Gets the 2D interpreted version of the cross product of two vectors.
Damage.prototype.VectorCross = function(p1, p2)
{
    return (p1.x * p2.z - p1.z * p2.x);
};

Engine.RegisterComponentType(IID_Damage, "Damage", Damage);