SCR_RotorDamageManagerComponent.c

Go to the documentation of this file.

class SCR_RotorDamageManagerComponentClass : SCR_DamageManagerComponentClass
{
}
 
class SCR_RotorDamageManagerComponent : SCR_DamageManagerComponent
{
    protected VehicleHelicopterSimulation m_HelicopterSimulation;
    protected SCR_VehicleDamageManagerComponent m_RootDamageManager;
    protected SoundComponent m_SoundComponent;
    protected SCR_RotorHitZone m_RotorHitZone;
    
    protected ParticleEffectEntity m_ParticleEffectEntity;
    protected ref ParticleEffectEntitySpawnParams m_ParticleSpawnParams;
    // Collider index for static rotor
    protected int m_iShapeIndex1 = -1;
    
    protected const float MIN_ROTOR_DAMAGE = 15.0; //everything below 15.0 gets discarded when calling HandleDamage 
    
    [Attribute(defvalue: "0.5")]
    protected float m_fImpulseDamageMultiplier;
    
    [Attribute(defvalue: "1.0")]
    protected float m_fRotorDamageMultiplier;
 
    [Attribute(defvalue: "1.0")]
    protected float m_fCharacterDamageMultiplier;
 
    [Attribute(defvalue: "10.0")]
    protected float m_fMinCharacterDamage;
 
    [Attribute(defvalue: "10000.0")]
    protected float m_fMaxCharacterDamage;
 
    [Attribute("{4AAF69CCD1AEA70E}Particles/Vehicle/Helicopter/Rotor Collision Effects/Helicopter_Rotor_Collision_Main_Solid.ptc")]
    protected ResourceName m_sDefaultParticlePath;
    
    [Attribute(defvalue: "2")]
    protected int m_iEffectIndex;
    
    [Attribute(desc: "Blade collision sound event")]
    protected string m_sImpactSoundEvent;
 
    //------------------------------------------------------------------------------------------------
    protected void DamageRotors(float damage)
    {       
        damage *= m_fRotorDamageMultiplier;
        if (damage < MIN_ROTOR_DAMAGE)
            damage = MIN_ROTOR_DAMAGE;
        
        m_RotorHitZone.HandleDamage(damage, EDamageType.COLLISION, null);
    }
 
    //------------------------------------------------------------------------------------------------
    protected void DamageOther(notnull IEntity other, float damage)
    {
        ChimeraCharacter character = ChimeraCharacter.Cast(other);
        SCR_DamageManagerComponent characterDamageManager;
        if (character)
            characterDamageManager = character.GetDamageManager();
 
        if (!characterDamageManager || characterDamageManager.IsDestroyed())
            return;
        
        damage = Math.Clamp(damage * m_fCharacterDamageMultiplier, m_fMinCharacterDamage, m_fMaxCharacterDamage);
 
        Physics otherPhysics = other.GetPhysics();
        array<HitZone> characterHitZones = {};
        characterDamageManager.GetAllHitZones(characterHitZones);
 
        foreach (HitZone characterHitZone : characterHitZones)
        {
            if (!characterHitZone.HasColliderNodes() || characterHitZone.GetDamageState() == EDamageState.DESTROYED)
                continue;
 
            array<int> colliderIDs = {};
            characterHitZone.GetColliderIDs(colliderIDs);
 
            foreach (int colliderID : colliderIDs)
            {
                if (m_RotorHitZone.HasCollision(otherPhysics.GetGeomWorldPosition(colliderID)))
                {
                    characterHitZone.HandleDamage(damage, EDamageType.COLLISION, null);
                    break;
                }
            }
        }
    }
    
