replaced all uses of sv_player with host_client->edict (because sv_player was often...

fixed a number of botclient crashes relating to invalid client->edict pointers after a level change
now sets client->spawned = true on botclients when freshly spawned (they were already being set correctly on level change)
DP_SV_BOTCLIENT now works properly

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@4744 d7cf8633-e32d-0410-b094-e92efae38249

diff --git a/host.c b/host.c
index e1bf554098494ec2b10160f1e989a3c713480c7f..194ba39f3e474b8fe9b03fc6c798a6a82076fca2 100644 (file)
--- a/host.c
+++ b/host.c
@@ -406,6 +406,9 @@ void SV_DropClient(qboolean crash)
        int i;
        Con_Printf("Client \"%s\" dropped\n", host_client->name);
 
+       // make sure edict is not corrupt (from a level change for example)
+       host_client->edict = EDICT_NUM(host_client - svs.clients + 1);
+
        if (host_client->netconnection)
        {
                // free the client (the body stays around)
@@ -434,8 +437,6 @@ void SV_DropClient(qboolean crash)
        }
 
        // remove leaving player from scoreboard
-       // clear a fields that matter to DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS, and also frags
-       ED_ClearEdict(host_client->edict);
        //host_client->edict->v->netname = PR_SetString(host_client->name);
        //if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
        //      val->_float = 0;
@@ -463,6 +464,13 @@ void SV_DropClient(qboolean crash)
                EntityFrame4_FreeDatabase(host_client->entitydatabase4);
        if (host_client->entitydatabase5)
                EntityFrame5_FreeDatabase(host_client->entitydatabase5);
+       
+       if (sv.active)
+       {
+               // clear a fields that matter to DP_SV_CLIENTNAME and DP_SV_CLIENTCOLORS, and also frags
+               ED_ClearEdict(host_client->edict);
+       }
+       
        // clear the client struct (this sets active to false)
        memset(host_client, 0, sizeof(*host_client));
 

diff --git a/host_cmd.c b/host_cmd.c
index 91aefcb1c71c6933cf9408b838b203364d50231f..dda37a1f23d328f3b1598121f924ac889066b7cb 100644 (file)
--- a/host_cmd.c
+++ b/host_cmd.c
@@ -116,17 +116,14 @@ void Host_God_f (void)
                return;
        }
 
-       if (!sv_player)
-               return;
-
        if (!allowcheats)
        {
                SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
                return;
        }
 
-       sv_player->v->flags = (int)sv_player->v->flags ^ FL_GODMODE;
-       if (!((int)sv_player->v->flags & FL_GODMODE) )
+       host_client->edict->v->flags = (int)host_client->edict->v->flags ^ FL_GODMODE;
+       if (!((int)host_client->edict->v->flags & FL_GODMODE) )
                SV_ClientPrint("godmode OFF\n");
        else
                SV_ClientPrint("godmode ON\n");
@@ -140,17 +137,14 @@ void Host_Notarget_f (void)
                return;
        }
 
-       if (!sv_player)
-               return;
-
        if (!allowcheats)
        {
                SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
                return;
        }
 
-       sv_player->v->flags = (int)sv_player->v->flags ^ FL_NOTARGET;
-       if (!((int)sv_player->v->flags & FL_NOTARGET) )
+       host_client->edict->v->flags = (int)host_client->edict->v->flags ^ FL_NOTARGET;
+       if (!((int)host_client->edict->v->flags & FL_NOTARGET) )
                SV_ClientPrint("notarget OFF\n");
        else
                SV_ClientPrint("notarget ON\n");
@@ -166,25 +160,22 @@ void Host_Noclip_f (void)
                return;
        }
 
-       if (!sv_player)
-               return;
-
        if (!allowcheats)
        {
                SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
                return;
        }
 
-       if (sv_player->v->movetype != MOVETYPE_NOCLIP)
+       if (host_client->edict->v->movetype != MOVETYPE_NOCLIP)
        {
                noclip_anglehack = true;
-               sv_player->v->movetype = MOVETYPE_NOCLIP;
+               host_client->edict->v->movetype = MOVETYPE_NOCLIP;
                SV_ClientPrint("noclip ON\n");
        }
        else
        {
                noclip_anglehack = false;
-               sv_player->v->movetype = MOVETYPE_WALK;
+               host_client->edict->v->movetype = MOVETYPE_WALK;
                SV_ClientPrint("noclip OFF\n");
        }
 }
@@ -204,23 +195,20 @@ void Host_Fly_f (void)
                return;
        }
 
-       if (!sv_player)
-               return;
-
        if (!allowcheats)
        {
                SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
                return;
        }
 
-       if (sv_player->v->movetype != MOVETYPE_FLY)
+       if (host_client->edict->v->movetype != MOVETYPE_FLY)
        {
-               sv_player->v->movetype = MOVETYPE_FLY;
+               host_client->edict->v->movetype = MOVETYPE_FLY;
                SV_ClientPrint("flymode ON\n");
        }
        else
        {
-               sv_player->v->movetype = MOVETYPE_WALK;
+               host_client->edict->v->movetype = MOVETYPE_WALK;
                SV_ClientPrint("flymode OFF\n");
        }
 }
@@ -963,22 +951,22 @@ void Host_Color_f(void)
                return;
        }
 
-       if (sv_player && (f = ED_FindFunction ("SV_ChangeTeam")) && (SV_ChangeTeam = (func_t)(f - pr_functions)))
+       if (host_client->edict && (f = ED_FindFunction ("SV_ChangeTeam")) && (SV_ChangeTeam = (func_t)(f - pr_functions)))
        {
                Con_DPrint("Calling SV_ChangeTeam\n");
                pr_global_struct->time = sv.time;
                pr_globals[OFS_PARM0] = playercolor;
-               pr_global_struct->self = EDICT_TO_PROG(sv_player);
+               pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
                PR_ExecuteProgram (SV_ChangeTeam, "QC function SV_ChangeTeam is missing");
        }
        else
        {
                eval_t *val;
-               if (sv_player)
+               if (host_client->edict)
                {
-                       if ((val = GETEDICTFIELDVALUE(sv_player, eval_clientcolors)))
+                       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
                                val->_float = playercolor;
-                       sv_player->v->team = bottom + 1;
+                       host_client->edict->v->team = bottom + 1;
                }
                host_client->colors = playercolor;
                if (host_client->old_colors != host_client->colors)
@@ -1030,7 +1018,7 @@ void Host_Kill_f (void)
                return;
        }
 
