DayZ Scripts: P:/scripts/3_Game/Effects/EffectParticle/BulletImpactBase.c Source File

class EffBulletImpactBase : EffectParticle

{

    static const int    SURVIVOR_HEAD = 0; // Head component

    static const int    INFECTED_HEAD = 3; // Head component

    static float        DEFAULT_PROJECTILE_WEIGHT = 0.015;


    float               MIN_SCALING_PARAM = 0.1;


    Object              m_DirectHit;

    float               m_StoppingForce;

    float               m_Weight; // projectile weight in kg

    int                 m_ImpactType;

    int                 m_ComponentIndex;

    vector              m_Pos;

    vector              m_SurfNormal;

    vector              m_ExitPos;

    vector              m_InSpeed;

    vector              m_OutSpeed;

    string              m_AmmoType;


    static vector INVALID = "0 0 0";


    // Particle Effects

    int m_ParticleEnter = -1;

    int m_ParticleExit = -1;

    int m_ParticleRicochet = -1;


    // Calculations

    float m_EnterSplashCoef = 0.003;

    float m_ExitSplashCoef = 0.002;

    float m_RicochetSplashCoef = 0.002;

    float m_EnterAngledSplashCoef = 0.01;

    float m_AngledEnter = 0.40;


    void EffBulletImpactBase()

    {


    }


    override void OnCheckUpdate()

    {

        //DbgUI.Text( m_ammoType );

    }


    void SetEnterParticle(int id)

    {

        m_ParticleEnter = id;

    }


    void SetExitParticle(int id)

    {

        m_ParticleExit = id;

    }


    void SetRicochetParticle(int id)

    {

        m_ParticleRicochet = id;

    }


    void SetSingleParticle(int id)

    {

        SetEnterParticle(id);

        SetExitParticle(id);

        SetRicochetParticle(id);

    }


    void SetAngledEnterValue(float f)

    {

        m_AngledEnter = f;

    }


    void EvaluateEffect(Object directHit, int componentIndex, vector pos, int impact_type, vector surfNormal, vector exitPos, vector inSpeed, vector outSpeed, string ammoType)

    {

        m_DirectHit         = directHit;

        m_Pos               = pos;

        m_ImpactType        = impact_type;

        m_ComponentIndex    = componentIndex;

        m_SurfNormal        = surfNormal;

        m_ExitPos           = exitPos;

        m_InSpeed           = inSpeed;

        m_OutSpeed          = outSpeed;

        m_AmmoType          = ammoType;

        m_Weight            = GetGame().ConfigGetFloat("CfgAmmo " + ammoType + " weight");


        m_StoppingForce     = CalculateStoppingForce(m_InSpeed.Length(), m_OutSpeed.Length(), ammoType, m_Weight);

    }


    float CalculateStoppingForce(float in_speedf, float out_speedf, string ammoType, float weight)

    {

        if ( m_ImpactType == ImpactTypes.MELEE )

        {

            return Math.RandomFloat(50, 100);

        }


        float projectile_weight_coef = weight / DEFAULT_PROJECTILE_WEIGHT;


        float stopping_force = (in_speedf - out_speedf) * projectile_weight_coef;


        return stopping_force;

    }


    void OnEnterCalculations( Particle p )

