fireworkslauncher.c

Go to the documentation of this file.

class ExplosionLight : PointLightBase
{
 void ExplosionLight()
 {
 SetVisibleDuringDaylight(true);
 SetRadiusTo(60);
 SetBrightnessTo(0.05);
 SetFlareVisible(false);
 SetAmbientColor(1.0, 1.0, 1.0);
 SetDiffuseColor(1.0, 1.0, 1.0);
 SetLifetime(2.1);
 //SetDisableShadowsWithinRadius(-1);
 SetFadeOutTime(1);
 m_FadeInTime = 0.25;
 SetFlickerSpeed(7);
 //SetFlickerAmplitude(0.5);
 SetFlickerAmplitudeMax(3);
 SetFlickerAmplitudeMin(0);
 SetCastShadow( false );
 }
}
//-----------------------------------------------------------------------------------------------
class FireworksLauncherClientEventBase
{
 void OnFired();
}
//-----------------------------------------------------------------------------------------------
class FireworksLauncherClientEvent : FireworksLauncherClientEventBase
{
 protected ref Timer m_Timer = new Timer();
 protected FireworksLauncher m_Item;
 protected int m_Index;
 protected vector m_ExplosionPos;
 protected EffectSound m_FireSound;
 protected EffectSound m_ExplosionSound;
 protected ParticleSource m_ParticleShot;
 protected ParticleSource m_ParticleExplosion;
 protected vector m_ShotDir;
 protected ExplosionLight m_ExplosionLight;
 protected ParticleSource m_ParticleAfterBurnEnd;
 protected string m_Color;
 protected int m_RemainingExplosions = GetSecondaryExplosionCount();
 protected ref array<ref FireworksLauncherClientEventBase> m_Events = new ref array<ref FireworksLauncherClientEventBase>;
 #ifdef DEVELOPER
 Shape m_ShotTrajectory;
 #endif
 
 
 // -----------------------------
 // ------- Tweaking Start-------
 // -----------------------------
 
 protected int GetSoundDelay()
 {
 return 0;
 }
 
 protected int GetLightDelay()
 {
 return 0;
 }
 
 protected float GetExplosionDistance()
 {
 return Math.RandomFloatInclusive(35,40);
 }
 
 protected float GetShotDispersionAngle()
 {
 return Math.RandomFloatInclusive(-25,25);//this is rotated 360 degrees around the UP vector too
 }
 
 protected string GetExplosionSoundSet()
 {
 return "FireworksLauncher_Explosion_SoundSet";
 }
 
 protected float GetExplosionDelay()
 {
 return Math.RandomFloatInclusive(1.5,1.75);
 }
 
 // -----------------------------
 // ------- Tweaking End --------
 // -----------------------------
 
 
 void FireworksLauncherClientEvent(FireworksLauncher item, int index)
 {
 m_Item = item;
 m_Index = index;
 
 int colorSequenceLastIndex = m_Item.GetColorSequence().Length() - 1;
 int coloreSequenceIndex = m_Index - 1;//shot index(m_Index) starts at 1
 
 if (colorSequenceLastIndex >= coloreSequenceIndex)
 {
 m_Color = m_Item.GetColorSequence().Get(coloreSequenceIndex);
 }
 else
 {
 Debug.LogError("Failed to obtain color from color sequence");
 m_Color = "B";
 }
 }
 
 void ~FireworksLauncherClientEvent()
 {
 SEffectManager.DestroyEffect(m_FireSound);
 SEffectManager.DestroyEffect(m_ExplosionSound);
 if (m_ParticleAfterBurnEnd)
 {
 m_ParticleAfterBurnEnd.StopParticle();
 }
 }
 
 override protected void OnFired()
 {
 m_Timer.Run(GetExplosionDelay(), this, "OnExplode", null);
 m_Item.PlaySoundSet( m_FireSound, "FireworksLauncher_Shot_SoundSet", 0, 0 );
 m_ParticleShot = ParticleManager.GetInstance().PlayInWorld(ParticleList.FIREWORKS_SHOT, GetShotPos());
 m_ParticleShot.SetYawPitchRoll(Vector(Math.RandomFloatInclusive(0,360),GetShotDispersionAngle(),0));
 
 m_ParticleAfterBurnEnd = ParticleManager.GetInstance().PlayInWorld(ParticleList.FIREWORKS_AFTERBURN_END, GetShotPos());
 if (m_ParticleAfterBurnEnd)
 m_ParticleAfterBurnEnd.SetOwner(this);
 m_ShotDir = m_ParticleShot.GetDirectionUp();
 
 #ifdef DEVELOPER
 vector pts[2];
 pts[0] = GetShotPos();
 pts[1] = GetShotPos() + m_ShotDir * GetExplosionDistance();
 //m_ShotTrajectory = Shape.CreateLines(COLOR_RED, ShapeFlags.TRANSP|ShapeFlags.NOOUTLINE|ShapeFlags.NOZBUFFER, pts, 2);
 #endif
 }
 
