Trigger.c

Go to the documentation of this file.

 
class TriggerInsider
{
  ref OLinkT insider; // DEPRECATED
 
  protected Object m_Object;
 
  int timeStamp;
 
  float timeEntered;
 
  float lastUpdated;
 
  void TriggerInsider(Object obj)
  {
    insider = new OLinkT(obj);
    m_Object = obj;
  }
 
  void ~TriggerInsider()
  {
  }
 
  Object GetObject()
  {
    return m_Object;
  }
};
 
#ifdef DIAG_DEVELOPER
  typedef Param7<vector, vector, vector, vector, float, string, array<ref TriggerInsider>> DebugTriggerInfo;
#endif
 
class Trigger : TriggerEvents
{
  const int TIMEOUT = 1000;
  ref array<ref TriggerInsider> m_insiders;
 
#ifdef DIAG_DEVELOPER
  bool m_Local;//is this trigger spawning on client only ?
  string m_DebugAreaType;
  ref array<ref TriggerInsider> m_dbgInsiders;
#endif
 
  private void Trigger()
  {
    SetEventMask(EntityEvent.INIT /*| EntityEvent.TOUCH*/ | EntityEvent.FRAME | EntityEvent.ENTER | EntityEvent.LEAVE);
    SetFlags(EntityFlags.TRIGGER, false);
 
    m_insiders = new array<ref TriggerInsider>;
  }
 
  private void ~Trigger()
  {
#ifdef DIAG_DEVELOPER
    CleanupDebugShapes(dbgTargets);
#endif
  }
 
  override void EOnInit(IEntity other, int extra)
  {
    SetExtents("-2 -4 -2", "2 4 2");
  }
 
  /*override void EOnTouch(IEntity other, int extra)
    {
    Object obj;
    if (Class.CastTo(obj, other) && CanAddObjectAsInsider(obj))
      AddInsider(obj);
    }*/
 
  override void EOnFrame(IEntity other, float timeSlice)
  {
    UpdateInsiders(TIMEOUT);
  }
 
  override void EOnEnter(IEntity other, int extra)
  {
    Object obj;
    if (Class.CastTo(obj, other) && CanAddObjectAsInsider(obj))
      AddInsider(obj);
  }
 
  override void EOnLeave(IEntity other, int extra)
  {
    Object obj;
    if (Class.CastTo(obj, other))
      RemoveInsiderByObject(obj);
  }
 
 
  void SetExtents(vector mins, vector maxs)
  {
    SetCollisionBox(mins, maxs);
  }
 
  float GetRadius(vector min, vector max)
  {
    return GetCollisionRadius();
  }
 
  array<ref TriggerInsider> GetInsiders()
  {
    return m_insiders;
  }
 
  TriggerInsider GetInsiderForObject(Object object)
  {
    TriggerInsider ins;
 
    for (int n = 0; n < m_insiders.Count(); ++n)
    {
      ins = m_insiders[n];
      if (ins.GetObject() == object)
        return ins;
    }
 
    return null;
  }
 
  int GetInsiderIndexForObject(Object object)
  {
    TriggerInsider ins;
 
    for (int n = 0; n < m_insiders.Count(); ++n)
    {
      ins = m_insiders[n];
      if (ins.GetObject() == object)
        return n;
    }
 
    return -1;
  }
 
 
  override protected void OnEnterBeginEvent(TriggerInsider insider)
  {
    // Call the old event for backwards compatibility
    OnEnter(insider.GetObject());
  }
 
  override protected void OnLeaveBeginEvent(TriggerInsider insider)
  {
    // Call the old event for backwards compatibility
    OnLeave(insider.GetObject());
  }
 
 
  void OnEnter(Object obj) {}
 
  void OnLeave(Object obj) {}
 
 
  protected bool CanAddObjectAsInsider(Object object)
  {
    return true;
  }
 
  protected bool ShouldRemoveInsider(TriggerInsider insider)
  {
    return false;
  }
 
  protected bool ShouldRemoveInsiderNoLeave(TriggerInsider insider)
  {
    return false;
  }
 
 
  protected TriggerInsider CreateInsider(Object obj)
  {
    return new TriggerInsider(obj);
  }
 
