djcev.com

////////////////////////////////////////////////////////////////////////////////
// trigger_push -- id1 with additions by dumptruck_ds & CEV
////////////////////////////////////////////////////////////////////////////////

//======================================================================
// constants
//======================================================================

#ifdef SSQC
//----------------------------------------------------------------------
// trigger_push spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        SPAWNFLAG_TRIGGER_PUSH_ONCE = 1, // only trigger once
        SPAWNFLAG_TRIGGER_PUSH_ADDITIVE = 2, // from mg1 -- CEV
        SPAWNFLAG_TRIGGER_PUSH_MGSTARTOFF = 4, // start off (mg1) -- CEV
        SPAWNFLAG_TRIGGER_PUSH_STARTOFF = 8, // start off
        SPAWNFLAG_TRIGGER_PUSH_SILENT = 16, // push silently
        SPAWNFLAG_TRIGGER_PUSH_NOISE = 32 // custom sound via noise key/value
        // SPAWNFLAG_NOT_ON_EASY = 256, // see base_entities.qc -- CEV
        // SPAWNFLAG_NOT_ON_NORMAL = 512,
        // SPAWNFLAG_NOT_ON_HARD_OR_NIGHTMARE = 1024,
        // SPAWNFLAG_NOT_IN_DEATHMATCH = 2048,
        // SPAWNFLAG_NOT_IN_COOP = 4096,
        // SPAWNFLAG_NOT_IN_SP = 8192,
        // SPAWNFLAG_NOT_ON_SKILL2 = 32768, // see base_entities.qc -- CEV
        // SPAWNFLAG_NOT_ON_SKILL3 = 65536, // see base_entities.qc -- CEV
        // SPAWNFLAG_CENTERPRINTALL = 131072 // see base_entities.qc -- CEV
} trigger_push_spawnflags;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// trigger_push netflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        NETFLAG_TRIGGER_PUSH_STATE = NETFLAG_BASE_TRIGGER_STATE,
        NETFLAG_TRIGGER_PUSH_ESTATE = NETFLAG_BASE_TRIGGER_ESTATE,
        NETFLAG_TRIGGER_PUSH_SIZE,
        NETFLAG_TRIGGER_PUSH_ANGLES,
        NETFLAG_TRIGGER_PUSH_MOVEDIR,
        NETFLAG_TRIGGER_PUSH_NEWORIGIN,
        NETFLAG_TRIGGER_PUSH_SPEED
} trigger_push_netflags;

const float NETFLAG_TRIGGER_PUSH_FULLSEND = NETFLAG_TRIGGER_PUSH_SIZE |
        NETFLAG_TRIGGER_PUSH_ANGLES | NETFLAG_TRIGGER_PUSH_MOVEDIR |
        NETFLAG_TRIGGER_PUSH_NEWORIGIN | NETFLAG_TRIGGER_PUSH_SPEED |
        NETFLAG_TRIGGER_PUSH_STATE | NETFLAG_TRIGGER_PUSH_ESTATE;
#endif

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
typedef enum
{
        TRIGGER_PUSH_STATE_TARGETED = 1,
        TRIGGER_PUSH_STATE_ADDITIVE = 2
} trigger_push_states;
#endif

//======================================================================
// forward declarations
//======================================================================

#if defined(CSQC) || defined(SSQC)
vector(float a, float b, float c) solve_quadratic;
#endif

// base_trigger_push
#ifdef CSQC
void(float isnew) base_trigger_push_netreceive;
#endif
#ifdef SSQC
float(entity to, float netflags) base_trigger_push_netsend;
void() base_trigger_push_think_findtarget;
#endif
#if defined(CSQC) || defined(SSQC)
vector(vector org, vector torg, float ht) base_trigger_push_calcvel;
void() base_trigger_push_touch;
#endif
#ifdef SSQC
void(string key, string value) base_trigger_push_init_field;
#endif

// trigger_push
// void() trigger_push_use;
#if defined(CSQC) || defined(SSQC)
void(entity e) trigger_push_init;
#endif
#ifdef SSQC
void() trigger_push;
#endif

