FWGS
/
Xash3DArchive
Archived
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

29 Mar 2011

This commit is contained in:
g-cont 2011-03-29 00:00:00 +04:00 committed by Alibek Omarov
parent 7e0cca5ba1
commit f02d3a55ae
17 changed files with 94 additions and 352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
engine/client/cl_frame.c
View File

@ -472,24 +472,27 @@ void CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta )
{
frame_t *newframe, *oldframe;
int oldindex, newnum, oldnum;
int oldpacket, newpacket;
entity_state_t *oldent;
int count;
// first, allocate packet for new frame
count = BF_ReadWord( msg );
newframe = &cl.frames[cl.parsecountmod];
newpacket = cl.parsecountmod;
newframe = &cl.frames[newpacket];
// allocate parse entities
newframe->first_entity = cls.next_client_entities;
newframe->num_entities = 0;
newframe->valid = true; // assume valid
if( delta )
{
int subtracted, delta_sequence;
int subtracted;
delta_sequence = BF_ReadByte( msg );
subtracted = ((( cls.netchan.incoming_sequence & 0xFF ) - delta_sequence ) & 0xFF );
oldpacket = BF_ReadByte( msg );
subtracted = ((( cls.netchan.incoming_sequence & 0xFF ) - oldpacket ) & 0xFF );
if( subtracted == 0 )
{
@ -500,43 +503,26 @@ void CL_ParsePacketEntities( sizebuf_t *msg, qboolean delta )
if( subtracted >= CL_UPDATE_MASK )
{
// we can't use this, it is too old
Con_NPrintf( 2, "^3Warning:^1 delta frame is too old^7\n" );
CL_FlushEntityPacket( msg );
return;
}
oldframe = &cl.frames[delta_sequence & CL_UPDATE_MASK];
oldframe = &cl.frames[oldpacket & CL_UPDATE_MASK];
if( !oldframe->valid )
{
// should never happen
MsgDev( D_INFO, "delta from invalid frame (not supposed to happen!)\n" );
}
if(( oldframe->delta_sequence & 0xFF ) != (( delta_sequence - 1 ) & 0xFF ))
{
// The frame that the server did the delta from
// is too old, so we can't reconstruct it properly.
MsgDev( D_INFO, "CL_ParsePacketEntities: delta frame too old\n" );
}
else if(( cls.next_client_entities - oldframe->first_entity ) > ( cls.num_client_entities - 128 ))
if(( cls.next_client_entities - oldframe->first_entity ) > ( cls.num_client_entities - 128 ))
{
MsgDev( D_INFO, "CL_ParsePacketEntities: delta parse_entities too old\n" );
Con_NPrintf( 2, "^3Warning:^1 delta frame is too old^7\n" );
CL_FlushEntityPacket( msg );
return;
}
else newframe->valid = true; // valid delta parse
if(( cl.delta_sequence & CL_UPDATE_MASK ) != ( delta_sequence & CL_UPDATE_MASK ))
MsgDev( D_WARN, "CL_ParsePacketEntities: mismatch delta_sequence %i != %i\n", cl.delta_sequence, ( delta_sequence & CL_UPDATE_MASK ));
// keep sequence an actual
newframe->delta_sequence = delta_sequence;
}
else
{
// this is a full update that we can start delta compressing from now
newframe->delta_sequence = ( cls.netchan.incoming_sequence - 1 ) & 0xFF;
newframe->valid = true;
oldframe = NULL;
oldpacket = -1; // delta too old or is initial message
cl.force_send_usercmd = true; // send reply
cls.demowaiting = false; // we can start recording now
}

28
engine/client/cl_game.c
View File

@ -2025,19 +2025,6 @@ static int pfnCheckParm( char *parm, char **ppnext )
return 0;
}
/*
=============
pfnKey_Event
=============
*/
static void pfnKey_Event( int key, int down )
{
// add event to queue
Sys_QueEvent( SE_KEY, key, down, 0, NULL );
}
/*
=============
pfnGetMousePosition
@ -2776,7 +2763,11 @@ pfnGetMousePos
*/
void pfnGetMousePos( struct tagPOINT *ppt )
{
ASSERT( ppt != NULL );
// find mouse movement
GetCursorPos( ppt );
ScreenToClient( host.hWnd, ppt );
}
/*
@ -2787,8 +2778,13 @@ pfnSetMousePos
*/
void pfnSetMousePos( int mx, int my )
{
if( !mx && !my ) return;
Sys_QueEvent( SE_MOUSE, mx, my, 0, NULL );
POINT pt;
pt.x = mx;
pt.y = my;
ClientToScreen( host.hWnd, &pt );
SetCursorPos( pt.x, pt.y );
}
/*
@ -3537,7 +3533,7 @@ static cl_enginefunc_t gEngfuncs =
pfnServerInfo_ValueForKey,
pfnGetClientMaxspeed,
pfnCheckParm,
pfnKey_Event,
Key_Event,
pfnGetMousePosition,
pfnIsNoClipping,
CL_GetLocalPlayer,

20
engine/client/cl_main.c
View File

@ -323,7 +323,19 @@ usercmd_t CL_CreateCmd( void )
if( ++cl.movemessages <= 10 )
return cmd;
active = ( cls.state == ca_active && !cl.refdef.paused && !cl.refdef.intermission );
switch( cls.state )
{
case ca_connected:
active = 1;
break;
case ca_active:
active = 2;
break;
default:
active = 0;
break;
}
clgame.dllFuncs.CL_CreateMove( cl.time - cl.oldtime, &cmd, active );
R_LightForPoint( cl.frame.local.client.origin, &color, false, 128.0f );
@ -401,10 +413,12 @@ void CL_WritePacket( void )
CL_ComputePacketLoss ();
#ifndef _DEBUG
if( cl_cmdrate->value < MIN_CMD_RATE )
{
Cvar_SetFloat( "cl_cmdrate", MIN_CMD_RATE );
}
#endif
BF_Init( &buf, "ClientData", data, sizeof( data ));
@ -490,7 +504,7 @@ void CL_WritePacket( void )
for( i = numcmds - 1; i >= 0; i-- )
{
cmdnumber = ( outgoing_sequence - i ) & CL_UPDATE_MASK;
cmdnumber = ( cls.netchan.outgoing_sequence - i ) & CL_UPDATE_MASK;
to = cmdnumber;
CL_WriteUsercmd( &buf, from, to );
@ -508,7 +522,7 @@ void CL_WritePacket( void )
i = cls.netchan.outgoing_sequence & CL_UPDATE_MASK;
// determine if we need to ask for a new set of delta's.
if( cl.validsequence && !( cls.demorecording && cls.demowaiting ))
if( cl.validsequence && (cls.state == ca_active) && !( cls.demorecording && cls.demowaiting ))
{
cl.delta_sequence = cl.validsequence;

11
engine/client/cl_parse.c
View File

@ -627,10 +627,6 @@ void CL_ParseServerData( sizebuf_t *msg )
menu.globals->maxClients = cl.maxclients;
Q_strncpy( menu.globals->maptitle, clgame.maptitle, sizeof( menu.globals->maptitle ));
// no effect for local client
// merge entcount only for remote clients
GI->max_edicts = clgame.maxEntities;
CL_InitEdicts (); // re-arrange edicts
// get splash name
@ -705,8 +701,8 @@ void CL_ParseClientData( sizebuf_t *msg )
{
if( cl.frames[j & CL_UPDATE_MASK].receivedtime >= 0.0 )
{
cl.frames[j & CL_UPDATE_MASK ].receivedtime = -1;
cl.frames[j & CL_UPDATE_MASK ].latency = 0;
cl.frames[j & CL_UPDATE_MASK].receivedtime = -1;
cl.frames[j & CL_UPDATE_MASK].latency = 0;
}
}
}
@ -738,9 +734,6 @@ void CL_ParseClientData( sizebuf_t *msg )
from_cd = &cl.frames[delta_sequence & CL_UPDATE_MASK].local.client;
from_wd = cl.frames[delta_sequence & CL_UPDATE_MASK].local.weapondata;
if(( delta_sequence & CL_UPDATE_MASK ) != ( cl.delta_sequence & CL_UPDATE_MASK ))
MsgDev( D_WARN, "CL_ParseClientData: mismatch delta_sequence\n" );
}
MSG_ReadClientData( msg, from_cd, to_cd, sv_time( ));

1
engine/client/client.h
View File

@ -51,7 +51,6 @@ typedef struct frame_s
int num_entities;
int first_entity; // into the circular cl_packet_entities[]
int delta_sequence; // last valid sequence
qboolean valid; // cleared if delta parsing was invalid
} frame_t;

2
engine/client/vgui/vgui_input.cpp
View File

@ -73,7 +73,7 @@ void VGUI_CursorSelect( Cursor *cursor )
void VGUI_ActivateCurrentCursor( void )
{
if( cls.key_dest != key_game )
if( cls.key_dest != key_game || cl.refdef.paused )
return;
if( host.mouse_visible )

7
engine/common/common.h
View File

@ -127,8 +127,6 @@ HOST INTERFACE
==============================================================
*/
#define MAX_SYSEVENTS 1024
/*
========================================================================
@ -251,10 +249,6 @@ typedef struct host_parm_s
uint framecount; // global framecount
int events_head;
int events_tail;
sys_event_t events[MAX_SYSEVENTS];
// list of unique decal indexes
char draw_decals[MAX_DECALS][CS_SIZE];
@ -682,7 +676,6 @@ void SV_InitGameProgs( void );
void SV_FreeGameProgs( void );
void SV_ForceError( void );
void CL_WriteMessageHistory( void );
void CL_MouseEvent( int mx, int my );
void CL_SendCmd( void );
void CL_Disconnect( void );
void CL_Crashed( void );

100
engine/common/host.c
View File

@ -297,96 +297,20 @@ void Host_InitDecals( void )
}
/*
=================
Host_InitEvents
=================
===================
Host_GetConsoleCommands
Add them exactly as if they had been typed at the console
===================
*/
void Host_InitEvents( void )
void Host_GetConsoleCommands( void )
{
Q_memset( host.events, 0, sizeof( host.events ));
host.events_head = 0;
host.events_tail = 0;
}
char *cmd;
/*
=================
Host_PushEvent
=================
*/
void Host_PushEvent( sys_event_t *event )
{
sys_event_t *ev;
static qboolean overflow = false;
ev = &host.events[host.events_head & (MAX_SYSEVENTS-1)];
if( host.events_head - host.events_tail >= MAX_SYSEVENTS )
if( host.type == HOST_DEDICATED )
{
if( !overflow )
{
MsgDev( D_WARN, "Host_PushEvent overflow\n" );
overflow = true;
}
if( ev->data ) Mem_Free( ev->data );
host.events_tail++;
}
else overflow = false;
*ev = *event;
host.events_head++;
}
/*
=================
Host_GetEvent
=================
*/
sys_event_t Host_GetEvent( void )
{
if( host.events_head > host.events_tail )
{
host.events_tail++;
return host.events[(host.events_tail - 1) & (MAX_SYSEVENTS-1)];
}
return Sys_GetEvent();
}
/*
=================
Host_EventLoop
Returns false while events is out
=================
*/
void Host_EventLoop( void )
{
sys_event_t ev;
while( 1 )
{
ev = Sys_GetEvent();
switch( ev.type )
{
case SE_NONE:
Cbuf_Execute();
return;
case SE_KEY:
Key_Event( ev.value[0], ev.value[1] );
break;
case SE_CHAR:
CL_CharEvent( ev.value[0] );
break;
case SE_MOUSE:
CL_MouseEvent( ev.value[0], ev.value[1] );
break;
case SE_CONSOLE:
Cbuf_AddText( va( "%s\n", ev.data ));
break;
default:
MsgDev( D_ERROR, "Host_EventLoop: bad event type %i", ev.type );
return;
}
if( ev.data ) Mem_Free( ev.data );
cmd = Con_Input();
if( cmd ) Cbuf_AddText( cmd );
}
}
@ -452,12 +376,13 @@ void Host_Frame( float time )
return;
Host_InputFrame (); // input frame
Host_EventLoop();
// decide the simulation time
if( !Host_FilterTime( time ))
return;
Host_GetConsoleCommands ();
Host_ServerFrame (); // server frame
Host_ClientFrame (); // client frame
@ -697,7 +622,6 @@ void Host_InitCommon( const char *progname, qboolean bChangeGame )
FS_LoadGameInfo( NULL );
Q_strncpy( host.gamefolder, GI->gamefolder, sizeof( host.gamefolder ));
Host_InitEvents();
HPAK_Init();
IN_Init();

30
engine/common/input.c
View File

@ -299,8 +299,10 @@ void IN_MouseMove( void )
mx = current_pos.x - host.window_center_x;
my = current_pos.y - host.window_center_y;
if( !mx && !my ) return;
Sys_QueEvent( SE_MOUSE, mx, my, 0, NULL );
if(( !mx && !my ) || !UI_IsVisible( )) return;
// if the menu is visible, move the menu cursor
UI_MouseMove( mx, my );
}
/*
@ -326,11 +328,11 @@ void IN_MouseEvent( int mstate )
{
if(( mstate & ( 1<<i )) && !( in_mouse_oldbuttonstate & ( 1<<i )))
{
Sys_QueEvent( SE_KEY, K_MOUSE1 + i, true, 0, NULL );
Key_Event( K_MOUSE1 + i, true );
}
if(!( mstate & ( 1<<i )) && ( in_mouse_oldbuttonstate & ( 1<<i )))
{
Sys_QueEvent( SE_KEY, K_MOUSE1 + i, false, 0, NULL );
Key_Event( K_MOUSE1 + i, false );
}
}
@ -371,6 +373,10 @@ void Host_InputFrame( void )
rand (); // keep the random time dependent
Sys_SendKeyEvents ();
Cbuf_Execute ();
if( host.state == HOST_RESTART )
host.state = HOST_FRAME; // restart is finished
@ -384,7 +390,7 @@ void Host_InputFrame( void )
if( host.state == HOST_NOFOCUS )
{
if( Host_ServerState() && CL_IsInGame( ))
Sys_Sleep( 5 ); // listenserver
Sys_Sleep( 1 ); // listenserver
else Sys_Sleep( 20 ); // sleep 20 ms otherwise
}
else if( host.state == HOST_SLEEP )
@ -443,13 +449,13 @@ long IN_WndProc( void *hWnd, uint uMsg, uint wParam, long lParam )
if( !in_mouseactive ) break;
if(( short )HIWORD( wParam ) > 0 )
{
Sys_QueEvent( SE_KEY, K_MWHEELUP, true, 0, NULL );
Sys_QueEvent( SE_KEY, K_MWHEELUP, false, 0, NULL );
Key_Event( K_MWHEELUP, true );
Key_Event( K_MWHEELUP, false );
}
else
{
Sys_QueEvent( SE_KEY, K_MWHEELDOWN, true, 0, NULL );
Sys_QueEvent( SE_KEY, K_MWHEELDOWN, false, 0, NULL );
Key_Event( K_MWHEELDOWN, true );
Key_Event( K_MWHEELDOWN, false );
}
break;
case WM_CREATE:
@ -540,14 +546,14 @@ long IN_WndProc( void *hWnd, uint uMsg, uint wParam, long lParam )
}
// intentional fallthrough
case WM_KEYDOWN:
Sys_QueEvent( SE_KEY, Host_MapKey( lParam ), true, 0, NULL );
Key_Event( Host_MapKey( lParam ), true );
break;
case WM_SYSKEYUP:
case WM_KEYUP:
Sys_QueEvent( SE_KEY, Host_MapKey( lParam ), false, 0, NULL );
Key_Event( Host_MapKey( lParam ), false );
break;
case WM_CHAR:
Sys_QueEvent( SE_CHAR, wParam, false, 0, NULL );
CL_CharEvent( wParam );
break;
}
return DefWindowProc( hWnd, uMsg, wParam, lParam );

14
engine/common/keys.c
View File

@ -698,18 +698,4 @@ void CL_CharEvent( int key )
{
UI_CharEvent( key );
}
}
/*
=================
CL_MouseEvent
=================
*/
void CL_MouseEvent( int mx, int my )
{
if( UI_IsVisible( ))
{
// if the menu is visible, move the menu cursor
UI_MouseMove( mx, my );
}
}

