BulletImpactBase.c

Go to the documentation of this 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);
      }
    }
  }
}