djcev.com

//==============================================================================
// trigger_ladder -- selections from Rubicon 2 qc by john fitzgibbons
//==============================================================================

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

#if defined(CSQC) || defined(SSQC)
//----------------------------------------------------------------------
// trigger_ladder netflags; should be able to do this in 8 bits -- CEV
//----------------------------------------------------------------------
typedef enumflags
{
        NETFLAG_TRIGGER_LADDER_STATE = NETFLAG_BASE_TRIGGER_STATE,
        NETFLAG_TRIGGER_LADDER_ESTATE = NETFLAG_BASE_TRIGGER_ESTATE,
        NETFLAG_TRIGGER_LADDER_SIZE,
        NETFLAG_TRIGGER_LADDER_ANGLES,
        NETFLAG_TRIGGER_LADDER_MOVEDIR
} trigger_ladder_netflags;

const float NETFLAG_TRIGGER_LADDER_FULLSEND = NETFLAG_TRIGGER_LADDER_SIZE |
        NETFLAG_TRIGGER_LADDER_ANGLES | NETFLAG_TRIGGER_LADDER_MOVEDIR |
        NETFLAG_TRIGGER_LADDER_ESTATE;
#endif

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

#ifdef CSQC
void(float isnew) trigger_ladder_netreceive;
#endif
#ifdef SSQC
float(entity to, float netflags) trigger_ladder_netsend;
#endif
#if defined(CSQC) || defined (SSQC)
void() trigger_ladder_touch;
void(entity e) trigger_ladder_init;
#endif
#ifdef SSQC
void() trigger_ladder;
#endif

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

/*QUAKED trigger_ladder (.5 .5 .5) ? X 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
invisible ladder entity. when player is touching this entity, he can climb by pushing 'jump'

Keys:

"angle" the direction player must be facing to climb ladder
*/
//----------------------------------------------------------------------
// class trigger_ladder: base_trigger
// {
#ifdef CSQC
        //--------------------------------------------------------------
        void(float isnew) trigger_ladder_netreceive =
        {
                local float netflags = ReadByte ();

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

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

                if (netflags & NETFLAG_TRIGGER_LADDER_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_LADDER_ANGLES)
                {
                        self.angles_x = ReadAngle ();
                        self.angles_y = ReadAngle ();
                        self.angles_z = ReadAngle ();
                }

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

                if (isnew)
                        trigger_ladder_init (self);

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

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

                if (netflags > NETFLAG_TRIGGER_LADDER_FULLSEND)
                        netflags = NETFLAG_TRIGGER_LADDER_FULLSEND;

                WriteByte (MSG_ENTITY, netflags);

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

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

                if (netflags & NETFLAG_TRIGGER_LADDER_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_LADDER_ANGLES)
                {
                        WriteAngle (MSG_ENTITY, self.angles_x);
                        WriteAngle (MSG_ENTITY, self.angles_y);
                        WriteAngle (MSG_ENTITY, self.angles_z);
                }

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

                return TRUE;
        };
#endif

#if defined(CSQC) || defined (SSQC)
        //--------------------------------------------------------------
        // trigger_ladder_touch
        //--------------------------------------------------------------
        void() trigger_ladder_touch =
        {
                // from Copper -- dumptruck_ds
                if (sub_checkvalidtouch(other) == FALSE)
                        return;

                // prevent the player "sticking" to a ladder if they are
                // standing on the platform at the top of the ladder with
                // the bottom of their bounding box flush with the top of
                // the trigger -- iw
                if (other.absmin_z + 1 >= self.absmax_z - 1)
                        return;

                // if the trigger has an angles field, check player's
                // facing direction
                if (self.movedir != '0 0 0')
                {
                        makevectors (other.angles);
                        if (v_forward * self.movedir < 0)
                        {
                                #if 0
                                dprint (sprintf("trigger_ladder_touch: "
                                        "facing wrong way; movedir %v, "
                                        "other ang %v\n", self.movedir,
                                        other.angles));
                                #endif
                                // not facing the right way
                                return;
                        }
                }

                // changed to PMFLAGS -- CEV
                other.pm_flags |= PMF_ONLADDER;
        };
#endif

#if defined(CSQC) || defined(SSQC)
        //--------------------------------------------------------------
        void(entity e) trigger_ladder_init =
        {
                e.classname = "trigger_ladder";
                e.classtype = CT_TRIGGER_LADDER;

                #ifdef SSQC
                // ignore an "up" or "down" angle (doesn't make sense
                // for a ladder)
                if (e.angles_y == -1 || e.angles_y == -2)
                {
                        dprint (sprintf("trigger_ladder_init: ignoring bad "
                                "'angle' value: %g\n", e.angles_y));

                        e.angles_y = 0;
                }
                #endif

                base_trigger_init (e);
                e.touch = trigger_ladder_touch;

                #ifdef SSQC
                sub_checkwaiting (e);

                // trigger_ladder needs to be networked to the client. set
                // our transmit function then full send the entity -- CEV
                e.SendEntity = trigger_ladder_netsend;
                e.SendFlags |= NETFLAG_TRIGGER_LADDER_FULLSEND;
                #endif
        };
#endif

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

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