areadamagelooped.c

Go to the documentation of this file.

class AreaDamageLooped : AreaDamageManager
{
 protected float m_CurrentTime = 0.0;
 protected float m_PreviousTime = 0.0; 
 protected float m_AccumulatedTime = 0.0; 
 protected float m_LoopInterval = 1.0;
 
 protected int m_AmountOfLoops = 0;
 
 protected bool m_LoopByObject = true;
 
 void AreaDamageLooped(EntityAI parent, bool loopByObject = true)
 {
 m_LoopByObject = loopByObject;
 }
 
 override void OnTriggerCreated()
 {
 super.OnTriggerCreated();
 
 m_PreviousTime = g_Game.GetTickTime();
 m_AccumulatedTime = 0.0;
 }
 
 override void SetLoopInterval( float time )
 {
 m_LoopInterval = time;
 }
 
 override void OnEnterServerEvent(TriggerInsider insider)
 {
 super.OnEnterServerEvent(insider);
 
 // Do direct damaging first time on entering
 if (m_LoopByObject)
 OnEvaluateDamageEx(insider, 1);
 }
 
 override void OnStayStartServerEvent(int nrOfInsiders)
 {
 super.OnStayStartServerEvent(nrOfInsiders);
 
 m_CurrentTime = g_Game.GetTickTime(); 
 m_AccumulatedTime += m_CurrentTime - m_PreviousTime; 
 m_PreviousTime = m_CurrentTime;
 
 m_AmountOfLoops = m_AccumulatedTime / m_LoopInterval;
 }
 
 override void OnStayServerEvent(TriggerInsider insider, float deltaTime)
 {
 super.OnStayServerEvent(insider, deltaTime);
 
 // As we are using the Ex variant, we can put the logic in CalculateDamageScale
 OnEvaluateDamageEx(insider, deltaTime);
 }
 
 override void OnStayFinishServerEvent()
 {
 super.OnStayFinishServerEvent();
 
 m_AccumulatedTime -= m_AmountOfLoops * m_LoopInterval;
 }
 
 // TODO: EMH: OnLeaveServerEvent -> perform the remaining buffered damage to be done?
 
 override protected float CalculateDamageScale(TriggerInsider insider, float deltaTime)
 { 
 // If we want the LoopInterval to be dependant on the Object, we will need their lastDamaged time
 if (m_LoopByObject)
 {
 float lastDamaged = 0;
 
 AreaDamageTriggerInsider dInsider;
 if ( CastTo( dInsider, insider ) )
 lastDamaged = dInsider.lastDamaged;
 
 // First time it is damaged, do full damage
 if (lastDamaged == 0)
 return 1;
 
 // This way, in case the server lags, it will scale the damage to catch up if necessary
 // We want to wait until it is at least above 1, to not spam the network with hit messages
 float damageCoeff = (m_CurrentTime - lastDamaged) / m_LoopInterval;
 if ( damageCoeff >= 1 )
 return damageCoeff;
 
 return 0;
 }
 else
 {
 return m_AmountOfLoops;
 }
 }
}