Merge branch 'master' into terencehill/bot_waypoints

[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / triggers / triggers.qc

diff --git a/qcsrc/common/triggers/triggers.qc b/qcsrc/common/triggers/triggers.qc
index 29cb70a7dcc935990309119f1acf2e403806ff18..0957699b37ad4ef9594e33f930c95b26397030e9 100644 (file)
--- a/qcsrc/common/triggers/triggers.qc
+++ b/qcsrc/common/triggers/triggers.qc
@@ -1,12 +1,12 @@
-void SUB_DontUseTargets() { }
+#include "triggers.qh"
+void SUB_DontUseTargets(entity this, entity actor, entity trigger) { }

 
 

-void() SUB_UseTargets;
+void SUB_UseTargets(entity this, entity actor, entity trigger);

 
 

-void DelayThink()
-{SELFPARAM();
-       activator = self.enemy;
-       SUB_UseTargets ();
-       remove(self);
+void DelayThink(entity this)
+{
+       SUB_UseTargets (this, this.enemy, NULL);
+       delete(this);

 }
 
 void FixSize(entity e)
 }
 
 void FixSize(entity e)


@@ -22,28 +22,33 @@ void FixSize(entity e)
 
 #ifdef SVQC
 
 
 #ifdef SVQC
 

+bool autocvar_g_triggers_debug = true;
+

 void trigger_init(entity this)
 {
        string m = this.model;
 void trigger_init(entity this)
 {
        string m = this.model;

-       WITH(entity, self, this, WarpZoneLib_ExactTrigger_Init());
-       if(m != "")
-       {
-               precache_model(m);
-               _setmodel(this, m); // no precision needed
+       EXACTTRIGGER_INIT;
+       if(autocvar_g_triggers_debug)
+       {
+               if(m != "")
+               {
+                       precache_model(m);
+                       _setmodel(this, m); // no precision needed
+               }
+               setorigin(this, this.origin);
+               if(this.scale)
+                       setsize(this, this.mins * this.scale, this.maxs * this.scale);
+               else
+                       setsize(this, this.mins, this.maxs);

        }
        }

-       setorigin(this, this.origin);
-       if(this.scale)
-               setsize(this, this.mins * this.scale, this.maxs * this.scale);
-       else
-               setsize(this, this.mins, this.maxs);

 
 

-       BITSET_ASSIGN(this.effects, EF_NODEPTHTEST);
+       if(autocvar_g_triggers_debug)
+               BITSET_ASSIGN(this.effects, EF_NODEPTHTEST);

 }
 
 void trigger_link(entity this, bool(entity this, entity to, int sendflags) sendfunc)
 {
 }
 
 void trigger_link(entity this, bool(entity this, entity to, int sendflags) sendfunc)
 {

-       this.SendEntity = SendEntity_self;
-       this.SendEntity3 = sendfunc;
+       setSendEntity(this, sendfunc);

        this.SendFlags = 0xFFFFFF;
 }
 
        this.SendFlags = 0xFFFFFF;
 }
 


@@ -54,196 +59,191 @@ void trigger_common_write(entity this, bool withtarget)
                BITSET_ASSIGN(f, 1);
        if(this.origin != '0 0 0')
                BITSET_ASSIGN(f, 4);
                BITSET_ASSIGN(f, 1);
        if(this.origin != '0 0 0')
                BITSET_ASSIGN(f, 4);

+       if(this.movedir != '0 0 0')
+               BITSET_ASSIGN(f, 8);
+       if(this.angles != '0 0 0')
+               BITSET_ASSIGN(f, 16);

        WriteByte(MSG_ENTITY, f);
 
        if(withtarget)
        {
        WriteByte(MSG_ENTITY, f);
 
        if(withtarget)
        {

-               WriteString(MSG_ENTITY, this.target);
-               WriteString(MSG_ENTITY, this.target2);
-               WriteString(MSG_ENTITY, this.target3);
-               WriteString(MSG_ENTITY, this.target4);
-               WriteString(MSG_ENTITY, this.targetname);
-               WriteString(MSG_ENTITY, this.killtarget);
+               // probably some way to clean this up...
+               int targbits = 0;
+               if(this.target && this.target != "") targbits |= BIT(0);
+               if(this.target2 && this.target2 != "") targbits |= BIT(1);
+               if(this.target3 && this.target3 != "") targbits |= BIT(2);
+               if(this.target4 && this.target4 != "") targbits |= BIT(3);
+               if(this.targetname && this.targetname != "") targbits |= BIT(4);
+               if(this.killtarget && this.killtarget != "") targbits |= BIT(5);
+
+               WriteByte(MSG_ENTITY, targbits);
+
+               if(targbits & BIT(0))
+                       WriteString(MSG_ENTITY, this.target);
+               if(targbits & BIT(1))
+                       WriteString(MSG_ENTITY, this.target2);
+               if(targbits & BIT(2))
+                       WriteString(MSG_ENTITY, this.target3);
+               if(targbits & BIT(3))
+                       WriteString(MSG_ENTITY, this.target4);
+               if(targbits & BIT(4))
+                       WriteString(MSG_ENTITY, this.targetname);
+               if(targbits & BIT(5))
+                       WriteString(MSG_ENTITY, this.killtarget);

        }
 
        if(f & 4)
        }
 
        if(f & 4)

-       {
-               WriteCoord(MSG_ENTITY, this.origin.x);
-               WriteCoord(MSG_ENTITY, this.origin.y);
-               WriteCoord(MSG_ENTITY, this.origin.z);
-       }
+               WriteVector(MSG_ENTITY, this.origin);

 
 

-       WriteShort(MSG_ENTITY, this.modelindex);
-       WriteCoord(MSG_ENTITY, this.mins.x);
-       WriteCoord(MSG_ENTITY, this.mins.y);
-       WriteCoord(MSG_ENTITY, this.mins.z);
-       WriteCoord(MSG_ENTITY, this.maxs.x);
-       WriteCoord(MSG_ENTITY, this.maxs.y);
-       WriteCoord(MSG_ENTITY, this.maxs.z);
-       WriteByte(MSG_ENTITY, bound(1, this.scale * 16, 255));
+       if(f & 8)
+               WriteVector(MSG_ENTITY, this.movedir);

 
 

-       WriteCoord(MSG_ENTITY, this.movedir_x);
-       WriteCoord(MSG_ENTITY, this.movedir_y);
-       WriteCoord(MSG_ENTITY, this.movedir_z);
+       if(f & 16)
+               WriteVector(MSG_ENTITY, this.angles);

 
 

-       WriteCoord(MSG_ENTITY, this.angles_x);
-       WriteCoord(MSG_ENTITY, this.angles_y);
-       WriteCoord(MSG_ENTITY, this.angles_z);
+       WriteShort(MSG_ENTITY, this.modelindex);
+       WriteVector(MSG_ENTITY, this.mins);
+       WriteVector(MSG_ENTITY, this.maxs);
+       WriteByte(MSG_ENTITY, bound(1, this.scale * 16, 255));

 }
 
 #elif defined(CSQC)
 
 }
 
 #elif defined(CSQC)
 

