djcev.com

//==============================================================================
// Player & Monster spawnpoint entities
//==============================================================================

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

#ifdef SSQC
// info_player_start
entity(entity src, vector org) spawn_info_player_start;
void(entity e) info_player_start_init;
void() info_player_start;
#endif

#ifdef SSQC
// info_player_start2
entity(entity src, vector org) spawn_info_player_start2;
void(entity e) info_player_start2_init;
void() info_player_start2;
#endif

#ifdef SSQC
// testplayerstart
entity(entity src, vector org) spawn_testplayerstart;
void(entity e) testplayerstart_init;
void() testplayerstart;
#endif

#ifdef SSQC
// info_player_coop
entity(entity src, vector org) spawn_info_player_coop;
void(entity e) info_player_coop_init;
void() info_player_coop;
#endif

#ifdef SSQC
// info_monster_spawnpoint
entity(entity src, vector org) spawn_info_monster_spawnpoint;
void(entity e) info_monster_spawnpoint_init;
void() info_monster_spawnpoint;
#endif

#ifdef SSQC
// info_player_deathmatch
entity(entity src, vector org) spawn_info_player_deathmatch;
void(entity e) info_player_deathmatch_init;
void() info_player_deathmatch;
#endif

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

#ifdef SSQC
/*QUAKED info_player_start (1 0 0) (-16 -16 -24) (16 16 24) 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
{
model ("progs/player.mdl");
}
The normal starting point for a level.
*/
//----------------------------------------------------------------------
// class info_player_start: base_mapentity
// {
        //--------------------------------------------------------------
        entity(entity src, vector org) spawn_info_player_start =
        {
                local entity e = spawn ();
                e.owner = src;
                e.origin = org;
                info_player_start_init (e);
                return e;
        };

        //--------------------------------------------------------------
        void(entity e) info_player_start_init =
        {
                base_mapentity_init (e);
                e.classname = "info_player_start";
                e.classtype = CT_INFO_PLAYER_START;
        };

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

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

#ifdef SSQC
/*QUAKED info_player_start2 (1 0 0) (-16 -16 -24) (16 16 24) 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
{
model ("progs/player.mdl");
}
Only used on start map for the return point from an episode.
*/
//----------------------------------------------------------------------
// class info_player_start2: base_mapentity
// {
        //--------------------------------------------------------------
        entity(entity src, vector org) spawn_info_player_start2 =
        {
                local entity e = spawn ();
                e.owner = src;
                e.origin = org;
                info_player_start2_init (e);
                return e;
        };

        //--------------------------------------------------------------
        void(entity e) info_player_start2_init =
        {
                base_mapentity_init (e);
                e.classname = "info_player_start2";
                e.classtype = CT_INFO_PLAYER_START2;
        };

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

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

//----------------------------------------------------------------------
// testplayerstart -- saved out by quaked in region mode
//----------------------------------------------------------------------

#ifdef SSQC
//----------------------------------------------------------------------
// class testplayerstart: base_mapentity
// {
        //--------------------------------------------------------------
        entity(entity src, vector org) spawn_testplayerstart =
        {
                local entity e = spawn ();
                e.owner = src;
                e.origin = org;
                testplayerstart_init (e);
                return e;
        };

        //--------------------------------------------------------------
        void(entity e) testplayerstart_init =
        {
                base_mapentity_init (e);
                e.classname = "testplayerstart";
                e.classtype = CT_INFO_TESTPLAYERSTART;
        };

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

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

#ifdef SSQC
/*QUAKED info_player_coop (1 0 1) (-16 -16 -24) (16 16 24) 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
{
model ("progs/player.mdl");
}
potential spawning position for coop games
*/
//----------------------------------------------------------------------
// class info_player_coop: base_mapentity
// {
        //--------------------------------------------------------------
        entity(entity src, vector org) spawn_info_player_coop =
        {
                local entity e = spawn ();
                e.owner = src;
                e.origin = org;
                info_player_coop_init (e);
                return e;
        };

        //--------------------------------------------------------------
        void(entity e) info_player_coop_init =
        {
                base_mapentity_init (e);
                e.classname = "info_player_coop";
                e.classtype = CT_INFO_PLAYER_COOP;
        };

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

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

#ifdef SSQC
/*QUAKED info_monster_spawnpoint (1 0 1) (-16 -16 -24) (16 16 24) 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
{
model ("progs/teleport.mdl");
}
 spawning position for func_monster_spawner
*/
//----------------------------------------------------------------------
// class info_monster_spawnpoint: base_mapentity
// {
        //--------------------------------------------------------------
        entity(entity src, vector org) spawn_info_monster_spawnpoint =
        {
                local entity e = spawn ();
                e.owner = src;
                e.origin = org;
                info_monster_spawnpoint_init (e);
                return e;
        };

        //--------------------------------------------------------------
        void(entity e) info_monster_spawnpoint_init =
        {
                base_mapentity_init (e);
                e.classname = "info_monster_spawnpoint";
                e.classtype = CT_INFO_MONSTER_SPAWNPOINT;
        };

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

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

#ifdef SSQC
/*QUAKED info_player_deathmatch (1 0 1) (-16 -16 -24) (16 16 24) 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
{
model ("progs/player.mdl");
}
potential spawning position for deathmatch games
*/
//----------------------------------------------------------------------
// class info_player_deathmatch: base_mapentity
// {
        //--------------------------------------------------------------
        entity(entity src, vector org) spawn_info_player_deathmatch =
        {
                local entity e = spawn ();
                e.owner = src;
                e.origin = org;
                info_player_deathmatch_init (e);
                return e;
        };

        //--------------------------------------------------------------
        void(entity e) info_player_deathmatch_init =
        {
                base_mapentity_init (e);
                e.classname = "info_player_deathmatch";
                e.classtype = CT_INFO_PLAYER_DEATHMATCH;
        };

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

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