djcev.com

//==============================================================================
// CSQC entrypoints
//==============================================================================

//======================================================================
// globals
//======================================================================

#ifdef CSQC
float skill;

float painfinishtime;                   // Track player damage for hud face

float intermission;                     // in intermission
float intermission_time;                // when the intermission started

float numclientseats;                   // coop or splitscreen?
float maxclients;                       // max players possible on this server
float cltime;                           // inc. regardless of pause or gamespeed

float player_localentnum;               // Ent number that csqc is attached to

float sb_showscores;                    // Show lower tab scores

// This is the input-frame sequence. frames < clientcommandframe have been
// sent to the server. frame==clientcommandframe is still being generated
// and can still change.
float clientcommandframe;

// This is the input-frame that was last acknowledged by the server.
// Input frames greater than this should be applied to the player's entity.
float servercommandframe;

// track the command frame last processed by pmove -- CEV
float pmovecommandframe;

entity view_player;                     // handle to the local player entity
float view_player_commandframe;         // 
entity view_entity;                     // camera -- CEV
vector view_origin;                     // origin for view_entity -- CEV
vector view_angles;                     // +x=DOWN

__used var float physics_mode = 2;      // 0 = not run, 1 = DP, 2 = movetypes
#endif

//======================================================================
// fields
//======================================================================

#ifdef CSQC
.float drawmask;                        // a filter in the addentities call
.float entnum;                          // The entnum as its known on the server
.float renderflags;

// The current frame the entity is meant to be displayed in. In CSQC,
// note the lerpfrac and frame2 fields as well. if it specifies a
// framegroup, the framegroup will autoanimate in ssqc, but not in csqc.
// .float frame;                        // already defined in entvars_t -- CEV
.float frame1time;                      // absolute time into anim/framegroup
.float frame2;                          // alt frame visible when lerpfrac is 1
.float frame2time;                      // absolute time into anim/group frame2
.float lerpfrac;                        // if 0 use frame1, if 1 use frame2,
.float lerptime;                        //      mix together for values between

// Called by addentities after the filter and before the entity is actually
// drawn. Do your interpolation and animation in here. Should return one of
// the PREDRAW_* constants.
.float() predraw;
#endif

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

#ifdef CSQC
void() CL_TE_Lightning2;
#endif

#ifdef CSQC
float(string cmd) CSQC_ConsoleCommand;
// float(float evtype, float scanx, float chary, float devid) CSQC_InputEvent;
// __used void() CSQC_Input_Frame;
float(float save, float take, vector dir) CSQC_Parse_Damage;
void() CSQC_Parse_Event;
// void(string printmsg, float printlvl) CSQC_Parse_Print;
void() CSQC_DrawViewModel;
void(float vwidth, float vheight, float notmenu) CSQC_UpdateView;
void(float isnew) CSQC_Ent_Update;
void() CSQC_Ent_Remove;
void() CSQC_WorldLoaded;
void(float apilevel, string enginename, float engineversion) CSQC_Init;
__wrap float(string str) CSQC_ConsoleCommand;
#endif

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

#ifdef CSQC
//----------------------------------------------------------------------
// stubs for server-side entry functions (silences compiler warnings)
//----------------------------------------------------------------------
void() main = sub_null;
void() StartFrame = sub_null;
void() PlayerPreThink = sub_null;
void() PlayerPostThink = sub_null;
void() ClientKill = sub_null;
void() ClientConnect = sub_null;
void() PutClientInServer = sub_null;
void() ClientDisconnect = sub_null;
void() SetNewParms = sub_null;
void() SetChangeParms = sub_null;
#endif

#ifdef CSQC
//----------------------------------------------------------------------
void() CL_TE_Lightning2 =
{
        local vector start, end;

        start_x = ReadCoord ();
        start_y = ReadCoord ();
        start_z = ReadCoord ();
        end_x = ReadCoord ();
        end_y = ReadCoord ();
        end_z = ReadCoord ();

        // TODO CEV
        dprint (sprintf("CL_TE_Lightning2: time %g\n", time));
        te_lightning2 (view_player, start, end);
};
#endif

