djcev.com

//==============================================================================
// trigger_shake -- point entity from Rubicon Rumble Pack; requires TARGETNAME
// trigger_screenshake - entity from MG1
//==============================================================================

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

#ifdef SSQC
//----------------------------------------------------------------------
// RRP trigger_shake spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        SPAWNFLAG_TRIGGER_SHAKE_VIEWONLY = 1
        // 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_shake_spawnflags;
#endif

#ifdef SSQC
//----------------------------------------------------------------------
// MG1 trigger_screenshake spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        SPAWNFLAG_TRIGGER_SCREENSHAKE_SILENT = 1
        // 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_screenshake_spawnflags;
#endif

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

#ifdef SSQC
// trigger_shake
void() trigger_shake_think;
void() trigger_shake_use;
void(entity e) trigger_shake_init;
void() trigger_shake;
#endif

#ifdef SSQC
// trigger_screenshake
void() trigger_screenshake_think;
void() trigger_screenshake_use;
void(entity e) trigger_screenshake_init;
void() trigger_screenshake;
#endif

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

#ifdef SSQC
/*QUAKED trigger_shake (.5 0 .5) (-8 -8 -8) (8 8 8) TRIGGER_SHAKE_VIEWONLY X X 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

Earthquake trigger - shakes players in it's radius when active.
Strength of tremor is greatest at the centre.
dmg Strength at center (default is 120)
wait Duration of shake (default is 1)
count Affect radius (defalt is 200)
noise Noise to play when starting to shake
noise1 Noise to play when stopping
targetname Must be triggered
Spawnflags
TRIGGER_SHAKE_VIEWONLY Shakes the view, but player movement is not affected
*/
//----------------------------------------------------------------------
// class trigger_shake: base_trigger
// {
        //--------------------------------------------------------------
        // was shake_think
        //--------------------------------------------------------------
        void() trigger_shake_think =
        {
                if (intermission)
                        return;

                if (self.attack_finished < time)
                {
                        // Done
                        self.nextthink = -1;

                        if (self.noise1 != "")
                                sound (self, CHAN_VOICE, self.noise1,
                                        VOL_HIGH, ATTN_NORM);

                        return;
                }

                // Shake all players in the effect radius...
                local entity p;
                p = findradius (self.origin, self.count);

                while (p)
                {
                        if (!(p.flags & FL_CLIENT))
                        {
                                p = p.chain;
                                continue;
                        }

                        local float d;

                        // Scale effect by distance
                        d = vlen (self.origin - p.origin);
                        d = (self.count - d) / self.count;

                        if (d > 0)
                        {
                                // shake up the view
                                p.punchangle_x = -1 * (random() +
                                        (0.025 * self.dmg * d));
                                if (p.SendEntity)
                                        p.SendFlags|=NETFLAG_PLAYER_PUNCHANGLE;

                                // push the player around
                                if (p.flags & FL_ONGROUND) {
                                if (!(self.spawnflags &
                                        SPAWNFLAG_TRIGGER_SHAKE_VIEWONLY))
                                {
                                        d = self.dmg * d;
                                        p.velocity_x = p.velocity_x +
                                                (random() * d * 2 - d);
                                        p.velocity_y = p.velocity_y +
                                                (random() * d * 2 - d);
                                        // always push up
                                        p.velocity_z = p.velocity_z +
                                                (random() * d);
                                } }
                        }
                        p = p.chain;
                }

                // keep going
                self.nextthink = time + 0.1;
        };

        //--------------------------------------------------------------
        void() trigger_shake_use =
        {
                // already active
                if (self.attack_finished > time)
                        return;

                // Start...
                if (self.noise != "")
                        sound (self, CHAN_VOICE, self.noise,
                                VOL_HIGH, ATTN_NORM);

                self.attack_finished = time + self.wait;
                self.nextthink = time + 0.1;
        };

        //--------------------------------------------------------------
        void(entity e) trigger_shake_init =
        {
                e.classname = "trigger_shake";
                e.classtype = CT_TRIGGER_SHAKE;

                if (!e.targetname)
                        objerror ("trigger_shake without name");

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

                if (!e.dmg)
                        e.dmg = 120;
                if (e.count <= 0)
                        e.count = 200;
                if (e.wait <= 0)
                        e.wait = 1.0;

                base_trigger_init (e);

                setorigin (e, e.origin);
                e.think = trigger_shake_think;
                e.use = trigger_shake_use;
                e.nextthink = -1;
        };

        //--------------------------------------------------------------
        void() trigger_shake =
        {
                // new spawnflags for all entities -- iw
                if (SUB_Inhibit())
                        return;

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

#ifdef SSQC
/*QUAKED trigger_screenshake

wait is duration of the shake
dmg is the intensity of the shake
*/
//----------------------------------------------------------------------
// class trigger_screenshake: base_trigger
// {
        //--------------------------------------------------------------
        // T_Shake from MG1. Similar to trigger_shake_think above but
        // has slightly different logic. -- CEV
        //--------------------------------------------------------------
        void() trigger_screenshake_think =
        {
                local entity t;
                local float starttime;
                local float hit;

                starttime = self.attack_finished - self.wait;
        
                // early out if intermission is running
                if (intermission)
                        return;
        
                // Completed, cleanup!
                if (time > self.attack_finished)
                {
                        if (!(self.spawnflags &
                                SPAWNFLAG_TRIGGER_SCREENSHAKE_SILENT))
                        {
                                sound (self, CHAN_VOICE, self.noise1,
                                        1, ATTN_NORM);
                        }
                
                        t = findfloat (world, classtype, CT_PLAYER);
                        while (t)
                        {
                                t.v_angle_z = 0;
                                t = findfloat (t, classtype, CT_PLAYER);
                        }
                        return;
                }
        
                // Ramp up? 
                if (time < self.delay)
                        hit = (time - starttime) / (self.wait / 3);
                else
                        hit = 1;
        
                // dprint ("intensity: ");
                // dprint (ftos(hit));
                // dprint ("\n");
        
                hit = self.dmg * hit;
        
                // for each player
                t = findfloat (world, classtype, CT_PLAYER);
                while (t)
                {
                        // do the shake!
                        t.punchangle_x = random() * hit;
                        t.punchangle_y = crandom() * hit;
                        t.punchangle_z = random() * hit;
                        if (t.SendEntity)
                                t.SendFlags |= NETFLAG_PLAYER_PUNCHANGLE;

                        t = findfloat (t, classtype, CT_PLAYER);
                }

                self.nextthink = time + 0.05;
        };

        //--------------------------------------------------------------
        void() trigger_screenshake_use =
        {
                // when to end
                self.attack_finished = time + self.wait;
                // how long to ramp up
                self.delay = time + (self.wait / 3);
        
                if (!(self.spawnflags & SPAWNFLAG_TRIGGER_SCREENSHAKE_SILENT))
                        sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);

                self.think = trigger_screenshake_think;
                self.nextthink = time + 0.05;
        };

        //--------------------------------------------------------------
        void(entity e) trigger_screenshake_init =
        {
                e.classname = "trigger_screenshake";
                e.classtype = CT_TRIGGER_SCREENSHAKE;

                base_trigger_init (e);

                // wait is sustain time
                // dmg is intensity
                if (!(e.spawnflags & SPAWNFLAG_TRIGGER_SCREENSHAKE_SILENT))
                {
                        e.noise = "misc/quake.wav";
                        e.noise1 = "misc/quakeend.wav";
                        precache_sound (e.noise);
                        precache_sound (e.noise1);
                }
        
                if (!e.wait)
                        // no duration!
                        e.wait = 2;
                
                if (!e.dmg)
                        // no intensity!
                        e.dmg = 3;

                e.use = trigger_screenshake_use;
        };

        //--------------------------------------------------------------
        void() trigger_screenshake =
        {
                // new spawnflags for all entities -- iw
                if (SUB_Inhibit())
                        return;

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