-void trigger_common_read(bool withtarget)
-{SELFPARAM();
+void trigger_common_read(entity this, bool withtarget)
+{

        int f = ReadByte();
        int f = ReadByte();

-       self.warpzone_isboxy = (f & 1);
+       this.warpzone_isboxy = (f & 1);

 
        if(withtarget)
        {
 
        if(withtarget)
        {

-               if(self.target) { strunzone(self.target); }
-               self.target = strzone(ReadString());
-               if(self.target2) { strunzone(self.target2); }
-               self.target2 = strzone(ReadString());
-               if(self.target3) { strunzone(self.target3); }
-               self.target3 = strzone(ReadString());
-               if(self.target4) { strunzone(self.target4); }
-               self.target4 = strzone(ReadString());
-               if(self.targetname) { strunzone(self.targetname); }
-               self.targetname = strzone(ReadString());
-               if(self.killtarget) { strunzone(self.killtarget); }
-               self.killtarget = strzone(ReadString());
+               strfree(this.target);
+               strfree(this.target2);
+               strfree(this.target3);
+               strfree(this.target4);
+               strfree(this.targetname);
+               strfree(this.killtarget);
+
+               int targbits = ReadByte();
+
+               this.target = ((targbits & BIT(0)) ? strzone(ReadString()) : string_null);
+               this.target2 = ((targbits & BIT(1)) ? strzone(ReadString()) : string_null);
+               this.target3 = ((targbits & BIT(2)) ? strzone(ReadString()) : string_null);
+               this.target4 = ((targbits & BIT(3)) ? strzone(ReadString()) : string_null);
+               this.targetname = ((targbits & BIT(4)) ? strzone(ReadString()) : string_null);
+               this.killtarget = ((targbits & BIT(5)) ? strzone(ReadString()) : string_null);

        }
 
        if(f & 4)
        }
 
        if(f & 4)

-       {
-               self.origin_x = ReadCoord();
-               self.origin_y = ReadCoord();
-               self.origin_z = ReadCoord();
-       }
+               this.origin = ReadVector();

        else
        else

-               self.origin = '0 0 0';
-       setorigin(self, self.origin);
-
-       self.modelindex = ReadShort();
-       self.mins_x = ReadCoord();
-       self.mins_y = ReadCoord();
-       self.mins_z = ReadCoord();
-       self.maxs_x = ReadCoord();
-       self.maxs_y = ReadCoord();
-       self.maxs_z = ReadCoord();
-       self.scale = ReadByte() / 16;
-       setsize(self, self.mins, self.maxs);
-
-       self.movedir_x = ReadCoord();
-       self.movedir_y = ReadCoord();
-       self.movedir_z = ReadCoord();
-
-       self.angles_x = ReadCoord();
-       self.angles_y = ReadCoord();
-       self.angles_z = ReadCoord();
-}
-
-void trigger_remove_generic(entity this)
-{
-       if(this.target) { strunzone(this.target); }
-       this.target = string_null;
-
-       if(this.target2) { strunzone(this.target2); }
-       this.target2 = string_null;
+               this.origin = '0 0 0';
+       setorigin(this, this.origin);

 
 

-       if(this.target3) { strunzone(this.target3); }
-       this.target3 = string_null;
+       if(f & 8)
+               this.movedir = ReadVector();
+       else
+               this.movedir = '0 0 0';

 
 

-       if(this.target4) { strunzone(this.target4); }
-       this.target4 = string_null;
+       if(f & 16)
+               this.angles = ReadVector();
+       else
+               this.angles = '0 0 0';

 
 

-       if(this.targetname) { strunzone(this.targetname); }
-       this.target = string_null;
+       this.modelindex = ReadShort();
+       this.mins = ReadVector();
+       this.maxs = ReadVector();
+       this.scale = ReadByte() / 16;
+       setsize(this, this.mins, this.maxs);
+}

 
 

-       if(this.killtarget) { strunzone(this.killtarget); }
-       this.killtarget = string_null;
+void trigger_remove_generic(entity this)
+{
+       strfree(this.target);
+       strfree(this.target2);
+       strfree(this.target3);
+       strfree(this.target4);
+       strfree(this.targetname);
+       strfree(this.killtarget);

 }
 #endif
 
 }
 #endif
 