  protected void AddInsider(Object obj)
  {
    if (!obj)
      return;
 
    // Already in?
    if (GetInsiderForObject(obj))
    {
      Error(string.Format("[WARNING] :: [Trigger] :: [%1] :: Insider (%2) is already inside.", GetDebugName(this), GetDebugName(obj)));
      return;
    }
 
    // New Object entered! Fill the data.
    TriggerInsider insider = CreateInsider(obj);
    insider.timeStamp = g_Game.GetTime();
    insider.timeEntered = g_Game.GetTickTime();
    insider.lastUpdated = insider.timeEntered;
 
    // Don't add if it is going to be removed anyways..
    if (ShouldRemoveInsider(insider) || ShouldRemoveInsiderNoLeave(insider))
      return;
 
    // Keep track of the Object as long as it is inside the Trigger
    int index = m_insiders.Insert(insider);
 
    // Call the enter event to signal this Object entered
    Enter(insider);
    obj.OnEnterTrigger(this);
 
#ifdef TRIGGER_DEBUG_NORMAL
    Debug.TriggerLog(string.Format("%1: inserted at index %2", GetDebugName(obj), index), "Trigger", "", "AddInsider", GetDebugName(this));
#endif
  }
 
  protected void RemoveInsider(TriggerInsider insider, int index = -1)
  {
    Leave(insider);
    insider.GetObject().OnLeaveTrigger(this);
 
#ifdef TRIGGER_DEBUG_NORMAL
    Debug.TriggerLog(string.Format("%1: removing at index %2", GetDebugName(insider.GetObject()), index), "Trigger", "", "RemoveInsider", GetDebugName(this));
#endif
 
    if (index >= 0)
      m_insiders.Remove(index);
    else
      m_insiders.RemoveItemUnOrdered(insider);
  }
 
  protected void RemoveInsiderByObject(Object object)
  {
    TriggerInsider ins;
    for (int n = 0; n < m_insiders.Count(); ++n)
    {
      ins = m_insiders[n];
      if (ins.GetObject() == object)
      {
        RemoveInsider(ins, n);
        return;
      }
    }
 
    // As EOnLeave can call this, it is perfectly valid that this Object is not found on Script side
    // because of "ShouldRemoveInsider" and "ShouldRemoveInsiderNoLeave"
  }
 
  protected void UpdateInsiders(int timeout)
  {
#ifdef DIAG_DEVELOPER
    DebugSendDmgTrigger();
#endif
 
    // Don't do anything if there aren't any insiders
    if (m_insiders.Count() == 0)
      return;
 
    // Mark the beginning of the update loop
    StayStart(m_insiders.Count());
 
    // Iterate over the current insiders, backwards because we are deleting
    for (int n = m_insiders.Count() - 1; n >= 0 ; --n)
    {
      TriggerInsider insider = m_insiders.Get(n);
      Object obj = insider.GetObject();
 
      // Check if the Object still exists or should be removed without calling OnLeaveEvent
      if (!obj || ShouldRemoveInsiderNoLeave(insider))
      {
#ifdef TRIGGER_DEBUG_BASIC
        Debug.TriggerLog(string.Format("%1: removed with no Leave.", GetDebugName(obj)), "Trigger", "", "UpdateInsiders", GetDebugName(this));
#endif
 
        m_insiders.Remove(n);
        continue;
      }
 
      // Check if Object left the Trigger or should be removed regardless
      if (ShouldRemoveInsider(insider))
      {
        RemoveInsider(insider, n);
        continue;
      }
 
      // Call the OnStayEvent, Object is still inside the Trigger and can be updated
      // Pass in the time since the Object was last updated (or entered)
      float currentTime = g_Game.GetTickTime();
      Stay(insider, currentTime - insider.lastUpdated);
      insider.lastUpdated = currentTime;
    }
 
    // Mark the end of the update loop
    StayFinish();
  }
 