// trigger_push_custom
#ifdef SSQC
void() trigger_push_custom_use;
#endif
#if defined(CSQC) || defined(SSQC)
void(entity e) trigger_push_custom_init;
#endif
#ifdef SSQC
void() trigger_push_custom;
#endif

//------------------------------------------------------------------------------

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// solve_quadratic -- from Nexuiz source code; original can be found at
// https://github.com/smlinux/nexuiz/blob/master/data/qcsrc/common/util.qc
//----------------------------------------------------------------------
vector(float a, float b, float c) solve_quadratic =
{
        // ax^2 + bx + c = 0
        local vector v = '0 0 0';
        local float D;
        if (a == 0)
        {
                if (b != 0)
                {
                        v_x = v_y = -c / b;
                        v_z = 1;
                }
                else
                {
                        if (c == 0)
                        {
                                // actually, every number solves the equation!
                                v_z = 1;
                        }
                }
        }
        else
        {
                D = b * b - 4 * a * c;
                if (D >= 0)
                {
                        D = sqrt (D);
                        if (a > 0)
                        {
                                // put the smaller solution first
                                v_x = ((-b) - D) / (2 * a);
                                v_y = ((-b) + D) / (2 * a);
                        }
                        else
                        {
                                v_x = (-b + D) / (2 * a);
                                v_y = (-b - D) / (2 * a);
                        }
                        v_z = 1;
                }
                else
                {
                        // complex solutions!
                        D = sqrt (-D);
                        v_x = -b / (2 * a);
                        if (a > 0)
                                v_y =  D / (2 * a);
                        else
                                v_y = -D / (2 * a);
                        v_z = 0;
                }
        }
        return v;
};
#endif

