Effect.c

Go to the documentation of this file.

 
enum EffectType
{
  NONE,
  SOUND,
  PARTICLE,
}
 
class Effect : Managed
{
  ref ScriptInvoker Event_OnStarted = new ScriptInvoker();
  ref ScriptInvoker Event_OnStopped = new ScriptInvoker();
  ref ScriptInvoker Event_OnEffectStarted = new ScriptInvoker();
  ref ScriptInvoker Event_OnEffectEnded = new ScriptInvoker();
 
  protected bool m_IsAutodestroy;
  protected bool m_IsPendingDeletion;
  protected bool m_IsPlaying;
  protected Object m_ParentObject;
  protected vector m_Position;
 
  protected int m_ID;
  protected bool m_IsRegistered;
 
  protected vector m_LocalPos;
  protected vector m_LocalOri;
 
 
  void Effect()
  {
    if (GetGame().IsDedicatedServer())
      ErrorEx("Created Effect on server.", ErrorExSeverity.WARNING);
 
    InitEffect();
  }
 
  void ~Effect()
  {
    // Safety
    if (IsRegistered())
      SEffectManager.EffectUnregister(GetID());
 
    // Certain effects need to be stopped to clean up properly
    Stop();
 
    // Another safety
    SetEnableEventFrame(false);
  }
 
  void InitEffect()
  {
    Event_OnStarted.Insert(Event_OnEffectStarted);
    Event_OnStarted.Insert(ValidateStart);
    Event_OnStopped.Insert(Event_OnEffectEnded);
  }
 
 
 
  EffectType GetEffectType()
  {
    return EffectType.NONE;
  }
 
  bool IsSound()
  {
    return false;
  }
 
  bool IsParticle()
  {
    return false;
  }
 
 
 
 
  void Start()
  {
    // It is already playing!
    if (IsPlaying())
      return;
 
    Event_OnStarted();
    // I can't call this from inside the method with same name
    // because that method is often overriden without super......
    Event_OnStarted.Invoke(this);
  }
 
  void ValidateStart()
  {
 
  }
 
  void Stop()
  {
    // It is not playing!
    if (!IsPlaying())
      return;
 
    Event_OnStopped();
    // Yes, that event is new, but let's keep up some consistency
    Event_OnStopped.Invoke(this);
  }
 
  bool IsPlaying()
  {
    return m_IsPlaying;
  }
 
 
 
 
  protected void Destroy()
  {
    // Already queued
    if (IsPendingDeletion())
      return;
 
    // Mark it to prevent queuing it up multiple times or get stuck in a call loop
    m_IsPendingDeletion = true;
 
    // Stop it, so that the effects can clean up themselves
    // Since if for example this is EffectParticle and the particle is looping
    // It NEEDS to be stopped to clean up the Particle
    Stop();
 
    // Queue up the destroying, as we should not do it while we are accessing it here
    if (GetGame())
      GetGame().GetCallQueue(CALL_CATEGORY_GAMEPLAY).Call(SEffectManager.DestroyEffect, this);
  }
 
  void SetAutodestroy(bool auto_destroy)
  {
    m_IsAutodestroy = auto_destroy;
  }
 
  bool IsAutodestroy()
  {
    return m_IsAutodestroy;
  }
 
  bool IsPendingDeletion()
  {
    return m_IsPendingDeletion;
  }
 
  bool CanDestroy()
  {
    return true;
  }
 
 
 
  void SetEnableEventFrame(bool enable)
  {
    if (enable)
      SEffectManager.Event_OnFrameUpdate.Insert(Event_OnFrameUpdate);
    else
      SEffectManager.Event_OnFrameUpdate.Remove(Event_OnFrameUpdate);
  }
 
 
 
  void Event_OnStarted()
  {
    // Override this method for own use
  }
 
  void Event_OnStopped()
  {
    // Override this method for own use
  }
 
  void Event_OnEffectStarted()
  {
    m_IsPlaying = true;
 
    Event_OnEffectStarted.Invoke(this);
  }
 
  void Event_OnEffectEnded()
  {
    m_IsPlaying = false;
 
    Event_OnEffectEnded.Invoke(this);
 
    if (IsAutodestroy())
      Destroy();
  }
 
  void Event_OnFrameUpdate(float time_delta)
  {
    // Override this method for own use
  }
 
  void Event_OnRegistered(int id)
  {
    SetID(id);
    m_IsRegistered = true;
  }
 
  void Event_OnUnregistered()
  {
    SetID(SEffectManager.INVALID_ID);
    m_IsRegistered = false;
  }
 
  void OnCheckUpdate()
  {
 
  }
 
 
 
 
  void SetParent(Object parent_obj)
  {
    m_ParentObject = parent_obj;
  }
 
  Object GetParent()
  {
    return m_ParentObject;
  }
 
  void SetCurrentParent(Object parent_obj, bool updateCached = true)
  {
    if (updateCached)
      SetParent(parent_obj);
  }
 
  Object GetCurrentParent()
  {
    return null;
  }
 
  void SetPosition(vector pos)
  {
    m_Position = pos;
  }
 
  vector GetPosition()
  {
    return m_Position;
  }
 
  void SetCurrentPosition(vector pos, bool updateCached = true)
  {
    if (updateCached)
      SetPosition(pos);
  }
 
  vector GetCurrentPosition()
  {
    return vector.Zero;
  }
 
  void SetLocalPosition(vector pos)
  {
    m_LocalPos = pos;
  }
 
  vector GetLocalPosition()
  {
    return m_LocalPos;
  }
 
  void SetCurrentLocalPosition(vector pos, bool updateCached = true)
  {
    if (updateCached)
      SetLocalPosition(pos);
  }
 
  vector GetCurrentLocalPosition()
  {
    return vector.Zero;
  }
 
 
 
 
  protected void SetID(int id)
  {
    m_ID = id;
  }
 
  int GetID()
  {
    return m_ID;
  }
 
  bool IsRegistered()
  {
    return m_IsRegistered;
  }
 
 
 
 
  void SetAttachmentParent(Object obj)
  {
    SetParent(obj);
  }
 
  Object GetAttachmentParent()
  {
    return GetParent();
  }
 
  void SetAttachedLocalPos(vector pos)
  {
    SetLocalPosition(pos);
  }
 
  vector GetAttachedLocalPos()
  {
    return GetLocalPosition();
  }
 
  void SetAttachedLocalOri(vector ori)
  {
    m_LocalOri = ori;
  }
 
  vector GetAttachedLocalOri()
  {
    return m_LocalOri;
  }
 
}