home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 113 / EnigmaAmiga113CD.iso / software / sviluppo / quakeworld_src / server / sv_user.c < prev    next >
C/C++ Source or Header  |  2000-06-17  |  43KB  |  1,703 lines
  1. /*
  2. Copyright (C) 1996-1997 Id Software, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU General Public License
  6. as published by the Free Software Foundation; either version 2
  7. of the License, or (at your option) any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
  12.  
  13. See the GNU General Public License for more details.
  14.  
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. */
  20. // sv_user.c -- server code for moving users
  21.  
  22. #include "qwsvdef.h"
  23.  
  24. edict_t *sv_player;
  25.  
  26. usercmd_t cmd;
  27.  
  28. cvar_t  cl_rollspeed = {"cl_rollspeed", "200"};
  29. cvar_t  cl_rollangle = {"cl_rollangle", "2.0"};
  30. cvar_t  sv_spectalk = {"sv_spectalk", "1"};
  31.  
  32. cvar_t  sv_mapcheck = {"sv_mapcheck", "1"};
  33.  
  34. extern  vec3_t  player_mins;
  35.  
  36. extern int fp_messages, fp_persecond, fp_secondsdead;
  37. extern char fp_msg[];
  38. extern cvar_t pausable;
  39.  
  40. /*
  41. ============================================================
  42.  
  43. USER STRINGCMD EXECUTION
  44.  
  45. host_client and sv_player will be valid.
  46. ============================================================
  47. */
  48.  
  49. /*
  50. ================
  51. SV_New_f
  52.  
  53. Sends the first message from the server to a connected client.
  54. This will be sent on the initial connection and upon each server load.
  55. ================
  56. */
  57. void SV_New_f (void)
  58. {
  59.   char    *gamedir;
  60.   int     playernum;
  61.  
  62.   if (host_client->state == cs_spawned)
  63.     return;
  64.  
  65.   host_client->state = cs_connected;
  66.   host_client->connection_started = realtime;
  67.  
  68.   // send the info about the new client to all connected clients
  69. //  SV_FullClientUpdate (host_client, &sv.reliable_datagram);
  70. //  host_client->sendinfo = true;
  71.  
  72.   gamedir = Info_ValueForKey (svs.info, "*gamedir");
  73.   if (!gamedir[0])
  74.     gamedir = "qw";
  75.  
  76. //NOTE:  This doesn't go through ClientReliableWrite since it's before the user
  77. //spawns.  These functions are written to not overflow
  78.   if (host_client->num_backbuf) {
  79.     Con_Printf("WARNING %s: [SV_New] Back buffered (%d0, clearing", host_client->name, host_client->netchan.message.cursize); 
  80.     host_client->num_backbuf = 0;
  81.     SZ_Clear(&host_client->netchan.message);
  82.   }
  83.  
  84.   // send the serverdata
  85.   MSG_WriteByte (&host_client->netchan.message, svc_serverdata);
  86.   MSG_WriteLong (&host_client->netchan.message, PROTOCOL_VERSION);
  87.   MSG_WriteLong (&host_client->netchan.message, svs.spawncount);
  88.   MSG_WriteString (&host_client->netchan.message, gamedir);
  89.  
  90.   playernum = NUM_FOR_EDICT(host_client->edict)-1;
  91.   if (host_client->spectator)
  92.     playernum |= 128;
  93.   MSG_WriteByte (&host_client->netchan.message, playernum);
  94.  
  95.   // send full levelname
  96.   MSG_WriteString (&host_client->netchan.message, PR_GetString(sv.edicts->v.message));
  97.  
  98.   // send the movevars
  99.   MSG_WriteFloat(&host_client->netchan.message, movevars.gravity);
  100.   MSG_WriteFloat(&host_client->netchan.message, movevars.stopspeed);
  101.   MSG_WriteFloat(&host_client->netchan.message, movevars.maxspeed);
  102.   MSG_WriteFloat(&host_client->netchan.message, movevars.spectatormaxspeed);
  103.   MSG_WriteFloat(&host_client->netchan.message, movevars.accelerate);
  104.   MSG_WriteFloat(&host_client->netchan.message, movevars.airaccelerate);
  105.   MSG_WriteFloat(&host_client->netchan.message, movevars.wateraccelerate);
  106.   MSG_WriteFloat(&host_client->netchan.message, movevars.friction);
  107.   MSG_WriteFloat(&host_client->netchan.message, movevars.waterfriction);
  108.   MSG_WriteFloat(&host_client->netchan.message, movevars.entgravity);
  109.  
  110.   // send music
  111.   MSG_WriteByte (&host_client->netchan.message, svc_cdtrack);
  112.   MSG_WriteByte (&host_client->netchan.message, sv.edicts->v.sounds);
  113.  
  114.   // send server info string
  115.   MSG_WriteByte (&host_client->netchan.message, svc_stufftext);
  116.   MSG_WriteString (&host_client->netchan.message, va("fullserverinfo \"%s\"\n", svs.info) );
  117. }
  118.  
  119. /*
  120. ==================
  121. SV_Soundlist_f
  122. ==================
  123. */
  124. void SV_Soundlist_f (void)
  125. {
  126.   char    **s;
  127.   int     n;
  128.  
  129.   if (host_client->state != cs_connected)
  130.   {
  131.     Con_Printf ("soundlist not valid -- allready spawned\n");
  132.     return;
  133.   }
  134.  
  135.   // handle the case of a level changing while a client was connecting
  136.   if ( atoi(Cmd_Argv(1)) != svs.spawncount )
  137.   {
  138.     Con_Printf ("SV_Soundlist_f from different level\n");
  139.     SV_New_f ();
  140.     return;
  141.   }
  142.  
  143.   n = atoi(Cmd_Argv(2));
  144.   
  145. //NOTE:  This doesn't go through ClientReliableWrite since it's before the user
  146. //spawns.  These functions are written to not overflow
  147.   if (host_client->num_backbuf) {
  148.     Con_Printf("WARNING %s: [SV_Soundlist] Back buffered (%d0, clearing", host_client->name, host_client->netchan.message.cursize); 
  149.     host_client->num_backbuf = 0;
  150.     SZ_Clear(&host_client->netchan.message);
  151.   }
  152.  
  153.   MSG_WriteByte (&host_client->netchan.message, svc_soundlist);
  154.   MSG_WriteByte (&host_client->netchan.message, n);
  155.   for (s = sv.sound_precache+1 + n ; 
  156.     *s && host_client->netchan.message.cursize < (MAX_MSGLEN/2); 
  157.     s++, n++)
  158.     MSG_WriteString (&host_client->netchan.message, *s);
  159.  
  160.   MSG_WriteByte (&host_client->netchan.message, 0);
  161.  
  162.   // next msg
  163.   if (*s)
  164.     MSG_WriteByte (&host_client->netchan.message, n);
  165.   else
  166.     MSG_WriteByte (&host_client->netchan.message, 0);
  167. }
  168.  
  169. /*
  170. ==================
  171. SV_Modellist_f
  172. ==================
  173. */
  174. void SV_Modellist_f (void)
  175. {
  176.   char    **s;
  177.   int     n;
  178.  
  179.   if (host_client->state != cs_connected)
  180.   {
  181.     Con_Printf ("modellist not valid -- allready spawned\n");
  182.     return;
  183.   }
  184.   
  185.   // handle the case of a level changing while a client was connecting
  186.   if ( atoi(Cmd_Argv(1)) != svs.spawncount )
  187.   {
  188.     Con_Printf ("SV_Modellist_f from different level\n");
  189.     SV_New_f ();
  190.     return;
  191.   }
  192.  
  193.   n = atoi(Cmd_Argv(2));
  194.  
  195. //NOTE:  This doesn't go through ClientReliableWrite since it's before the user
  196. //spawns.  These functions are written to not overflow
  197.   if (host_client->num_backbuf) {
  198.     Con_Printf("WARNING %s: [SV_Modellist] Back buffered (%d0, clearing", host_client->name, host_client->netchan.message.cursize); 
  199.     host_client->num_backbuf = 0;
  200.     SZ_Clear(&host_client->netchan.message);
  201.   }
  202.  
  203.   MSG_WriteByte (&host_client->netchan.message, svc_modellist);
  204.   MSG_WriteByte (&host_client->netchan.message, n);
  205.   for (s = sv.model_precache+1+n ; 
  206.     *s && host_client->netchan.message.cursize < (MAX_MSGLEN/2); 
  207.     s++, n++)
  208.     MSG_WriteString (&host_client->netchan.message, *s);
  209.   MSG_WriteByte (&host_client->netchan.message, 0);
  210.  
  211.   // next msg
  212.   if (*s)
  213.     MSG_WriteByte (&host_client->netchan.message, n);
  214.   else
  215.     MSG_WriteByte (&host_client->netchan.message, 0);
  216. }
  217.  
  218. /*
  219. ==================
  220. SV_PreSpawn_f
  221. ==================
  222. */
  223. void SV_PreSpawn_f (void)
  224. {
  225.   unsigned  buf;
  226.   unsigned  check;
  227.  
  228.   if (host_client->state != cs_connected)
  229.   {
  230.     Con_Printf ("prespawn not valid -- allready spawned\n");
  231.     return;
  232.   }
  233.   
  234.   // handle the case of a level changing while a client was connecting
  235.   if ( atoi(Cmd_Argv(1)) != svs.spawncount )
  236.   {
  237.     Con_Printf ("SV_PreSpawn_f from different level\n");
  238.     SV_New_f ();
  239.     return;
  240.   }
  241.   
  242.   buf = atoi(Cmd_Argv(2));
  243.   if (buf >= sv.num_signon_buffers)
  244.     buf = 0;
  245.  
  246.   if (!buf) {
  247.     // should be three numbers following containing checksums
  248.     check = atoi(Cmd_Argv(3));
  249.  
  250. //    Con_DPrintf("Client check = %d\n", check);
  251.  
  252.     if (sv_mapcheck.value && check != sv.worldmodel->checksum &&
  253.       check != sv.worldmodel->checksum2) {
  254.       SV_ClientPrintf (host_client, PRINT_HIGH, 
  255.         "Map model file does not match (%s), %i != %i/%i.\n"
  256.         "You may need a new version of the map, or the proper install files.\n",
  257.         sv.modelname, check, sv.worldmodel->checksum, sv.worldmodel->checksum2);
  258.       SV_DropClient (host_client); 
  259.       return;
  260.     }
  261.     host_client->checksum = check;
  262.   }
  263.  
  264. //NOTE:  This doesn't go through ClientReliableWrite since it's before the user
  265. //spawns.  These functions are written to not overflow
  266.   if (host_client->num_backbuf) {
  267.     Con_Printf("WARNING %s: [SV_PreSpawn] Back buffered (%d0, clearing", host_client->name, host_client->netchan.message.cursize); 
  268.     host_client->num_backbuf = 0;
  269.     SZ_Clear(&host_client->netchan.message);
  270.   }
  271.  
  272.   SZ_Write (&host_client->netchan.message, 
  273.     sv.signon_buffers[buf],
  274.     sv.signon_buffer_size[buf]);
  275.  
  276.   buf++;
  277.   if (buf == sv.num_signon_buffers)
  278.   { // all done prespawning
  279.     MSG_WriteByte (&host_client->netchan.message, svc_stufftext);
  280.     MSG_WriteString (&host_client->netchan.message, va("cmd spawn %i 0\n",svs.spawncount) );
  281.   }
  282.   else
  283.   { // need to prespawn more
  284.     MSG_WriteByte (&host_client->netchan.message, svc_stufftext);
  285.     MSG_WriteString (&host_client->netchan.message, 
  286.       va("cmd prespawn %i %i\n", svs.spawncount, buf) );
  287.   }
  288. }
  289.  
  290. /*
  291. ==================
  292. SV_Spawn_f
  293. ==================
  294. */
  295. void SV_Spawn_f (void)
  296. {
  297.   int   i;
  298.   client_t  *client;
  299.   edict_t *ent;
  300.   eval_t *val;
  301.   int n;
  302.  
  303.   if (host_client->state != cs_connected)
  304.   {
  305.     Con_Printf ("Spawn not valid -- allready spawned\n");
  306.     return;
  307.   }
  308.  
  309. // handle the case of a level changing while a client was connecting
  310.   if ( atoi(Cmd_Argv(1)) != svs.spawncount )
  311.   {
  312.     Con_Printf ("SV_Spawn_f from different level\n");
  313.     SV_New_f ();
  314.     return;
  315.   }
  316.  
  317.   n = atoi(Cmd_Argv(2));
  318.  
  319.   // make sure n is valid
  320.   if ( n < 0 || n > MAX_CLIENTS )
  321.   {
  322.     Con_Printf ("SV_Spawn_f invalid client start\n");
  323.     SV_New_f ();
  324.     return;
  325.   }
  326.  
  327.  
  328.   
  329. // send all current names, colors, and frag counts
  330.   // FIXME: is this a good thing?
  331.   SZ_Clear (&host_client->netchan.message);
  332.  
  333. // send current status of all other players
  334.  
  335.   // normally this could overflow, but no need to check due to backbuf
  336.   for (i=n, client = svs.clients + n ; i<MAX_CLIENTS ; i++, client++)
  337.     SV_FullClientUpdateToClient (client, host_client);
  338.   
  339. // send all current light styles
  340.   for (i=0 ; i<MAX_LIGHTSTYLES ; i++)
  341.   {
  342.     ClientReliableWrite_Begin (host_client, svc_lightstyle, 
  343.       3 + (sv.lightstyles[i] ? strlen(sv.lightstyles[i]) : 1));
  344.     ClientReliableWrite_Byte (host_client, (char)i);
  345.     ClientReliableWrite_String (host_client, sv.lightstyles[i]);
  346.   }
  347.  
  348.   // set up the edict
  349.   ent = host_client->edict;
  350.  
  351.   memset (&ent->v, 0, progs->entityfields * 4);
  352.   ent->v.colormap = NUM_FOR_EDICT(ent);
  353.   ent->v.team = 0;  // FIXME
  354.   ent->v.netname = PR_SetString(host_client->name);
  355.  
  356.   host_client->entgravity = 1.0;
  357.   val = GetEdictFieldValue(ent, "gravity");
  358.   if (val)
  359.     val->_float = 1.0;
  360.   host_client->maxspeed = sv_maxspeed.value;
  361.   val = GetEdictFieldValue(ent, "maxspeed");
  362.   if (val)
  363.     val->_float = sv_maxspeed.value;
  364.  
  365. //
  366. // force stats to be updated
  367. //
  368.   memset (host_client->stats, 0, sizeof(host_client->stats));
  369.  
  370.   ClientReliableWrite_Begin (host_client, svc_updatestatlong, 6);
  371.   ClientReliableWrite_Byte (host_client, STAT_TOTALSECRETS);
  372.   ClientReliableWrite_Long (host_client, pr_global_struct->total_secrets);
  373.  
  374.   ClientReliableWrite_Begin (host_client, svc_updatestatlong, 6);
  375.   ClientReliableWrite_Byte (host_client, STAT_TOTALMONSTERS);
  376.   ClientReliableWrite_Long (host_client, pr_global_struct->total_monsters);
  377.  
  378.   ClientReliableWrite_Begin (host_client, svc_updatestatlong, 6);
  379.   ClientReliableWrite_Byte (host_client, STAT_SECRETS);
  380.   ClientReliableWrite_Long (host_client, pr_global_struct->found_secrets);
  381.  
  382.   ClientReliableWrite_Begin (host_client, svc_updatestatlong, 6);
  383.   ClientReliableWrite_Byte (host_client, STAT_MONSTERS);
  384.   ClientReliableWrite_Long (host_client, pr_global_struct->killed_monsters);
  385.  
  386.   // get the client to check and download skins
  387.   // when that is completed, a begin command will be issued
  388.   ClientReliableWrite_Begin (host_client, svc_stufftext, 8);
  389.   ClientReliableWrite_String (host_client, "skins\n" );
  390.  
  391. }
  392.  
  393. /*
  394. ==================
  395. SV_SpawnSpectator
  396. ==================
  397. */
  398. void SV_SpawnSpectator (void)
  399. {
  400.   int   i;
  401.   edict_t *e;
  402.  
  403.   VectorCopy (vec3_origin, sv_player->v.origin);
  404.   VectorCopy (vec3_origin, sv_player->v.view_ofs);
  405.   sv_player->v.view_ofs[2] = 22;
  406.  
  407.   // search for an info_playerstart to spawn the spectator at
  408.   for (i=MAX_CLIENTS-1 ; i<sv.num_edicts ; i++)
  409.   {
  410.     e = EDICT_NUM(i);
  411.     if (!strcmp(PR_GetString(e->v.classname), "info_player_start"))
  412.     {
  413.       VectorCopy (e->v.origin, sv_player->v.origin);
  414.       return;
  415.     }
  416.   }
  417.  
  418. }
  419.  
  420. /*
  421. ==================
  422. SV_Begin_f
  423. ==================
  424. */
  425. void SV_Begin_f (void)
  426. {
  427.   unsigned pmodel = 0, emodel = 0;
  428.   int   i;
  429.  
  430.   if (host_client->state == cs_spawned)
  431.     return; // don't begin again
  432.  
  433.   host_client->state = cs_spawned;
  434.   
  435.   // handle the case of a level changing while a client was connecting
  436.   if ( atoi(Cmd_Argv(1)) != svs.spawncount )
  437.   {
  438.     Con_Printf ("SV_Begin_f from different level\n");
  439.     SV_New_f ();
  440.     return;
  441.   }
  442.  
  443.   if (host_client->spectator)
  444.   {
  445.     SV_SpawnSpectator ();
  446.  
  447.     if (SpectatorConnect) {
  448.       // copy spawn parms out of the client_t
  449.       for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
  450.         (&pr_global_struct->parm1)[i] = host_client->spawn_parms[i];
  451.   
  452.       // call the spawn function
  453.       pr_global_struct->time = sv.time;
  454.       pr_global_struct->self = EDICT_TO_PROG(sv_player);
  455.       PR_ExecuteProgram (SpectatorConnect);
  456.     }
  457.   }
  458.   else
  459.   {
  460.     // copy spawn parms out of the client_t
  461.     for (i=0 ; i< NUM_SPAWN_PARMS ; i++)
  462.       (&pr_global_struct->parm1)[i] = host_client->spawn_parms[i];
  463.  
  464.     // call the spawn function
  465.     pr_global_struct->time = sv.time;
  466.     pr_global_struct->self = EDICT_TO_PROG(sv_player);
  467.     PR_ExecuteProgram (pr_global_struct->ClientConnect);
  468.  
  469.     // actually spawn the player
  470.     pr_global_struct->time = sv.time;
  471.     pr_global_struct->self = EDICT_TO_PROG(sv_player);
  472.     PR_ExecuteProgram (pr_global_struct->PutClientInServer);  
  473.   }
  474.  
  475.   // clear the net statistics, because connecting gives a bogus picture
  476.   host_client->netchan.frame_latency = 0;
  477.   host_client->netchan.frame_rate = 0;
  478.   host_client->netchan.drop_count = 0;
  479.   host_client->netchan.good_count = 0;
  480.  
  481.   //check he's not cheating
  482.  
  483.   pmodel = atoi(Info_ValueForKey (host_client->userinfo, "pmodel"));
  484.   emodel = atoi(Info_ValueForKey (host_client->userinfo, "emodel"));
  485.  
  486.   if (pmodel != sv.model_player_checksum ||
  487.     emodel != sv.eyes_player_checksum)
  488.     SV_BroadcastPrintf (PRINT_HIGH, "%s WARNING: non standard player/eyes model detected\n", host_client->name);
  489.  
  490.   // if we are paused, tell the client
  491.   if (sv.paused) {
  492.     ClientReliableWrite_Begin (host_client, svc_setpause, 2);
  493.     ClientReliableWrite_Byte (host_client, sv.paused);
  494.     SV_ClientPrintf(host_client, PRINT_HIGH, "Server is paused.\n");
  495.   }
  496.  
  497. #if 0
  498. //
  499. // send a fixangle over the reliable channel to make sure it gets there
  500. // Never send a roll angle, because savegames can catch the server
  501. // in a state where it is expecting the client to correct the angle
  502. // and it won't happen if the game was just loaded, so you wind up
  503. // with a permanent head tilt
  504.   ent = EDICT_NUM( 1 + (host_client - svs.clients) );
  505.   MSG_WriteByte (&host_client->netchan.message, svc_setangle);
  506.   for (i=0 ; i < 2 ; i++)
  507.     MSG_WriteAngle (&host_client->netchan.message, ent->v.angles[i] );
  508.   MSG_WriteAngle (&host_client->netchan.message, 0 );
  509. #endif
  510. }
  511.  
  512. //=============================================================================
  513.  
  514. /*
  515. ==================
  516. SV_NextDownload_f
  517. ==================
  518. */
  519. void SV_NextDownload_f (void)
  520. {
  521.   byte  buffer[1024];
  522.   int   r;
  523.   int   percent;
  524.   int   size;
  525.  
  526.   if (!host_client->download)
  527.     return;
  528.  
  529.   r = host_client->downloadsize - host_client->downloadcount;
  530.   if (r > 768)
  531.     r = 768;
  532.   r = fread (buffer, 1, r, host_client->download);
  533.   ClientReliableWrite_Begin (host_client, svc_download, 6+r);
  534.   ClientReliableWrite_Short (host_client, r);
  535.  
  536.   host_client->downloadcount += r;
  537.   size = host_client->downloadsize;
  538.   if (!size)
  539.     size = 1;
  540.   percent = host_client->downloadcount*100/size;
  541.   ClientReliableWrite_Byte (host_client, percent);
  542.   ClientReliableWrite_SZ (host_client, buffer, r);
  543.  
  544.   if (host_client->downloadcount != host_client->downloadsize)
  545.     return;
  546.  
  547.   fclose (host_client->download);
  548.   host_client->download = NULL;
  549.  
  550. }
  551.  
  552. void OutofBandPrintf(netadr_t where, char *fmt, ...)
  553. {
  554.   va_list   argptr;
  555.   char  send[1024];
  556.   
  557.   send[0] = 0xff;
  558.   send[1] = 0xff;
  559.   send[2] = 0xff;
  560.   send[3] = 0xff;
  561.   send[4] = A2C_PRINT;
  562.   va_start (argptr, fmt);
  563.   vsprintf (send+5, fmt, argptr);
  564.   va_end (argptr);
  565.  
  566.   NET_SendPacket (strlen(send)+1, send, where);
  567. }
  568.  
  569. /*
  570. ==================
  571. SV_NextUpload
  572. ==================
  573. */
  574. void SV_NextUpload (void)
  575. {
  576.   byte  buffer[1024];
  577.   int   r;
  578.   int   percent;
  579.   int   size;
  580.   client_t *client;
  581.  
  582.   if (!*host_client->uploadfn) {
  583.     SV_ClientPrintf(host_client, PRINT_HIGH, "Upload denied\n");
  584.     ClientReliableWrite_Begin (host_client, svc_stufftext, 8);
  585.     ClientReliableWrite_String (host_client, "stopul");
  586.  
  587.     // suck out rest of packet
  588.     size = MSG_ReadShort ();  MSG_ReadByte ();
  589.     msg_readcount += size;
  590.     return;
  591.   }
  592.  
  593.   size = MSG_ReadShort ();
  594.   percent = MSG_ReadByte ();
  595.  
  596.   if (!host_client->upload)
  597.   {
  598.     host_client->upload = fopen(host_client->uploadfn, "wb");
  599.     if (!host_client->upload) {
  600.       Sys_Printf("Can't create %s\n", host_client->uploadfn);
  601.       ClientReliableWrite_Begin (host_client, svc_stufftext, 8);
  602.       ClientReliableWrite_String (host_client, "stopul");
  603.       *host_client->uploadfn = 0;
  604.       return;
  605.     }
  606.     Sys_Printf("Receiving %s from %d...\n", host_client->uploadfn, host_client->userid);
  607.     if (host_client->remote_snap)
  608.       OutofBandPrintf(host_client->snap_from, "Server receiving %s from %d...\n", host_client->uploadfn, host_client->userid);
  609.   }
  610.  
  611.   fwrite (net_message.data + msg_readcount, 1, size, host_client->upload);
  612.   msg_readcount += size;
  613.  
  614. Con_DPrintf ("UPLOAD: %d received\n", size);
  615.  
  616.   if (percent != 100) {
  617.     ClientReliableWrite_Begin (host_client, svc_stufftext, 8);
  618.     ClientReliableWrite_String (host_client, "nextul\n");
  619.   } else {
  620.     fclose (host_client->upload);
  621.     host_client->upload = NULL;
  622.  
  623.     Sys_Printf("%s upload completed.\n", host_client->uploadfn);
  624.  
  625.     if (host_client->remote_snap) {
  626.       char *p;
  627.  
  628.       if ((p = strchr(host_client->uploadfn, '/')) != NULL)
  629.         p++;
  630.       else
  631.         p = host_client->uploadfn;
  632.       OutofBandPrintf(host_client->snap_from, "%s upload completed.\nTo download, enter:\ndownload %s\n", 
  633.         host_client->uploadfn, p);
  634.     }
  635.   }
  636.  
  637. }
  638.  
  639. /*
  640. ==================
  641. SV_BeginDownload_f
  642. ==================
  643. */
  644. void SV_BeginDownload_f(void)
  645. {
  646.   char  *name;
  647.   extern  cvar_t  allow_download;
  648.   extern  cvar_t  allow_download_skins;
  649.   extern  cvar_t  allow_download_models;
  650.   extern  cvar_t  allow_download_sounds;
  651.   extern  cvar_t  allow_download_maps;
  652.   extern  int   file_from_pak; // ZOID did file come from pak?
  653.  
  654.   name = Cmd_Argv(1);
  655. // hacked by zoid to allow more conrol over download
  656.     // first off, no .. or global allow check
  657.   if (strstr (name, "..") || !allow_download.value
  658.     // leading dot is no good
  659.     || *name == '.' 
  660.     // leading slash bad as well, must be in subdir
  661.     || *name == '/'
  662.     // next up, skin check
  663.     || (strncmp(name, "skins/", 6) == 0 && !allow_download_skins.value)
  664.     // now models
  665.     || (strncmp(name, "progs/", 6) == 0 && !allow_download_models.value)
  666.     // now sounds
  667.     || (strncmp(name, "sound/", 6) == 0 && !allow_download_sounds.value)
  668.     // now maps (note special case for maps, must not be in pak)
  669.     || (strncmp(name, "maps/", 6) == 0 && !allow_download_maps.value)
  670.     // MUST be in a subdirectory  
  671.     || !strstr (name, "/") )  
  672.   { // don't allow anything with .. path
  673.     ClientReliableWrite_Begin (host_client, svc_download, 4);
  674.     ClientReliableWrite_Short (host_client, -1);
  675.     ClientReliableWrite_Byte (host_client, 0);
  676.     return;
  677.   }
  678.  
  679.   if (host_client->download) {
  680.     fclose (host_client->download);
  681.     host_client->download = NULL;
  682.   }
  683.  
  684.   // lowercase name (needed for casesen file systems)
  685.   {
  686.     char *p;
  687.  
  688.     for (p = name; *p; p++)
  689.       *p = (char)tolower(*p);
  690.   }
  691.  
  692.  
  693.   host_client->downloadsize = COM_FOpenFile (name, &host_client->download);
  694.   host_client->downloadcount = 0;
  695.  
  696.   if (!host_client->download
  697.     // special check for maps, if it came from a pak file, don't allow
  698.     // download  ZOID
  699.     || (strncmp(name, "maps/", 5) == 0 && file_from_pak))
  700.   {
  701.     if (host_client->download) {
  702.       fclose(host_client->download);
  703.       host_client->download = NULL;
  704.     }
  705.  
  706.     Sys_Printf ("Couldn't download %s to %s\n", name, host_client->name);
  707.     ClientReliableWrite_Begin (host_client, svc_download, 4);
  708.     ClientReliableWrite_Short (host_client, -1);
  709.     ClientReliableWrite_Byte (host_client, 0);
  710.     return;
  711.   }
  712.  
  713.   SV_NextDownload_f ();
  714.   Sys_Printf ("Downloading %s to %s\n", name, host_client->name);
  715. }
  716.  
  717. //=============================================================================
  718.  
  719. /*
  720. ==================
  721. SV_Say
  722. ==================
  723. */
  724. void SV_Say (qboolean team)
  725. {
  726.   client_t *client;
  727.   int   j, tmp;
  728.   char  *p;
  729.   char  text[2048];
  730.   char  t1[32], *t2;
  731.  
  732.   if (Cmd_Argc () < 2)
  733.     return;
  734.  
  735.   if (team)
  736.   {
  737.     strncpy (t1, Info_ValueForKey (host_client->userinfo, "team"), 31);
  738.     t1[31] = 0;
  739.   }
  740.  
  741.   if (host_client->spectator && (!sv_spectalk.value || team))
  742.     sprintf (text, "[SPEC] %s: ", host_client->name);
  743.   else if (team)
  744.     sprintf (text, "(%s): ", host_client->name);
  745.   else {
  746.     sprintf (text, "%s: ", host_client->name);
  747.   }
  748.  
  749.   if (fp_messages) {
  750.     if (!sv.paused && realtime<host_client->lockedtill) {
  751.       SV_ClientPrintf(host_client, PRINT_CHAT,
  752.         "You can't talk for %d more seconds\n", 
  753.           (int) (host_client->lockedtill - realtime));
  754.       return;
  755.     }
  756.     tmp = host_client->whensaidhead - fp_messages + 1;
  757.     if (tmp < 0)
  758.       tmp = 10+tmp;
  759.     if (!sv.paused &&
  760.       host_client->whensaid[tmp] && (realtime-host_client->whensaid[tmp] < fp_persecond)) {
  761.       host_client->lockedtill = realtime + fp_secondsdead;
  762.       if (fp_msg[0])
  763.         SV_ClientPrintf(host_client, PRINT_CHAT,
  764.           "FloodProt: %s\n", fp_msg);
  765.       else
  766.         SV_ClientPrintf(host_client, PRINT_CHAT,
  767.           "FloodProt: You can't talk for %d seconds.\n", fp_secondsdead);
  768.       return;
  769.     }
  770.     host_client->whensaidhead++;
  771.     if (host_client->whensaidhead > 9)
  772.       host_client->whensaidhead = 0;
  773.     host_client->whensaid[host_client->whensaidhead] = realtime;
  774.   }
  775.  
  776.   p = Cmd_Args();
  777.  
  778.   if (*p == '"')
  779.   {
  780.     p++;
  781.     p[Q_strlen(p)-1] = 0;
  782.   }
  783.  
  784.   Q_strcat(text, p);
  785.   Q_strcat(text, "\n");
  786.  
  787.   Sys_Printf ("%s", text);
  788.  
  789.   for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
  790.   {
  791.     if (client->state != cs_spawned)
  792.       continue;
  793.     if (host_client->spectator && !sv_spectalk.value)
  794.       if (!client->spectator)
  795.         continue;
  796.  
  797.     if (team)
  798.     {
  799.       // the spectator team
  800.       if (host_client->spectator) {
  801.         if (!client->spectator)
  802.           continue;
  803.       } else {
  804.         t2 = Info_ValueForKey (client->userinfo, "team");
  805.         if (strcmp(t1, t2) || client->spectator)
  806.           continue; // on different teams
  807.       }
  808.     }
  809.     SV_ClientPrintf(client, PRINT_CHAT, "%s", text);
  810.   }
  811. }
  812.  
  813.  
  814. /*
  815. ==================
  816. SV_Say_f
  817. ==================
  818. */
  819. void SV_Say_f(void)
  820. {
  821.   SV_Say (false);
  822. }
  823. /*
  824. ==================
  825. SV_Say_Team_f
  826. ==================
  827. */
  828. void SV_Say_Team_f(void)
  829. {
  830.   SV_Say (true);
  831. }
  832.  
  833.  
  834.  
  835. //============================================================================
  836.  
  837. /*
  838. =================
  839. SV_Pings_f
  840.  
  841. The client is showing the scoreboard, so send new ping times for all
  842. clients
  843. =================
  844. */
  845. void SV_Pings_f (void)
  846. {
  847.   client_t *client;
  848.   int   j;
  849.  
  850.   for (j = 0, client = svs.clients; j < MAX_CLIENTS; j++, client++)
  851.   {
  852.     if (client->state != cs_spawned)
  853.       continue;
  854.  
  855.     ClientReliableWrite_Begin (host_client, svc_updateping, 4);
  856.     ClientReliableWrite_Byte (host_client, j);
  857.     ClientReliableWrite_Short (host_client, SV_CalcPing(client));
  858.     ClientReliableWrite_Begin (host_client, svc_updatepl, 4);
  859.     ClientReliableWrite_Byte (host_client, j);
  860.     ClientReliableWrite_Byte (host_client, client->lossage);
  861.   }
  862. }
  863.  
  864.  
  865.  
  866. /*
  867. ==================
  868. SV_Kill_f
  869. ==================
  870. */
  871. void SV_Kill_f (void)
  872. {
  873.   if (sv_player->v.health <= 0)
  874.   {
  875.     SV_ClientPrintf (host_client, PRINT_HIGH, "Can't suicide -- allready dead!\n");
  876.     return;
  877.   }
  878.   
  879.   pr_global_struct->time = sv.time;
  880.   pr_global_struct->self = EDICT_TO_PROG(sv_player);
  881.   PR_ExecuteProgram (pr_global_struct->ClientKill);
  882. }
  883.  
  884. /*
  885. ==================
  886. SV_TogglePause
  887. ==================
  888. */
  889. void SV_TogglePause (const char *msg)
  890. {
  891.   int i;
  892.   client_t *cl;
  893.  
  894.   sv.paused ^= 1;
  895.  
  896.   if (msg)
  897.     SV_BroadcastPrintf (PRINT_HIGH, "%s", msg);
  898.  
  899.   // send notification to all clients
  900.   for (i=0, cl = svs.clients ; i<MAX_CLIENTS ; i++, cl++)
  901.   {
  902.     if (!cl->state)
  903.       continue;
  904.     ClientReliableWrite_Begin (cl, svc_setpause, 2);
  905.     ClientReliableWrite_Byte (cl, sv.paused);
  906.   }
  907. }
  908.  
  909.  
  910. /*
  911. ==================
  912. SV_Pause_f
  913. ==================
  914. */
  915. void SV_Pause_f (void)
  916. {
  917.   int i;
  918.   client_t *cl;
  919.   char st[sizeof(host_client->name) + 32];
  920.  
  921.   if (!pausable.value) {
  922.     SV_ClientPrintf (host_client, PRINT_HIGH, "Pause not allowed.\n");
  923.     return;
  924.   }
  925.  
  926.   if (host_client->spectator) {
  927.     SV_ClientPrintf (host_client, PRINT_HIGH, "Spectators can not pause.\n");
  928.     return;
  929.   }
  930.  
  931.   if (sv.paused)
  932.     sprintf (st, "%s paused the game\n", host_client->name);
  933.   else
  934.     sprintf (st, "%s unpaused the game\n", host_client->name);
  935.  
  936.   SV_TogglePause(st);
  937. }
  938.  
  939.  
  940. /*
  941. =================
  942. SV_Drop_f
  943.  
  944. The client is going to disconnect, so remove the connection immediately
  945. =================
  946. */
  947. void SV_Drop_f (void)
  948. {
  949.   SV_EndRedirect ();
  950.   if (!host_client->spectator)
  951.     SV_BroadcastPrintf (PRINT_HIGH, "%s dropped\n", host_client->name);
  952.   SV_DropClient (host_client);  
  953. }
  954.  
  955. /*
  956. =================
  957. SV_PTrack_f
  958.  
  959. Change the bandwidth estimate for a client
  960. =================
  961. */
  962. void SV_PTrack_f (void)
  963. {
  964.   int   i;
  965.   edict_t *ent, *tent;
  966.   
  967.   if (!host_client->spectator)
  968.     return;
  969.  
  970.   if (Cmd_Argc() != 2)
  971.   {
  972.     // turn off tracking
  973.     host_client->spec_track = 0;
  974.     ent = EDICT_NUM(host_client - svs.clients + 1);
  975.     tent = EDICT_NUM(0);
  976.     ent->v.goalentity = EDICT_TO_PROG(tent);
  977.     return;
  978.   }
  979.   
  980.   i = atoi(Cmd_Argv(1));
  981.   if (i < 0 || i >= MAX_CLIENTS || svs.clients[i].state != cs_spawned ||
  982.     svs.clients[i].spectator) {
  983.     SV_ClientPrintf (host_client, PRINT_HIGH, "Invalid client to track\n");
  984.     host_client->spec_track = 0;
  985.     ent = EDICT_NUM(host_client - svs.clients + 1);
  986.     tent = EDICT_NUM(0);
  987.     ent->v.goalentity = EDICT_TO_PROG(tent);
  988.     return;
  989.   }
  990.   host_client->spec_track = i + 1; // now tracking
  991.  
  992.   ent = EDICT_NUM(host_client - svs.clients + 1);
  993.   tent = EDICT_NUM(i + 1);
  994.   ent->v.goalentity = EDICT_TO_PROG(tent);
  995. }
  996.  
  997.  
  998. /*
  999. =================
  1000. SV_Rate_f
  1001.  
  1002. Change the bandwidth estimate for a client
  1003. =================
  1004. */
  1005. void SV_Rate_f (void)
  1006. {
  1007.   int   rate;
  1008.   
  1009.   if (Cmd_Argc() != 2)
  1010.   {
  1011.     SV_ClientPrintf (host_client, PRINT_HIGH, "Current rate is %i\n",
  1012.       (int)(1.0/host_client->netchan.rate + 0.5));
  1013.     return;
  1014.   }
  1015.   
  1016.   rate = atoi(Cmd_Argv(1));
  1017.   if (rate < 500)
  1018.     rate = 500;
  1019.   if (rate > 10000)
  1020.     rate = 10000;
  1021.  
  1022.   SV_ClientPrintf (host_client, PRINT_HIGH, "Net rate set to %i\n", rate);
  1023.   host_client->netchan.rate = 1.0/rate;
  1024. }
  1025.  
  1026.  
  1027. /*
  1028. =================
  1029. SV_Msg_f
  1030.  
  1031. Change the message level for a client
  1032. =================
  1033. */
  1034. void SV_Msg_f (void)
  1035. { 
  1036.   if (Cmd_Argc() != 2)
  1037.   {
  1038.     SV_ClientPrintf (host_client, PRINT_HIGH, "Current msg level is %i\n",
  1039.       host_client->messagelevel);
  1040.     return;
  1041.   }
  1042.   
  1043.   host_client->messagelevel = atoi(Cmd_Argv(1));
  1044.  
  1045.   SV_ClientPrintf (host_client, PRINT_HIGH, "Msg level set to %i\n", host_client->messagelevel);
  1046. }
  1047.  
  1048. /*
  1049. ==================
  1050. SV_SetInfo_f
  1051.  
  1052. Allow clients to change userinfo
  1053. ==================
  1054. */
  1055. void SV_SetInfo_f (void)
  1056. {
  1057.   int i;
  1058.   char oldval[MAX_INFO_STRING];
  1059.  
  1060.  
  1061.   if (Cmd_Argc() == 1)
  1062.   {
  1063.     Con_Printf ("User info settings:\n");
  1064.     Info_Print (host_client->userinfo);
  1065.     return;
  1066.   }
  1067.  
  1068.   if (Cmd_Argc() != 3)
  1069.   {
  1070.     Con_Printf ("usage: setinfo [ <key> <value> ]\n");
  1071.     return;
  1072.   }
  1073.  
  1074.   if (Cmd_Argv(1)[0] == '*')
  1075.     return;   // don't set priveledged values
  1076.  
  1077.   strcpy(oldval, Info_ValueForKey(host_client->userinfo, Cmd_Argv(1)));
  1078.  
  1079.   Info_SetValueForKey (host_client->userinfo, Cmd_Argv(1), Cmd_Argv(2), MAX_INFO_STRING);
  1080. // name is extracted below in ExtractFromUserInfo
  1081. //  strncpy (host_client->name, Info_ValueForKey (host_client->userinfo, "name")
  1082. //    , sizeof(host_client->name)-1); 
  1083. //  SV_FullClientUpdate (host_client, &sv.reliable_datagram);
  1084. //  host_client->sendinfo = true;
  1085.  
  1086.   if (!strcmp(Info_ValueForKey(host_client->userinfo, Cmd_Argv(1)), oldval))
  1087.     return; // key hasn't changed
  1088.  
  1089.   // process any changed values
  1090.   SV_ExtractFromUserinfo (host_client);
  1091.  
  1092.   i = host_client - svs.clients;
  1093.   MSG_WriteByte (&sv.reliable_datagram, svc_setinfo);
  1094.   MSG_WriteByte (&sv.reliable_datagram, i);
  1095.   MSG_WriteString (&sv.reliable_datagram, Cmd_Argv(1));
  1096.   MSG_WriteString (&sv.reliable_datagram, Info_ValueForKey(host_client->userinfo, Cmd_Argv(1)));
  1097. }
  1098.  
  1099. /*
  1100. ==================
  1101. SV_ShowServerinfo_f
  1102.  
  1103. Dumps the serverinfo info string
  1104. ==================
  1105. */
  1106. void SV_ShowServerinfo_f (void)
  1107. {
  1108.   Info_Print (svs.info);
  1109. }
  1110.  
  1111. void SV_NoSnap_f(void)
  1112. {
  1113.   if (*host_client->uploadfn) {
  1114.     *host_client->uploadfn = 0;
  1115.     SV_BroadcastPrintf (PRINT_HIGH, "%s refused remote screenshot\n", host_client->name);
  1116.   }
  1117. }
  1118.  
  1119. typedef struct
  1120. {
  1121.   char  *name;
  1122.   void  (*func) (void);
  1123. } ucmd_t;
  1124.  
  1125. ucmd_t ucmds[] =
  1126. {
  1127.   {"new", SV_New_f},
  1128.   {"modellist", SV_Modellist_f},
  1129.   {"soundlist", SV_Soundlist_f},
  1130.   {"prespawn", SV_PreSpawn_f},
  1131.   {"spawn", SV_Spawn_f},
  1132.   {"begin", SV_Begin_f},
  1133.  
  1134.   {"drop", SV_Drop_f},
  1135.   {"pings", SV_Pings_f},
  1136.  
  1137. // issued by hand at client consoles  
  1138.   {"rate", SV_Rate_f},
  1139.   {"kill", SV_Kill_f},
  1140.   {"pause", SV_Pause_f},
  1141.   {"msg", SV_Msg_f},
  1142.  
  1143.   {"say", SV_Say_f},
  1144.   {"say_team", SV_Say_Team_f},
  1145.  
  1146.   {"setinfo", SV_SetInfo_f},
  1147.  
  1148.   {"serverinfo", SV_ShowServerinfo_f},
  1149.  
  1150.   {"download", SV_BeginDownload_f},
  1151.   {"nextdl", SV_NextDownload_f},
  1152.  
  1153.   {"ptrack", SV_PTrack_f}, //ZOID - used with autocam
  1154.  
  1155.   {"snap", SV_NoSnap_f},
  1156.   
  1157.   {NULL, NULL}
  1158. };
  1159.  
  1160. /*
  1161. ==================
  1162. SV_ExecuteUserCommand
  1163. ==================
  1164. */
  1165. void SV_ExecuteUserCommand (char *s)
  1166. {
  1167.   ucmd_t  *u;
  1168.   
  1169.   Cmd_TokenizeString (s);
  1170.   sv_player = host_client->edict;
  1171.  
  1172.   SV_BeginRedirect (RD_CLIENT);
  1173.  
  1174.   for (u=ucmds ; u->name ; u++)
  1175.     if (!strcmp (Cmd_Argv(0), u->name) )
  1176.     {
  1177.       u->func ();
  1178.       break;
  1179.     }
  1180.  
  1181.   if (!u->name)
  1182.     Con_Printf ("Bad user command: %s\n", Cmd_Argv(0));
  1183.  
  1184.   SV_EndRedirect ();
  1185. }
  1186.  
  1187. /*
  1188. ===========================================================================
  1189.  
  1190. USER CMD EXECUTION
  1191.  
  1192. ===========================================================================
  1193. */
  1194.  
  1195. /*
  1196. ===============
  1197. V_CalcRoll
  1198.  
  1199. Used by view and sv_user
  1200. ===============
  1201. */
  1202. float V_CalcRoll (vec3_t angles, vec3_t velocity)
  1203. {
  1204.   vec3_t  forward, right, up;
  1205.   float sign;
  1206.   float side;
  1207.   float value;
  1208.   
  1209.   AngleVectors (angles, forward, right, up);
  1210.   side = DotProduct (velocity, right);
  1211.   sign = side < 0 ? -1 : 1;
  1212.   side = fabs(side);
  1213.   
  1214.   value = cl_rollangle.value;
  1215.  
  1216.   if (side < cl_rollspeed.value)
  1217.     side = side * value / cl_rollspeed.value;
  1218.   else
  1219.     side = value;
  1220.   
  1221.   return side*sign;
  1222.   
  1223. }
  1224.  
  1225.  
  1226.  
  1227.  
  1228. //============================================================================
  1229.  
  1230. vec3_t  pmove_mins, pmove_maxs;
  1231.  
  1232. /*
  1233. ====================
  1234. AddLinksToPmove
  1235.  
  1236. ====================
  1237. */
  1238. void AddLinksToPmove ( areanode_t *node )
  1239. {
  1240.   link_t    *l, *next;
  1241.   edict_t   *check;
  1242.   int     pl;
  1243.   int     i;
  1244.   physent_t *pe;
  1245.  
  1246.   pl = EDICT_TO_PROG(sv_player);
  1247.  
  1248.   // touch linked edicts
  1249.   for (l = node->solid_edicts.next ; l != &node->solid_edicts ; l = next)
  1250.   {
  1251.     next = l->next;
  1252.     check = EDICT_FROM_AREA(l);
  1253.  
  1254.     if (check->v.owner == pl)
  1255.       continue;   // player's own missile
  1256.     if (check->v.solid == SOLID_BSP 
  1257.       || check->v.solid == SOLID_BBOX 
  1258.       || check->v.solid == SOLID_SLIDEBOX)
  1259.     {
  1260.       if (check == sv_player)
  1261.         continue;
  1262.  
  1263.       for (i=0 ; i<3 ; i++)
  1264.         if (check->v.absmin[i] > pmove_maxs[i]
  1265.         || check->v.absmax[i] < pmove_mins[i])
  1266.           break;
  1267.       if (i != 3)
  1268.         continue;
  1269.       if (pmove.numphysent == MAX_PHYSENTS)
  1270.         return;
  1271.       pe = &pmove.physents[pmove.numphysent];
  1272.       pmove.numphysent++;
  1273.  
  1274.       VectorCopy (check->v.origin, pe->origin);
  1275.       pe->info = NUM_FOR_EDICT(check);
  1276.       if (check->v.solid == SOLID_BSP)
  1277.         pe->model = sv.models[(int)(check->v.modelindex)];
  1278.       else
  1279.       {
  1280.         pe->model = NULL;
  1281.         VectorCopy (check->v.mins, pe->mins);
  1282.         VectorCopy (check->v.maxs, pe->maxs);
  1283.       }
  1284.     }
  1285.   }
  1286.   
  1287. // recurse down both sides
  1288.   if (node->axis == -1)
  1289.     return;
  1290.  
  1291.   if ( pmove_maxs[node->axis] > node->dist )
  1292.     AddLinksToPmove ( node->children[0] );
  1293.   if ( pmove_mins[node->axis] < node->dist )
  1294.     AddLinksToPmove ( node->children[1] );
  1295. }
  1296.  
  1297.  
  1298. /*
  1299. ================
  1300. AddAllEntsToPmove
  1301.  
  1302. For debugging
  1303. ================
  1304. */
  1305. void AddAllEntsToPmove (void)
  1306. {
  1307.   int     e;
  1308.   edict_t   *check;
  1309.   int     i;
  1310.   physent_t *pe;
  1311.   int     pl;
  1312.  
  1313.   pl = EDICT_TO_PROG(sv_player);
  1314.   check = NEXT_EDICT(sv.edicts);
  1315.   for (e=1 ; e<sv.num_edicts ; e++, check = NEXT_EDICT(check))
  1316.   {
  1317.     if (check->free)
  1318.       continue;
  1319.     if (check->v.owner == pl)
  1320.       continue;
  1321.     if (check->v.solid == SOLID_BSP 
  1322.       || check->v.solid == SOLID_BBOX 
  1323.       || check->v.solid == SOLID_SLIDEBOX)
  1324.     {
  1325.       if (check == sv_player)
  1326.         continue;
  1327.  
  1328.       for (i=0 ; i<3 ; i++)
  1329.         if (check->v.absmin[i] > pmove_maxs[i]
  1330.         || check->v.absmax[i] < pmove_mins[i])
  1331.           break;
  1332.       if (i != 3)
  1333.         continue;
  1334.       pe = &pmove.physents[pmove.numphysent];
  1335.  
  1336.       VectorCopy (check->v.origin, pe->origin);
  1337.       pmove.physents[pmove.numphysent].info = e;
  1338.       if (check->v.solid == SOLID_BSP)
  1339.         pe->model = sv.models[(int)(check->v.modelindex)];
  1340.       else
  1341.       {
  1342.         pe->model = NULL;
  1343.         VectorCopy (check->v.mins, pe->mins);
  1344.         VectorCopy (check->v.maxs, pe->maxs);
  1345.       }
  1346.  
  1347.       if (++pmove.numphysent == MAX_PHYSENTS)
  1348.         break;
  1349.     }
  1350.   }
  1351. }
  1352.  
  1353. /*
  1354. ===========
  1355. SV_PreRunCmd
  1356. ===========
  1357. Done before running a player command.  Clears the touch array
  1358. */
  1359. byte playertouch[(MAX_EDICTS+7)/8];
  1360.  
  1361. void SV_PreRunCmd(void)
  1362. {
  1363.   memset(playertouch, 0, sizeof(playertouch));
  1364. }
  1365.  
  1366. /*
  1367. ===========
  1368. SV_RunCmd
  1369. ===========
  1370. */
  1371. void SV_RunCmd (usercmd_t *ucmd)
  1372. {
  1373.   edict_t   *ent;
  1374.   int     i, n;
  1375.   int     oldmsec;
  1376.  
  1377.   cmd = *ucmd;
  1378.  
  1379.   // chop up very long commands
  1380.   if (cmd.msec > 50)
  1381.   {
  1382.     oldmsec = ucmd->msec;
  1383.     cmd.msec = oldmsec/2;
  1384.     SV_RunCmd (&cmd);
  1385.     cmd.msec = oldmsec/2;
  1386.     cmd.impulse = 0;
  1387.     SV_RunCmd (&cmd);
  1388.     return;
  1389.   }
  1390.  
  1391.   if (!sv_player->v.fixangle)
  1392.     VectorCopy (ucmd->angles, sv_player->v.v_angle);
  1393.  
  1394.   sv_player->v.button0 = ucmd->buttons & 1;
  1395.   sv_player->v.button2 = (ucmd->buttons & 2)>>1;
  1396.   if (ucmd->impulse)
  1397.     sv_player->v.impulse = ucmd->impulse;
  1398.  
  1399. //
  1400. // angles
  1401. // show 1/3 the pitch angle and all the roll angle  
  1402.   if (sv_player->v.health > 0)
  1403.   {
  1404.     if (!sv_player->v.fixangle)
  1405.     {
  1406.       sv_player->v.angles[PITCH] = -sv_player->v.v_angle[PITCH]/3;
  1407.       sv_player->v.angles[YAW] = sv_player->v.v_angle[YAW];
  1408.     }
  1409.     sv_player->v.angles[ROLL] = 
  1410.       V_CalcRoll (sv_player->v.angles, sv_player->v.velocity)*4;
  1411.   }
  1412.  
  1413.   host_frametime = ucmd->msec * 0.001;
  1414.   if (host_frametime > 0.1)
  1415.     host_frametime = 0.1;
  1416.  
  1417.   if (!host_client->spectator)
  1418.   {
  1419.     pr_global_struct->frametime = host_frametime;
  1420.  
  1421.     pr_global_struct->time = sv.time;
  1422.     pr_global_struct->self = EDICT_TO_PROG(sv_player);
  1423.     PR_ExecuteProgram (pr_global_struct->PlayerPreThink);
  1424.  
  1425.     SV_RunThink (sv_player);
  1426.   }
  1427.  
  1428.   for (i=0 ; i<3 ; i++)
  1429.     pmove.origin[i] = sv_player->v.origin[i] + (sv_player->v.mins[i] - player_mins[i]);
  1430.   VectorCopy (sv_player->v.velocity, pmove.velocity);
  1431.   VectorCopy (sv_player->v.v_angle, pmove.angles);
  1432.  
  1433.   pmove.spectator = host_client->spectator;
  1434.   pmove.waterjumptime = sv_player->v.teleport_time;
  1435.   pmove.numphysent = 1;
  1436.   pmove.physents[0].model = sv.worldmodel;
  1437.   pmove.cmd = *ucmd;
  1438.   pmove.dead = sv_player->v.health <= 0;
  1439.   pmove.oldbuttons = host_client->oldbuttons;
  1440.  
  1441.   movevars.entgravity = host_client->entgravity;
  1442.   movevars.maxspeed = host_client->maxspeed;
  1443.  
  1444.   for (i=0 ; i<3 ; i++)
  1445.   {
  1446.     pmove_mins[i] = pmove.origin[i] - 256;
  1447.     pmove_maxs[i] = pmove.origin[i] + 256;
  1448.   }
  1449. #if 1
  1450.   AddLinksToPmove ( sv_areanodes );
  1451. #else
  1452.   AddAllEntsToPmove ();
  1453. #endif
  1454.  
  1455. #if 0
  1456. {
  1457.   int before, after;
  1458.  
  1459. before = PM_TestPlayerPosition (pmove.origin);
  1460.   PlayerMove ();
  1461. after = PM_TestPlayerPosition (pmove.origin);
  1462.  
  1463. if (sv_player->v.health > 0 && before && !after )
  1464.   Con_Printf ("player %s got stuck in playermove!!!!\n", host_client->name);
  1465. }
  1466. #else
  1467.   PlayerMove ();
  1468. #endif
  1469.  
  1470.   host_client->oldbuttons = pmove.oldbuttons;
  1471.   sv_player->v.teleport_time = pmove.waterjumptime;
  1472.   sv_player->v.waterlevel = waterlevel;
  1473.   sv_player->v.watertype = watertype;
  1474.   if (onground != -1)
  1475.   {
  1476.     sv_player->v.flags = (int)sv_player->v.flags | FL_ONGROUND;
  1477.     sv_player->v.groundentity = EDICT_TO_PROG(EDICT_NUM(pmove.physents[onground].info));
  1478.   }
  1479.   else
  1480.     sv_player->v.flags = (int)sv_player->v.flags & ~FL_ONGROUND;
  1481.   for (i=0 ; i<3 ; i++)
  1482.     sv_player->v.origin[i] = pmove.origin[i] - (sv_player->v.mins[i] - player_mins[i]);
  1483.  
  1484. #if 0
  1485.   // truncate velocity the same way the net protocol will
  1486.   for (i=0 ; i<3 ; i++)
  1487.     sv_player->v.velocity[i] = (int)pmove.velocity[i];
  1488. #else
  1489.   VectorCopy (pmove.velocity, sv_player->v.velocity);
  1490. #endif
  1491.  
  1492.   VectorCopy (pmove.angles, sv_player->v.v_angle);
  1493.  
  1494.   if (!host_client->spectator)
  1495.   {
  1496.     // link into place and touch triggers
  1497.     SV_LinkEdict (sv_player, true);
  1498.  
  1499.     // touch other objects
  1500.     for (i=0 ; i<pmove.numtouch ; i++)
  1501.     {
  1502.       n = pmove.physents[pmove.touchindex[i]].info;
  1503.       ent = EDICT_NUM(n);
  1504.       if (!ent->v.touch || (playertouch[n/8]&(1<<(n%8))))
  1505.         continue;
  1506.       pr_global_struct->self = EDICT_TO_PROG(ent);
  1507.       pr_global_struct->other = EDICT_TO_PROG(sv_player);
  1508.       PR_ExecuteProgram (ent->v.touch);
  1509.       playertouch[n/8] |= 1 << (n%8);
  1510.     }
  1511.   }
  1512. }
  1513.  
  1514. /*
  1515. ===========
  1516. SV_PostRunCmd
  1517. ===========
  1518. Done after running a player command.
  1519. */
  1520. void SV_PostRunCmd(void)
  1521. {
  1522.   // run post-think
  1523.  
  1524.   if (!host_client->spectator) {
  1525.     pr_global_struct->time = sv.time;
  1526.     pr_global_struct->self = EDICT_TO_PROG(sv_player);
  1527.     PR_ExecuteProgram (pr_global_struct->PlayerPostThink);
  1528.     SV_RunNewmis ();
  1529.   } else if (SpectatorThink) {
  1530.     pr_global_struct->time = sv.time;
  1531.     pr_global_struct->self = EDICT_TO_PROG(sv_player);
  1532.     PR_ExecuteProgram (SpectatorThink);
  1533.   }
  1534. }
  1535.  
  1536.  
  1537. /*
  1538. ===================
  1539. SV_ExecuteClientMessage
  1540.  
  1541. The current net_message is parsed for the given client
  1542. ===================
  1543. */
  1544. void SV_ExecuteClientMessage (client_t *cl)
  1545. {
  1546.   int   c;
  1547.   char  *s;
  1548.   usercmd_t oldest, oldcmd, newcmd;
  1549.   client_frame_t  *frame;
  1550.   vec3_t o;
  1551.   qboolean  move_issued = false; //only allow one move command
  1552.   int   checksumIndex;
  1553.   byte  checksum, calculatedChecksum;
  1554.   int   seq_hash;
  1555.  
  1556.   // calc ping time
  1557.   frame = &cl->frames[cl->netchan.incoming_acknowledged & UPDATE_MASK];
  1558.   frame->ping_time = realtime - frame->senttime;
  1559.  
  1560.   // make sure the reply sequence number matches the incoming
  1561.   // sequence number 
  1562.   if (cl->netchan.incoming_sequence >= cl->netchan.outgoing_sequence)
  1563.     cl->netchan.outgoing_sequence = cl->netchan.incoming_sequence;
  1564.   else
  1565.     cl->send_message = false; // don't reply, sequences have slipped    
  1566.  
  1567.   // save time for ping calculations
  1568.   cl->frames[cl->netchan.outgoing_sequence & UPDATE_MASK].senttime = realtime;
  1569.   cl->frames[cl->netchan.outgoing_sequence & UPDATE_MASK].ping_time = -1;
  1570.  
  1571.   host_client = cl;
  1572.   sv_player = host_client->edict;
  1573.  
  1574. //  seq_hash = (cl->netchan.incoming_sequence & 0xffff) ; // ^ QW_CHECK_HASH;
  1575.   seq_hash = cl->netchan.incoming_sequence;
  1576.   
  1577.   // mark time so clients will know how much to predict
  1578.   // other players
  1579.   cl->localtime = sv.time;
  1580.   cl->delta_sequence = -1;  // no delta unless requested
  1581.   while (1)
  1582.   {
  1583.     if (msg_badread)
  1584.     {
  1585.       Con_Printf ("SV_ReadClientMessage: badread\n");
  1586.       SV_DropClient (cl);
  1587.       return;
  1588.     } 
  1589.  
  1590.     c = MSG_ReadByte ();
  1591.     if (c == -1)
  1592.       break;
  1593.         
  1594.     switch (c)
  1595.     {
  1596.     default:
  1597.       Con_Printf ("SV_ReadClientMessage: unknown command char\n");
  1598.       SV_DropClient (cl);
  1599.       return;
  1600.             
  1601.     case clc_nop:
  1602.       break;
  1603.  
  1604.     case clc_delta:
  1605.       cl->delta_sequence = MSG_ReadByte ();
  1606.       break;
  1607.  
  1608.     case clc_move:
  1609.       if (move_issued)
  1610.         return;   // someone is trying to cheat...
  1611.  
  1612.       move_issued = true;
  1613.  
  1614.       checksumIndex = MSG_GetReadCount();
  1615.       checksum = (byte)MSG_ReadByte ();
  1616.  
  1617.       // read loss percentage
  1618.       cl->lossage = MSG_ReadByte();
  1619.  
  1620.       MSG_ReadDeltaUsercmd (&nullcmd, &oldest);
  1621.       MSG_ReadDeltaUsercmd (&oldest, &oldcmd);
  1622.       MSG_ReadDeltaUsercmd (&oldcmd, &newcmd);
  1623.  
  1624.       if ( cl->state != cs_spawned )
  1625.         break;
  1626.  
  1627.       // if the checksum fails, ignore the rest of the packet
  1628.       calculatedChecksum = COM_BlockSequenceCRCByte(
  1629.         net_message.data + checksumIndex + 1,
  1630.         MSG_GetReadCount() - checksumIndex - 1,
  1631.         seq_hash);
  1632.  
  1633.       if (calculatedChecksum != checksum)
  1634.       {
  1635.         Con_DPrintf ("Failed command checksum for %s(%d) (%d != %d)\n", 
  1636.           cl->name, cl->netchan.incoming_sequence, checksum, calculatedChecksum);
  1637.         return;
  1638.       }
  1639.  
  1640.       if (!sv.paused) {
  1641.         SV_PreRunCmd();
  1642.  
  1643.         if (net_drop < 20)
  1644.         {
  1645.           while (net_drop > 2)
  1646.           {
  1647.             SV_RunCmd (&cl->lastcmd);
  1648.             net_drop--;
  1649.           }
  1650.           if (net_drop > 1)
  1651.             SV_RunCmd (&oldest);
  1652.           if (net_drop > 0)
  1653.             SV_RunCmd (&oldcmd);
  1654.         }
  1655.         SV_RunCmd (&newcmd);
  1656.  
  1657.         SV_PostRunCmd();
  1658.       }
  1659.  
  1660.       cl->lastcmd = newcmd;
  1661.       cl->lastcmd.buttons = 0; // avoid multiple fires on lag
  1662.       break;
  1663.  
  1664.  
  1665.     case clc_stringcmd: 
  1666.       s = MSG_ReadString ();
  1667.       SV_ExecuteUserCommand (s);
  1668.       break;
  1669.  
  1670.     case clc_tmove:
  1671.       o[0] = MSG_ReadCoord();
  1672.       o[1] = MSG_ReadCoord();
  1673.       o[2] = MSG_ReadCoord();
  1674.       // only allowed by spectators
  1675.       if (host_client->spectator) {
  1676.         VectorCopy(o, sv_player->v.origin);
  1677.         SV_LinkEdict(sv_player, false);
  1678.       }
  1679.       break;
  1680.  
  1681.     case clc_upload:
  1682.       SV_NextUpload();
  1683.       break;
  1684.  
  1685.     }
  1686.   }
  1687. }
  1688.  
  1689. /*
  1690. ==============
  1691. SV_UserInit
  1692. ==============
  1693. */
  1694. void SV_UserInit (void)
  1695. {
  1696.   Cvar_RegisterVariable (&cl_rollspeed);
  1697.   Cvar_RegisterVariable (&cl_rollangle);
  1698.   Cvar_RegisterVariable (&sv_spectalk);
  1699.   Cvar_RegisterVariable (&sv_mapcheck);
  1700. }
  1701.  
  1702.  
  1703.