Return to sv_user.c CVS log

Up to [Quake] / quakeworld / server

Annotation of quakeworld/server/sv_user.c, revision 1.1

1.1     ! root        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: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.