3
engine/common/net_encode.c
View File

@ -14,6 +14,7 @@
#include "weaponinfo.h"
#include "event_args.h"
#include "protocol.h"
#include "client.h"
#define DELTA_PATH "delta.lst"
static qboolean delta_init = false;
@ -1611,7 +1612,7 @@ qboolean MSG_ReadDeltaEntity( sizebuf_t *msg, entity_state_t *from, entity_state
delta_t *pField;
int i, fRemoveType;
if( number < 0 || number >= GI->max_edicts )
if( number < 0 || number >= clgame.maxEntities )
Host_Error( "MSG_ReadDeltaEntity: bad delta entity number: %i\n", number );
*to = *from;

148
engine/common/sys_win.c
View File

@ -6,68 +6,7 @@
#include "common.h"
#include "mathlib.h"
#define MAX_QUED_EVENTS 256
#define MASK_QUED_EVENTS (MAX_QUED_EVENTS - 1)
qboolean error_on_exit = false; // arg for exit();
sys_event_t event_que[MAX_QUED_EVENTS];
int event_head, event_tail;
typedef struct register_s
{
dword eax;
dword ebx;
dword ecx;
dword edx;
qboolean retval;
} register_t;
static register_t Sys_CpuId( uint function )
{
register_t local;
local.retval = true;
_asm pushad;
__try
{
_asm
{
xor edx, edx // Clue the compiler that EDX is about to be used.
mov eax, function // set up CPUID to return processor version and features
// 0 = vendor string, 1 = version info, 2 = cache info
cpuid // code bytes = 0fh, 0a2h
mov local.eax, eax // features returned in eax
mov local.ebx, ebx // features returned in ebx
mov local.ecx, ecx // features returned in ecx
mov local.edx, edx // features returned in edx
}
}
__except( EXCEPTION_EXECUTE_HANDLER )
{
local.retval = false;
}
_asm popad
return local;
}
qboolean Sys_CheckMMX( void )
{
register_t mmx = Sys_CpuId( 1 );
if( !mmx.retval ) return false;
return ( mmx.edx & 0x800000 ) != 0;
}
qboolean Sys_CheckSSE( void )
{
register_t sse = Sys_CpuId( 1 );
if( !sse.retval ) return false;
return ( sse.edx & 0x2000000L ) != 0;
}
qboolean error_on_exit = false; // arg for exit();
/*
================
@ -290,93 +229,18 @@ qboolean _Sys_GetParmFromCmdLine( char *parm, char *out, size_t size )
return true;
}
/*
================
Sys_QueEvent
A time of 0 will get the current time
Ptr should either be null, or point to a block of data that can
be freed by the game later.
================
*/
void Sys_QueEvent( ev_type_t type, int value, int value2, int length, void *ptr )
void Sys_SendKeyEvents( void )
{
sys_event_t *ev;
MSG msg;
ev = &event_que[event_head & MASK_QUED_EVENTS];
if( event_head - event_tail >= MAX_QUED_EVENTS )
{
MsgDev( D_ERROR, "Sys_QueEvent: overflow\n");
// make sure what memory is allocated by engine
if( Mem_IsAllocatedExt( host.mempool, ev->data ))
Mem_Free( ev->data );
event_tail++;
}
event_head++;
ev->type = type;
ev->value[0] = value;
ev->value[1] = value2;
ev->length = length;
ev->data = ptr;
}
/*
================
Sys_GetEvent
================
*/
sys_event_t Sys_GetEvent( void )
{
MSG msg;
sys_event_t ev;
char *s;
// return if we have data
if( event_head > event_tail )
{
event_tail++;
return event_que[(event_tail - 1) & MASK_QUED_EVENTS];
}
// pump the message loop
while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ))
{
if( !GetMessage( &msg, NULL, 0, 0 ))
{
// FIXME: set reason to quit
Sys_Quit();
}
TranslateMessage(&msg );
Sys_Quit ();
TranslateMessage( &msg );
DispatchMessage( &msg );
}
// check for console commands
s = Con_Input();
if( s )
{
char *b;
int len;
len = Q_strlen( s );
b = Z_Malloc( len + 1 );
Q_strcpy( b, s );
Sys_QueEvent( SE_CONSOLE, 0, 0, len, b );
}
// return if we have data
if( event_head > event_tail )
{
event_tail++;
return event_que[(event_tail - 1) & MASK_QUED_EVENTS];
}
// create an empty event to return
Q_memset( &ev, 0, sizeof( ev ));
return ev;
}
//=======================================================================

