DustKickupEffects.c

См. документацию.

class DustKickupParams
{
    Object object;
    string surfaceName;
    vector position;
    vector orientation;
    int playerStance;
    float hitFraction;
    string ammoType;
    float traceDepth;
}

class DustKickupParticleData
{
    void DustKickupParticleData(string path, int id, string className)
    {
        m_Path = path;
        m_ID = id;
        m_ParticleClass = className;
    }
    
    string m_Path;
    string m_ParticleClass;
    int m_ID;
}
 
class DustKickupEffectDistanceData
{
    void DustKickupEffectDistanceData(float minDist, float maxDist, array<string> variants)
    {
        m_MinDistance = minDist;
        m_MaxDistance = maxDist;
        m_Variants      = variants;
    }
    
    float m_MinDistance;
    float m_MaxDistance;
    ref array<string> m_Variants;
};
 
class DustKickupEffects
{
    private string m_DustKickupSoundSetName = "KickupDustEffect_SoundSet";
    
    protected ref map<string, ref map<string, ref DustKickupParticleData>> m_DustEffPaths = new map<string, ref map<string, ref DustKickupParticleData>>();
    
    protected ref map<string, ref array<ref DustKickupEffectDistanceData>> m_EffectRanges = new map<string, ref array<ref DustKickupEffectDistanceData>>();
 
    private static ref DustKickupEffects m_DustKickupEffects = NULL;
    
    private const float MAX_DISTANCE_FOR_EFFECT = 2.0;
    
    private const float EFFECT_COOLDOWN_MIN = 0.5;
    private const float EFFECT_COOLDOWN_MAX = 1.0;
    
    private float m_TimeUntilNextEffect = 0.0;
    
    void DustKickupEffects()
    {
        Init();
    }
    
    void Init()
    {
        LoadAmmoTypes();
        LoadDustEffectPaths();
    }
    
    static DustKickupEffects GetInstance()
    {
        if (!m_DustKickupEffects)
        {
            m_DustKickupEffects = new DustKickupEffects();
        }
        
        return m_DustKickupEffects;
    }
    
    static void CleanupInstance()
    {
        if (m_DustKickupEffects)
            delete m_DustKickupEffects;
        m_DustKickupEffects = null;
    }
    
    private void LoadAmmoTypes()
    {
        string configPath = "CfgMagazines ";
        string childClass = "";
        
        int count = g_Game.ConfigGetChildrenCount(configPath);
        
        for (int i = 0; i < count; ++i)
        {
            g_Game.ConfigGetChildName(configPath, i, childClass);
            if (!childClass.Contains("Ammo")) 
                continue;
 
            string ammoType = "";
            
            int effCount = g_Game.ConfigGetChildrenCount(configPath + childClass + " Effects");
            array<ref DustKickupEffectDistanceData> dataArray = new array <ref DustKickupEffectDistanceData>();
            
            for (int j = 0; j < effCount; ++j)
            {
                string stance;
                g_Game.ConfigGetChildName(configPath + childClass + " Effects", j, stance);
                
                string effectPath = configPath + childClass + " Effects" + " " + stance;
                
                float minDist;
                float maxDist;
                array<string> effects = new array<string>();
                
                minDist = g_Game.ConfigGetFloat(effectPath + " minDist");
                maxDist = g_Game.ConfigGetFloat(effectPath + " maxDist");
                g_Game.ConfigGetTextArray(effectPath + " Effects", effects);
                
                dataArray.Insert(new DustKickupEffectDistanceData(minDist, maxDist, effects));
            }
            
            if (effCount > 0)
            {
                m_EffectRanges.Insert(childClass, dataArray);
            }
        }
    }
    