    {

        // All values represent scale

        float velocity_min      = (m_StoppingForce * m_EnterSplashCoef);

        float velocity_max      = (m_StoppingForce * m_EnterSplashCoef);

        float size              = (m_StoppingForce * m_EnterSplashCoef);

        float birth_rate        = (m_StoppingForce * m_EnterSplashCoef);

        float air_resistance    = velocity_min;

        float lifetime          = (m_StoppingForce * m_EnterSplashCoef);

        float lifetime_rnd      = (m_StoppingForce * m_EnterSplashCoef);


        if ( m_AmmoType == "Bullet_12GaugePellets" )

        {

            birth_rate *= 0.5;

            velocity_min *= 2;

            velocity_max *= 2;

        }


        if (velocity_min < 0.75)

            velocity_min = 0.75;


        if (size < 0.75)

            size = 0.75;


        if (lifetime < 0.5)

            lifetime = 0.5;


        if (lifetime_rnd < 0.5)

            lifetime_rnd = 0.5;


        if (velocity_max < 1)

            velocity_max = 1;


        /*Print("===============");

        Print(velocity_min);

        Print(velocity_max);

        Print(size);

        Print(birth_rate);

        Print(air_resistance);

        Print(lifetime);

        Print(lifetime_rnd);*/


        p.ScaleParticleParam(EmitorParam.VELOCITY, velocity_min);

        p.ScaleParticleParam(EmitorParam.VELOCITY_RND, velocity_max);

        p.ScaleParticleParam(EmitorParam.SIZE, size);

        p.ScaleParticleParam(EmitorParam.BIRTH_RATE, birth_rate);

        p.ScaleParticleParam(EmitorParam.AIR_RESISTANCE, air_resistance);

        p.ScaleParticleParam(EmitorParam.AIR_RESISTANCE_RND, air_resistance);

        p.ScaleParticleParam(EmitorParam.LIFETIME, lifetime);

        p.ScaleParticleParam(EmitorParam.LIFETIME_RND, lifetime_rnd);

    }


    void OnExitCalculations(Particle p, float outSpeedf)

    {

        float velocity_min = 1 + (outSpeedf * m_ExitSplashCoef);

        float velocity_max = 1 + (outSpeedf * m_ExitSplashCoef);

        float size = 1 + ( outSpeedf * m_ExitSplashCoef);

        float birth_rate = 1 + (outSpeedf * m_ExitSplashCoef);


        if (velocity_min < MIN_SCALING_PARAM)

            velocity_min = MIN_SCALING_PARAM;


        if (size < MIN_SCALING_PARAM)

            size = MIN_SCALING_PARAM;


        if (birth_rate < MIN_SCALING_PARAM)

            birth_rate = MIN_SCALING_PARAM;


        p.ScaleParticleParam(EmitorParam.VELOCITY, velocity_min);

        p.ScaleParticleParam(EmitorParam.VELOCITY_RND, velocity_max);

        p.ScaleParticleParam(EmitorParam.SIZE, size);

        p.ScaleParticleParam(EmitorParam.BIRTH_RATE, birth_rate);

    }


    void OnRicochetCalculations(Particle p, float outspeedf)

    {

        float velocity_min = MIN_SCALING_PARAM + (m_StoppingForce * m_RicochetSplashCoef);

        float velocity_max = MIN_SCALING_PARAM + (m_StoppingForce * m_RicochetSplashCoef);

        float size = MIN_SCALING_PARAM + ( m_StoppingForce * m_RicochetSplashCoef);

        float birth_rate = MIN_SCALING_PARAM + (m_StoppingForce * m_RicochetSplashCoef);


        if (velocity_min < MIN_SCALING_PARAM)

            velocity_min = MIN_SCALING_PARAM;


        if (size < MIN_SCALING_PARAM)

            size = MIN_SCALING_PARAM;


        if (birth_rate < MIN_SCALING_PARAM)

            birth_rate = MIN_SCALING_PARAM;


        p.ScaleParticleParam(EmitorParam.VELOCITY, velocity_min);

        p.ScaleParticleParam(EmitorParam.VELOCITY_RND, velocity_max);

        p.ScaleParticleParam(EmitorParam.SIZE, size);

        p.ScaleParticleParam(EmitorParam.BIRTH_RATE, birth_rate);

    }


    void OnEnterAngledCalculations(Particle p)