#ifdef CSQC
//----------------------------------------------------------------------
// Stubs for extra CSQC functions (not all supported)
//----------------------------------------------------------------------

// Can query or check anything types on the console here
float(string cmd) CSQC_ConsoleCommand =
{
        tokenize_console (cmd);
        return FALSE;
};

// Can query/check keyboard/mouse/joystick input with this function
// For key events, scanx is one of the KEY_* values
// chary is the character code (chr2str to shove it into a string)
// For mouse events then x+y are the mouse delta/position values
/*
float(float evtype, float scanx, float chary, float devid) CSQC_InputEvent =
{
        return FALSE;
};
*/

// Called just before each time clientcommandframe is updated. You
// can edit the input_* globals in order to apply your own player
// inputs within csqc, which may allow you a convienient way to
// pass certain info to ssqc.
#if 0
__used void() CSQC_Input_Frame =
{
        if (serverkeyfloat(SERVERKEY_PAUSESTATE))
                return;

        if (intermission == TRUE)
                return;

        // rework user input, copying something like QuakeSpasm's always run
        // feature here. This turns the +speed button into a hold-to-walk
        // button when cl_run is 0 (when FTE's always run setting is on).
        // -- CEV
        /*
        if (world_clrun == FALSE)
        {
        */
                local float m;

                // we care about x and y, not so much z -- CEV
                if (input_movevalues_x)
                {
                        m = fabs (input_movevalues_x);
                        if (m > 400.0f)
                                input_movevalues_x = PM_WALKSPEED *
                                        (input_movevalues_x / m);
                        else if (m == 400.0f)
                                input_movevalues_x = PM_RUNSPEED *
                                        (input_movevalues_x / m);
                        else if (m != 0)
                                input_movevalues_x = PM_RUNSPEED *
                                        (input_movevalues_x / m);
                }

                if (input_movevalues_y)
                {
                        m = fabs (input_movevalues_y);
                        if (m > 400.0f)
                                input_movevalues_y = PM_WALKSPEED *
                                        (input_movevalues_y / m);
                        else if (m == 400.0f)
                                input_movevalues_y = PM_RUNSPEED *
                                        (input_movevalues_y / m);
                        else if (m != 0)
                                input_movevalues_y = PM_RUNSPEED *
                                        (input_movevalues_y / m);
                }
        /*
        }
        */
};
#endif

// This is linked to client dmg_take / dmg_save / dmg_inflictor fields
// returning TRUE will block the red flash damage stuff
float(float save, float take, vector dir) CSQC_Parse_Damage =
{
        dprint (sprintf("CSQC_Parse_Damage: save %g, take %g, dir %v\n",
                save, take, dir));
        painfinishtime = time + 0.2;
        return FALSE;
};

//----------------------------------------------------------------------
// Can query/check server MSG events
// CSQC_Parse_Event is called when the client sees a
// #define svcfte_cgamepacket (83) message from the server
// Not supported for DP, is called from only QSS/FTE
//----------------------------------------------------------------------
void() CSQC_Parse_Event =
{
        local float event = ReadByte ();
        switch (event)
        {
                case EVENT_INTERMISSION:
                        intermission = ReadByte ();
                        return;
                case EVENT_CSHIFT_FADE:
                        csf_fade_netreceive (view_player);
                        return;
                case EVENT_CSHIFT_SET:
                        csf_set_netreceive (view_player);
                        return;
                case EVENT_LIGHTNING2:
                        CL_TE_Lightning2 ();
                        return;
                default:
                        dprint ("CSQC_Parse_Event: received unknown event "
                                "type!\n");
                        return;
        }
};

