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;
  }
}