    //------------------------------------------------------------------------------------------------
    protected void EmitRotorParticles(vector contactPos, GameMaterial contactMat)
    {
        //set particle emitter transform
 
        vector ownerTransform[4];
        m_RootDamageManager.GetOwner().GetWorldTransform(ownerTransform);
 
        vector rotorTransformLocal[4];
        m_HelicopterSimulation.RotorGetTransform(m_RotorHitZone.GetRotorIndex(), rotorTransformLocal);
        
        float rotorRadius = m_RotorHitZone.GetRotorRadius();
        float rotorRadiusSq = rotorRadius * rotorRadius;
 
        vector rotorEdge = vector.Right * rotorRadius;
        vector contactPositionLocal = contactPos.InvMultiply4(ownerTransform).InvMultiply4(rotorTransformLocal).Normalized() * rotorRadius;
 
        float distanceEdgeToContactSq = vector.DistanceSq(rotorEdge, contactPositionLocal);
        float rotorContactAngle = Math.RAD2DEG * Math.Acos((2 * rotorRadiusSq - distanceEdgeToContactSq) / (2 * rotorRadiusSq));
        if (contactPositionLocal[1] < 0) // if contact is below half-circle, add 180 degrees to complete 360 degree circle
            rotorContactAngle = 360 - rotorContactAngle;
        
        vector rotationMatrix[3];
        if (m_HelicopterSimulation.RotorGetSpinDirection(m_RotorHitZone.GetRotorIndex()) == SpinDirection.CLOCKWISE)
            Math3D.AnglesToMatrix({180, 0, rotorContactAngle}, rotationMatrix);
        else
            Math3D.AnglesToMatrix({180, 0, rotorContactAngle + 180}, rotationMatrix);
 
        vector resultRotation[3];
        Math3D.MatrixMultiply3(rotorTransformLocal, rotationMatrix, resultRotation);
 
        vector translatedTransform[4];
        Math3D.MatrixMultiply3(ownerTransform, resultRotation, translatedTransform);
        translatedTransform[3] = contactPos;
 
        //set particle emitter ptc
        GameMaterial material = contactMat;
        ParticleEffectInfo effectInfo = material.GetParticleEffectInfo();
        
        ResourceName resource = effectInfo.GetVehicleDustResource(m_iEffectIndex);
        if (!resource || resource.IsEmpty())
            resource = m_sDefaultParticlePath;      
 
        //play effect               
        m_ParticleSpawnParams.Transform = translatedTransform;
        m_ParticleEffectEntity = ParticleEffectEntity.SpawnParticleEffect(resource, m_ParticleSpawnParams);
    }
    
    //------------------------------------------------------------------------------------------------
    void PlayRotorImpactSound(vector contactPos, int contactShapeIndex1)
    {
        if (!m_SoundComponent)
            return;
        
        if (m_sImpactSoundEvent.IsEmpty())
            return; 
        
        RotorState rotorState = m_HelicopterSimulation.RotorGetState(m_RotorHitZone.GetRotorIndex());
        if (rotorState == RotorState.DESTROYED)
            return;
        
        if (rotorState == RotorState.STATIC)
        {
            int shapeIndex1 = contactShapeIndex1;
            if (m_iShapeIndex1 == shapeIndex1)
                return;
            
            m_iShapeIndex1 = shapeIndex1;
        }
        
        // Get sound position
        vector mat[4];
        Math3D.MatrixIdentity4(mat);
        mat[3] = contactPos;
        
        m_SoundComponent.SoundEventTransform(m_sImpactSoundEvent, mat);
    }
 
    //------------------------------------------------------------------------------------------------
    override void OnDamageStateChanged(EDamageState state)
    {
        super.OnDamageStateChanged(state);
 
        if (state != EDamageState.DESTROYED)
            SetEventMask(GetOwner(), EntityEvent.CONTACT);
        else
            ClearEventMask(GetOwner(), EntityEvent.CONTACT);
    }
    
    //------------------------------------------------------------------------------------------------
    protected bool TraceFilter(notnull IEntity e)
    {
        return e != GetOwner() && e != m_RootDamageManager.GetOwner(); // ignore if traced entity is rotor or hull
    }
    
