WeaponParticles.c
class WeaponParticlesBaseclass WeaponParticlesOnFireclass WeaponParticlesOnBulletCasingEjectclass WeaponParticlesOnOverheatingclass OverheatingParticle
/*
Author: Boris Vacula
For documentation go to: DayZ Confluence -> How-to articles -> Weapon muzzle flash particle system configuration
This system plays effect(s) on any weapon that is fired/jammed/ruined/...
*/
class WeaponParticlesBase // This class represents every particle effect you see in config within OnFire or OnOverheating events
{
bool m_IlluminateWorld;
bool m_IgnoreIfSuppressed;
bool m_OnlyIfBoltIsOpen;
int m_MuzzleIndex;
int m_OverrideParticle;
int m_OnlyWithinHealthLabelMin;
int m_OnlyWithinHealthLabelMax;
float m_OnlyWithinOverheatLimitsMin;
float m_OnlyWithinOverheatLimitsMax;
float m_OnlyWithinRainLimitsMin;
float m_OnlyWithinRainLimitsMax;
string m_OverrideDirectionPoint;
string m_OnlyIfBulletIs;
string m_OnlyIfWeaponIs;
string m_OverridePoint;
vector m_OverrideDirectionVector;
vector m_PositionOffset;
string m_Name;
//======================================
// PRELOAD EVERYTHING
//======================================
void WeaponParticlesBase(ItemBase muzzle_owner, string config_OnFire_entry)
{
m_Name = config_OnFire_entry;
// ignoreIfSuppressed
m_IgnoreIfSuppressed = g_Game.ConfigGetFloat(string.Format("%1 ignoreIfSuppressed", m_Name));
// onlyIfBoltIsOpen
m_OnlyIfBoltIsOpen = g_Game.ConfigGetFloat(string.Format("%1 onlyIfBoltIsOpen", m_Name));
// illuminateWorld
m_IlluminateWorld = g_Game.ConfigGetFloat(string.Format("%1 illuminateWorld", m_Name));
m_MuzzleIndex = -1;
if (g_Game.ConfigIsExisting(string.Format("%1 muzzleIndex", m_Name)))
{
m_MuzzleIndex = g_Game.ConfigGetInt(string.Format("%1 muzzleIndex", m_Name));
}
// onlyIfWeaponIs
m_OnlyIfWeaponIs = "";
g_Game.ConfigGetText(string.Format("%1 onlyIfWeaponIs", m_Name), m_OnlyIfWeaponIs);
// onlyIfBulletIs
m_OnlyIfBulletIs = "";
g_Game.ConfigGetText(string.Format("%1 onlyIfBulletIs", m_Name), m_OnlyIfBulletIs);
// onlyWithinHealthLabel[]
array<float> health_limit = new array<float>;
g_Game.ConfigGetFloatArray(string.Format("%1 onlyWithinHealthLabel", m_Name), health_limit);
if (health_limit.Count() == 2)
{
m_OnlyWithinHealthLabelMin = health_limit.Get(0);
m_OnlyWithinHealthLabelMax = health_limit.Get(1);
}
else
{
// Disable this filter
m_OnlyWithinHealthLabelMin = -1;
m_OnlyWithinHealthLabelMax = 99;
}
// onlyWithinOverheatLimits[]
array<float> overheat_limit = new array<float>;
g_Game.ConfigGetFloatArray(string.Format("%1 onlyWithinOverheatLimits", m_Name), overheat_limit);
if (overheat_limit.Count() == 2)
{
m_OnlyWithinOverheatLimitsMin = overheat_limit.Get(0);
m_OnlyWithinOverheatLimitsMax = overheat_limit.Get(1);
}
else
{
// Disable this filter
m_OnlyWithinOverheatLimitsMin = -1;
m_OnlyWithinOverheatLimitsMax = 2;
}
// onlyWithinRainLimits[]
array<float> rain_limit = new array<float>;
g_Game.ConfigGetFloatArray(string.Format("%1 onlyWithinRainLimits", m_Name), rain_limit);
if (rain_limit.Count() == 2)
{
m_OnlyWithinRainLimitsMin = rain_limit.Get(0);
m_OnlyWithinRainLimitsMax = rain_limit.Get(1);
}
else
{
// Disable this filter
m_OnlyWithinRainLimitsMin = -1;
m_OnlyWithinRainLimitsMax = 2;
}
// overridePoint
m_OverridePoint = "";
g_Game.ConfigGetText(string.Format("%1 overridePoint", m_Name), m_OverridePoint);
if (m_OverridePoint == "")
m_OverridePoint = "Usti hlavne"; // default memory point name
// overrideParticle
string particle_name = "";
g_Game.ConfigGetText( string.Format("%1 overrideParticle", m_Name), particle_name);
if (particle_name != "")
{
m_OverrideParticle = ParticleList.GetParticleIDByName(particle_name);
}
else
{
m_OverrideParticle = -1;
ErrorEx(string.Format("'%1' does not contain a definition for 'overrideparticle'",
config_OnFire_entry), ErrorExSeverity.INFO);
}
// overrideDirectionPoint
m_OverrideDirectionPoint = "";
g_Game.ConfigGetText(string.Format("%1 overrideDirectionPoint", m_Name), m_OverrideDirectionPoint);
if (m_OverrideDirectionPoint == "")
{
// overrideDirectionVector
vector test_ori = g_Game.ConfigGetVector(string.Format("%1 overrideDirectionVector", m_Name));
if (test_ori != vector.Zero)
{
m_OverrideDirectionVector = test_ori;
}
}
// positionOffset[]
array<float> v = new array<float>;
g_Game.ConfigGetFloatArray(string.Format("%1 positionOffset", m_Name), v);
if (v.Count() == 3)
{
float v1 = v.Get(0);
float v2 = v.Get(1);
float v3 = v.Get(2);
m_PositionOffset = Vector(v1, v2, v3);
}
}
//======================================
// PLAY PARTICLES
//======================================
// It is important to know that this block of script is called for weapons and muzzle attachments alike.
// Thus weapon == muzzle_owner when this is called for a weapon, and weapon != muzzle_owner when this is called for a suppressor.
void OnActivate(ItemBase weapon, int muzzle_index, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
{
if ( !g_Game.IsServer() || !g_Game.IsMultiplayer() )
{
// Handle effect's parameters
if ( PrtTest.m_GunParticlesState ) // Check if particles are enabled by debug
{
if ( m_MuzzleIndex == -1 || m_MuzzleIndex == muzzle_index )
{
if ( CheckBoltStateCondition(weapon) ) // onlyIfBoltIsOpen
{
if ( !suppressor || suppressor.IsRuined() || !(m_IgnoreIfSuppressed) ) // ignoreIfSuppressed
{
if ( CheckHealthCondition( muzzle_owner.GetHealthLevel() ) ) // onlyWithinHealthLabel
{
if ( CheckOverheatingCondition( muzzle_owner.GetOverheatingCoef() ) ) // onlyWithinOverheatLimits
{
if ( CheckRainCondition( g_Game.GetWeather().GetRain().GetActual() ) ) // onlyWithinRainLimits
{
if ( m_OnlyIfBulletIs == "" || m_OnlyIfBulletIs == ammoType ) // onlyIfBulletIs
{
if ( m_OnlyIfWeaponIs == "" || m_OnlyIfWeaponIs == weapon.GetType() ) // onlyIfWeaponIs
{
// Get particle ID
int particle_id = CheckParticleOverride(ammoType);
if (ParticleList.IsValidId(particle_id))
{
// Get position of the particle
vector local_pos = muzzle_owner.GetSelectionPositionLS(m_OverridePoint);
local_pos += m_PositionOffset;
// Set orientation of the particle
vector particle_ori = CheckOrientationOverride(local_pos, muzzle_owner);
// Create particle
Particle p = ParticleManager.GetInstance().PlayOnObject( particle_id, muzzle_owner, local_pos, particle_ori );
OnParticleCreated(weapon, ammoType, muzzle_owner, suppressor, config_to_search, p);
}
else
{
ErrorEx(string.Format("No valid particle found for: '%1'", m_Name));
}
// Create light
if (m_IlluminateWorld)
{
vector global_pos = muzzle_owner.ModelToWorld(local_pos + Vector(-0.2, 0, 0));
int randX = Math.RandomInt( 0,10 );
if ( randX > 8 )
ScriptedLightBase.CreateLight( MuzzleFlashLight_2, global_pos );
else if ( randX > 4 )
ScriptedLightBase.CreateLight( MuzzleFlashLight_1, global_pos );
else
ScriptedLightBase.CreateLight(MuzzleFlashLight, global_pos);
}
}
}
}
}
}
}
}
}
}
}
}
void OnParticleCreated(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search, Particle p)
{
}
void OnDeactivate(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
{
}
void OnUpdate(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
{
}
//==============================================
// HANDLE CONFIG PARAMETERS
//==============================================
// OnlyWithinHealthLabelMin & OnlyWithinHealthLabelMax
bool CheckBoltStateCondition(ItemBase weapon)
{
if ( m_OnlyIfBoltIsOpen )
{
Weapon_Base wb = Weapon_Base.Cast( weapon );
WeaponStateBase current_state = wb.GetCurrentState();
return current_state.IsBoltOpen();
}
return true;
}
// OnlyWithinHealthLabelMin & OnlyWithinHealthLabelMax
bool CheckHealthCondition(int health_label)
{
return ( (health_label >= m_OnlyWithinHealthLabelMin) && (health_label <= m_OnlyWithinHealthLabelMax) );
}
// OnlyWithinOverheatLimitsMin & OnlyWithinOverheatLimitsMax
bool CheckOverheatingCondition(float overheating_coef)
{
return ( (overheating_coef >= m_OnlyWithinOverheatLimitsMin) && (overheating_coef <= m_OnlyWithinOverheatLimitsMax) );
}
// OnlyWithinRainLimitsMin & OnlyWithinRainLimitsMax
bool CheckRainCondition(float rain_coef)
{
return ( (rain_coef >= m_OnlyWithinRainLimitsMin) && (rain_coef <= m_OnlyWithinRainLimitsMax) );
}
// muzzleFlashParticle
int CheckParticleOverride(string ammoType)
{
int particle_id = -1;
string particle_file = "";
string cfg_path = "CfgAmmo " + ammoType + " muzzleFlashParticle";
if (g_Game.ConfigGetText( cfg_path, particle_file))
particle_id = ParticleList.GetParticleIDByName(particle_file);
// Config is accessed only once because the data is saved into a map for repeated access.
if ( particle_id > 0 || m_OverrideParticle == -1)
{
if (particle_file == "")
{
ErrorEx(string.Format("Cannot spawn particle effect because item %1 is missing config parameter muzzleFlashParticle!", ammoType), ErrorExSeverity.INFO);
}
else
{
particle_id = ParticleList.GetParticleIDByName(particle_file);
if (particle_id == 0)
{
string devStr;
#ifdef DEVELOPER
devStr = " Make sure it's registered there and then rebuild Scripts and Graphics PBOs.";
#endif
ErrorEx(string.Format("Cannot play particle effect with name %1 because no such file is registered in ParticleList.c!%2", particle_file, devStr));
m_OverrideParticle = particle_id; // Prevents another appearence of the above error.
}
}
}
else
{
particle_id = m_OverrideParticle;
}
return particle_id;
}
// OverrideDirectionPoint & OverrideDirectionVector
vector CheckOrientationOverride(vector local_pos, ItemBase muzzle_owner)
{
vector particle_ori = "0 0 0";
if (m_OverrideDirectionPoint != "")
{
vector target_pos = muzzle_owner.GetSelectionPositionLS(m_OverrideDirectionPoint);
target_pos = vector.Direction(local_pos, target_pos);
particle_ori = target_pos.VectorToAngles();
}
else
{
if (m_OverrideDirectionVector != Vector(0, 0, 0))
{
particle_ori = m_OverrideDirectionVector;
}
if (muzzle_owner.IsInherited(ItemSuppressor))
{
particle_ori = particle_ori + Vector(0,0,270); // This rotation is necesarry due to suppressors being rotated into ground in their p3d files
}
}
return particle_ori;
}
}
// FIRE particles
class WeaponParticlesOnFire : WeaponParticlesBase {}
// BULLET EJECT particles
class WeaponParticlesOnBulletCasingEject : WeaponParticlesBase {}
// OVERHEATING particles
class WeaponParticlesOnOverheating: WeaponParticlesBase
{
override void OnParticleCreated(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search, Particle p)
{
muzzle_owner.RegisterOverheatingParticle(p, m_OnlyWithinOverheatLimitsMin, m_OnlyWithinOverheatLimitsMax, p.GetParticleID(), muzzle_owner, p.m_DefaultPos, p.m_DefaultOri );
}
override void OnDeactivate(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
{
if ( !g_Game.IsServer() || !g_Game.IsMultiplayer() )
{
weapon.KillAllOverheatingParticles();
}
}
override void OnUpdate(ItemBase weapon, string ammoType, ItemBase muzzle_owner, ItemBase suppressor, string config_to_search)
{
OnActivate(weapon, 0, ammoType, muzzle_owner, suppressor, config_to_search);
}
}
class OverheatingParticle
{
Particle m_Particle;
int m_ParticleID;
Object m_Parent;
vector m_LocalPos;
vector m_LocalOri;
float m_OverheatingLimitMin;
float m_OverheatingLimitMax;
void RegisterParticle( Particle p)
{
m_Particle = p;
}
Particle GetParticle()
{
return m_Particle;
}
void SetOverheatingLimitMin(float min)
{
m_OverheatingLimitMin = min;
}
void SetOverheatingLimitMax(float max)
{
m_OverheatingLimitMax = max;
}
float GetOverheatingLimitMin()
{
return m_OverheatingLimitMin;
}
float GetOverheatingLimitMax()
{
return m_OverheatingLimitMax;
}
void SetParticleParams(int particle_id, Object parent, vector local_pos, vector local_ori)
{
m_ParticleID = particle_id;
m_Parent = parent;
m_LocalPos = local_pos;
m_LocalOri = local_ori;
}
int GetParticleID()
{
return m_ParticleID;
}
Object GetParticleParent()
{
return m_Parent;
}
vector GetParticlePos()
{
return m_LocalPos;
}
vector GetParticleOri()
{
return m_LocalOri;
}
}