+

 /*
 ==============================
 SUB_UseTargets
 
 the global "activator" should be set to the entity that initiated the firing.
 
 /*
 ==============================
 SUB_UseTargets
 
 the global "activator" should be set to the entity that initiated the firing.
 

-If self.delay is set, a DelayedUse entity will be created that will actually
+If this.delay is set, a DelayedUse entity will be created that will actually

 do the SUB_UseTargets after that many seconds have passed.
 
 do the SUB_UseTargets after that many seconds have passed.
 

-Centerprints any self.message to the activator.
+Centerprints any this.message to the activator.

 
 

-Removes all entities with a targetname that match self.killtarget,
+Removes all entities with a targetname that match this.killtarget,

 and removes them, so some events can remove other triggers.
 
 Search for (string)targetname in all entities that
 and removes them, so some events can remove other triggers.
 
 Search for (string)targetname in all entities that

-match (string)self.target and call their .use function
+match (string)this.target and call their .use function

 
 ==============================
 */
 
 ==============================
 */

-void SUB_UseTargets()
-{SELFPARAM();
-       entity t, otemp, act;
-       string s;
-       float i;

 
 

+void SUB_UseTargets_Ex(entity this, entity actor, entity trigger, bool preventReuse)
+{

 //
 // check for a delay
 //
 //
 // check for a delay
 //

-       if (self.delay)
+       if (this.delay)

        {
        // create a temp object to fire at a later time
        {
        // create a temp object to fire at a later time

-               t = new(DelayedUse);
-               t.nextthink = time + self.delay;
-               t.think = DelayThink;
-               t.enemy = activator;
-               t.message = self.message;
-               t.killtarget = self.killtarget;
-               t.target = self.target;
-               t.target2 = self.target2;
-               t.target3 = self.target3;
-               t.target4 = self.target4;
+               entity t = new(DelayedUse);
+               t.nextthink = time + this.delay;
+               setthink(t, DelayThink);
+               t.enemy = actor;
+               t.message = this.message;
+               t.killtarget = this.killtarget;
+               t.target = this.target;
+               t.target2 = this.target2;
+               t.target3 = this.target3;
+               t.target4 = this.target4;
+               t.antiwall_flag = this.antiwall_flag;

                return;
        }
 
                return;
        }
 

+       string s;

 
 //
 // print the message
 //
 #ifdef SVQC
 
 //
 // print the message
 //
 #ifdef SVQC

-       if(self)
-       if(IS_PLAYER(activator) && self.message != "")
-       if(IS_REAL_CLIENT(activator))
+       if(this)
+       if(IS_PLAYER(actor) && this.message != "")
+       if(IS_REAL_CLIENT(actor))

        {
        {

-               centerprint(activator, self.message);
-               if (self.noise == "")
-                       play2(activator, SND(TALK));
+               centerprint(actor, this.message);
+               if (this.noise == "")
+                       play2(actor, SND(TALK));

        }
 
 //
 // kill the killtagets
 //
        }
 
 //
 // kill the killtagets
 //

-       s = self.killtarget;
+       s = this.killtarget;

        if (s != "")
        {
        if (s != "")
        {

-               for(t = world; (t = find(t, targetname, s)); )
-                       remove(t);
+               for(entity t = NULL; (t = find(t, targetname, s)); )
+                       delete(t);

        }
 #endif
 
 //
 // fire targets
 //
        }
 #endif
 
 //
 // fire targets
 //

-       act = activator;
-       otemp = other;

 
        if(this.target_random)
                RandomSelection_Init();
 
 
        if(this.target_random)
                RandomSelection_Init();
 

-       for(i = 0; i < 4; ++i)
+       for(int i = 0; i < 4; ++i)

        {
                switch(i)
                {
        {
                switch(i)
                {


@@ -257,22 +257,24 @@ void SUB_UseTargets()
                {
                        // Flag to set func_clientwall state
                        // 1 == deactivate, 2 == activate, 0 == do nothing
                {
                        // Flag to set func_clientwall state
                        // 1 == deactivate, 2 == activate, 0 == do nothing

-                       float aw_flag = self.antiwall_flag;
-                       for(t = world; (t = find(t, targetname, s)); )
-                       if(t.use)
+                       int aw_flag = this.antiwall_flag;
+                       for(entity t = NULL; (t = find(t, targetname, s)); )

                        {
                        {

-                               if(this.target_random)
-                               {
-                                       RandomSelection_Add(t, 0, string_null, 1, 0);
-                               }
-                               else
+                               if(t.use && (t.sub_target_used != time || !preventReuse))

                                {
                                {

-                                       if (t.classname == "func_clientwall" || t.classname == "func_clientillusionary")
-                                               t.antiwall_flag = aw_flag;
-                                       setself(t);
-                                       other = this;
-                                       activator = act;
-                                       self.use();
+                                       if(this.target_random)
+                                       {
+                                               RandomSelection_AddEnt(t, 1, 0);
+                                       }
+                                       else
+                                       {
+                                               if (t.classname == "func_clientwall" || t.classname == "func_clientillusionary")
+                                                       t.antiwall_flag = aw_flag;
+
+                                               t.use(t, actor, this);
+                                               if(preventReuse)
+                                                       t.sub_target_used = time;
+                                       }

                                }
                        }
                }
                                }
                        }
                }


@@ -280,44 +282,11 @@ void SUB_UseTargets()
 
        if(this.target_random && RandomSelection_chosen_ent)
        {
 
        if(this.target_random && RandomSelection_chosen_ent)
        {

-               setself(RandomSelection_chosen_ent);
-               other = this;
-               activator = act;
-               self.use();
-       }
-
-       activator = act;
-       setself(this);
-       other = otemp;
-}
-
-#ifdef CSQC
-void trigger_touch_generic(entity this, void() touchfunc)
-{
-       entity e;
-       for(e = findradius((this.absmin + this.absmax) * 0.5, vlen(this.absmax - this.absmin) * 0.5 + 1); e; e = e.chain)
-       if(e.classname == "csqcprojectile")
-       {
-               vector emin = e.absmin, emax = e.absmax;
-               if(this.solid == SOLID_BSP)
-               {
-                       emin -= '1 1 1';
-                       emax += '1 1 1';
-               }
-               if(boxesoverlap(emin, emax, this.absmin, this.absmax)) // quick
-               if(WarpZoneLib_BoxTouchesBrush(emin, emax, this, e)) // accurate
-               {
-                       other = e;
-                       WITH(entity, self, this, touchfunc());
-               }
+               RandomSelection_chosen_ent.use(RandomSelection_chosen_ent, actor, this);
+               if(preventReuse)
+                       RandomSelection_chosen_ent.sub_target_used = time;

        }
 }
        }
 }

-void trigger_draw_generic(entity this)
-{
-       float dt = time - this.move_time;
-       this.move_time = time;
-       if(dt <= 0) { return; }

 
 

-       if(this.trigger_touch) { trigger_touch_generic(this, this.trigger_touch); }
-}
-#endif
+void SUB_UseTargets(entity this, entity actor, entity trigger) { SUB_UseTargets_Ex(this, actor, trigger, false); }
+void SUB_UseTargets_PreventReuse(entity this, entity actor, entity trigger) { SUB_UseTargets_Ex(this, actor, trigger, true); }