C++ Damage::Clear方法代码示例

/**
* @param damage damage description for this weapon detonation
* Point defense and air cannons should use a different model
*/
void tcDamageModel::CalculateTotalDamage(tcWeaponObject* weapon, tcGameObject* target, Damage& damage)
{
    if ((weapon == 0) || (target == 0))
    {
        wxASSERT(false);
        return;
    }

    bool goodDetonation = weapon->IsGoodDetonation();

    damage.Clear();


    const tcWeaponDamage* weaponDamage = GetWeaponDamageModel(weapon);


    /* if missile is targeted and has scored direct hit, then apply
    ** kinetic damage from missile (big fragment) and apply
    ** internal damage assuming missile has delayed warhead that explodes
    ** after penetrating target exterior
    */
    if (weapon->IsDirectHit() && (weapon->GetIntendedTarget() == target->mnID))
    {
        float speed_collide = weapon->mcKin.CalculateRangeRate(target->mcKin);
        if (speed_collide < 0)
        {
            wxASSERT(false);
            speed_collide = 0; // opening range rate case, shouldnt happen
        }

        float kinEnergy_J = 0.5*weapon->GetMassKg()*speed_collide*speed_collide;

        // fractional damage from kinetic energy of impact
        damage.kinetic_J = kinEnergy_J;

        damage.isPenetration = weaponDamage->isPenetration;

        // treat blast and frag as the same for now
        damage.explosive_kg = weaponDamage->blastCharge_kg + weaponDamage->fragCharge_kg + weaponDamage->fragMetal_kg; 
        return;
    }

    // no damage for direct hit weapons to other targets, or if weapon is a dud
    if (weapon->IsDirectHit() || (!goodDetonation)) return;

	tcBallisticWeapon* ballistic = dynamic_cast<tcBallisticWeapon*>(weapon);
	if ((ballistic != 0) && ballistic->IsClusterBomb())
	{
		CalculateTotalDamageCluster(ballistic, target, damage);
		return;
	}


    // determine if this is an underwater or underground explosion
    bool underwaterExplosion = ((weapon->mcKin.mfAlt_m <= -1.0f) && (weapon->mcTerrain.mfHeight_m < -1.0f));
    bool targetUnderwater = (target->mcKin.mfAlt_m <= 0) && (target->mcTerrain.mfHeight_m < -1.0f);
    bool targetAbovewater = (target->mcKin.mfAlt_m >= -3.0f); // target can be both under and above water
    
    bool affectsTarget = (underwaterExplosion && targetUnderwater) || (!underwaterExplosion && targetAbovewater);
    if (!affectsTarget) return;


    float range_m = 1000.0f * weapon->mcKin.RangeToKmAlt(target->mcKin);

    //float cumulativeDamage = 0;

    if (underwaterExplosion)
    {
        float damageRange_m = range_m;
        Vec3 collisionPoint;
        float collisionRange_m;

        if (damageRange_m < 250.0f) // dont check collisions for distance platforms affected by blast
        {
            // check collision along ray to origin
            if (target->CalculateCollisionPointOrigin(weapon, collisionPoint, collisionRange_m))
            {
                // wxASSERT(collisionRange_m < damageRange_m);
                damageRange_m = std::min(damageRange_m, collisionRange_m);
            }

            // check collision along "up" ray
            if (target->CalculateCollisionPointDir(weapon, Vec3(0, 1, 0), collisionPoint, collisionRange_m))
            {
                damageRange_m = std::min(damageRange_m, collisionRange_m);
            }
        }

        damageRange_m = std::max(damageRange_m, 10.0f); // don't allow anything closer than 10 m

        damage.waterBlast_psi = CalculateWaterBlastOverpressure(damageRange_m, weaponDamage->blastCharge_kg);
#ifdef _DEBUG
        fprintf(stdout, "Underwater explosion, %s, range: %.1f m, blast: %.1f PSI\n", target->mzClass.c_str(), damageRange_m, damage.waterBlast_psi);
#endif
        return; // no thermal or frag damage underwater
    }
//.........这里部分代码省略.........