28
engine/common/system.h
View File

@ -33,31 +33,6 @@ typedef vec_t matrix4x4[4][4];
#define ASSERT( exp ) if(!( exp )) Sys_Break( "assert failed at %s:%i\n", __FILE__, __LINE__ )
/*
========================================================================
SYS EVENT
keep console cmds, network messages, mouse reletives and key buttons
========================================================================
*/
typedef enum
{
SE_NONE = 0, // end of events queue
SE_KEY, // ev.value[0] is a key code, ev.value[1] is the down flag
SE_CHAR, // ev.value[0] is an ascii char
SE_CONSOLE, // ev.data is a char*
SE_MOUSE, // ev.value[0] and ev.value[1] are reletive signed x / y moves
} ev_type_t;
typedef struct
{
ev_type_t type;
int value[2];
void *data;
size_t length;
} sys_event_t;
/*
========================================================================
internal dll's loader
@ -97,8 +72,7 @@ long _stdcall Sys_Crash( PEXCEPTION_POINTERS pInfo );
#define Sys_GetParmFromCmdLine( parm, out ) _Sys_GetParmFromCmdLine( parm, out, sizeof( out ))
qboolean _Sys_GetParmFromCmdLine( char *parm, char *out, size_t size );
void Sys_ShellExecute( const char *path, const char *parms, qboolean exit );
void Sys_QueEvent( ev_type_t type, int value, int value2, int length, void *ptr );
sys_event_t Sys_GetEvent( void );
void Sys_SendKeyEvents( void );
qboolean Sys_CheckMMX( void );
qboolean Sys_CheckSSE( void );
void Sys_Print( const char *pMsg );

3
engine/server/sv_client.c
View File

@ -215,6 +215,7 @@ gotnewcl:
Netchan_OutOfBandPrint( NS_SERVER, from, "print\n%s\nConnection refused.\n", Info_ValueForKey( userinfo, "rejmsg" ));
else Netchan_OutOfBandPrint( NS_SERVER, from, "print\nConnection refused.\n" );
MsgDev( D_ERROR, "SV_DirectConnect: game rejected a connection.\n");
SV_DropClient( newcl );
return;
}
@ -1295,7 +1296,7 @@ void SV_DeltaInfo_f( sv_client_t *cl )
}
tableIndex = Q_atoi( Cmd_Argv( 2 ));
fieldIndex = Q_atoi( Cmd_Argv( 2 ));
fieldIndex = Q_atoi( Cmd_Argv( 3 ));
// write a packet full of data
while( BF_GetNumBytesWritten( &cl->netchan.message ) < ( MAX_MSGLEN / 2 ) && tableIndex < Delta_NumTables( ))

2
engine/server/sv_frame.c
View File

@ -236,7 +236,7 @@ void SV_EmitPacketEntities( sv_client_t *cl, client_frame_t *to, sizebuf_t *msg
// delta update from old position
// because the force parm is false, this will not result
// in any bytes being emited if the entity has not changed at all
MSG_WriteDeltaEntity( oldent, newent, msg, false, SV_IsPlayerIndex( newent->number ), sv_time( ));
MSG_WriteDeltaEntity( oldent, newent, msg, false, SV_IsPlayerIndex( newent->number ), sv.time );
oldindex++;
newindex++;
continue;

1
engine/server/sv_init.c
View File

@ -565,7 +565,6 @@ void SV_InitGame( void )
}
svgame.globals->maxClients = sv_maxclients->integer;
SV_UPDATE_BACKUP = ( svgame.globals->maxClients == 1 ) ? SINGLEPLAYER_BACKUP : MULTIPLAYER_BACKUP;
svs.spawncount = Com_RandomLong( 0, 65535 );

6
engine/server/sv_pmove.c
View File

@ -900,6 +900,12 @@ void SV_RunCmd( sv_client_t *cl, usercmd_t *ucmd, int random_seed )
clent->v.button = ucmd->buttons;
if( ucmd->impulse ) clent->v.impulse = ucmd->impulse;
if( ucmd->impulse == 204 )
{
// force client.dll update
SV_RefreshUserinfo();
}
if( clent->v.flags & FL_DUCKING )
SV_SetMinMaxSize( clent, svgame.pmove->player_mins[1], svgame.pmove->player_maxs[1] );
else SV_SetMinMaxSize( clent, svgame.pmove->player_mins[0], svgame.pmove->player_maxs[0] );