-       if (!sv_player || sv_player->v->health <= 0)
+       if (host_client->edict->v->health <= 0)
        {
                SV_ClientPrint("Can't suicide -- already dead!\n");
                return;
@@ -1096,7 +1084,7 @@ static void Host_PModel_f (void)
                return;
        }
 
-       if (sv_player && (val = GETEDICTFIELDVALUE(sv_player, eval_pmodel)))
+       if (host_client->edict && (val = GETEDICTFIELDVALUE(host_client->edict, eval_pmodel)))
                val->_float = i;
 }
 
@@ -1155,12 +1143,6 @@ void Host_Spawn_f (void)
                return;
        }
 
-       if (!sv_player)
-       {
-               Con_Print("Host_Spawn: no edict??\n");
-               return;
-       }
-
        // reset name change timer again because they might want to change name
        // again in the first 5 seconds after connecting
        host_client->nametime = 0;
@@ -1181,16 +1163,16 @@ void Host_Spawn_f (void)
                {
                        Con_DPrint("Calling RestoreGame\n");
                        pr_global_struct->time = sv.time;
-                       pr_global_struct->self = EDICT_TO_PROG(sv_player);
+                       pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
                        PR_ExecuteProgram (RestoreGame, "QC function RestoreGame is missing");
                }
        }
        else
        {
                // set up the edict
-               ED_ClearEdict(sv_player);
+               ED_ClearEdict(host_client->edict);
 
-               //Con_Printf("Host_Spawn_f: host_client->edict->netname = %s, sv_player->netname = %s, host_client->name = %s\n", PR_GetString(host_client->edict->v->netname), PR_GetString(sv_player->v->netname), host_client->name);
+               //Con_Printf("Host_Spawn_f: host_client->edict->netname = %s, host_client->edict->netname = %s, host_client->name = %s\n", PR_GetString(host_client->edict->v->netname), PR_GetString(host_client->edict->v->netname), host_client->name);
 
                // copy spawn parms out of the client_t
                for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
@@ -1198,7 +1180,7 @@ void Host_Spawn_f (void)
 
                // call the spawn function
                pr_global_struct->time = sv.time;
-               pr_global_struct->self = EDICT_TO_PROG(sv_player);
+               pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
                PR_ExecuteProgram (pr_global_struct->ClientConnect, "QC function ClientConnect is missing");
 
                if ((Sys_DoubleTime() - host_client->connecttime) <= sv.time)
@@ -1258,11 +1240,11 @@ void Host_Spawn_f (void)
        // and it won't happen if the game was just loaded, so you wind up
        // with a permanent head tilt
        MSG_WriteByte (&host_client->message, svc_setangle);
-       MSG_WriteAngle (&host_client->message, sv_player->v->angles[0], sv.protocol);
-       MSG_WriteAngle (&host_client->message, sv_player->v->angles[1], sv.protocol);
+       MSG_WriteAngle (&host_client->message, host_client->edict->v->angles[0], sv.protocol);
+       MSG_WriteAngle (&host_client->message, host_client->edict->v->angles[1], sv.protocol);
        MSG_WriteAngle (&host_client->message, 0, sv.protocol);
 
-       SV_WriteClientdataToMessage (sv_player, &host_client->message);
+       SV_WriteClientdataToMessage (host_client->edict, &host_client->message);
 
        MSG_WriteByte (&host_client->message, svc_signonnum);
        MSG_WriteByte (&host_client->message, 3);
@@ -1391,9 +1373,6 @@ void Host_Give_f (void)
                return;
        }
 
-       if (!sv_player)
-               return;
-
        if (!allowcheats)
        {
                SV_ClientPrint("No cheats allowed, use sv_cheats 1 and restart level to enable.\n");
@@ -1421,113 +1400,113 @@ void Host_Give_f (void)
                        if (t[0] == '6')
                        {
                                if (t[1] == 'a')
-                                       sv_player->v->items = (int)sv_player->v->items | HIT_PROXIMITY_GUN;
+                                       host_client->edict->v->items = (int)host_client->edict->v->items | HIT_PROXIMITY_GUN;
                                else
-                                       sv_player->v->items = (int)sv_player->v->items | IT_GRENADE_LAUNCHER;
+                                       host_client->edict->v->items = (int)host_client->edict->v->items | IT_GRENADE_LAUNCHER;
                        }
                        else if (t[0] == '9')
-                               sv_player->v->items = (int)sv_player->v->items | HIT_LASER_CANNON;
+                               host_client->edict->v->items = (int)host_client->edict->v->items | HIT_LASER_CANNON;
                        else if (t[0] == '0')
-                               sv_player->v->items = (int)sv_player->v->items | HIT_MJOLNIR;
+                               host_client->edict->v->items = (int)host_client->edict->v->items | HIT_MJOLNIR;
                        else if (t[0] >= '2')
-                               sv_player->v->items = (int)sv_player->v->items | (IT_SHOTGUN << (t[0] - '2'));
+                               host_client->edict->v->items = (int)host_client->edict->v->items | (IT_SHOTGUN << (t[0] - '2'));
                }
                else
                {
                        if (t[0] >= '2')
-                               sv_player->v->items = (int)sv_player->v->items | (IT_SHOTGUN << (t[0] - '2'));
+                               host_client->edict->v->items = (int)host_client->edict->v->items | (IT_SHOTGUN << (t[0] - '2'));
                }
                break;
 
        case 's':
-               if (gamemode == GAME_ROGUE && (val = GETEDICTFIELDVALUE(sv_player, eval_ammo_shells1)))
+               if (gamemode == GAME_ROGUE && (val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_shells1)))
                        val->_float = v;
 
-               sv_player->v->ammo_shells = v;
+               host_client->edict->v->ammo_shells = v;
                break;
        case 'n':
                if (gamemode == GAME_ROGUE)
                {
-                       if ((val = GETEDICTFIELDVALUE(sv_player, eval_ammo_nails1)))
+                       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_nails1)))
                        {
                                val->_float = v;
-                               if (sv_player->v->weapon <= IT_LIGHTNING)
-                                       sv_player->v->ammo_nails = v;
+                               if (host_client->edict->v->weapon <= IT_LIGHTNING)
+                                       host_client->edict->v->ammo_nails = v;
                        }
                }
                else
                {
-                       sv_player->v->ammo_nails = v;
+                       host_client->edict->v->ammo_nails = v;
                }
                break;
        case 'l':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(sv_player, eval_ammo_lava_nails);