 protected vector GetShotPos()
 {
 vector memPos; 
 string memName = "Shot_" + m_Index;
 
 if (m_Item.MemoryPointExists(memName))
 {
 memPos = m_Item.GetMemoryPointPos(memName);
 memPos = m_Item.ModelToWorld(memPos);
 }
 else
 {
 memPos = m_Item.GetPosition();//fallback to item's location
 Debug.LogError("Missing shot memory point on Fireworks");
 }
 return memPos;
 }
 
 protected void CalculateExplosionPosition()
 {
 m_ExplosionPos = GetShotPos() + m_ShotDir * GetExplosionDistance();
 }
 
 protected vector GetExplosionPosition()
 {
 if (!m_ExplosionPos)
 {
 CalculateExplosionPosition();
 }
 return m_ExplosionPos;
 }
 
 int GetSecondaryExplosionCount()
 {
 return 4;
 }
 
 
 protected void OnExplode()
 {
 #ifdef DEVELOPER
 if (m_ShotTrajectory)
 {
 m_ShotTrajectory.Destroy();
 m_ShotTrajectory = null;
 }
 #endif
 m_ParticleAfterBurnEnd.Stop();
 
 GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( PlayExplosionSound, GetSoundDelay(), false);
 GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( SpawnLight, GetLightDelay(), false);
 m_ParticleExplosion = ParticleManager.GetInstance().PlayInWorld(GetExplParticleFromSequence(), GetExplosionPosition());
 
 RequestSecondaryExplosion();
 
 }
 
 protected void RequestSecondaryExplosion()
 {
 if (m_RemainingExplosions> 0)
 {
 m_RemainingExplosions--;
 GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( SpawnSecondaryExplosion, GetSecondaryExplosionDelay(), false);
 }
 }
 
 protected void SpawnSecondaryExplosion()
 {
 FireworksLauncherClientEventSecondary evnt = new FireworksLauncherClientEventSecondary(m_Item,m_Index);
 evnt.Init(GetExplosionPosition());
 evnt.OnExplode();
 m_Events.Insert(evnt);
 RequestSecondaryExplosion();
 }
 
 protected int GetSecondaryExplosionDelay()
 {
 return Math.RandomIntInclusive(100,250);
 }
 
 protected int GetExplParticleFromSequence()
 {
 switch (m_Color)
 {
 case "R":
 return ParticleList.FIREWORKS_EXPLOSION_RED;
 case "G":
 return ParticleList.FIREWORKS_EXPLOSION_GREEN;
 case "B":
 return ParticleList.FIREWORKS_EXPLOSION_BLUE;
 case "Y":
 return ParticleList.FIREWORKS_EXPLOSION_YELLOW;
 case "P":
 return ParticleList.FIREWORKS_EXPLOSION_PINK;
 default:
 ErrorEx("Incorrect explosion particle color in the sequence");
 }
 return ParticleList.FIREWORKS_EXPLOSION_RED;
 }
 
 protected void SetupLight(PointLightBase light)
 {
 switch (m_Color)
 {
 case "R":
 light.SetDiffuseColor(255,51,51);
 light.SetAmbientColor(255,51,51);
 
 break;
 case "G":
 light.SetDiffuseColor(0,255,128);
 light.SetAmbientColor(0,255,128);
 break;
 case "B":
 light.SetDiffuseColor(51,153,255);
 light.SetAmbientColor(51,153,255);
 break;
 case "Y":
 light.SetDiffuseColor(255,255,51);
 light.SetAmbientColor(255,255,51);
 break;
 case "P":
 light.SetDiffuseColor(255,102,255);
 light.SetAmbientColor(255,102,255);
 break;
 default:
 ErrorEx("Incorrect explosion particle color in the sequence");
 }
 }
 