//----------------------------------------------------------------------
// Can intercept printed messages from the server (top of screen)
// printlvl (text filtering) 0=low, 1=medium, 2=high, 3=chat
// con_notifytime = amount of time the text remains on screen
// ONLY define this function, if doing something with the text!!
//----------------------------------------------------------------------
/*
void(string printmsg, float printlvl) CSQC_Parse_Print =
{
        print (printmsg);
};
*/

//----------------------------------------------------------------------
// TODO CEV
//----------------------------------------------------------------------
void() CSQC_DrawViewModel =
{
        // don't draw viewmodel when the player is climbing -- CEV
        if (view_player.pm_flags & PMF_CLIMB)
                return;

        // don't draw viewmodel when climbing a ladder -- CEV
        if (view_player.pm_flags & PMF_ONLADDER)
                return;

        local float newframe = view_player.weaponframe;

        local float view_entity_item_index = 0;
        switch (view_entity.weapon)
        {
                case 1: view_entity_item_index = view_entity.inventory1; break;
                case 2: view_entity_item_index = view_entity.inventory2; break;
                case 3: view_entity_item_index = view_entity.inventory3; break;
                case 4: view_entity_item_index = view_entity.inventory4; break;
                case 5: view_entity_item_index = view_entity.inventory5; break;
                case 6: view_entity_item_index = view_entity.inventory6; break;
                case 7: view_entity_item_index = view_entity.inventory7; break;
                case 8: view_entity_item_index = view_entity.inventory8; break;
        }

        local float view_player_item_index = 0;
        switch (view_player.weapon)
        {
                case 1: view_player_item_index = view_player.inventory1; break;
                case 2: view_player_item_index = view_player.inventory2; break;
                case 3: view_player_item_index = view_player.inventory3; break;
                case 4: view_player_item_index = view_player.inventory4; break;
                case 5: view_player_item_index = view_player.inventory5; break;
                case 6: view_player_item_index = view_player.inventory6; break;
                case 7: view_player_item_index = view_player.inventory7; break;
                case 8: view_player_item_index = view_player.inventory8; break;
        }

        local item_info_t item = item_info[view_player_item_index];

        if (view_player.weapon != view_entity.weapon ||
                view_player_item_index != view_entity_item_index)
        {
                // changed entirely
                view_entity.weapon = view_player.weapon;
                switch (view_player.weapon)
                {
                        case 1: view_entity.inventory1 = view_player.inventory1;
                                break;
                        case 2: view_entity.inventory2 = view_player.inventory2;
                                break;
                        case 3: view_entity.inventory3 = view_player.inventory3;
                                break;
                        case 4: view_entity.inventory4 = view_player.inventory4;
                                break;
                        case 5: view_entity.inventory5 = view_player.inventory5;
                                break;
                        case 6: view_entity.inventory6 = view_player.inventory6;
                                break;
                        case 7: view_entity.inventory7 = view_player.inventory7;
                                break;
                        case 8: view_entity.inventory8 = view_player.inventory8;
                                break;
                }

                #if 0
                dprint (sprintf("CSQC_DrawViewModel: .weapon %g, "
                        "index %g, frame %g, viewmodel %s\n",
                        view_player.weapon, view_player_item_index,
                        newframe, item.view_model));
                #endif

                // need to grab skin from item.option for armor -- CEV
                if (view_player_item_index >= ITEM_SEQ_ARMOR_GREEN &&
                        view_player_item_index <= ITEM_SEQ_ARMOR_SHARD)
                {
                        view_entity.skin = item.option;
                }
                else if (view_entity.skin)
                {
                        view_entity.skin = 0;
                }

                view_entity.frame2 = view_entity.frame = newframe;
                view_entity.lerptime = time;
                setmodel (view_entity, item.view_model);
        }
        else if (newframe != view_entity.frame)
        {
                view_entity.frame2 = view_entity.frame;
                view_entity.frame = newframe;
                view_entity.lerptime = time;
        }

        view_entity.lerpfrac = 1 - (time - view_entity.lerptime) * 10;

        // apply user's configured viewmodel offset -- CEV
        // TODO CEV this has gotta be slow
        view_entity.origin = [
                item.view_origin_offset.x + autocvar(cl_gunx, 0),
                item.view_origin_offset.y + autocvar(cl_guny, 0),
                item.view_origin_offset.z + autocvar(cl_gunz, 0)];
        view_entity.angles = [
                item.view_angles_offset.x + autocvar(cl_gunanglex, 0),
                item.view_angles_offset.y + autocvar(cl_gunangley, 0),
                item.view_angles_offset.z + autocvar(gl_gunanglez, 0)];

        if (view_player.items & IT_INVISIBILITY)
                view_entity.alpha = 0.5f;
        else if (view_entity.alpha == 0.5f)
                view_entity.alpha = 1.0f;

        addentity (view_entity);
};