    //------------------------------------------------------------------------------------------------
    [RplRpc(RplChannel.Unreliable, RplRcver.Broadcast)]
    protected void RPC_OnContactBroadcast(vector contactPos, vector contactNormal, int contactShapeIndex1)
    {                   
        TraceParam trace = new TraceParam();
        trace.Start = contactPos + contactNormal;
        trace.End = contactPos - contactNormal;
        trace.Flags = TraceFlags.WORLD | TraceFlags.ENTS;
        
        GetGame().GetWorld().TraceMove(trace, TraceFilter);
        
        GameMaterial contactMat = trace.SurfaceProps;
        
        EmitRotorParticles(contactPos, contactMat);
        PlayRotorImpactSound(contactPos, contactShapeIndex1);
    }
 
    //------------------------------------------------------------------------------------------------
    override bool OnContact(IEntity owner, IEntity other, Contact contact)
    {           
        if (!m_RotorHitZone)
            return false;
        
        //compute damage
        
        vector rotorTransform[4];
        m_RotorHitZone.GetPointInfo().GetTransform(rotorTransform);
 
        float rotorRPM = m_HelicopterSimulation.RotorGetRPM(m_RotorHitZone.GetRotorIndex()) * 0.1;
        float rotorRadius = m_RotorHitZone.GetRotorRadius();                
        float rotorCenterToContact = vector.Distance(rotorTransform[3], contact.Position);
        float rotorRPMMultiplier = Math.Clamp(rotorCenterToContact / rotorRadius, 0, 1);
        int rotorBladeCount = m_RotorHitZone.GetBladeCount();
        
        if (rotorRadius <= 0)
            rotorRadius = 1;
        if (rotorBladeCount <= 0)
            rotorBladeCount = 1;
        
        float damage = rotorRPM * rotorRPMMultiplier / m_RotorHitZone.GetBladeCount() + contact.Impulse * m_fImpulseDamageMultiplier;
 
        ChimeraCharacter character = ChimeraCharacter.Cast(other);
        if (!character && m_RootDamageManager && contact.Impulse >= m_RootDamageManager.GetMinImpulse())
            m_RootDamageManager.CollisionDamage(owner, other, contact);
        
        if (m_RotorHitZone.IsSpinning())
        {
            if (character)
                DamageOther(other, damage);
            
            RPC_OnContactBroadcast(contact.Position, contact.Normal, contact.ShapeIndex1);
            Rpc(RPC_OnContactBroadcast, contact.Position, contact.Normal, contact.ShapeIndex1);
        }
        
        DamageRotors(damage);
 
        return super.OnContact(owner, other, contact);
    }
    
    //------------------------------------------------------------------------------------------------
    protected void GetComponentsDelayed()
    {
        IEntity root = GetOwner().GetRootParent();
 
        m_HelicopterSimulation = VehicleHelicopterSimulation.Cast(root.FindComponent(VehicleHelicopterSimulation));
        m_RootDamageManager = SCR_VehicleDamageManagerComponent.Cast(root.FindComponent(SCR_VehicleDamageManagerComponent));
        m_SoundComponent = SoundComponent.Cast(root.FindComponent(SoundComponent));
        
        m_ParticleSpawnParams = new ParticleEffectEntitySpawnParams();      
        m_ParticleSpawnParams.TransformMode = ETransformMode.WORLD;
        m_ParticleSpawnParams.UseFrameEvent = true;
    }
    
    //------------------------------------------------------------------------------------------------
    override void OnInit(IEntity owner)
    {
        super.OnInit(owner);
        
        // Do not do anything if the default hitzone is not rotor hitzone
        m_RotorHitZone = SCR_RotorHitZone.Cast(GetDefaultHitZone());
        if (!m_RotorHitZone)
            return;
 
        GetGame().GetCallqueue().CallLater(GetComponentsDelayed); //get components after init
        
        RplComponent rplComp = RplComponent.Cast(GetOwner().FindComponent(RplComponent));
        if (!rplComp || rplComp.IsProxy())
            return;
        
        SetEventMask(GetOwner(), EntityEvent.CONTACT);
    }
}