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