+                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_lava_nails);
                        if (val)
                        {
                                val->_float = v;
-                               if (sv_player->v->weapon > IT_LIGHTNING)
-                                       sv_player->v->ammo_nails = v;
+                               if (host_client->edict->v->weapon > IT_LIGHTNING)
+                                       host_client->edict->v->ammo_nails = v;
                        }
                }
                break;
        case 'r':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(sv_player, eval_ammo_rockets1);
+                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_rockets1);
                        if (val)
                        {
                                val->_float = v;
-                               if (sv_player->v->weapon <= IT_LIGHTNING)
-                                       sv_player->v->ammo_rockets = v;
+                               if (host_client->edict->v->weapon <= IT_LIGHTNING)
+                                       host_client->edict->v->ammo_rockets = v;
                        }
                }
                else
                {
-                       sv_player->v->ammo_rockets = v;
+                       host_client->edict->v->ammo_rockets = v;
                }
                break;
        case 'm':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(sv_player, eval_ammo_multi_rockets);
+                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_multi_rockets);
                        if (val)
                        {
                                val->_float = v;
-                               if (sv_player->v->weapon > IT_LIGHTNING)
-                                       sv_player->v->ammo_rockets = v;
+                               if (host_client->edict->v->weapon > IT_LIGHTNING)
+                                       host_client->edict->v->ammo_rockets = v;
                        }
                }
                break;
        case 'h':
-               sv_player->v->health = v;
+               host_client->edict->v->health = v;
                break;
        case 'c':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(sv_player, eval_ammo_cells1);
+                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_cells1);
                        if (val)
                        {
                                val->_float = v;
-                               if (sv_player->v->weapon <= IT_LIGHTNING)
-                                       sv_player->v->ammo_cells = v;
+                               if (host_client->edict->v->weapon <= IT_LIGHTNING)
+                                       host_client->edict->v->ammo_cells = v;
                        }
                }
                else
                {
-                       sv_player->v->ammo_cells = v;
+                       host_client->edict->v->ammo_cells = v;
                }
                break;
        case 'p':
                if (gamemode == GAME_ROGUE)
                {
-                       val = GETEDICTFIELDVALUE(sv_player, eval_ammo_plasma);
+                       val = GETEDICTFIELDVALUE(host_client->edict, eval_ammo_plasma);
                        if (val)
                        {
                                val->_float = v;
-                               if (sv_player->v->weapon > IT_LIGHTNING)
-                                       sv_player->v->ammo_cells = v;
+                               if (host_client->edict->v->weapon > IT_LIGHTNING)
+                                       host_client->edict->v->ammo_cells = v;
                        }
                }
                break;

diff --git a/netconn.c b/netconn.c
index 211bd9296113aa515cf561013af3ba8ea77e7f7f..e3fe3123a17369ce93d596ff566e8c3e24db504d 100755 (executable)
--- a/netconn.c
+++ b/netconn.c
@@ -1357,7 +1357,6 @@ int NetConn_ServerParsePacket(lhnetsocket_t *mysocket, qbyte *data, int length,
                {
                        if (host_client->netconnection && host_client->netconnection->mysocket == mysocket && !LHNETADDRESS_Compare(&host_client->netconnection->peeraddress, peeraddress))
                        {
-                               sv_player = host_client->edict;
                                if ((ret = NetConn_ReceivedMessage(host_client->netconnection, data, length)) == 2)
                                        SV_ReadClientMessage();
                                return ret;
@@ -1382,7 +1381,6 @@ void NetConn_ServerFrame(void)
                if (host_client->netconnection && realtime > host_client->netconnection->timeout && LHNETADDRESS_GetAddressType(&host_client->netconnection->peeraddress) != LHNETADDRESSTYPE_LOOP)
                {
                        Con_Printf("Client \"%s\" connection timed out\n", host_client->name);
-                       sv_player = host_client->edict;
                        SV_DropClient(false);
                }
        }

diff --git a/sv_main.c b/sv_main.c
index 52ae5327d947a3bbbc826e14c4fb3a640d21bea3..a1dab0066d348063dc6c7d59b7bf0f383dc655a3 100644 (file)
--- a/sv_main.c
+++ b/sv_main.c
@@ -298,7 +298,7 @@ void SV_SendServerinfo (client_t *client)
 
                // call the spawn function
                pr_global_struct->time = sv.time;
-               pr_global_struct->self = EDICT_TO_PROG(sv_player);
+               pr_global_struct->self = EDICT_TO_PROG(client->edict);
                PR_ExecuteProgram (pr_global_struct->ClientConnect, "QC function ClientConnect is missing");
                PR_ExecuteProgram (pr_global_struct->PutClientInServer, "QC function PutClientInServer is missing");
                host_client->spawned = true;
@@ -413,6 +413,8 @@ void SV_ConnectClient (int clientnum, netconn_t *netconnection)
        // not been set up by the qc yet
        if (client->netconnection)
                SV_SendServerinfo (client);
+       else
+               client->spawned = true;
 }
 
 
@@ -1152,15 +1154,15 @@ void SV_UpdateToReliableMessages (void)
        for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
        {
                // update the host_client fields we care about according to the entity fields
-               sv_player = EDICT_NUM(i+1);
+               host_client->edict = EDICT_NUM(i+1);
 
                // DP_SV_CLIENTNAME
-               name = PR_GetString(sv_player->v->netname);
+               name = PR_GetString(host_client->edict->v->netname);
                if (name == NULL)
                        name = "";
                // always point the string back at host_client->name to keep it safe
                strlcpy (host_client->name, name, sizeof (host_client->name));
-               sv_player->v->netname = PR_SetString(host_client->name);
+               host_client->edict->v->netname = PR_SetString(host_client->name);
                if (strcmp(host_client->old_name, host_client->name))
                {
                        if (host_client->spawned)
@@ -1174,7 +1176,7 @@ void SV_UpdateToReliableMessages (void)
 
                // DP_SV_CLIENTCOLORS
                // this is always found (since it's added by the progs loader)
-               if ((val = GETEDICTFIELDVALUE(sv_player, eval_clientcolors)))
+               if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_clientcolors)))
                        host_client->colors = (int)val->_float;
                if (host_client->old_colors != host_client->colors)
                {
@@ -1186,7 +1188,7 @@ void SV_UpdateToReliableMessages (void)
                }
 
                // frags