//----------------------------------------------------------------------
void(float vwidth, float vheight, float notmenu) CSQC_UpdateView =
{
        local vector ssize = [vwidth, vheight, 0];

        clearscene ();

        setproperty (VF_MIN, '0 0');
        setproperty (VF_SIZE, ssize);
        setproperty (VF_DRAWENGINESBAR, FALSE);

        if (view_player)
        {
                view_player.renderflags |= RF_EXTERNALMODEL;
                addentities (DRAWMASK_ENGINE | DRAWMASK_NORMAL);

                // read our smoothed & predicted view origin
                setproperty (VF_ORIGIN, view_origin);

                makevectors (view_angles);

                if (intermission)
                {
                        // camera wobble
                        view_angles_x += autocvar(v_ipitch_level, 0.3) *
                                sin(time * autocvar(v_ipitch_cycle, 1));
                        view_angles_y += autocvar(v_iyaw_level, 0.3) *
                                sin(time * autocvar(v_iyaw_cycle, 2));
                        view_angles_z += autocvar(v_iroll_level, 0.1) *
                                sin(time * autocvar(v_iroll_cycle, 0.5));

                        setproperty (VF_DRAWCROSSHAIR, FALSE);
                        setproperty (VF_ANGLES, view_angles);
                        SetListener (view_origin, v_forward, v_right, v_up);
                }
                else
                {
                        // view_angle adjustments done in player_predraw -- CEV
                        setproperty (VF_DRAWCROSSHAIR, TRUE);
                        setproperty (VF_ANGLES, view_angles);
                        SetListener (view_origin, v_forward, v_right, v_up);

                        // draw view model when not invisible & when alive
                        if (view_player.health > 0)
                        {
                                setproperty (VF_VIEWENTITY, view_player.entnum);
                                CSQC_DrawViewModel ();
                        }
                }
        }
        else
        {
                dprint ("CSQC_UpdateView: no local player!\n");
                if (intermission)
                {
                        setproperty (VF_DRAWCROSSHAIR, FALSE);
                        addentities (DRAWMASK_ENGINE | DRAWMASK_NORMAL);
                }
                else
                {
                        setproperty (VF_DRAWCROSSHAIR, TRUE);
                        addentities (DRAWMASK_ENGINE | DRAWMASK_VIEWMODEL |
                                DRAWMASK_NORMAL);
                }
        }

        renderscene ();

        #if 0
        local entity t = world;
        while ((t = nextent(t)))
        {
                dprint (sprintf("CSQC_UpdateView: found %s num %g, model %s\n",
                t.classname, t.entnum, modelnameforindex(t.modelindex)));
        }
        #endif

        // Used on intermission screen later
        if (!intermission)
                intermission_time = time;

        // Read deathmatch variable and create csprogs coop variable
        // csprogs has no knowledge of the coop variable
        deathmatch = stof (serverkey("deathmatch"));
        coop = !deathmatch && maxclients > 1;

        // Draw the HUDs, scoreboards, and any requested colorshifts
        CSQC_DrawHud (ssize, sb_showscores);
        CSQC_DrawScores (ssize, sb_showscores);
        csf_draw (ssize);
};