 protected void SpawnLight()
 {
 m_ExplosionLight = ExplosionLight.Cast( ScriptedLightBase.CreateLight( ExplosionLight, GetExplosionPosition()) );
 SetupLight(m_ExplosionLight);
 }
 
 protected void PlayExplosionSound()
 {
 if (m_FireSound)
 {
 m_FireSound.Stop();
 }
 m_Item.PlaySoundSet( m_ExplosionSound, GetExplosionSoundSet(), 0, 0 );
 }
}
//------------------------------------------------------------------------------------
 
class FireworksLauncherClientEventSecondary : FireworksLauncherClientEvent
{
 protected vector m_ShotPos;
 
 override protected vector GetExplosionPosition()
 {
 return GetShotPos() + m_ShotDir * GetExplosionDistance();
 }
 
 void Init(vector pos)
 {
 m_ShotPos = pos;
 m_ShotDir[0] = Math.RandomFloatInclusive(-1,1);
 m_ShotDir[1] = Math.RandomFloatInclusive(-1,1);
 m_ShotDir[2] = Math.RandomFloatInclusive(-1,1);
 m_ShotDir.Normalize();
 }
 override protected vector GetShotPos()
 {
 return m_ShotPos;
 }
 
 override protected float GetExplosionDistance()
 {
 return Math.RandomFloatInclusive(10,15);
 }
 
 override void OnExplode()
 {
 GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( PlayExplosionSound, GetSoundDelay(), false);
 GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( SpawnLight, GetLightDelay(), false);
 m_ParticleExplosion = ParticleManager.GetInstance().PlayInWorld(GetExplParticleFromSequence(), GetExplosionPosition());
 }
}
 
class FireworksLauncher: FireworksBase
{
 int m_Index;//counts the shots
 int m_IndexPrev;//counts the shots
 int m_ColorSequenceIndex;
 ref Timer m_TimerFuse;
 ref array<ref FireworksLauncherClientEventBase> m_Events;
 EffectSound m_FuseSoundStart;
 EffectSound m_FuseSound;
 ParticleSource m_ParticleFuse;
 ParticleSource m_ParticleAfterBurnEnd;
 ref array<string> m_ColorSequence;
 
 void FireworksLauncher()
 {
 m_ColorSequence = new array<string>();
 SetupColorSequences();
 RegisterNetSyncVariableInt("m_State", 0, EnumTools.GetLastEnumValue(EFireworksState));
 RegisterNetSyncVariableInt("m_Index", 0, GetMaxShots());
 RegisterNetSyncVariableInt("m_RandomSeed", 0, 1023);
 int lastIndex = m_ColorSequence.Count() - 1;
 RegisterNetSyncVariableInt("m_ColorSequenceIndex", 0, lastIndex);
 m_RandomSeed = Math.RandomInt(0,1023);
 m_ColorSequenceIndex = Math.RandomIntInclusive(0, lastIndex);
 }
 
 void ~FireworksLauncher()
 {
 SEffectManager.DestroyEffect(m_FuseSound);
 SEffectManager.DestroyEffect(m_FuseSoundStart);
 }
 
 override protected bool UsesGlobalDeploy()
 {
 return true;
 }
 
 override bool IsDeployable()
 {
 return true;
 }
 
 override float GetDeployTime()
 {
 return 2;
 }
 
 protected void SetupColorSequences()
 {
 m_ColorSequence.Insert("RGBYPBRGBRGBYPBRGBRGBYPBRGBPBRGBRGBY");
 m_ColorSequence.Insert("PGPYPBYPYPBYYPBRPYPBYYPBRGBPBRGRGBRB");
 m_ColorSequence.Insert("YPBRPYPBYYPBRGBPBRGRGBRBGRPBRGBRYPBY");
 m_ColorSequence.Insert("YRBGPRYPGRYBGRGRGBRBBYPYPBYRYPGRYGRP");
 m_ColorSequence.Insert("BGRYPYRPBYYPYRBGPRYPGBYPBRGBPBRGBRGB");
 m_ColorSequence.Insert("RYGRPBRGBYPBRRPBRGBBRBBYPYPRGBRGBRPY");
 m_ColorSequence.Insert("GBRGBYRGBYPBRRPBRBYRYPGPYPRGBRGBRPYG");
 m_ColorSequence.Insert("RYPBYYPBRGBYPBRGBRBGBPBRGRGBRBGRYPYR");
 m_ColorSequence.Insert("PBRGBYPBRGBRBGBPBRGRGBRBGRYPYRRYPBYY");
 m_ColorSequence.Insert("RGRGBRBBYPYPBYRYPGRYGRPYRBGPRYPGRYBG");
 m_ColorSequence.Insert("RBYRYPGPYPRGBRGBRPYGGBRGBYRGBYPBRRPB");
 m_ColorSequence.Insert("PRGBRGBRPYGGBRRBYRYPGPYGBYRGBYPBRRPB");
 }
 