-               host_client->frags = (int)sv_player->v->frags;
+               host_client->frags = (int)host_client->edict->v->frags;
                if (host_client->old_frags != host_client->frags)
                {
                        host_client->old_frags = host_client->frags;
@@ -1642,6 +1644,10 @@ void SV_SpawnServer (const char *server)
                ent->v = (void *)((qbyte *)sv.edictsfields + i * pr_edict_size);
        }
 
+       // fix up client->edict pointers for returning clients right away...
+       for (i = 0, host_client = svs.clients;i < svs.maxclients;i++, host_client++)
+               host_client->edict = EDICT_NUM(i + 1);
+
        sv.datagram.maxsize = sizeof(sv.datagram_buf);
        sv.datagram.cursize = 0;
        sv.datagram.data = sv.datagram_buf;

diff --git a/sv_phys.c b/sv_phys.c
index 8c6681d7ad65c697df65e5109d4513dfeefd613e..c03cdb26a36ceba9099e45af558718e6fd041e9f 100644 (file)
--- a/sv_phys.c
+++ b/sv_phys.c
@@ -1092,7 +1092,8 @@ void SV_WalkMove (edict_t *ent)
                if (clip & 2 && sv_wallfriction.integer)
                        SV_WallFriction (ent, stepnormal);
        }
-       else if (!sv_gameplayfix_stepdown.integer || !oldonground || start_velocity[2] > 0 || ((int)ent->v->flags & FL_ONGROUND) || ent->v->waterlevel >= 2)
+       // skip out if stepdown is enabled, moving downward, not in water, and the move started onground and ended offground
+       else if (!(sv_gameplayfix_stepdown.integer && ent->v->waterlevel < 2 && start_velocity[2] < (1.0 / 32.0) && oldonground && !((int)ent->v->flags & FL_ONGROUND)))
                return;
 
        // move down
@@ -1233,6 +1234,10 @@ void SV_Physics_Toss (edict_t *ent)
        if (!SV_RunThink (ent))
                return;
 