    {

        float velocity_min = MIN_SCALING_PARAM + (m_StoppingForce * m_EnterAngledSplashCoef);

        float velocity_max = MIN_SCALING_PARAM + (m_StoppingForce * m_EnterAngledSplashCoef);

        float size = MIN_SCALING_PARAM + (m_StoppingForce * m_EnterAngledSplashCoef);

        float birth_rate = MIN_SCALING_PARAM + (m_StoppingForce * m_EnterAngledSplashCoef);


        if (velocity_min < MIN_SCALING_PARAM)

            velocity_min = MIN_SCALING_PARAM;


        if (size < MIN_SCALING_PARAM)

            size = MIN_SCALING_PARAM;


        if (birth_rate < MIN_SCALING_PARAM)

            birth_rate = MIN_SCALING_PARAM;


        p.ScaleParticleParam(EmitorParam.VELOCITY, velocity_min);

        p.ScaleParticleParam(EmitorParam.VELOCITY_RND, velocity_max);

        p.ScaleParticleParam(EmitorParam.SIZE, size);

        p.ScaleParticleParam(EmitorParam.BIRTH_RATE, birth_rate);

    }


    override void Event_OnStarted()

    {

        Particle p;

        vector particle_orientation;

        float outSpeedf = m_OutSpeed.Length();


        ParticleManager gPM = ParticleManager.GetInstance();


        if ( m_ImpactType == ImpactTypes.RICOCHET )

        {

            p = gPM.PlayInWorld(m_ParticleRicochet, m_Pos);


            if (p)

            {

                particle_orientation = m_OutSpeed.VectorToAngles();

                particle_orientation = particle_orientation + "0 -90 0";

                p.SetOrientation(particle_orientation);


                OnRicochetCalculations(p, outSpeedf);

            }

        }

        else

        {

            p = gPM.PlayInWorld(m_ParticleEnter, m_Pos );


            if (p)

            {

                if (m_SurfNormal != INVALID)

                {

                    particle_orientation = m_SurfNormal.VectorToAngles();

                    particle_orientation = particle_orientation + "0 270 0";

                }

                else

                {

                    particle_orientation = "0 0 0"; // This vector is in angles

                }


                p.SetOrientation(particle_orientation);


                OnEnterCalculations(p);

            }


            if (outSpeedf > 0  &&  m_SurfNormal != INVALID)

            {

                p = gPM.PlayInWorld(m_ParticleExit, m_ExitPos);


                if (p)

                {

                    particle_orientation = m_OutSpeed.VectorToAngles();

                    particle_orientation = particle_orientation + "0 -90 0";

                    p.SetOrientation(particle_orientation);


                    OnExitCalculations(p, outSpeedf);

                }

            }

            else

            {

                if (m_SurfNormal != INVALID)

                {

                    vector surfNormalN = m_SurfNormal.Normalized();

                    vector inSpeedN = m_InSpeed.Normalized();

                    vector bounce_ori = surfNormalN + inSpeedN;


                    float dot = vector.Dot(bounce_ori, surfNormalN);


                    if ( dot > m_AngledEnter )

                    {

                        p = gPM.PlayInWorld(m_ParticleRicochet, m_Pos);


                        if (p)

                        {

                            particle_orientation = bounce_ori.VectorToAngles();

                            particle_orientation = particle_orientation + "0 -90 0";

                            p.SetOrientation(particle_orientation);


                            OnEnterAngledCalculations(p);

                        }

                    }

                }

            }

        }


        if (p)

        {

            SetParticle(p);

        }


        // Additional impact particle over long ranges. It shows players where their bullets land


        if ( Type() != Hit_MeatBones )

        {

            vector camera_pos = GetGame().GetCurrentCameraPosition();

            float distance = vector.Distance(camera_pos, m_Pos);


            // Additional size increase by distance from camera

            float scaling_by_distance = distance * 0.01;


            // Now scale down the above size increase by player's zoom-in value

            float current_FOV = Camera.GetCurrentFOV();

            float config_FOV = GetDayZGame().GetUserFOVFromConfig();

            float FOV_scale = current_FOV / config_FOV;

            scaling_by_distance = 1 + scaling_by_distance * FOV_scale;


            if (scaling_by_distance > 1.1)

            {

                Particle p_distant = gPM.PlayInWorld(ParticleList.IMPACT_DISTANT_DUST, m_Pos);


                particle_orientation = m_SurfNormal.VectorToAngles();

                particle_orientation[1] = particle_orientation[1] + 270;

                p_distant.SetOrientation(particle_orientation);


                p_distant.ScaleParticleParam(EmitorParam.SIZE, scaling_by_distance - 0.5);

                p_distant.ScaleParticleParam(EmitorParam.BIRTH_RATE, scaling_by_distance * 0.1);

                p_distant.ScaleParticleParam(EmitorParam.BIRTH_RATE_RND, scaling_by_distance * 0.1);

                p_distant.ScaleParticleParam(EmitorParam.LIFETIME, scaling_by_distance * 0.3);

                p_distant.ScaleParticleParam(EmitorParam.LIFETIME_RND, scaling_by_distance * 0.3);

            }

        }

    }

}

