djcev.com

//==============================================================================
// func_toss -- entity from MG1
//==============================================================================

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

#ifdef SSQC
//----------------------------------------------------------------------
// func_toss spawnflags -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        SPAWNFLAG_FUNC_TOSS_WAVE_ORIGIN = 1,
        SPAWNFLAG_FUNC_TOSS_REM_ON_STOP = 2,
        SPAWNFLAG_FUNC_TOSS_NO_BOUNCE = 4,
        SPAWNFLAG_FUNC_TOSS_ONLY_REM_IF_FAR = 8
        // 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
} func_toss_spawnflags;
#endif

#ifdef SSQC
const string FUNC_TOSS_WAVE_NETNAME = "_toss_origin";
#endif

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

// func_toss
#ifdef CSQC
void(float isnew) func_toss_netreceive;
#endif
#ifdef SSQC
void() func_toss_fire;
void() func_toss_linkcascade;
void() func_toss_think;
void() func_toss_use;
#endif
#ifdef SSQC
void(string key, string value) func_toss_init_field;
#endif
#if defined(CSQC) || defined(SSQC)
void(entity e) func_toss_init;
#endif
#ifdef SSQC
void() func_toss;
#endif

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

//----------------------------------------------------------------------
// class func_toss: base_func
// {
#ifdef CSQC
        //--------------------------------------------------------------
        void(float isnew) func_toss_netreceive =
        {
                // creates the netflag variable -- CEV
                BASE_FUNC_NETRECEIVE (func_toss_init)
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        void() func_toss_fire =
        {
                local vector min = self.mins + '4 4 0';
                // not sure what this was doing in MG1 -- CEV
                // local vector max = self.maxs - self.dest2;

                self.solid = SOLID_BBOX;
                if (self.spawnflags & SPAWNFLAG_FUNC_TOSS_NO_BOUNCE)
                        self.movetype = MOVETYPE_TOSS;
                else
                        self.movetype = MOVETYPE_BOUNCE;

                self.size = self.size - '8 8 0';
                self.mins = min;

                self.velocity = self.movedir;

                if (self.noise != __NULL__ && self.noise != "")
                        sound (self, CHAN_VOICE, self.noise, 1, ATTN_NORM);

                // update listening clients -- CEV
                self.classgroup |= CG_FRAMETICK;
                self.SendFlags |= NETFLAG_BASE_ENTITY_SOLID |
                        NETFLAG_BASE_ENTITY_ORIGIN;

                self.think = func_toss_think;
                self.nextthink = time + 0.25;
        };

        //--------------------------------------------------------------
        void() func_toss_linkcascade =
        {
                local vector p;
                local float dist, mindist = 16384;
                local entity o = find (world, netname, FUNC_TOSS_WAVE_NETNAME);

                while (o)
                {
                        if (o.targetname == self.targetname)
                        {
                                p = self.mins + self.size * 0.5;
                                p -= o.mins + o.size * 0.5;
                                dist = vlen(p) / o.speed;
                                if (dist < mindist)
                                        mindist = dist;
                        }

                        o = find (o, netname, FUNC_TOSS_WAVE_NETNAME);
                }

                if (mindist < 16384)
                        self.delay = mindist;
        };

        //--------------------------------------------------------------
        void() func_toss_think =
        {
                if (vlen(self.velocity) < 0.01)
                {
                        if (self.spawnflags & SPAWNFLAG_FUNC_TOSS_REM_ON_STOP)
                        {
                                if (self.spawnflags &
                                        SPAWNFLAG_FUNC_TOSS_ONLY_REM_IF_FAR)
                                {
                                        if (vlen(self.oldorigin -
                                                self.origin) > 64)
                                        {
                                                base_entity_remove (self);
                                                return;
                                        }
                                }
                                else
                                {
                                        base_entity_remove (self);
                                        return;
                                }
                        }

                        self.velocity = '0 0 0';
                        self.solid = SOLID_BSP;
                        self.movetype = MOVETYPE_PUSH;

                        // we've come to rest so cancel per-frame updates
                        // and transmit SOLID and ORIGIN now -- CEV
                        self.classgroup &= ~CG_FRAMETICK;
                        self.SendFlags |= NETFLAG_BASE_ENTITY_SOLID |
                                NETFLAG_BASE_ENTITY_ORIGIN;
                        return;
                }

                self.nextthink = time + 0.5;
        };

        //--------------------------------------------------------------
        void() func_toss_use =
        {
                self.use = sub_null;

                if (self.delay)
                {
                        self.think = func_toss_fire;
                        self.nextthink = self.ltime + self.delay;
                }
                else
                {
                        func_toss_fire ();
                }
        };
#endif

        //==============================================================
        // Initialization
        //==============================================================

#ifdef SSQC
        void(string key, string value) func_toss_init_field =
        {
                switch (key)
                {
                        case "dest":
                                // dest is used in MG1 -- CEV
                                if (!self.pos1)
                                        self.pos1 = stov (value);
                                break;
                        case "dest2":
                                // remap dest2, just in case -- CEV
                                if (!self.pos2)
                                        self.pos2 = stov (value);
                                break;
                }
        };
#endif

#if defined(CSQC) || defined(SSQC)
        //--------------------------------------------------------------
        void(entity e) func_toss_init =
        {
                e.classname = "func_toss";
                e.classtype = CT_FUNC_TOSS;
                base_func_init (e);

                #ifdef CSQC
                setmodelindex (e, e.modelindex);
                setsize (e, e.mins, e.maxs);
                setorigin (e, e.origin);
                e.drawmask = DRAWMASK_NORMAL;
                e.predraw = base_func_predraw;
                #endif

                #ifdef SSQC
                e.solid = SOLID_BSP;
                e.movetype = MOVETYPE_PUSH;
                setmodel (e, e.model);
                setorigin (e, e.origin);
                e.oldorigin = e.origin;

                e.use = func_toss_use;

                if (!e.movedir)
                        e.movedir = '0 0 200';

                if (e.pos1)
                {
                        e.movedir_x += crandom() * e.pos1_x;
                        e.movedir_y += crandom() * e.pos1_y;
                        e.movedir_z += crandom() * e.pos1_z;
                }

                if (e.spawnflags & SPAWNFLAG_FUNC_TOSS_WAVE_ORIGIN)
                {
                        e.netname = FUNC_TOSS_WAVE_NETNAME;
                        if (!e.speed)
                                e.speed = 200;
                }
                else if (!e.delay)
                {
                        e.think = func_toss_linkcascade;
                        e.nextthink = e.ltime + 0.2;
                }

                if (e.noise != __NULL__ && e.noise != "")
                {
                        precache_sound (e.noise);
                }

                // send it off to CSQC -- CEV
                e.tick = base_func_neteval;
                e.SendEntity = base_entity_netsend;
                e.SendFlags = NETFLAG_BASE_ENTITY_FULLSEND;
                #endif
        };
#endif

#ifdef SSQC
        //--------------------------------------------------------------
        void() func_toss =
        {
                BASE_FUNC_PREINIT (func_toss_init_field)
                func_toss_init (self);
        };
#endif
// }