+       // don't stick to ground if onground and moving upward
+       if (ent->v->velocity[2] >= (1.0 / 32.0) && ((int)ent->v->flags & FL_ONGROUND))
+               ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
+
 // if onground, return without moving
        if ((int)ent->v->flags & FL_ONGROUND)
        {
@@ -1351,6 +1356,10 @@ will fall if the floor is pulled out from under them.
 */
 void SV_Physics_Step (edict_t *ent)
 {
+       // don't stick to ground if onground and moving upward
+       if (ent->v->velocity[2] >= (1.0 / 32.0) && ((int)ent->v->flags & FL_ONGROUND))
+               ent->v->flags = (int)ent->v->flags & ~FL_ONGROUND;
+
        // freefall if not onground/fly/swim
        if (!((int)ent->v->flags & (FL_ONGROUND | FL_FLY | FL_SWIM)))
        {
@@ -1407,8 +1416,6 @@ void SV_Physics (void)
                {
                        if (i > 0)
                        {
-                               if (!svs.clients[i-1].spawned)
-                                       continue;
                                // connected slot
                                // call standard client pre-think
                                SV_CheckVelocity (ent);

diff --git a/sv_user.c b/sv_user.c
index 332f725e191e32dc3badda9dc5cfb32bb672c5f1..a2057f07beded4e88396bf693660579562d71e98 100644 (file)
--- a/sv_user.c
+++ b/sv_user.c
@@ -21,8 +21,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
 #include "quakedef.h"
 
-edict_t *sv_player;
-
 cvar_t sv_edgefriction = {0, "edgefriction", "2"};
 cvar_t sv_deltacompress = {0, "sv_deltacompress", "1"};
 cvar_t sv_idealpitchscale = {0, "sv_idealpitchscale","0.8"};
@@ -47,24 +45,24 @@ void SV_SetIdealPitch (void)
        int             i, j;
        int             step, dir, steps;
 
-       if (!((int)sv_player->v->flags & FL_ONGROUND))
+       if (!((int)host_client->edict->v->flags & FL_ONGROUND))
                return;
 
-       angleval = sv_player->v->angles[YAW] * M_PI*2 / 360;
+       angleval = host_client->edict->v->angles[YAW] * M_PI*2 / 360;
        sinval = sin(angleval);
        cosval = cos(angleval);
 
        for (i=0 ; i<MAX_FORWARD ; i++)
        {
-               top[0] = sv_player->v->origin[0] + cosval*(i+3)*12;
-               top[1] = sv_player->v->origin[1] + sinval*(i+3)*12;
-               top[2] = sv_player->v->origin[2] + sv_player->v->view_ofs[2];
+               top[0] = host_client->edict->v->origin[0] + cosval*(i+3)*12;
+               top[1] = host_client->edict->v->origin[1] + sinval*(i+3)*12;
+               top[2] = host_client->edict->v->origin[2] + host_client->edict->v->view_ofs[2];
 
                bottom[0] = top[0];
                bottom[1] = top[1];
                bottom[2] = top[2] - 160;
 
-               tr = SV_Move (top, vec3_origin, vec3_origin, bottom, MOVE_NOMONSTERS, sv_player);
+               tr = SV_Move (top, vec3_origin, vec3_origin, bottom, MOVE_NOMONSTERS, host_client->edict);
                // if looking at a wall, leave ideal the way is was
                if (tr.startsolid)
                        return;
@@ -94,13 +92,13 @@ void SV_SetIdealPitch (void)
 
        if (!dir)
        {
-               sv_player->v->idealpitch = 0;
+               host_client->edict->v->idealpitch = 0;
                return;
        }
 
        if (steps < 2)
                return;
-       sv_player->v->idealpitch = -dir * sv_idealpitchscale.value;
+       host_client->edict->v->idealpitch = -dir * sv_idealpitchscale.value;
 }
 
 #if 1
@@ -121,17 +119,17 @@ void SV_UserFriction (void)
        vec3_t start, stop;
        trace_t trace;
 
-       speed = sqrt(sv_player->v->velocity[0]*sv_player->v->velocity[0]+sv_player->v->velocity[1]*sv_player->v->velocity[1]);
+       speed = sqrt(host_client->edict->v->velocity[0]*host_client->edict->v->velocity[0]+host_client->edict->v->velocity[1]*host_client->edict->v->velocity[1]);
        if (!speed)
                return;
 
        // if the leading edge is over a dropoff, increase friction
-       start[0] = stop[0] = sv_player->v->origin[0] + sv_player->v->velocity[0]/speed*16;
-       start[1] = stop[1] = sv_player->v->origin[1] + sv_player->v->velocity[1]/speed*16;
-       start[2] = sv_player->v->origin[2] + sv_player->v->mins[2];
+       start[0] = stop[0] = host_client->edict->v->origin[0] + host_client->edict->v->velocity[0]/speed*16;
+       start[1] = stop[1] = host_client->edict->v->origin[1] + host_client->edict->v->velocity[1]/speed*16;
+       start[2] = host_client->edict->v->origin[2] + host_client->edict->v->mins[2];
        stop[2] = start[2] - 34;
 
-       trace = SV_Move (start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, sv_player);
+       trace = SV_Move (start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, host_client->edict);
 
        if (trace.fraction == 1.0)
                friction = sv_friction.value*sv_edgefriction.value;
@@ -147,7 +145,7 @@ void SV_UserFriction (void)
        else
                newspeed /= speed;
 
-       VectorScale(sv_player->v->velocity, newspeed, sv_player->v->velocity);
+       VectorScale(host_client->edict->v->velocity, newspeed, host_client->edict->v->velocity);
 }
 
 /*
@@ -160,7 +158,7 @@ void SV_Accelerate (void)
        int i;
        float addspeed, accelspeed, currentspeed;
 
-       currentspeed = DotProduct (sv_player->v->velocity, wishdir);
+       currentspeed = DotProduct (host_client->edict->v->velocity, wishdir);
        addspeed = wishspeed - currentspeed;
        if (addspeed <= 0)
                return;
@@ -169,7 +167,7 @@ void SV_Accelerate (void)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)
-               sv_player->v->velocity[i] += accelspeed*wishdir[i];
+               host_client->edict->v->velocity[i] += accelspeed*wishdir[i];
 }
 
 void SV_AirAccelerate (vec3_t wishveloc)
@@ -180,7 +178,7 @@ void SV_AirAccelerate (vec3_t wishveloc)
        wishspd = VectorNormalizeLength (wishveloc);
        if (wishspd > 30)
                wishspd = 30;
-       currentspeed = DotProduct (sv_player->v->velocity, wishveloc);
+       currentspeed = DotProduct (host_client->edict->v->velocity, wishveloc);
        addspeed = wishspd - currentspeed;
        if (addspeed <= 0)
                return;
@@ -189,7 +187,7 @@ void SV_AirAccelerate (vec3_t wishveloc)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)
-               sv_player->v->velocity[i] += accelspeed*wishveloc[i];
+               host_client->edict->v->velocity[i] += accelspeed*wishveloc[i];
 }
 
 
@@ -198,14 +196,14 @@ void DropPunchAngle (void)
        float len;
        eval_t *val;
 
-       len = VectorNormalizeLength (sv_player->v->punchangle);
+       len = VectorNormalizeLength (host_client->edict->v->punchangle);
 
        len -= 10*sv.frametime;
        if (len < 0)
                len = 0;
-       VectorScale (sv_player->v->punchangle, len, sv_player->v->punchangle);
+       VectorScale (host_client->edict->v->punchangle, len, host_client->edict->v->punchangle);
 
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_punchvector)))
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_punchvector)))
        {
                len = VectorNormalizeLength (val->vector);
 
@@ -226,16 +224,16 @@ void SV_FreeMove (void)
        int i;
        float wishspeed;
 
-       AngleVectors (sv_player->v->v_angle, forward, right, up);
+       AngleVectors (host_client->edict->v->v_angle, forward, right, up);
 
        for (i = 0; i < 3; i++)
-               sv_player->v->velocity[i] = forward[i] * cmd.forwardmove + right[i] * cmd.sidemove;
+               host_client->edict->v->velocity[i] = forward[i] * cmd.forwardmove + right[i] * cmd.sidemove;
 
-       sv_player->v->velocity[2] += cmd.upmove;
+       host_client->edict->v->velocity[2] += cmd.upmove;
 
-       wishspeed = VectorLength(sv_player->v->velocity);
+       wishspeed = VectorLength(host_client->edict->v->velocity);
        if (wishspeed > sv_maxspeed.value)
-               VectorScale(sv_player->v->velocity, sv_maxspeed.value / wishspeed, sv_player->v->velocity);
+               VectorScale(host_client->edict->v->velocity, sv_maxspeed.value / wishspeed, host_client->edict->v->velocity);
 }
 
 /*
@@ -251,7 +249,7 @@ void SV_WaterMove (void)
        float speed, newspeed, wishspeed, addspeed, accelspeed, temp;
 
        // user intentions
-       AngleVectors (sv_player->v->v_angle, forward, right, up);
+       AngleVectors (host_client->edict->v->v_angle, forward, right, up);
 
        for (i=0 ; i<3 ; i++)
                wishvel[i] = forward[i]*cmd.forwardmove + right[i]*cmd.sidemove;
@@ -271,14 +269,14 @@ void SV_WaterMove (void)
        wishspeed *= 0.7;
 
        // water friction
-       speed = VectorLength(sv_player->v->velocity);
+       speed = VectorLength(host_client->edict->v->velocity);
        if (speed)
        {
                newspeed = speed - sv.frametime * speed * sv_friction.value;
                if (newspeed < 0)
                        newspeed = 0;
                temp = newspeed/speed;
-               VectorScale(sv_player->v->velocity, temp, sv_player->v->velocity);
+               VectorScale(host_client->edict->v->velocity, temp, host_client->edict->v->velocity);
        }
        else
                newspeed = 0;
@@ -297,18 +295,18 @@ void SV_WaterMove (void)
                accelspeed = addspeed;
 
        for (i=0 ; i<3 ; i++)
-               sv_player->v->velocity[i] += accelspeed * wishvel[i];
+               host_client->edict->v->velocity[i] += accelspeed * wishvel[i];
 }
 
 void SV_WaterJump (void)
 {
-       if (sv.time > sv_player->v->teleport_time || !sv_player->v->waterlevel)
+       if (sv.time > host_client->edict->v->teleport_time || !host_client->edict->v->waterlevel)
        {
-               sv_player->v->flags = (int)sv_player->v->flags & ~FL_WATERJUMP;
-               sv_player->v->teleport_time = 0;
+               host_client->edict->v->flags = (int)host_client->edict->v->flags & ~FL_WATERJUMP;
+               host_client->edict->v->teleport_time = 0;
        }
-       sv_player->v->velocity[0] = sv_player->v->movedir[0];
-       sv_player->v->velocity[1] = sv_player->v->movedir[1];
+       host_client->edict->v->velocity[0] = host_client->edict->v->movedir[0];
+       host_client->edict->v->velocity[1] = host_client->edict->v->movedir[1];
 }
 
 
@@ -326,20 +324,20 @@ void SV_AirMove (void)
 
        // LordHavoc: correct quake movement speed bug when looking up/down
        wishvel[0] = wishvel[2] = 0;
-       wishvel[1] = sv_player->v->angles[1];
+       wishvel[1] = host_client->edict->v->angles[1];
        AngleVectors (wishvel, forward, right, up);
 
        fmove = cmd.forwardmove;
        smove = cmd.sidemove;
 
 // hack to not let you back into teleporter
-       if (sv.time < sv_player->v->teleport_time && fmove < 0)
+       if (sv.time < host_client->edict->v->teleport_time && fmove < 0)
                fmove = 0;
 
        for (i=0 ; i<3 ; i++)
                wishvel[i] = forward[i]*fmove + right[i]*smove;
 
-       if ((int)sv_player->v->movetype != MOVETYPE_WALK)
+       if ((int)host_client->edict->v->movetype != MOVETYPE_WALK)
                wishvel[2] += cmd.upmove;
 
        VectorCopy (wishvel, wishdir);
@@ -351,10 +349,10 @@ void SV_AirMove (void)
                wishspeed = sv_maxspeed.value;
        }
 
-       if (sv_player->v->movetype == MOVETYPE_NOCLIP)
+       if (host_client->edict->v->movetype == MOVETYPE_NOCLIP)
        {
                // noclip
-               VectorCopy (wishvel, sv_player->v->velocity);
+               VectorCopy (wishvel, host_client->edict->v->velocity);
        }
        else if ( onground )
        {
@@ -380,30 +378,30 @@ void SV_ClientThink (void)
 {
        vec3_t v_angle;
 
-       if (sv_player->v->movetype == MOVETYPE_NONE)
+       if (host_client->edict->v->movetype == MOVETYPE_NONE)
                return;
 
-       onground = (int)sv_player->v->flags & FL_ONGROUND;
+       onground = (int)host_client->edict->v->flags & FL_ONGROUND;
 
        DropPunchAngle ();
 
        // if dead, behave differently
-       if (sv_player->v->health <= 0)
+       if (host_client->edict->v->health <= 0)
                return;
 
        cmd = host_client->cmd;
 
        // angles
        // show 1/3 the pitch angle and all the roll angle
-       VectorAdd (sv_player->v->v_angle, sv_player->v->punchangle, v_angle);
-       sv_player->v->angles[ROLL] = V_CalcRoll (sv_player->v->angles, sv_player->v->velocity)*4;
-       if (!sv_player->v->fixangle)
+       VectorAdd (host_client->edict->v->v_angle, host_client->edict->v->punchangle, v_angle);
+       host_client->edict->v->angles[ROLL] = V_CalcRoll (host_client->edict->v->angles, host_client->edict->v->velocity)*4;
+       if (!host_client->edict->v->fixangle)
        {
-               sv_player->v->angles[PITCH] = -v_angle[PITCH]/3;
-               sv_player->v->angles[YAW] = v_angle[YAW];
+               host_client->edict->v->angles[PITCH] = -v_angle[PITCH]/3;
+               host_client->edict->v->angles[YAW] = v_angle[YAW];
        }
 
-       if ( (int)sv_player->v->flags & FL_WATERJUMP )
+       if ( (int)host_client->edict->v->flags & FL_WATERJUMP )
        {
                SV_WaterJump ();
                return;
@@ -411,8 +409,8 @@ void SV_ClientThink (void)
 
        /*
        // Player is (somehow) outside of the map, or flying, or noclipping
-       if (sv_player->v->movetype != MOVETYPE_NOCLIP && (sv_player->v->movetype == MOVETYPE_FLY || SV_TestEntityPosition (sv_player)))
-       //if (sv_player->v->movetype == MOVETYPE_NOCLIP || sv_player->v->movetype == MOVETYPE_FLY || SV_TestEntityPosition (sv_player))
+       if (host_client->edict->v->movetype != MOVETYPE_NOCLIP && (host_client->edict->v->movetype == MOVETYPE_FLY || SV_TestEntityPosition (host_client->edict)))
+       //if (host_client->edict->v->movetype == MOVETYPE_NOCLIP || host_client->edict->v->movetype == MOVETYPE_FLY || SV_TestEntityPosition (host_client->edict))
        {
                SV_FreeMove ();
                return;
@@ -420,7 +418,7 @@ void SV_ClientThink (void)
        */
 
        // walk
-       if ((sv_player->v->waterlevel >= 2) && (sv_player->v->movetype != MOVETYPE_NOCLIP))
+       if ((host_client->edict->v->waterlevel >= 2) && (host_client->edict->v->movetype != MOVETYPE_NOCLIP))
        {
                SV_WaterMove ();
                return;
@@ -440,48 +438,48 @@ void SV_ClientThink(void)
        float wishspeed, f, limit;
        trace_t trace;
 
-       if (sv_player->v->movetype == MOVETYPE_NONE)
+       if (host_client->edict->v->movetype == MOVETYPE_NONE)
                return;
 
-       f = DotProduct(sv_player->v->punchangle, sv_player->v->punchangle);
+       f = DotProduct(host_client->edict->v->punchangle, host_client->edict->v->punchangle);
        if (f)
        {
                limit = sqrt(f);
                f = (limit - 10 * sv.frametime);
                f /= limit;
                f = max(0, f);
-               VectorScale(sv_player->v->punchangle, f, sv_player->v->punchangle);
+               VectorScale(host_client->edict->v->punchangle, f, host_client->edict->v->punchangle);
        }
 
        // if dead, behave differently
-       if (sv_player->v->health <= 0)
+       if (host_client->edict->v->health <= 0)
                return;
 
-       AngleVectors(sv_player->v->v_angle, v_forward, v_right, v_up);
+       AngleVectors(host_client->edict->v->v_angle, v_forward, v_right, v_up);
        // show 1/3 the pitch angle and all the roll angle
-       f = DotProduct(sv_player->v->velocity, v_right) * (1.0 / cl_rollspeed.value);
-       sv_player->v->angles[2] = bound(-1, f, 1) * cl_rollangle.value * 4;
-       if (!sv_player->v->fixangle)
+       f = DotProduct(host_client->edict->v->velocity, v_right) * (1.0 / cl_rollspeed.value);
+       host_client->edict->v->angles[2] = bound(-1, f, 1) * cl_rollangle.value * 4;
+       if (!host_client->edict->v->fixangle)
        {
-               sv_player->v->angles[0] = (sv_player->v->v_angle[0] + sv_player->v->punchangle[0]) * -0.333;
-               sv_player->v->angles[1] = sv_player->v->v_angle[1] + sv_player->v->punchangle[1];
+               host_client->edict->v->angles[0] = (host_client->edict->v->v_angle[0] + host_client->edict->v->punchangle[0]) * -0.333;
+               host_client->edict->v->angles[1] = host_client->edict->v->v_angle[1] + host_client->edict->v->punchangle[1];
        }
 
-       if ((int)sv_player->v->flags & FL_WATERJUMP)
+       if ((int)host_client->edict->v->flags & FL_WATERJUMP)
        {
-               sv_player->v->velocity[0] = sv_player->v->movedir[0];
-               sv_player->v->velocity[1] = sv_player->v->movedir[1];
-               if (sv.time > sv_player->v->teleport_time || sv_player->v->waterlevel == 0)
+               host_client->edict->v->velocity[0] = host_client->edict->v->movedir[0];
+               host_client->edict->v->velocity[1] = host_client->edict->v->movedir[1];
+               if (sv.time > host_client->edict->v->teleport_time || host_client->edict->v->waterlevel == 0)
                {
-                       sv_player->v->flags = (int)sv_player->v->flags - ((int)sv_player->v->flags & FL_WATERJUMP);
-                       sv_player->v->teleport_time = 0;
+                       host_client->edict->v->flags = (int)host_client->edict->v->flags - ((int)host_client->edict->v->flags & FL_WATERJUMP);
+                       host_client->edict->v->teleport_time = 0;
                }
                return;
        }
 
        // swim
-       if (sv_player->v->waterlevel >= 2)
-       if (sv_player->v->movetype != MOVETYPE_NOCLIP)
+       if (host_client->edict->v->waterlevel >= 2)
+       if (host_client->edict->v->movetype != MOVETYPE_NOCLIP)
        {
                if (host_client->cmd.forwardmove == 0 && host_client->cmd.sidemove == 0 && host_client->cmd.upmove == 0)
                {
@@ -501,12 +499,12 @@ void SV_ClientThink(void)
                wishspeed = min(wishspeed, sv_maxspeed.value) * 0.7;
 
                // water friction
-               f = VectorLength(sv_player->v->velocity) * (1 - sv.frametime * sv_friction.value);
+               f = VectorLength(host_client->edict->v->velocity) * (1 - sv.frametime * sv_friction.value);
                if (f > 0)
-                       f /= VectorLength(sv_player->v->velocity);
+                       f /= VectorLength(host_client->edict->v->velocity);
                else
                        f = 0;
-               VectorScale(sv_player->v->velocity, f, sv_player->v->velocity);
+               VectorScale(host_client->edict->v->velocity, f, host_client->edict->v->velocity);
 
                // water acceleration
                if (wishspeed <= f)
@@ -519,23 +517,23 @@ void SV_ClientThink(void)
                limit = VectorLength(wishvel);
                if (limit)
                        f /= limit;
-               VectorMA(sv_player->v->velocity, f, wishvel, sv_player->v->velocity);
+               VectorMA(host_client->edict->v->velocity, f, wishvel, host_client->edict->v->velocity);
                return;
        }
 
        // if not flying, move horizontally only
-       if (sv_player->v->movetype != MOVETYPE_FLY)
+       if (host_client->edict->v->movetype != MOVETYPE_FLY)
        {
                VectorClear(wishvel);
-               wishvel[1] = sv_player->v->v_angle[1];
+               wishvel[1] = host_client->edict->v->v_angle[1];
                AngleVectors(wishvel, v_forward, v_right, v_up);
        }
 
        // hack to not let you back into teleporter
        VectorScale(v_right, host_client->cmd.sidemove, wishvel);
-       if (sv.time >= sv_player->v->teleport_time || host_client->cmd.forwardmove > 0)
+       if (sv.time >= host_client->edict->v->teleport_time || host_client->cmd.forwardmove > 0)
                VectorMA(wishvel, host_client->cmd.forwardmove, v_forward, wishvel);
-       if (sv_player->v->movetype != MOVETYPE_WALK)
+       if (host_client->edict->v->movetype != MOVETYPE_WALK)
                wishvel[2] += cmd.upmove;
 
        VectorCopy(wishvel, wishdir);
@@ -544,31 +542,31 @@ void SV_ClientThink(void)
        if (wishspeed > sv_maxspeed.value)
                wishspeed = sv_maxspeed.value;
 
-       if (sv_player->v->movetype == MOVETYPE_NOCLIP || sv_player->v->movetype == MOVETYPE_FLY)
+       if (host_client->edict->v->movetype == MOVETYPE_NOCLIP || host_client->edict->v->movetype == MOVETYPE_FLY)
        {
-               VectorScale(wishdir, wishspeed, sv_player->v->velocity);
+               VectorScale(wishdir, wishspeed, host_client->edict->v->velocity);
                return;
        }
 
-       if ((int)sv_player->v->flags & FL_ONGROUND) // walking
+       if ((int)host_client->edict->v->flags & FL_ONGROUND) // walking
        {
                // friction
-               f = sv_player->v->velocity[0] * sv_player->v->velocity[0] + sv_player->v->velocity[1] * sv_player->v->velocity[1];
+               f = host_client->edict->v->velocity[0] * host_client->edict->v->velocity[0] + host_client->edict->v->velocity[1] * host_client->edict->v->velocity[1];
                if (f)
                {
                        f = sqrt(f);
-                       VectorCopy(sv_player->v->velocity, v);
+                       VectorCopy(host_client->edict->v->velocity, v);
                        v[2] = 0;
 
                        // if the leading edge is over a dropoff, increase friction
                        limit = 16.0f / f;
-                       VectorMA(sv_player->v->origin, limit, v, v);
-                       v[2] += sv_player->v->mins[2];
+                       VectorMA(host_client->edict->v->origin, limit, v, v);
+                       v[2] += host_client->edict->v->mins[2];
 
                        VectorCopy(v, start);
                        VectorCopy(v, stop);
                        stop[2] -= 34;
-                       trace = SV_Move(start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, sv_player);
+                       trace = SV_Move(start, vec3_origin, vec3_origin, stop, MOVE_NOMONSTERS, host_client->edict);
 
                        // apply friction
                        if (f < sv_stopspeed.value)
@@ -581,20 +579,20 @@ void SV_ClientThink(void)
 
                        if (f < 0)
                                f = 0;
-                       VectorScale(sv_player->v->velocity, f, sv_player->v->velocity);
+                       VectorScale(host_client->edict->v->velocity, f, host_client->edict->v->velocity);
                }
        }
        else // airborn
                wishspeed = min(wishspeed, 30);
 
        // ground or air acceleration
-       f = wishspeed - DotProduct(sv_player->v->velocity, wishdir);
+       f = wishspeed - DotProduct(host_client->edict->v->velocity, wishdir);
        if (f > 0)
        {
                limit = sv_accelerate.value * sv.frametime * wishspeed;
                if (f > limit)
                        f = limit;
-               VectorMA(sv_player->v->velocity, f, wishdir, sv_player->v->velocity);
+               VectorMA(host_client->edict->v->velocity, f, wishdir, host_client->edict->v->velocity);
        }
 }
 #endif
@@ -621,7 +619,7 @@ void SV_ReadClientMove (usercmd_t *move)
                total += host_client->ping_times[i];
        // can be used for prediction
        host_client->ping = total / NUM_PING_TIMES;
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_ping)))
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_ping)))
                val->_float = host_client->ping * 1000.0;
 
        // read current angles