GetDayZGame
DayZGame GetDayZGame()
Definition DayZGame.c:3656

ImpactTypes
ImpactTypes
Definition ImpactEffects.c:2

Type
string Type
Definition JsonDataContaminatedArea.c:11

ParticleManager
void ParticleManager(ParticleManagerSettings settings)
Constructor (ctor)
Definition ParticleManager.c:84

CGame::ConfigGetFloat
proto native float ConfigGetFloat(string path)
Get float value from config on path.

CGame::GetCurrentCameraPosition
proto native vector GetCurrentCameraPosition()

Camera
Definition Camera.c:70

EffBulletImpactBase
Definition BulletImpactBase.c:2

EffBulletImpactBase::OnEnterCalculations
void OnEnterCalculations(Particle p)
Definition BulletImpactBase.c:102

EffBulletImpactBase::m_EnterSplashCoef
float m_EnterSplashCoef
Definition BulletImpactBase.c:29

EffBulletImpactBase::m_ImpactType
int m_ImpactType
Definition BulletImpactBase.c:12

EffBulletImpactBase::DEFAULT_PROJECTILE_WEIGHT
static float DEFAULT_PROJECTILE_WEIGHT
Definition BulletImpactBase.c:5

EffBulletImpactBase::SURVIVOR_HEAD
static const int SURVIVOR_HEAD
Definition BulletImpactBase.c:3

EffBulletImpactBase::m_InSpeed
vector m_InSpeed
Definition BulletImpactBase.c:17

EffBulletImpactBase::MIN_SCALING_PARAM
float MIN_SCALING_PARAM
Definition BulletImpactBase.c:7

EffBulletImpactBase::m_ExitSplashCoef
float m_ExitSplashCoef
Definition BulletImpactBase.c:30

EffBulletImpactBase::m_ExitPos
vector m_ExitPos
Definition BulletImpactBase.c:16

EffBulletImpactBase::m_Pos
vector m_Pos
Definition BulletImpactBase.c:14

EffBulletImpactBase::EffBulletImpactBase
void EffBulletImpactBase()
Definition BulletImpactBase.c:35

EffBulletImpactBase::INFECTED_HEAD
static const int INFECTED_HEAD
Definition BulletImpactBase.c:4

EffBulletImpactBase::OnEnterAngledCalculations
void OnEnterAngledCalculations(Particle p)
Definition BulletImpactBase.c:199

EffBulletImpactBase::m_Weight
float m_Weight
Definition BulletImpactBase.c:11

EffBulletImpactBase::SetSingleParticle
void SetSingleParticle(int id)
Definition BulletImpactBase.c:60

EffBulletImpactBase::m_OutSpeed
vector m_OutSpeed
Definition BulletImpactBase.c:18

EffBulletImpactBase::m_ParticleRicochet
int m_ParticleRicochet
Definition BulletImpactBase.c:26

EffBulletImpactBase::m_ParticleExit
int m_ParticleExit
Definition BulletImpactBase.c:25

EffBulletImpactBase::Event_OnStarted
override void Event_OnStarted()
Definition BulletImpactBase.c:221

EffBulletImpactBase::m_AmmoType
string m_AmmoType
Definition BulletImpactBase.c:19

EffBulletImpactBase::m_ParticleEnter
int m_ParticleEnter
Definition BulletImpactBase.c:24

EffBulletImpactBase::m_ComponentIndex
int m_ComponentIndex
Definition BulletImpactBase.c:13