//----------------------------------------------------------------------
// Handle incoming MSG_ENTITY data from the server
// Entities are networked in this way either because they need movement
// prediction or they can affect movement prediction -- CEV
//----------------------------------------------------------------------
void(float isnew) CSQC_Ent_Update =
{
        local float ctype = ReadByte ();

        if (self.classtype && self.classtype != ctype)
        {
                if (self.classtype != ctype)
                {
                        dprint (sprintf("CSQC_Ent_Update: classtype "
                                "mismatch, cleaning up etype %g num %g\n",
                                ctype, self.entnum));

                        // TODO CEV
                        if (view_player == self)
                                view_player = world;

                        setmodel (self, "");
                        self.predraw = __NULL__;

                        if (self.queflag)
                                base_entity_que_rem (self, self.queflag);

                        isnew = TRUE;
                        self.classtype = ctype;
                }
        }
        else
        {
                self.classtype = ctype;
        }

        switch (self.classtype)
        {
                case CT_PLAYER:
                        player_netreceive (isnew);
                        return;
                case CT_FUNC_BOB:
                case CT_MISC_BOB:
                        base_func_bob_netreceive (isnew);
                        return;
                case CT_FUNC_BOSSGATE:
                        func_bossgate_netreceive (isnew);
                        return;
                case CT_FUNC_BUTTON:
                        func_button_netreceive (isnew);
                        return;
                case CT_FUNC_DOOR:
                        func_door_netreceive (isnew);
                        return;
                case CT_FUNC_DOOR_SECRET:
                        func_door_secret_netreceive (isnew);
                        return;
                case CT_FUNC_ELVTR_BUTTON:
                        func_elvtr_button_netreceive (isnew);
                        return;
                case CT_FUNC_EPISODEGATE:
                        func_episodegate_netreceive (isnew);
                        return;
                case CT_FUNC_EXPLOBOX:
                        func_explobox_netreceive (isnew);
                        return;
                case CT_FUNC_FALL:
                        func_fall_netreceive (isnew);
                        return;
                case CT_FUNC_FALL2:
                        func_fall2_netreceive (isnew);
                        return;
                #if 0
                case CT_FUNC_ILLUSIONARY:
                        func_illusionary_netreceive (isnew);
                        return;
                #endif
                case CT_FUNC_LASER:
                        func_laser_netreceive (isnew);
                        return;
                case CT_FUNC_MOVEWALL:
                        func_movewall_netreceive (isnew);
                        return;
                case CT_FUNC_NEW_PLAT:
                        func_new_plat_netreceive (isnew);
                        return;
                case CT_FUNC_PLAT:
                        func_plat_netreceive (isnew);
                        return;
                case CT_FUNC_ROTATE_DOOR:
                        func_rotate_door_netreceive (isnew);
                        return;
                case CT_FUNC_ROTATE_ENTITY:
                        func_rotate_entity_netreceive (isnew);
                        return;
                case CT_FUNC_ROTATE_TRAIN:
                        func_rotate_train_netreceive (isnew);
                        return;
                case CT_FUNC_TOGGLEVISIBLEWALL:
                        func_togglevisiblewall_netreceive (isnew);
                        return;
                case CT_FUNC_TOGGLEWALL:
                        func_togglewall_netreceive (isnew);
                        return;
                case CT_FUNC_TRAIN:
                        func_train_netreceive (isnew);
                        return;
                case CT_FUNC_WALL:
                        func_wall_netreceive (isnew);
                        return;
                case CT_ITEM_AMMO_CELLS:
                        item_cells_netreceive (isnew);
                        return;
                case CT_ITEM_AMMO_ROCKETS:
                        item_rockets_netreceive (isnew);
                        return;
                case CT_ITEM_AMMO_SHELLS:
                        item_shells_netreceive (isnew);
                        return;
                case CT_ITEM_AMMO_SPIKES:
                        item_spikes_netreceive (isnew);
                        return;
                case CT_ITEM_ARMOR_GREEN:
                        item_armor1_netreceive (isnew);
                        return;
                case CT_ITEM_ARMOR_YELLOW:
                        item_armor2_netreceive (isnew);
                        return;
                case CT_ITEM_ARMOR_RED:
                        item_armorInv_netreceive (isnew);
                        return;
                case CT_ITEM_ARMOR_SHARD:
                        item_armor_shard_netreceive (isnew);
                        return;
                case CT_ITEM_AXE:
                        weapon_axe_netreceive (isnew);
                        return;
                case CT_ITEM_BACKPACK:
                        item_backpack_netreceive (isnew);
                        return;
                case CT_ITEM_ENVIROSUIT:
                        item_artifact_envirosuit_netreceive (isnew);
                        return;
                case CT_ITEM_GIB1:
                        base_item_gib_netreceive (isnew, item_gib1_init);
                        return;
                case CT_ITEM_GIB2:
                        base_item_gib_netreceive (isnew, item_gib2_init);
                        return;
                case CT_ITEM_GIB3:
                        base_item_gib_netreceive (isnew, item_gib3_init);
                        return;
                case CT_ITEM_GRENADE_LAUNCHER:
                        weapon_grenadelauncher_netreceive (isnew);
                        return;
                case CT_ITEM_HEAD_ARMY:
                        base_item_gib_netreceive (isnew, item_head_army_init);
                        return;
                case CT_ITEM_HEAD_DEMON:
                        base_item_gib_netreceive (isnew, item_head_demon_init);
                        return;
                case CT_ITEM_HEAD_DOG:
                        base_item_gib_netreceive (isnew, item_head_dog_init);
                        return;
                case CT_ITEM_HEAD_ENFORCER:
                        base_item_gib_netreceive (isnew,
                                item_head_enforcer_init);
                        return;
                case CT_ITEM_HEAD_HELLKNIGHT:
                        base_item_gib_netreceive (isnew,
                                item_head_hell_knight_init);
                        return;
                case CT_ITEM_HEAD_KNIGHT:
                        base_item_gib_netreceive (isnew, item_head_knight_init);
                        return;
                case CT_ITEM_HEAD_OGRE:
                        base_item_gib_netreceive (isnew, item_head_ogre_init);
                        return;
                case CT_ITEM_HEAD_PLAYER:
                        base_item_gib_netreceive (isnew, item_head_player_init);
                        return;
                case CT_ITEM_HEAD_SHALRATH:
                        base_item_gib_netreceive (isnew,
                                item_head_shalrath_init);
                        return;
                case CT_ITEM_HEAD_SHAMBLER:
                        base_item_gib_netreceive (isnew,
                                item_head_shambler_init);
                        return;
                case CT_ITEM_HEAD_WIZARD:
                        base_item_gib_netreceive (isnew, item_head_wizard_init);
                        return;
                case CT_ITEM_HEAD_ZOMBIE:
                        base_item_gib_netreceive (isnew, item_head_zombie_init);
                        return;
                case CT_ITEM_HEALTH:
                        item_health_netreceive (isnew);
                        return;
                case CT_ITEM_HEALTH_VIAL:
                        item_health_vial_netreceive (isnew);
                        return;
                case CT_ITEM_INVISIBILITY:
                        item_artifact_invisibility_netreceive (isnew);
                        return;
                case CT_ITEM_INVULNERABILITY:
                        item_artifact_invulnerability_netreceive (isnew);
                        return;
                case CT_ITEM_KEY1:
                        item_key1_netreceive (isnew);
                        return;
                case CT_ITEM_KEY2:
                        item_key2_netreceive (isnew);
                        return;
                case CT_ITEM_KEY_CUSTOM:
                        item_key_custom_netreceive (isnew);
                        return;
                case CT_ITEM_LIGHTNING_GUN:
                        weapon_lightning_netreceive (isnew);
                        return;
                case CT_ITEM_NAILGUN:
                        weapon_nailgun_netreceive (isnew);
                        return;
                case CT_ITEM_QUAD:
                        item_artifact_super_damage_netreceive (isnew);
                        return;
                case CT_ITEM_ROCKET_LAUNCHER:
                        weapon_rocketlauncher_netreceive (isnew);
                        return;
                case CT_ITEM_RUNE:
                        item_sigil_netreceive (isnew);
                        return;
                case CT_ITEM_SHOTGUN:
                        weapon_shotgun_netreceive (isnew);
                        return;
                case CT_ITEM_SUPER_NAILGUN:
                        weapon_supernailgun_netreceive (isnew);
                        return;
                case CT_ITEM_SUPER_SHOTGUN:
                        weapon_supershotgun_netreceive (isnew);
                        return;
                case CT_MISC_EXPLOBOX:
                case CT_MISC_EXPLOBOX2:
                        base_explobox_netreceive (isnew);
                        return;
                case CT_MISC_MODEL:
                        base_misc_model_netreceive (isnew);
                        return;
                case CT_MISC_ROTATE_OBJECT:
                        rotate_object_netreceive (isnew);
                        return;
                case CT_MISC_ROTATE_OBJECT_CONTINUOUSLY:
                        rotate_object_continuously_netreceive (isnew);
                        return;
                case CT_MONSTER_BOSS_CHTHON:
                        monster_boss_netreceive (isnew);
                        return;
                case CT_MONSTER_BOSS_CHTHON2:
                        monster_boss2_netreceive (isnew);
                        return;
                case CT_MONSTER_BOSS_OLDONE:
                        monster_oldone_netreceive (isnew);
                        return;
                case CT_MONSTER_BOSS_OLDONE2:
                        monster_oldone2_netreceive (isnew);
                        return;
                case CT_MONSTER_DEATHKNIGHT:
                        monster_hell_knight_netreceive (isnew);
                        return;
                case CT_MONSTER_DOG:
                        monster_dog_netreceive (isnew);
                        return;
                case CT_MONSTER_ENFORCER:
                        monster_enforcer_netreceive (isnew);
                        return;
                case CT_MONSTER_FIEND:
                        monster_demon1_netreceive (isnew);
                        return;
                case CT_MONSTER_FISH:
                        monster_fish_netreceive (isnew);
                        return;
                case CT_MONSTER_GRUNT:
                        monster_army_netreceive (isnew);
                        return;
                case CT_MONSTER_KNIGHT:
                        monster_knight_netreceive (isnew);
                        return;
                case CT_MONSTER_OGRE:
                        monster_ogre_netreceive (isnew);
                        return;
                case CT_MONSTER_OGRE_MARKSMAN:
                        monster_ogre_marksman_netreceive (isnew);
                        return;
                case CT_MONSTER_SCRAG:
                        monster_wizard_netreceive (isnew);
                        return;
                case CT_MONSTER_SHAMBLER:
                        monster_shambler_netreceive (isnew);
                        return;
                case CT_MONSTER_VORE:
                        monster_shalrath_netreceive (isnew);
                        return;
                case CT_MONSTER_ZOMBIE:
                        monster_zombie_netreceive (isnew);
                        return;
                case CT_TRIGGER_LADDER:
                        trigger_ladder_netreceive (isnew);
                        return;
                case CT_TRIGGER_PUSH:
                case CT_TRIGGER_PUSH_CUSTOM:
                        base_trigger_push_netreceive (isnew);
                        return;
                case CT_TRIGGER_SETGRAVITY:
                        trigger_setgravity_netreceive (isnew);
                        return;
                case CT_TRIGGER_TELEPORT:
                        trigger_teleport_netreceive (isnew);
                        return;
                default:
                        dprint (sprintf("CSQC_Ent_Update: received unknown "
                                "classtype %f!\n", self.classtype));
                        return;
        }
};