@@ -637,7 +635,7 @@ void SV_ReadClientMove (usercmd_t *move)
                if (msg_badread) Con_Printf("SV_ReadClientMessage: badread at %s:%i\n", __FILE__, __LINE__);
        }
 
-       VectorCopy (angle, sv_player->v->v_angle);
+       VectorCopy (angle, host_client->edict->v->v_angle);
 
        // read movement
        if (msg_badread) Con_Printf("SV_ReadClientMessage: badread at %s:%i\n", __FILE__, __LINE__);
@@ -647,7 +645,7 @@ void SV_ReadClientMove (usercmd_t *move)
        if (msg_badread) Con_Printf("SV_ReadClientMessage: badread at %s:%i\n", __FILE__, __LINE__);
        move->upmove = MSG_ReadCoord16i ();
        if (msg_badread) Con_Printf("SV_ReadClientMessage: badread at %s:%i\n", __FILE__, __LINE__);
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_movement)))
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_movement)))
        {
                val->vector[0] = move->forwardmove;
                val->vector[1] = move->sidemove;
@@ -657,20 +655,20 @@ void SV_ReadClientMove (usercmd_t *move)
        // read buttons
        bits = MSG_ReadByte ();
        if (msg_badread) Con_Printf("SV_ReadClientMessage: badread at %s:%i\n", __FILE__, __LINE__);
-       sv_player->v->button0 = bits & 1;
-       sv_player->v->button2 = (bits & 2)>>1;
+       host_client->edict->v->button0 = bits & 1;
+       host_client->edict->v->button2 = (bits & 2)>>1;
        // LordHavoc: added 6 new buttons
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_button3))) val->_float = ((bits >> 2) & 1);
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_button4))) val->_float = ((bits >> 3) & 1);
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_button5))) val->_float = ((bits >> 4) & 1);
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_button6))) val->_float = ((bits >> 5) & 1);
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_button7))) val->_float = ((bits >> 6) & 1);
-       if ((val = GETEDICTFIELDVALUE(sv_player, eval_button8))) val->_float = ((bits >> 7) & 1);
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_button3))) val->_float = ((bits >> 2) & 1);
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_button4))) val->_float = ((bits >> 3) & 1);
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_button5))) val->_float = ((bits >> 4) & 1);
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_button6))) val->_float = ((bits >> 5) & 1);
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_button7))) val->_float = ((bits >> 6) & 1);
+       if ((val = GETEDICTFIELDVALUE(host_client->edict, eval_button8))) val->_float = ((bits >> 7) & 1);
 
        i = MSG_ReadByte ();
        if (msg_badread) Con_Printf("SV_ReadClientMessage: badread at %s:%i\n", __FILE__, __LINE__);
        if (i)