EffBulletImpactBase::OnExitCalculations
void OnExitCalculations(Particle p, float outSpeedf)
Definition BulletImpactBase.c:155

EffBulletImpactBase::m_AngledEnter
float m_AngledEnter
Definition BulletImpactBase.c:33

EffBulletImpactBase::SetExitParticle
void SetExitParticle(int id)
Definition BulletImpactBase.c:50

EffBulletImpactBase::SetRicochetParticle
void SetRicochetParticle(int id)
Definition BulletImpactBase.c:55

EffBulletImpactBase::CalculateStoppingForce
float CalculateStoppingForce(float in_speedf, float out_speedf, string ammoType, float weight)
Definition BulletImpactBase.c:88

EffBulletImpactBase::SetAngledEnterValue
void SetAngledEnterValue(float f)
Definition BulletImpactBase.c:67

EffBulletImpactBase::m_StoppingForce
float m_StoppingForce
Definition BulletImpactBase.c:10

EffBulletImpactBase::m_RicochetSplashCoef
float m_RicochetSplashCoef
Definition BulletImpactBase.c:31

EffBulletImpactBase::SetEnterParticle
void SetEnterParticle(int id)
Definition BulletImpactBase.c:45

EffBulletImpactBase::EvaluateEffect
void EvaluateEffect(Object directHit, int componentIndex, vector pos, int impact_type, vector surfNormal, vector exitPos, vector inSpeed, vector outSpeed, string ammoType)
Definition BulletImpactBase.c:72

EffBulletImpactBase::INVALID
static vector INVALID
Definition BulletImpactBase.c:21

EffBulletImpactBase::m_SurfNormal
vector m_SurfNormal
Definition BulletImpactBase.c:15

EffBulletImpactBase::m_DirectHit
Object m_DirectHit
Definition BulletImpactBase.c:9

EffBulletImpactBase::OnCheckUpdate
override void OnCheckUpdate()
Definition BulletImpactBase.c:40

EffBulletImpactBase::OnRicochetCalculations
void OnRicochetCalculations(Particle p, float outspeedf)
Definition BulletImpactBase.c:177

EffBulletImpactBase::m_EnterAngledSplashCoef
float m_EnterAngledSplashCoef
Definition BulletImpactBase.c:32

EffectParticle
Wrapper class for managing particles through SEffectManager.
Definition EffectParticle.c:5

EffectParticle::SetParticle
void SetParticle(Particle p)
Sets the main particle which this Effect will manage.
Definition EffectParticle.c:134

Hit_MeatBones
Definition Hit_MeatBones.c:2

Math
Definition EnMath.c:7

Object
Definition ObjectTyped.c:2

Particle
Legacy way of using particles in the game.
Definition Particle.c:7

Particle::ScaleParticleParam
void ScaleParticleParam(int parameter_id, float coef)
Scales the given parameter on all emitors relatively to their CURRENT value.
Definition Particle.c:687

Particle::PlayInWorld
static Particle PlayInWorld(int particle_id, vector global_pos)
Creates a particle emitter on the given position and activates it.
Definition Particle.c:174

ParticleList
Definition ParticleList.c:12

ParticleList::IMPACT_DISTANT_DUST
static const int IMPACT_DISTANT_DUST
Definition ParticleList.c:193

vector
Definition EnConvert.c:106

vector::Normalized
proto vector Normalized()
return normalized vector (keeps orginal vector untouched)

vector::Distance
static proto native float Distance(vector v1, vector v2)
Returns the distance between tips of two 3D vectors.

vector::VectorToAngles
proto vector VectorToAngles()
Converts vector to spherical coordinates with radius = 1.

vector::Length
proto native float Length()
Returns length of vector (magnitude)

vector::Dot
static float Dot(vector v1, vector v2)
Returns Dot product of vector v1 and vector v2.
Definition EnConvert.c:271

GetGame
proto native CGame GetGame()

Math::RandomFloat
static proto float RandomFloat(float min, float max)
Returns a random float number between and min[inclusive] and max[exclusive].

EmitorParam
EmitorParam
Definition EnVisual.c:114