 string GetColorSequence()
 {
 if (m_ColorSequence.IsValidIndex(m_ColorSequenceIndex))
 {
 return m_ColorSequence.Get(m_ColorSequenceIndex);
 }
 else
 {
 ErrorEx("Failed to obtain color sequence");
 return "RYPBYYPBRGBYPBRGBRBGBPBRGRGBRBGRYPYR";
 }
 }
 
 
 override protected void OnPlacementComplete(Man player, vector position = "0 0 0", vector orientation = "0 0 0")
 {
 super.OnPlacementComplete(player, position, orientation);
 if (GetGame().IsServer())
 {
 if (GetState() == EFireworksState.DEFAULT)
 {
 SetState(EFireworksState.PLACED);
 }
 }
 }
 
 override protected float GetMaxAllowedWetness()
 {
 return GameConstants.STATE_WET;
 }
 
 
 override protected float GetEventDelay()
 {
 return Math.RandomFloatInclusive(3,3.35);
 }
 
 protected string GetFuseSoundSet()
 {
 return "FireworksLauncher_Ignition_Loop_SoundSet";
 }
 
 protected int GetMaxShots()
 {
 return 16;
 }
 
 protected float GetFuseDelay()
 {
 return 3;
 }
 
 protected string GetAmmoType()
 {
 return "Fireworks_Ammo";
 }
 
 protected int GetDamageType()
 {
 return DamageType.EXPLOSION;
 }
 
 
 override protected void OnStateChangedServer(EFireworksState currentState)
 {
 switch (currentState)
 {
 case EFireworksState.PLACED:
 break
 case EFireworksState.IGNITED:
 OnFuseIgnitedServer();
 break
 case EFireworksState.FIRING:
 HideSelection("cover");
 OnFiringStartServer();
 break
 case EFireworksState.FINISHED:
 HideSelection("cover");//when loading from storage
 break
 default: {};
 }
 }
 
 override protected void OnStateChangedClient(EFireworksState currentState)
 {
 switch (currentState)
 {
 case EFireworksState.IGNITED:
 OnFuseIgnitedClient();
 break
 case EFireworksState.PLACED:
 break
 case EFireworksState.FIRING:
 OnFiringStartClient();
 break
 default: {};
 }
 }
 
 override void OnIgnitedThis( EntityAI fire_source)
 {
 super.OnIgnitedThis(fire_source);
 if (m_Events)
 {
 m_Events.Clear();
 }
 m_Index = 0;
 
 if (m_TimerEvent)
 {
 m_TimerEvent.Stop();
 }
 }
 