-               sv_player->v->impulse = i;
+               host_client->edict->v->impulse = i;
 }
 
 /*
@@ -799,26 +797,24 @@ void SV_RunClients (void)
 
                if (sv.frametime)
                {
-                       sv_player = host_client->edict;
-
                        // LordHavoc: QuakeC replacement for SV_ClientThink (player movement)
                        if (SV_PlayerPhysicsQC)
                        {
                                pr_global_struct->time = sv.time;
-                               pr_global_struct->self = EDICT_TO_PROG(sv_player);
+                               pr_global_struct->self = EDICT_TO_PROG(host_client->edict);
                                PR_ExecuteProgram ((func_t)(SV_PlayerPhysicsQC - pr_functions), "QC function SV_PlayerPhysics is missing");
                        }
                        else
                                SV_ClientThink ();
 
-                       SV_CheckVelocity(sv_player);
+                       SV_CheckVelocity(host_client->edict);
 
                        // LordHavoc: a hack to ensure that the (rather silly) id1 quakec
                        // player_run/player_stand1 does not horribly malfunction if the
                        // velocity becomes a number that is both == 0 and != 0
                        // (sounds to me like NaN but to be absolutely safe...)
-                       if (DotProduct(sv_player->v->velocity, sv_player->v->velocity) < 0.0001)
-                               VectorClear(sv_player->v->velocity);
+                       if (DotProduct(host_client->edict->v->velocity, host_client->edict->v->velocity) < 0.0001)
+                               VectorClear(host_client->edict->v->velocity);
                }
        }
 }