//----------------------------------------------------------------------
// class base_trigger_push: base_trigger
// {
#ifdef CSQC
        //--------------------------------------------------------------
        void(float isnew) base_trigger_push_netreceive =
        {
                local float netflags = ReadByte ();

                if (netflags & NETFLAG_TRIGGER_PUSH_STATE)
                        self.state = ReadByte ();

                if (netflags & NETFLAG_TRIGGER_PUSH_ESTATE)
                        self.estate = ReadByte ();

                if (netflags & NETFLAG_TRIGGER_PUSH_SIZE)
                {
                        self.mins_x = ReadCoord ();
                        self.mins_y = ReadCoord ();
                        self.mins_z = ReadCoord ();
                        self.maxs_x = ReadCoord ();
                        self.maxs_y = ReadCoord ();
                        self.maxs_z = ReadCoord ();
                }

                if (netflags & NETFLAG_TRIGGER_PUSH_MOVEDIR)
                {
                        self.movedir_x = ReadAngle ();
                        self.movedir_y = ReadAngle ();
                        self.movedir_z = ReadAngle ();
                }

                if (netflags & NETFLAG_TRIGGER_PUSH_NEWORIGIN)
                {
                        self.neworigin_x = ReadCoord ();
                        self.neworigin_y = ReadCoord ();
                        self.neworigin_z = ReadCoord ();
                }

                if (netflags & NETFLAG_TRIGGER_PUSH_SPEED)
                        self.speed = ReadShort ();

                if (isnew)
                        if (self.classtype == CT_TRIGGER_PUSH)
                                trigger_push_init (self);
                        else if (self.classtype == CT_TRIGGER_PUSH_CUSTOM)
                                trigger_push_custom_init (self);

                // make sure size is set -- CEV
                if (netflags & NETFLAG_TRIGGER_PUSH_SIZE)
                        setsize (self, self.mins, self.maxs);
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        float(entity to, float netflags) base_trigger_push_netsend =
        {
                WriteByte (MSG_ENTITY, self.classtype);

                // restrict netflags so we can send it in one byte -- CEV
                if (netflags > NETFLAG_TRIGGER_PUSH_FULLSEND)
                        netflags = NETFLAG_TRIGGER_PUSH_FULLSEND;

                WriteByte (MSG_ENTITY, netflags);

                if (netflags & NETFLAG_TRIGGER_PUSH_STATE)
                        WriteByte (MSG_ENTITY, self.state);

                if (netflags & NETFLAG_TRIGGER_PUSH_ESTATE)
                        WriteByte (MSG_ENTITY, self.estate);

                if (netflags & NETFLAG_TRIGGER_PUSH_SIZE)
                {
                        WriteCoord (MSG_ENTITY, self.mins_x);
                        WriteCoord (MSG_ENTITY, self.mins_y);
                        WriteCoord (MSG_ENTITY, self.mins_z);
                        WriteCoord (MSG_ENTITY, self.maxs_x);
                        WriteCoord (MSG_ENTITY, self.maxs_y);
                        WriteCoord (MSG_ENTITY, self.maxs_z);
                }

                if (netflags & NETFLAG_TRIGGER_PUSH_MOVEDIR)
                {
                        WriteAngle (MSG_ENTITY, self.movedir_x);
                        WriteAngle (MSG_ENTITY, self.movedir_y);
                        WriteAngle (MSG_ENTITY, self.movedir_z);
                }

                if (netflags & NETFLAG_TRIGGER_PUSH_NEWORIGIN)
                {
                        WriteCoord (MSG_ENTITY, self.neworigin_x);
                        WriteCoord (MSG_ENTITY, self.neworigin_y);
                        WriteCoord (MSG_ENTITY, self.neworigin_z);
                }

                if (netflags & NETFLAG_TRIGGER_PUSH_SPEED)
                        WriteShort (MSG_ENTITY, self.speed);

                return TRUE;
        };

        //--------------------------------------------------------------
        void() base_trigger_push_think_findtarget =
        {
                // attempt to find the target -- CEV
                self.enemy = find (world, targetname, self.target);
                if (self.enemy)
                {
                        self.neworigin = self.enemy.origin;
                        self.state |= TRIGGER_PUSH_STATE_TARGETED;
                }
                else
                {
                        // force a default if no target was found -- CEV
                        if (!self.movedir)
                        {
                                // TODO CEV is this up? I don't remember
                                self.movedir = '0 0 180';
                                self.speed = 1000;
                        }
                }

                // make sure SendEntity and SendFlags are set so the client
                // sees this entity -- CEV
                self.SendEntity = base_trigger_push_netsend;
                self.SendFlags = NETFLAG_TRIGGER_PUSH_SIZE |
                        NETFLAG_TRIGGER_PUSH_STATE |
                        NETFLAG_TRIGGER_PUSH_ESTATE |
                        NETFLAG_TRIGGER_PUSH_SPEED;
                if (self.neworigin)
                        self.SendFlags |= NETFLAG_TRIGGER_PUSH_NEWORIGIN;
                if (self.movedir)
                        self.SendFlags |= NETFLAG_TRIGGER_PUSH_MOVEDIR;

                // don't (shouldn't) need to call think anymore -- CEV
                self.think = sub_null;
        };
#endif

#if defined(CSQC) || defined(SSQC)
        //--------------------------------------------------------------
        // trigger_push_calculatevelocity
        //
        // Arguments:
        //   org - origin of the object which is to be pushed
        //   tgt - target entity (can be either a point or a model entity;
        //   if it is the latter, its midpoint is used)
        //   ht  - jump height, measured from the higher one of org and tgt's
        //         midpoint
        //
        // Returns: velocity for the jump
        // the global trigger_push_calculatevelocity_flighttime is set to the
        // total jump time
        //
        // copied from Nexuiz source code; original can be found here:
        // github.com/smlinux/nexuiz/blob/master/data/qcsrc/server/t_jumppads.qc
        //--------------------------------------------------------------
        vector(vector org, vector torg, float ht) base_trigger_push_calcvel =
        {
                local float sdist, zdist, vs, vz, jumpheight;
                local vector sdir;
                local vector solution;
                local float flighttime;

                zdist = torg_z - org_z;
                sdist = vlen (torg - org - zdist * '0 0 1');
                sdir = normalize (torg - org - zdist * '0 0 1');

                // how high do we need to push the player?
                jumpheight = fabs (ht);
                if (zdist > 0)
                        jumpheight = jumpheight + zdist;

                /*
                STOP.

                You will not understand the following equations anyway...
                But here is what I did to get them.

                I used the functions

                  s(t) = t * vs
                  z(t) = t * vz - 1/2 grav t^2

                and solved for:

                  s(ti) = sdist
                  z(ti) = zdist
                  max(z, ti) = jumpheight

                From these three equations, you will find the three
                parameters vs, vz and ti.
                */

                // push him so high... NOTE: sqrt(positive)!
                vz = sqrt (2 * world_gravity * jumpheight);

                // we start with downwards velocity only if it's a downjump
                // and the jump apex should be outside the jump!
                if (ht < 0)
                        if (zdist < 0)
                                vz = -vz;

                // equation "z(ti) = zdist"
                solution = solve_quadratic (0.5 * world_gravity, -vz, zdist);
                // ALWAYS solvable because jumpheight >= zdist
                if (!solution_z)
                        // just in case it is not solvable due to roundoff
                        // errors, assume two equal solutions at their center
                        // (this is mainly for the usual case with ht == 0)
                        solution_y = solution_x;
                if (zdist == 0)
                        // solution_x is 0 in this case, so don't use it, but
                        // rather use solution_y (which will be
                        // sqrt(0.5 * jumpheight / grav), actually)
                        solution_x = solution_y;

                if (zdist < 0)
                {
                        // down-jump
                        if (ht < 0)
                        {
                                // almost straight line type
                                // jump apex is before the jump
                                // we must take the larger one
                                flighttime = solution_y;
                        }
                        else
                        {
                                // regular jump
                                // jump apex is during the jump
                                // we must take the larger one too
                                flighttime = solution_y;
                        }
                }
                else
                {
                        // up-jump
                        if (ht < 0)
                        {
                                // almost straight line type
                                // jump apex is after the jump
                                // we must take the smaller one
                                flighttime = solution_x;
                        }
                        else
                        {
                                // regular jump
                                // jump apex is during the jump
                                // we must take the larger one
                                flighttime = solution_y;
                        }
                }
                vs = sdist / flighttime;

                // finally calculate the velocity
                return sdir * vs + '0 0 1' * vz;
        };

        //--------------------------------------------------------------
        void() base_trigger_push_touch =
        {
                if (self.estate != STATE_ACTIVE)
                        return;

                // from Copper -- dumptruck_ds
                if (other.movetype == MOVETYPE_NOCLIP)
                        return;

                if (other.classtype == CT_PROJECTILE_GRENADE)
                {
                        if (self.state & TRIGGER_PUSH_STATE_TARGETED)
                                other.velocity = self.movedir;
                        else
                                other.velocity = self.speed * self.movedir * 10;
                }
                else if (other.health > 0)
                {
                        if (self.state & TRIGGER_PUSH_STATE_TARGETED)
                                // jumppad style
                                other.velocity = base_trigger_push_calcvel (
                                        other.origin, self.neworigin,
                                        self.height);
                        else if (self.state & TRIGGER_PUSH_STATE_ADDITIVE)
                                // MG1 additive push
                                other.velocity = other.velocity + self.speed *
                                        self.movedir * 10 * frametime;
                        else
                                // regular
                                other.velocity = self.speed * self.movedir * 10;

                        #if 0
                        dprint (sprintf("base_trigger_push_touch: "
                                "moving player... self movedir %v, "
                                "self speed %g, other vel %v\n",
                                self.movedir, self.speed, other.velocity));
                        #endif

                        if (other.classtype == CT_PLAYER)
                        {
                                // signal pmove that player has touched a
                                // push brush -- CEV
                                other.pm_flags |= PMF_PUSHED;
                                other.pm_timer = 0;

                                #ifdef SSQC
                                // carry on with normal push sound behavior
                                if (!(self.spawnflags &
                                        SPAWNFLAG_TRIGGER_PUSH_SILENT) &&
                                        other.fly_sound < time)
                                {
                                        if (!(self.spawnflags &
                                                SPAWNFLAG_TRIGGER_PUSH_NOISE))
                                        {
                                                other.fly_sound = time + 1.5;
                                                sound (other, CHAN_AUTO,
                                                        "ambience/windfly.wav",
                                                        VOL_HIGH, ATTN_NORM);
                                        }
                                        else
                                        {
                                                other.fly_sound = time + 1.5;
                                                sound (other, CHAN_AUTO,
                                                        self.noise,
                                                        VOL_HIGH, ATTN_NORM);
                                        }
                                }
                                #endif
                        }
                }

                #ifdef SSQC
                if (self.spawnflags & SPAWNFLAG_TRIGGER_PUSH_ONCE)
                        remove (self);
                #endif
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        void(string key, string value) base_trigger_push_init_field =
        {
                #if 0
                if (cvar("developer"))
                        dprint (sprintf("base_trigger_push_init_field: "
                                "key %s, value %s\n", key, value));
                #endif

                switch (key)
                {
                        case "height":
                                self.height = stof (value);
                                break;
                }
        };
#endif
// };

/*QUAKED trigger_push (.5 .5 .5) ? TRIGGER_PUSH_ONCE TRIGGER_PUSH_ADDITIVE TRIGGER_PUSH_MGSTARTOFF TRIGGER_PUSH_STARTOFF TRIGGER_PUSH_SILENT TRIGGER_PUSH_NOISE X X NOT_ON_EASY NOT_ON_NORMAL NOT_ON_HARD_OR_NIGHTMARE NOT_IN_DEATHMATCH NOT_IN_COOP NOT_IN_SINGLEPLAYER X NOT_ON_HARD_ONLY NOT_ON_NIGHTMARE_ONLY
Pushes the player
*/
//----------------------------------------------------------------------
// class trigger_push: base_trigger_push
// {
        //--------------------------------------------------------------
        // dumptruck_ds
        //--------------------------------------------------------------
        /*
        void() trigger_push_use =
        {
                self.is_waiting = !self.is_waiting;
        }
        */

#if defined(CSQC) || defined(SSQC)
        //--------------------------------------------------------------
        void(entity e) trigger_push_init =
        {
                e.classname = "trigger_push";
                e.classtype = CT_TRIGGER_PUSH;
                e.touch = base_trigger_push_touch;

                base_trigger_init (e);

                #ifdef SSQC
                precache_sound ("ambience/windfly.wav");

                // TODO CEV should probably test this
                if (e.spawnflags & SPAWNFLAG_TRIGGER_PUSH_STARTOFF ||
                        e.spawnflags & SPAWNFLAG_TRIGGER_PUSH_MGSTARTOFF)
                {
                        e.estate = STATE_INACTIVE;
                }

                if (e.spawnflags & SPAWNFLAG_TRIGGER_PUSH_ADDITIVE)
                        self.state |= TRIGGER_PUSH_STATE_ADDITIVE;

                if (e.noise != "")
                        precache_sound (e.noise);

                if (e.target != __NULL__ && e.target != "")
                {
                        // schedule a think to find target -- CEV
                        e.think = base_trigger_push_think_findtarget;
                        e.nextthink = time + 0.2 + (random() * 0.25);
                }
                else
                {
                        if (!e.speed)
                                e.speed = 1000;

                        e.SendEntity = base_trigger_push_netsend;
                        e.SendFlags = NETFLAG_TRIGGER_PUSH_SIZE |
                                NETFLAG_TRIGGER_PUSH_STATE |
                                NETFLAG_TRIGGER_PUSH_ESTATE |
                                NETFLAG_TRIGGER_PUSH_SPEED;
                        // don't need to send NEWORIGIN -- CEV
                        if (e.movedir)
                                e.SendFlags |= NETFLAG_TRIGGER_PUSH_MOVEDIR;
                }

                sub_checkwaiting (e);
                #endif
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        void() trigger_push =
        {
                // read unprocessed fields as present in the map file -- CEV
                base_mapentity_init_spawndata (base_trigger_push_init_field);

                // new spawnflags for all entities -- iw
                if (SUB_Inhibit())
                        return;

                trigger_push_init (self);
        };
#endif
// };

/*QUAKED trigger_push_custom (.5 .5 .5) ? TRIGGER_PUSH_ONCE TRIGGER_PUSH_STARTOFF TRIGGER_PUSH_SILENT X X X X X NOT_ON_EASY NOT_ON_NORMAL NOT_ON_HARD_OR_NIGHTMARE NOT_IN_DEATHMATCH NOT_IN_COOP NOT_IN_SINGLEPLAYER X NOT_ON_HARD_ONLY NOT_ON_NIGHTMARE_ONLY


dumptruck_ds

trigger_push_custom is a new entity. This can be used to create traps,
jumppads, currents in water and more.

If TRIGGER_PUSH_STARTOFF flag is set, this disables the trigger.  This can
be targeted and toggled off and on. If the TRIGGER_PUSH_SILENT flag is set
it won't make the windfly sound. Use TRIGGER_PUSH_NOISE spawnflag and the
noise key/value to use a custom push sound. Custom sounds should be "one
off" sounds NOT be looping.

Adapted from Hipnotic's func_togglewall
*/
//----------------------------------------------------------------------
// class trigger_push_custom: base_trigger_push
// {
#ifdef SSQC
        //--------------------------------------------------------------
        // dumptruck_ds was based on hipnotic blocker_use now Alkaline estate
        //--------------------------------------------------------------
        void() trigger_push_custom_use =
        {
                if (self.estate != STATE_ACTIVE)
                        self.estate = STATE_ACTIVE;
                else
                        self.estate = STATE_INACTIVE;
        };
#endif

#if defined(CSQC) || defined(SSQC)
        //--------------------------------------------------------------
        void(entity e) trigger_push_custom_init =
        {
                e.classname = "trigger_push_custom";
                e.classtype = CT_TRIGGER_PUSH_CUSTOM;
                e.touch = base_trigger_push_touch;

                #ifdef SSQC
                e.use = trigger_push_custom_use;
                #endif

                base_trigger_init (e);

                #ifdef SSQC
                precache_sound ("ambience/windfly.wav");

                if (e.spawnflags & SPAWNFLAG_TRIGGER_PUSH_STARTOFF ||
                        e.spawnflags & SPAWNFLAG_TRIGGER_PUSH_MGSTARTOFF)
                {
                        e.estate = STATE_INACTIVE;
                }

                if (e.spawnflags & SPAWNFLAG_TRIGGER_PUSH_ADDITIVE)
                        self.state |= TRIGGER_PUSH_STATE_ADDITIVE;

                if (e.noise != "")
                        precache_sound (e.noise);

                if (e.target != __NULL__ && e.target != "")
                {
                        // schedule a think to find target -- CEV
                        e.think = base_trigger_push_think_findtarget;
                        e.nextthink = time + 0.2 + (random() * 0.25);
                }
                else
                {
                        if (!e.speed)
                                e.speed = 1000;

                        e.SendEntity = base_trigger_push_netsend;
                        e.SendFlags = NETFLAG_TRIGGER_PUSH_SIZE |
                                NETFLAG_TRIGGER_PUSH_STATE |
                                NETFLAG_TRIGGER_PUSH_ESTATE |
                                NETFLAG_TRIGGER_PUSH_SPEED;
                        // don't need to send NEWORIGIN -- CEV
                        if (e.movedir)
                                e.SendFlags |= NETFLAG_TRIGGER_PUSH_MOVEDIR;
                }

                sub_checkwaiting (e);
                #endif
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        void() trigger_push_custom =
        {
                // new spawnflags for all entities -- iw
                if (SUB_Inhibit())
                        return;

                trigger_push_custom_init (self);
        };
#endif
// };