 override protected bool CanPutInCargo( EntityAI parent )
 {
 return (GetState() == EFireworksState.DEFAULT || (GetState() == EFireworksState.PLACED) || (GetState() == EFireworksState.FINISHED);
 }
 
 override protected bool CanPutIntoHands( EntityAI parent )
 {
 return (GetState() == EFireworksState.DEFAULT || (GetState() == EFireworksState.PLACED) || (GetState() == EFireworksState.FINISHED);
 }
 
 protected void OnFuseIgnitedServer()
 {
 int state = EFireworksState.FIRING;
 GetGame().GetCallQueue( CALL_CATEGORY_SYSTEM ).CallLater( SetState, GetFuseDelay()*1000, false, state);
 }
 
 protected void OnFuseIgnitedClient()
 {
 m_ParticleFuse = ParticleManager.GetInstance().PlayInWorld(ParticleList.FIREWORKS_FUSE, GetPosition() + "0 0.15 0");
 if (m_ParticleFuse)
 m_ParticleFuse.SetOwner(this);
 PlaySoundSet( m_FuseSoundStart, "FireworksLauncher_Ignition_Start_SoundSet", 0, 0 );
 vector fuseStart;
 vector fuseEnd;
 
 if (MemoryPointExists("Fuse_Start"))
 {
 fuseStart = GetMemoryPointPos("Fuse_Start");
 fuseStart = ModelToWorld(fuseStart);
 }
 if (MemoryPointExists("Fuse_End"))
 {
 fuseEnd = GetMemoryPointPos("Fuse_End");
 fuseEnd = ModelToWorld(fuseEnd);
 }
 
 vector fuseDir = fuseEnd - fuseStart;
 vector fuseOrientation[4];
 vector ori = fuseDir.VectorToAngles();
 m_ParticleFuse.SetOrientation(ori);
 m_ParticleFuse.SetPosition(fuseStart);
 
 PlaySoundSetLoop( m_FuseSound, GetFuseSoundSet(), 0, 0 );
 }
 
 protected void OnFiringStartServer()
 {
 OnEventServer(0);
 }
 
 protected void OnFiringStartClient()
 {
 if (m_ParticleFuse)
 {
 m_ParticleFuse.StopParticle(StopParticleFlags.IMMEDIATE);
 }
 if (m_FuseSound)
 {
 m_FuseSound.Stop();
 }
 }
 
 protected void OnFiringStop()
 {
 SetHealth01("","",0);
 }
 
 protected void RestartEventTimer()
 {
 if (!m_TimerEvent)
 {
 m_TimerEvent = new Timer();
 }
 m_TimerEvent.Run(GetEventDelay(), this, "OnEventServer", new Param1<int>(0));
 }
 
 
 override protected bool IsIgnited()
 {
 return GetState()==EFireworksState.IGNITED;
 }
 
 override protected bool CanIgniteItem(EntityAI ignite_target = NULL)
 {
 return false;
 }
 
 
 
 override protected void OnEventServer(int type)
 {
 m_Index++;
 DamageSystem.ExplosionDamage(this, NULL, GetAmmoType(), GetPosition(), GetDamageType());
 
 SetSynchDirty();
 if (m_Index > GetMaxShots())
 {
 m_Index = GetMaxShots();
 m_TimerEvent = null;
 SetState(EFireworksState.FINISHED);
 }
 else
 {
 RestartEventTimer();
 }
 }
 
 protected void OnIndexChangedClient()
 {
 if (!m_Events)
 {
 m_Events = new array<ref FireworksLauncherClientEventBase>;
 }
 if (m_Index != 0 && m_State == EFireworksState.FIRING)//can only be true when restarting the device during debug calls
 {
 FireworksLauncherClientEventBase fireEvent = SpawnEvent();
 m_Events.Insert(fireEvent);
 }
 }
 
 protected FireworksLauncherClientEventBase SpawnEvent()
 {
 FireworksLauncherClientEventBase evnt = new FireworksLauncherClientEvent(this,m_Index);
 evnt.OnFired();
 return evnt;
 }
 
 override protected void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 //Print("index: " + m_Index);
 if (m_Index != m_IndexPrev)
 {
 Math.Randomize(m_RandomSeed+m_Index);
 OnIndexChangedClient();
 m_IndexPrev = m_Index;
 }
 }
 
 override protected void OnStoreSave(ParamsWriteContext ctx)
 {
 super.OnStoreSave(ctx);
 ctx.Write(m_Index);
 ctx.Write(m_State);
 }
 
 
 override protected bool OnStoreLoad( ParamsReadContext ctx, int version )
 {
 if (!super.OnStoreLoad(ctx, version))
 {
 return false;
 }
 
 if (version >= 130)
 {
 if (!ctx.Read(m_Index))
 {
 return false;
 }
 
 if (!ctx.Read(m_State))
 {
 return false;
 }
 
 SetState(m_State);
 }
 return true;
 }
 
 override string GetDeploySoundset()
 {
 return "placeFireworks_SoundSet";
 }
 
 override string GetLoopDeploySoundset()
 {
 return "fireworks_deploy_SoundSet";
 }
 
 #ifdef DEVELOPER
 override protected string GetDebugText()
 {
 string debug_output;
 
 if( GetGame().IsDedicatedServer())
 {
 debug_output+= EnumTools.EnumToString(EFireworksState, m_State) +"\n";
 debug_output+= "m_Index:" + m_Index +"\n";
 }
 else
 {
 
 }
 return debug_output;
 }
 
 #endif
}