//----------------------------------------------------------------------
// Entity has been removed on the server
//----------------------------------------------------------------------
void() CSQC_Ent_Remove =
{
        /*
        if (view_player == self)
                view_player = world;
        */

        setmodel (self, "");
        self.predraw = __NULL__;

        base_entity_remove (self);
};

//----------------------------------------------------------------------
void() CSQC_WorldLoaded =
{
        // set latched-at-map-load-time cvars -- CEV
        world_latched_cvars ();

        // now read (some, not many) entities from the map file.
        // the following is based on CSQC_WorldLoaded in CSQCTest
        // and CSQC_WorldLoaded in Nuclide -- CEV
        local string token = "";
        getentitytoken (0);

        while (1)
        {
                token = getentitytoken ();
                if (token == "")
                        break;

                if (token != "{")
                {
                        dprint (sprintf("CSQC_WorldLoaded: bad entity data!, "
                                "token %s\n", token));
                        return;
                }

                if (base_entity_parsemapdata() == FALSE)
                {
                        dprint (sprintf("CSQC_WorldLoaded: bad map data %s!\n",
                                token));
                        return;
                }
        }
};

//----------------------------------------------------------------------
// Registers HUD gfx images (all setup in string arrays)
//----------------------------------------------------------------------
void(float apilevel, string enginename, float engineversion) CSQC_Init =
{
        local float i, wadonly;

        // precache from gfx.wad ONLY!?!
        wadonly = TRUE;

        // Cache all string tables
        for (i = 0; i < 14; i++)
        {
                // HUD background images (320 wide+)
                if (i < backgrd.length)
                        precache_pic (backgrd[i], wadonly);
                // Large 24x24 brown/red numbers
                if (i < number.length)
                {
                        precache_pic (number[i], wadonly);
                        precache_pic (anumber[i], wadonly);
                }
                // Large 24x24 extra font characters (intermission)
                if (i < extrachar.length)
                        precache_pic (extrachar[i], wadonly);
                // Large 24x24 player face
                if (i < facetab.length)
                        precache_pic (facetab[i], wadonly);
                // Large 24x24 icons
                if (i < sbitems.length)
                        precache_pic (sbitems[i], wadonly);
                // Small 16x16 icons
                if (i < ibitems.length)
                        precache_pic (ibitems[i], wadonly);
                // Special 8x16 runes
                if (i < ibrunes.length)
                        precache_pic (ibrunes[i], wadonly);
                // All weapon setups (on/off/flashing)
                if (i < wpnnames.length)
                {
                        precache_pic(strcat(wpnselect[0], wpnnames[i]),wadonly);
                        precache_pic(strcat(wpnselect[1], wpnnames[i]),wadonly);
                        precache_pic(strcat(wpnflash[0], wpnnames[i]), wadonly);
                        precache_pic(strcat(wpnflash[1], wpnnames[i]), wadonly);
                        precache_pic(strcat(wpnflash[2], wpnnames[i]), wadonly);
                        precache_pic(strcat(wpnflash[3], wpnnames[i]), wadonly);
                        precache_pic(strcat(wpnflash[4], wpnnames[i]), wadonly);
                }
        }
};

//----------------------------------------------------------------------
// Wrapper for CSQC_ConsoleCommand to show different scoreboards
//----------------------------------------------------------------------
__wrap float(string str) CSQC_ConsoleCommand =
{
        if (prior(str))
                return TRUE;

        string c = argv(0);

        if (c == "+showscores")
                sb_showscores |= 1;
        else if (c == "-showscores")
                sb_showscores &= ~1;
        else if (c == "+showteamscores")
                sb_showscores |= 2;
        else if (c == "-showteamscores")
                sb_showscores &= ~2;
        else
                return FALSE;

        return TRUE;
};
#endif