  override void OnRPC(PlayerIdentity sender, int rpc_type, ParamsReadContext ctx)
  {
    super.OnRPC(sender, rpc_type, ctx);
 
#ifdef DIAG_DEVELOPER
    switch (rpc_type)
    {
    case ERPCs.DIAG_TRIGGER_DEBUG:
      DebugTriggerInfo data = new DebugTriggerInfo(vector.Zero, vector.Zero, vector.Zero, vector.Zero, 0, "", null);
 
      if (ctx.Read(data))
        DebugDmgTrigger(data.param1, data.param2, data.param3, data.param4, data.param5, data.param6, data.param7);
      break;
    }
#endif
  }
 
#ifdef DIAG_DEVELOPER
  void DebugSendDmgTrigger()
  {
    vector minmax[2];
    GetCollisionBox(minmax);
 
    DebugTriggerInfo data = new DebugTriggerInfo(vector.Zero, vector.Zero, vector.Zero, vector.Zero, 0, "", null);
    data.param1 = GetWorldPosition();
    data.param2 = GetOrientation();
    data.param3 = minmax[0];
    data.param4 = minmax[1];
    data.param5 = GetCollisionRadius();
    data.param6 = m_DebugAreaType;
    data.param7 = m_insiders;
 
    if (GetGame().IsMultiplayer() && GetGame().IsServer())
      PluginDiagMenuServer.SendDataToSubscribersServer(this, ESubscriberSystems.TRIGGERS, ERPCs.DIAG_TRIGGER_DEBUG, data, false);
    else if (!GetGame().IsMultiplayer() || m_Local)
      DebugDmgTrigger(data.param1, data.param2, data.param3, data.param4, data.param5, data.param6, data.param7);
  }
 
  protected ref array<Shape> dbgTargets = new array<Shape>();
 
  void DebugDmgTrigger(vector pos, vector orientation, vector min, vector max, float radius, string dmgType, array<ref TriggerInsider> insiders)
  {
    CleanupDebugShapes(dbgTargets);
 
    bool enableDebug = DiagMenu.GetBool(DiagMenuIDs.TRIGGER_DEBUG);
    if (enableDebug)
    {
      if (GetGame().IsMultiplayer() && GetGame().IsServer())
        return;
 
      vector w_pos, w_pos_sphr, w_pos_lend;
 
      w_pos = pos;
      // sphere pos tweaks
      w_pos_sphr = w_pos;
      // line pos tweaks
      w_pos_lend = w_pos;
 
      //Find way to change colour of box depending on ammoType in a more elegant fashion
      m_DebugAreaType = dmgType;
      Shape dbgShape;
 
      switch (m_DebugAreaType)
      {
      case "FireDamage":
        dbgShape = DrawDebugShape(pos, min, max, radius, COLOR_RED_A);
        break;
 
      case "BarbedWireHit":
        dbgShape = DrawDebugShape(pos, min, max, radius, COLOR_BLUE_A);
        break;
 
      default:
        dbgShape = DrawDebugShape(pos, min, max, radius, COLOR_GREEN_A);
        break;
      }
 
      if (GetGame().IsMultiplayer() || GetGame().IsServer())
        m_dbgInsiders = insiders;
 
      if (m_dbgInsiders.Count() > 0)
      {
        //Change colour to make state clearer
        dbgShape.SetColor(COLOR_YELLOW_A);
 
        for (int i = 0; i < m_dbgInsiders.Count(); i++)
        {
          EntityAI insider_EAI = EntityAI.Cast(m_dbgInsiders[i].GetObject());
          if (insider_EAI)
          {
            vector insiderPos = insider_EAI.GetWorldPosition() + "0 0.1 0";
            dbgTargets.Insert(Debug.DrawArrow(w_pos, insiderPos));
          }
        }
      }
    }
  }
 
  protected Shape DrawDebugShape(vector pos, vector min, vector max, float radius, int color)
  {
    Shape dbgShape;
 
    switch (GetTriggerShape())
    {
    case TriggerShape.BOX:
      dbgShape = Debug.DrawBoxEx(min, max, color, ShapeFlags.TRANSP | ShapeFlags.NOZWRITE);
 
      vector mat[4];
      GetTransform(mat);
      dbgShape.CreateMatrix(mat);
      dbgShape.SetMatrix(mat);
      break;
    case TriggerShape.CYLINDER:
      dbgShape = Debug.DrawCylinder(pos, radius, max[1], color, ShapeFlags.TRANSP | ShapeFlags.NOZWRITE);
      break;
    case TriggerShape.SPHERE:
      dbgShape = Debug.DrawSphere(pos, radius, color, ShapeFlags.TRANSP | ShapeFlags.NOZWRITE);
      break;
    default:
      ErrorEx("TriggerShape not found", ErrorExSeverity.WARNING);
      break;
    }
 
    dbgTargets.Insert(dbgShape);
 
    return dbgShape;
  }
 
  protected void CleanupDebugShapes(array<Shape> shapes)
  {
    foreach (Shape shape : shapes)
      Debug.RemoveShape(shape);
 
    shapes.Clear();
  }
 
#endif
};