    private void LoadDustEffectPaths()
    {
        string configPath = "CfgSurfaces ";
        string childClass = "";
        
        int count = g_Game.ConfigGetChildrenCount(configPath);
        
        for (int i = 0; i < count; ++i)
        {
            g_Game.ConfigGetChildName(configPath, i, childClass);
            
            map<string, ref DustKickupParticleData> dustEffectParticles = new map <string, ref DustKickupParticleData>();
            
            int effectsCount = g_Game.ConfigGetChildrenCount(configPath + childClass + " DustEffects");
            
            for (int j = 0; j < effectsCount; j++)
            {
                string dustPath     = " ";
                string effectClass  = " ";
                
                g_Game.ConfigGetChildName(configPath + childClass + " DustEffects", j, effectClass);
                
                g_Game.ConfigGetText(configPath + childClass + " DustEffects" + " " + effectClass + " path", dustPath);
                
                if (dustPath.Length() > 1)
                {
                    int particleID = ParticleList.RegisterParticleByFullPath(dustPath);
                    dustEffectParticles.Insert(effectClass, new DustKickupParticleData(dustPath, particleID, effectClass));
                }
            }
            if (effectsCount > 0)
            {
                m_DustEffPaths.Insert(childClass, dustEffectParticles);
            }
        }   
    }
    
    private array<string> DetermineParticles(string ammoType, float fraction, float depth)
    {
        float distance = fraction * depth;
        array<ref DustKickupEffectDistanceData> distances = m_EffectRanges.Get(ammoType);
        if (!distances)
            return null;
        
        foreach (DustKickupEffectDistanceData data : distances)
        {
            if (distance >= data.m_MinDistance && distance < data.m_MaxDistance)
                return data.m_Variants;
        }
        
        return null;
    }
    
    void PlaySoundEffect(DustKickupParams params)
    {
        EffectSound dustKickupSound = SEffectManager.CreateSound(m_DustKickupSoundSetName, params.position);
        
        if (!dustKickupSound)
        {
            string errorMsgSound = "Soundset is invalid, please check the value of m_DustKickupSoundSetName, as well as the config to see if the soundset is correct";
            ErrorEx(string.Format("%1: SoundSetName: '%2' :: %3", this, m_DustKickupSoundSetName, errorMsgSound));
        }
 
        params.object.PlaySoundSet(dustKickupSound, m_DustKickupSoundSetName, 0.0, 0.0); //the two zeros are fade in/out values, will leave them as is and add constants in the future if needed
        dustKickupSound.SetPosition(params.position);
        dustKickupSound.SetAutodestroy(true);
    }
    
    void PlayParticle(DustKickupParams params)
    {
        float now = g_Game.GetTickTime();
        
        if (now < m_TimeUntilNextEffect)
            return;
        
        float distanceMeters = params.hitFraction * params.traceDepth;
        
        if (distanceMeters >= MAX_DISTANCE_FOR_EFFECT)
            return;
        
        array<string> particleNames = DetermineParticles(params.ammoType, params.hitFraction, params.traceDepth);
        if (!particleNames)
            return;
        
        map<string, ref DustKickupParticleData> surfaceVariants = m_DustEffPaths.Get(params.surfaceName);
        if (!surfaceVariants)
            return;
        
        bool effectPlayed = false;
        
        foreach (string name : particleNames)
        {
            DustKickupParticleData data = surfaceVariants.Get(name);
            
            if (!data)
            {
                string errorMsg = "No such particles exists. Check to see if the name of the particle inside the ammo config is correct";
                ErrorEx(string.Format("Particle: '%1'", name, errorMsg));
                continue;
            }
            
            ParticleSource particle = ParticleManager.GetInstance().CreateParticleEx(data.m_ID, params.position);
            particle.SetOrientation(params.orientation); 
            particle.SetParticleAutoDestroyFlags(ParticleAutoDestroyFlags.ON_END);
            particle.PlayParticle();
            
            effectPlayed = true;
        }
        
        if (effectPlayed)
        {
            m_TimeUntilNextEffect = now + Math.RandomFloat(EFFECT_COOLDOWN_MIN, EFFECT_COOLDOWN_MAX);
        }
        
        PlaySoundEffect(params);
    }
};