quick/Quake-III-Arena-VS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

C++ conversion: fixed compilation errors for quake3 project.

Browse Source
This commit is contained in:
Artem Kharytoniuk 2014-05-11 00:22:27 +03:00
parent e2e32bca15
commit ff834b8b59
39 changed files with 419 additions and 405 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
code/client/cl_cgame.c
View File

@ -426,27 +426,27 @@ intptr_t CL_CgameSystemCalls( intptr_t *args ) {
case CG_MILLISECONDS: case CG_MILLISECONDS:
return Sys_Milliseconds(); return Sys_Milliseconds();
case CG_CVAR_REGISTER: case CG_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] ); Cvar_Register( (vmCvar_t*) VMA(1), (const char*) VMA(2), (const char*) VMA(3), args[4] );
return 0; return 0;
case CG_CVAR_UPDATE: case CG_CVAR_UPDATE:
Cvar_Update( VMA(1) ); Cvar_Update( (vmCvar_t*) VMA(1) );
return 0; return 0;
case CG_CVAR_SET: case CG_CVAR_SET:
Cvar_Set( VMA(1), VMA(2) ); Cvar_Set( (const char*) VMA(1), (const char*) VMA(2) );
return 0; return 0;
case CG_CVAR_VARIABLESTRINGBUFFER: case CG_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] ); Cvar_VariableStringBuffer( (const char*) VMA(1), (char*) VMA(2), args[3] );
return 0; return 0;
case CG_ARGC: case CG_ARGC:
return Cmd_Argc(); return Cmd_Argc();
case CG_ARGV: case CG_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] ); Cmd_ArgvBuffer( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case CG_ARGS: case CG_ARGS:
Cmd_ArgsBuffer( VMA(1), args[2] ); Cmd_ArgsBuffer( (char*) VMA(1), args[2] );
return 0; return 0;
case CG_FS_FOPENFILE: case CG_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] ); return FS_FOpenFileByMode( (const char*) VMA(1), (fileHandle_t*) VMA(2), (fsMode_t) args[3] );
case CG_FS_READ: case CG_FS_READ:
FS_Read2( VMA(1), args[2], args[3] ); FS_Read2( VMA(1), args[2], args[3] );
return 0; return 0;
@ -459,16 +459,16 @@ intptr_t CL_CgameSystemCalls( intptr_t *args ) {
case CG_FS_SEEK: case CG_FS_SEEK:
return FS_Seek( args[1], args[2], args[3] ); return FS_Seek( args[1], args[2], args[3] );
case CG_SENDCONSOLECOMMAND: case CG_SENDCONSOLECOMMAND:
Cbuf_AddText( VMA(1) ); Cbuf_AddText( (const char*) VMA(1) );
return 0; return 0;
case CG_ADDCOMMAND: case CG_ADDCOMMAND:
CL_AddCgameCommand( VMA(1) ); CL_AddCgameCommand( (const char*) VMA(1) );
return 0; return 0;
case CG_REMOVECOMMAND: case CG_REMOVECOMMAND:
Cmd_RemoveCommand( VMA(1) ); Cmd_RemoveCommand( (const char*) VMA(1) );
return 0; return 0;
case CG_SENDCLIENTCOMMAND: case CG_SENDCLIENTCOMMAND:
CL_AddReliableCommand( VMA(1) ); CL_AddReliableCommand( (const char*) VMA(1) );
return 0; return 0;
case CG_UPDATESCREEN: case CG_UPDATESCREEN:
// this is used during lengthy level loading, so pump message loop // this is used during lengthy level loading, so pump message loop
@ -479,127 +479,127 @@ intptr_t CL_CgameSystemCalls( intptr_t *args ) {
SCR_UpdateScreen(); SCR_UpdateScreen();
return 0; return 0;
case CG_CM_LOADMAP: case CG_CM_LOADMAP:
CL_CM_LoadMap( VMA(1) ); CL_CM_LoadMap( (const char*) VMA(1) );
return 0; return 0;
case CG_CM_NUMINLINEMODELS: case CG_CM_NUMINLINEMODELS:
return CM_NumInlineModels(); return CM_NumInlineModels();
case CG_CM_INLINEMODEL: case CG_CM_INLINEMODEL:
return CM_InlineModel( args[1] ); return CM_InlineModel( args[1] );
case CG_CM_TEMPBOXMODEL: case CG_CM_TEMPBOXMODEL:
return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qfalse ); return CM_TempBoxModel((const vec_t*)VMA(1), (const vec_t*) VMA(2), /*int capsule*/ qfalse);
case CG_CM_TEMPCAPSULEMODEL: case CG_CM_TEMPCAPSULEMODEL:
return CM_TempBoxModel( VMA(1), VMA(2), /*int capsule*/ qtrue ); return CM_TempBoxModel((const vec_t*)VMA(1), (const vec_t*) VMA(2), /*int capsule*/ qtrue);
case CG_CM_POINTCONTENTS: case CG_CM_POINTCONTENTS:
return CM_PointContents( VMA(1), args[2] ); return CM_PointContents((const vec_t*) VMA(1), args[2]);
case CG_CM_TRANSFORMEDPOINTCONTENTS: case CG_CM_TRANSFORMEDPOINTCONTENTS:
return CM_TransformedPointContents( VMA(1), args[2], VMA(3), VMA(4) ); return CM_TransformedPointContents((const vec_t*)VMA(1), args[2], (const vec_t*)VMA(3), (const vec_t*) VMA(4));
case CG_CM_BOXTRACE: case CG_CM_BOXTRACE:
CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qfalse ); CM_BoxTrace((trace_t*)VMA(1), (const vec_t*)VMA(2), (const vec_t*) VMA(3), (vec_t*) VMA(4), (vec_t*) VMA(5), args[6], args[7], /*int capsule*/ qfalse);
return 0; return 0;
case CG_CM_CAPSULETRACE: case CG_CM_CAPSULETRACE:
CM_BoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qtrue ); CM_BoxTrace((trace_t*)VMA(1), (const vec_t*)VMA(2), (const vec_t*) VMA(3), (vec_t*) VMA(4), (vec_t*) VMA(5), args[6], args[7], /*int capsule*/ qtrue);
return 0; return 0;
case CG_CM_TRANSFORMEDBOXTRACE: case CG_CM_TRANSFORMEDBOXTRACE:
CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qfalse ); CM_TransformedBoxTrace((trace_t*)VMA(1), (const vec_t*)VMA(2), (const vec_t*)VMA(3), (vec_t*)VMA(4), (vec_t*)VMA(5), args[6], args[7], (const vec_t*)VMA(8), (const vec_t*) VMA(9), /*int capsule*/ qfalse);
return 0; return 0;
case CG_CM_TRANSFORMEDCAPSULETRACE: case CG_CM_TRANSFORMEDCAPSULETRACE:
CM_TransformedBoxTrace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], VMA(8), VMA(9), /*int capsule*/ qtrue ); CM_TransformedBoxTrace((trace_t*)VMA(1), (const vec_t*)VMA(2), (const vec_t*)VMA(3), (vec_t*)VMA(4), (vec_t*)VMA(5), args[6], args[7], (const vec_t*)VMA(8), (const vec_t*) VMA(9), /*int capsule*/ qtrue);
return 0; return 0;
case CG_CM_MARKFRAGMENTS: case CG_CM_MARKFRAGMENTS:
return re.MarkFragments( args[1], VMA(2), VMA(3), args[4], VMA(5), args[6], VMA(7) ); return re.MarkFragments(args[1], (const vec3_t*)VMA(2), (const vec_t*) VMA(3), args[4], (vec_t*) VMA(5), args[6], (markFragment_t*) VMA(7));
case CG_S_STARTSOUND: case CG_S_STARTSOUND:
S_StartSound( VMA(1), args[2], args[3], args[4] ); S_StartSound( (vec_t*) VMA(1), args[2], args[3], args[4] );
return 0; return 0;
case CG_S_STARTLOCALSOUND: case CG_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] ); S_StartLocalSound( args[1], args[2] );
return 0; return 0;
case CG_S_CLEARLOOPINGSOUNDS: case CG_S_CLEARLOOPINGSOUNDS:
S_ClearLoopingSounds(args[1]); S_ClearLoopingSounds((qboolean) args[1]);
return 0; return 0;
case CG_S_ADDLOOPINGSOUND: case CG_S_ADDLOOPINGSOUND:
S_AddLoopingSound( args[1], VMA(2), VMA(3), args[4] ); S_AddLoopingSound(args[1], (const vec_t*)VMA(2), (const vec_t*) VMA(3), args[4]);
return 0; return 0;
case CG_S_ADDREALLOOPINGSOUND: case CG_S_ADDREALLOOPINGSOUND:
S_AddRealLoopingSound( args[1], VMA(2), VMA(3), args[4] ); S_AddRealLoopingSound(args[1], (const vec_t*)VMA(2), (const vec_t*) VMA(3), args[4]);
return 0; return 0;
case CG_S_STOPLOOPINGSOUND: case CG_S_STOPLOOPINGSOUND:
S_StopLoopingSound( args[1] ); S_StopLoopingSound( args[1] );
return 0; return 0;
case CG_S_UPDATEENTITYPOSITION: case CG_S_UPDATEENTITYPOSITION:
S_UpdateEntityPosition( args[1], VMA(2) ); S_UpdateEntityPosition(args[1], (const vec_t*) VMA(2));
return 0; return 0;
case CG_S_RESPATIALIZE: case CG_S_RESPATIALIZE:
S_Respatialize( args[1], VMA(2), VMA(3), args[4] ); S_Respatialize(args[1], (const vec_t*) VMA(2), (vec3_t*) VMA(3), args[4]);
return 0; return 0;
case CG_S_REGISTERSOUND: case CG_S_REGISTERSOUND:
return S_RegisterSound( VMA(1), args[2] ); return S_RegisterSound( (const char*) VMA(1), (qboolean) args[2] );
case CG_S_STARTBACKGROUNDTRACK: case CG_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA(1), VMA(2) ); S_StartBackgroundTrack( (const char*) VMA(1), (const char*) VMA(2) );
return 0; return 0;
case CG_R_LOADWORLDMAP: case CG_R_LOADWORLDMAP:
re.LoadWorld( VMA(1) ); re.LoadWorld( (const char*) VMA(1) );
return 0; return 0;
case CG_R_REGISTERMODEL: case CG_R_REGISTERMODEL:
return re.RegisterModel( VMA(1) ); return re.RegisterModel( (const char*) VMA(1) );
case CG_R_REGISTERSKIN: case CG_R_REGISTERSKIN:
return re.RegisterSkin( VMA(1) ); return re.RegisterSkin( (const char*) VMA(1) );
case CG_R_REGISTERSHADER: case CG_R_REGISTERSHADER:
return re.RegisterShader( VMA(1) ); return re.RegisterShader( (const char*) VMA(1) );
case CG_R_REGISTERSHADERNOMIP: case CG_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA(1) ); return re.RegisterShaderNoMip( (const char*) VMA(1) );
case CG_R_REGISTERFONT: case CG_R_REGISTERFONT:
re.RegisterFont( VMA(1), args[2], VMA(3)); re.RegisterFont( (const char*) VMA(1), args[2], (fontInfo_t*) VMA(3));
case CG_R_CLEARSCENE: case CG_R_CLEARSCENE:
re.ClearScene(); re.ClearScene();
return 0; return 0;
case CG_R_ADDREFENTITYTOSCENE: case CG_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA(1) ); re.AddRefEntityToScene( (const refEntity_t*) VMA(1) );
return 0; return 0;
case CG_R_ADDPOLYTOSCENE: case CG_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), 1 ); re.AddPolyToScene( args[1], args[2], (const polyVert_t*) VMA(3), 1 );
return 0; return 0;
case CG_R_ADDPOLYSTOSCENE: case CG_R_ADDPOLYSTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), args[4] ); re.AddPolyToScene( args[1], args[2], (const polyVert_t*) VMA(3), args[4] );
return 0; return 0;
case CG_R_LIGHTFORPOINT: case CG_R_LIGHTFORPOINT:
return re.LightForPoint( VMA(1), VMA(2), VMA(3), VMA(4) ); return re.LightForPoint( (vec_t*) VMA(1), (vec_t*) VMA(2), (vec_t*) VMA(3), (vec_t*) VMA(4) );
case CG_R_ADDLIGHTTOSCENE: case CG_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) ); re.AddLightToScene((const vec_t*) VMA(1), VMF(2), VMF(3), VMF(4), VMF(5));
return 0; return 0;
case CG_R_ADDADDITIVELIGHTTOSCENE: case CG_R_ADDADDITIVELIGHTTOSCENE:
re.AddAdditiveLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) ); re.AddAdditiveLightToScene((const vec_t*) VMA(1), VMF(2), VMF(3), VMF(4), VMF(5));
return 0; return 0;
case CG_R_RENDERSCENE: case CG_R_RENDERSCENE:
re.RenderScene( VMA(1) ); re.RenderScene( (const refdef_t*) VMA(1) );
return 0; return 0;
case CG_R_SETCOLOR: case CG_R_SETCOLOR:
re.SetColor( VMA(1) ); re.SetColor( (const float*) VMA(1) );
return 0; return 0;
case CG_R_DRAWSTRETCHPIC: case CG_R_DRAWSTRETCHPIC:
re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] ); re.DrawStretchPic( VMF(1), VMF(2), VMF(3), VMF(4), VMF(5), VMF(6), VMF(7), VMF(8), args[9] );
return 0; return 0;
case CG_R_MODELBOUNDS: case CG_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA(2), VMA(3) ); re.ModelBounds( args[1], (vec_t*) VMA(2), (vec_t*) VMA(3) );
return 0; return 0;
case CG_R_LERPTAG: case CG_R_LERPTAG:
return re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) ); return re.LerpTag( (orientation_t*) VMA(1), args[2], args[3], args[4], VMF(5), (const char*) VMA(6) );
case CG_GETGLCONFIG: case CG_GETGLCONFIG:
CL_GetGlconfig( VMA(1) ); CL_GetGlconfig( (glconfig_t*) VMA(1) );
return 0; return 0;
case CG_GETGAMESTATE: case CG_GETGAMESTATE:
CL_GetGameState( VMA(1) ); CL_GetGameState( (gameState_t*) VMA(1) );
return 0; return 0;
case CG_GETCURRENTSNAPSHOTNUMBER: case CG_GETCURRENTSNAPSHOTNUMBER:
CL_GetCurrentSnapshotNumber( VMA(1), VMA(2) ); CL_GetCurrentSnapshotNumber( (int*) VMA(1), (int*) VMA(2) );
return 0; return 0;
case CG_GETSNAPSHOT: case CG_GETSNAPSHOT:
return CL_GetSnapshot( args[1], VMA(2) ); return CL_GetSnapshot( args[1], (snapshot_t*) VMA(2) );
case CG_GETSERVERCOMMAND: case CG_GETSERVERCOMMAND:
return CL_GetServerCommand( args[1] ); return CL_GetServerCommand( args[1] );
case CG_GETCURRENTCMDNUMBER: case CG_GETCURRENTCMDNUMBER:
return CL_GetCurrentCmdNumber(); return CL_GetCurrentCmdNumber();
case CG_GETUSERCMD: case CG_GETUSERCMD:
return CL_GetUserCmd( args[1], VMA(2) ); return CL_GetUserCmd( args[1], (usercmd_t*) VMA(2) );
case CG_SETUSERCMDVALUE: case CG_SETUSERCMDVALUE:
CL_SetUserCmdValue( args[1], VMF(2) ); CL_SetUserCmdValue( args[1], VMF(2) );
return 0; return 0;
@ -613,7 +613,7 @@ intptr_t CL_CgameSystemCalls( intptr_t *args ) {
Key_SetCatcher( args[1] ); Key_SetCatcher( args[1] );
return 0; return 0;
case CG_KEY_GETKEY: case CG_KEY_GETKEY:
return Key_GetKey( VMA(1) ); return Key_GetKey( (const char*) VMA(1) );
@ -624,7 +624,7 @@ intptr_t CL_CgameSystemCalls( intptr_t *args ) {
Com_Memcpy( VMA(1), VMA(2), args[3] ); Com_Memcpy( VMA(1), VMA(2), args[3] );
return 0; return 0;
case CG_STRNCPY: case CG_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] ); strncpy( (char*)VMA(1), (const char*)VMA(2), args[3] );
return args[1]; return args[1];
case CG_SIN: case CG_SIN:
return FloatAsInt( sin( VMF(1) ) ); return FloatAsInt( sin( VMF(1) ) );
@ -642,28 +642,28 @@ intptr_t CL_CgameSystemCalls( intptr_t *args ) {
return FloatAsInt( Q_acos( VMF(1) ) ); return FloatAsInt( Q_acos( VMF(1) ) );
case CG_PC_ADD_GLOBAL_DEFINE: case CG_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA(1) ); return botlib_export->PC_AddGlobalDefine( (char*) VMA(1) );
case CG_PC_LOAD_SOURCE: case CG_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA(1) ); return botlib_export->PC_LoadSourceHandle( (const char*) VMA(1) );
case CG_PC_FREE_SOURCE: case CG_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] ); return botlib_export->PC_FreeSourceHandle( args[1] );
case CG_PC_READ_TOKEN: case CG_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) ); return botlib_export->PC_ReadTokenHandle( args[1], (pc_token_t*) VMA(2) );
case CG_PC_SOURCE_FILE_AND_LINE: case CG_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) ); return botlib_export->PC_SourceFileAndLine( args[1], (char*) VMA(2), (int*) VMA(3) );
case CG_S_STOPBACKGROUNDTRACK: case CG_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack(); S_StopBackgroundTrack();
return 0; return 0;
case CG_REAL_TIME: case CG_REAL_TIME:
return Com_RealTime( VMA(1) ); return Com_RealTime( (qtime_t*) VMA(1) );
case CG_SNAPVECTOR: case CG_SNAPVECTOR:
Sys_SnapVector( VMA(1) ); Sys_SnapVector( (float*) VMA(1) );
return 0; return 0;
case CG_CIN_PLAYCINEMATIC: case CG_CIN_PLAYCINEMATIC:
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]); return CIN_PlayCinematic((const char*) VMA(1), args[2], args[3], args[4], args[5], args[6]);
case CG_CIN_STOPCINEMATIC: case CG_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]); return CIN_StopCinematic(args[1]);
@ -680,7 +680,7 @@ intptr_t CL_CgameSystemCalls( intptr_t *args ) {
return 0; return 0;
case CG_R_REMAP_SHADER: case CG_R_REMAP_SHADER:
re.RemapShader( VMA(1), VMA(2), VMA(3) ); re.RemapShader( (const char*) VMA(1), (const char*) VMA(2), (const char*) VMA(3) );
return 0; return 0;
/* /*
@ -695,9 +695,9 @@ intptr_t CL_CgameSystemCalls( intptr_t *args ) {
return getCameraInfo(args[1], VMA(2), VMA(3)); return getCameraInfo(args[1], VMA(2), VMA(3));
*/ */
case CG_GET_ENTITY_TOKEN: case CG_GET_ENTITY_TOKEN:
return re.GetEntityToken( VMA(1), args[2] ); return re.GetEntityToken( (char*) VMA(1), args[2] );
case CG_R_INPVS: case CG_R_INPVS:
return re.inPVS( VMA(1), VMA(2) ); return re.inPVS((const vec_t*)VMA(1), (const vec_t*) VMA(2));
default: default:
assert(0); // bk010102 assert(0); // bk010102
@ -736,7 +736,7 @@ void CL_InitCGame( void ) {
interpret = VMI_BYTECODE; interpret = VMI_BYTECODE;
} }
else { else {
interpret = Cvar_VariableValue( "vm_cgame" ); interpret = (vmInterpret_t) (int) Cvar_VariableValue( "vm_cgame" );
} }
cgvm = VM_Create( "cgame", CL_CgameSystemCalls, interpret ); cgvm = VM_Create( "cgame", CL_CgameSystemCalls, interpret );
if ( !cgvm ) { if ( !cgvm ) {
@ -783,7 +783,7 @@ qboolean CL_GameCommand( void ) {
return qfalse; return qfalse;
} }
return VM_Call( cgvm, CG_CONSOLE_COMMAND ); return (qboolean) VM_Call( cgvm, CG_CONSOLE_COMMAND );
} }

18
code/client/cl_cin.c
View File

@ -1221,7 +1221,7 @@ redump:
if (cinTable[currentHandle].numQuads != 1) cinTable[currentHandle].numQuads = 0; if (cinTable[currentHandle].numQuads != 1) cinTable[currentHandle].numQuads = 0;
break; break;
case ROQ_PACKET: case ROQ_PACKET:
cinTable[currentHandle].inMemory = cinTable[currentHandle].roq_flags; cinTable[currentHandle].inMemory = (qboolean) cinTable[currentHandle].roq_flags;
cinTable[currentHandle].RoQFrameSize = 0; // for header cinTable[currentHandle].RoQFrameSize = 0; // for header
break; break;
case ROQ_QUAD_HANG: case ROQ_QUAD_HANG:
@ -1264,7 +1264,7 @@ redump:
} }
return; return;
} }
if (cinTable[currentHandle].inMemory && (cinTable[currentHandle].status != FMV_EOF)) { cinTable[currentHandle].inMemory--; framedata += 8; goto redump; } if (cinTable[currentHandle].inMemory && (cinTable[currentHandle].status != FMV_EOF)) { ((int&)cinTable[currentHandle].inMemory)--; framedata += 8; goto redump; }
// //
// one more frame hits the dust // one more frame hits the dust
// //
@ -1419,7 +1419,7 @@ e_status CIN_RunCinematic (int handle)
// we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer // we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer
thisTime = CL_ScaledMilliseconds()*com_timescale->value; thisTime = CL_ScaledMilliseconds()*com_timescale->value;
if (cinTable[currentHandle].shader && (abs(thisTime - cinTable[currentHandle].lastTime))>100) { if (cinTable[currentHandle].shader && (abs((int)(thisTime - cinTable[currentHandle].lastTime)))>100) {
cinTable[currentHandle].startTime += thisTime - cinTable[currentHandle].lastTime; cinTable[currentHandle].startTime += thisTime - cinTable[currentHandle].lastTime;
} }
// we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer // we need to use CL_ScaledMilliseconds because of the smp mode calls from the renderer
@ -1499,15 +1499,15 @@ int CIN_PlayCinematic( const char *arg, int x, int y, int w, int h, int systemBi
} }
CIN_SetExtents(currentHandle, x, y, w, h); CIN_SetExtents(currentHandle, x, y, w, h);
CIN_SetLooping(currentHandle, (systemBits & CIN_loop)!=0); CIN_SetLooping(currentHandle, (qboolean) ((systemBits & CIN_loop)!=0));
cinTable[currentHandle].CIN_HEIGHT = DEFAULT_CIN_HEIGHT; cinTable[currentHandle].CIN_HEIGHT = DEFAULT_CIN_HEIGHT;
cinTable[currentHandle].CIN_WIDTH = DEFAULT_CIN_WIDTH; cinTable[currentHandle].CIN_WIDTH = DEFAULT_CIN_WIDTH;
cinTable[currentHandle].holdAtEnd = (systemBits & CIN_hold) != 0; cinTable[currentHandle].holdAtEnd = (qboolean) ((systemBits & CIN_hold) != 0);
cinTable[currentHandle].alterGameState = (systemBits & CIN_system) != 0; cinTable[currentHandle].alterGameState = (qboolean) ((systemBits & CIN_system) != 0);
cinTable[currentHandle].playonwalls = 1; cinTable[currentHandle].playonwalls = 1;
cinTable[currentHandle].silent = (systemBits & CIN_silent) != 0; cinTable[currentHandle].silent = (qboolean) ((systemBits & CIN_silent) != 0);
cinTable[currentHandle].shader = (systemBits & CIN_shader) != 0; cinTable[currentHandle].shader = (qboolean) ((systemBits & CIN_shader) != 0);
if (cinTable[currentHandle].alterGameState) { if (cinTable[currentHandle].alterGameState) {
// close the menu // close the menu
@ -1597,7 +1597,7 @@ void CIN_DrawCinematic (int handle) {
} }
buf3 = (int*)buf; buf3 = (int*)buf;
buf2 = Hunk_AllocateTempMemory( 256*256*4 ); buf2 = (int*) Hunk_AllocateTempMemory( 256*256*4 );
if (xm==2 && ym==2) { if (xm==2 && ym==2) {
byte *bc2, *bc3; byte *bc2, *bc3;
int ic, iiy; int ic, iiy;

4
code/client/cl_input.c
View File

@ -559,10 +559,10 @@ usercmd_t CL_CreateCmd( void ) {
// draw debug graphs of turning for mouse testing // draw debug graphs of turning for mouse testing
if ( cl_debugMove->integer ) { if ( cl_debugMove->integer ) {
if ( cl_debugMove->integer == 1 ) { if ( cl_debugMove->integer == 1 ) {
SCR_DebugGraph( abs(cl.viewangles[YAW] - oldAngles[YAW]), 0 ); SCR_DebugGraph( fabs(cl.viewangles[YAW] - oldAngles[YAW]), 0 );
} }
if ( cl_debugMove->integer == 2 ) { if ( cl_debugMove->integer == 2 ) {
SCR_DebugGraph( abs(cl.viewangles[PITCH] - oldAngles[PITCH]), 0 ); SCR_DebugGraph( fabs(cl.viewangles[PITCH] - oldAngles[PITCH]), 0 );
} }
} }

10
code/client/cl_keys.c
View File

@ -377,7 +377,7 @@ void Field_KeyDownEvent( field_t *edit, int key ) {
} }
if ( key == K_INS ) { if ( key == K_INS ) {
key_overstrikeMode = !key_overstrikeMode; key_overstrikeMode = (qboolean) !key_overstrikeMode;
return; return;
} }
} }
@ -1030,13 +1030,13 @@ void CL_KeyEvent (int key, qboolean down, unsigned time) {
if (down) { if (down) {
keys[key].repeats++; keys[key].repeats++;
if ( keys[key].repeats == 1) { if ( keys[key].repeats == 1) {
anykeydown++; ((int&)anykeydown)++;
} }
} else { } else {
keys[key].repeats = 0; keys[key].repeats = 0;
anykeydown--; ((int&)anykeydown)--;
if (anykeydown < 0) { if (anykeydown < 0) {
anykeydown = 0; (int&)anykeydown = 0;
} }
} }
@ -1245,7 +1245,7 @@ void Key_ClearStates (void)
CL_KeyEvent( i, qfalse, 0 ); CL_KeyEvent( i, qfalse, 0 );
} }
keys[i].down = 0; keys[i].down = (qboolean) 0;
keys[i].repeats = 0; keys[i].repeats = 0;
} }
} }

2
code/client/cl_main.c
View File

@ -1543,7 +1543,7 @@ void CL_CheckForResend( void ) {
data[10+i] = 0; data[10+i] = 0;
// NOTE TTimo don't forget to set the right data length! // NOTE TTimo don't forget to set the right data length!
NET_OutOfBandData( NS_CLIENT, clc.serverAddress, &data[0], i+10 ); NET_OutOfBandData( NS_CLIENT, clc.serverAddress, (byte*) &data[0], i+10 );
// the most current userinfo has been sent, so watch for any // the most current userinfo has been sent, so watch for any
// newer changes to userinfo variables // newer changes to userinfo variables
cvar_modifiedFlags &= ~CVAR_USERINFO; cvar_modifiedFlags &= ~CVAR_USERINFO;

10
code/client/cl_net_chan.c
View File

@ -50,13 +50,13 @@ static void CL_Netchan_Encode( msg_t *msg ) {
msg->bit = 0; msg->bit = 0;
msg->readcount = 0; msg->readcount = 0;
msg->oob = 0; msg->oob = (qboolean) 0;
serverId = MSG_ReadLong(msg); serverId = MSG_ReadLong(msg);
messageAcknowledge = MSG_ReadLong(msg); messageAcknowledge = MSG_ReadLong(msg);
reliableAcknowledge = MSG_ReadLong(msg); reliableAcknowledge = MSG_ReadLong(msg);
msg->oob = soob; msg->oob = (qboolean) soob;
msg->bit = sbit; msg->bit = sbit;
msg->readcount = srdc; msg->readcount = srdc;
@ -98,15 +98,15 @@ static void CL_Netchan_Decode( msg_t *msg ) {
sbit = msg->bit; sbit = msg->bit;
soob = msg->oob; soob = msg->oob;
msg->oob = 0; msg->oob = (qboolean) 0;
reliableAcknowledge = MSG_ReadLong(msg); reliableAcknowledge = MSG_ReadLong(msg);
msg->oob = soob; msg->oob = (qboolean) soob;
msg->bit = sbit; msg->bit = sbit;
msg->readcount = srdc; msg->readcount = srdc;
string = clc.reliableCommands[ reliableAcknowledge & (MAX_RELIABLE_COMMANDS-1) ]; string = (byte*) clc.reliableCommands[ reliableAcknowledge & (MAX_RELIABLE_COMMANDS-1) ];
index = 0; index = 0;
// xor the client challenge with the netchan sequence number (need something that changes every message) // xor the client challenge with the netchan sequence number (need something that changes every message)
key = clc.challenge ^ LittleLong( *(unsigned *)msg->data ); key = clc.challenge ^ LittleLong( *(unsigned *)msg->data );

113
code/client/cl_ui.c
View File

@ -782,53 +782,53 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return Sys_Milliseconds(); return Sys_Milliseconds();
case UI_CVAR_REGISTER: case UI_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] ); Cvar_Register( (vmCvar_t*) VMA(1), (const char*) VMA(2), (const char*) VMA(3), args[4] );
return 0; return 0;
case UI_CVAR_UPDATE: case UI_CVAR_UPDATE:
Cvar_Update( VMA(1) ); Cvar_Update( (vmCvar_t*) VMA(1) );
return 0; return 0;
case UI_CVAR_SET: case UI_CVAR_SET:
Cvar_Set( VMA(1), VMA(2) ); Cvar_Set( (const char*) VMA(1), (const char*) VMA(2) );
return 0; return 0;
case UI_CVAR_VARIABLEVALUE: case UI_CVAR_VARIABLEVALUE:
return FloatAsInt( Cvar_VariableValue( VMA(1) ) ); return FloatAsInt( Cvar_VariableValue( (const char*) VMA(1) ) );
case UI_CVAR_VARIABLESTRINGBUFFER: case UI_CVAR_VARIABLESTRINGBUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] ); Cvar_VariableStringBuffer( (const char*) VMA(1), (char*) VMA(2), args[3] );
return 0; return 0;
case UI_CVAR_SETVALUE: case UI_CVAR_SETVALUE:
Cvar_SetValue( VMA(1), VMF(2) ); Cvar_SetValue( (const char*) VMA(1), VMF(2) );
return 0; return 0;
case UI_CVAR_RESET: case UI_CVAR_RESET:
Cvar_Reset( VMA(1) ); Cvar_Reset( (const char*) VMA(1) );
return 0; return 0;
case UI_CVAR_CREATE: case UI_CVAR_CREATE:
Cvar_Get( VMA(1), VMA(2), args[3] ); Cvar_Get( (const char*) VMA(1), (const char*) VMA(2), args[3] );
return 0; return 0;
case UI_CVAR_INFOSTRINGBUFFER: case UI_CVAR_INFOSTRINGBUFFER:
Cvar_InfoStringBuffer( args[1], VMA(2), args[3] ); Cvar_InfoStringBuffer( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case UI_ARGC: case UI_ARGC:
return Cmd_Argc(); return Cmd_Argc();
case UI_ARGV: case UI_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] ); Cmd_ArgvBuffer( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case UI_CMD_EXECUTETEXT: case UI_CMD_EXECUTETEXT:
Cbuf_ExecuteText( args[1], VMA(2) ); Cbuf_ExecuteText( args[1], (char*) VMA(2) );
return 0; return 0;
case UI_FS_FOPENFILE: case UI_FS_FOPENFILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] ); return FS_FOpenFileByMode( (const char*) VMA(1), (fileHandle_t*) VMA(2), (fsMode_t) args[3] );
case UI_FS_READ: case UI_FS_READ:
FS_Read2( VMA(1), args[2], args[3] ); FS_Read2( VMA(1), args[2], args[3] );
@ -843,42 +843,42 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_FS_GETFILELIST: case UI_FS_GETFILELIST:
return FS_GetFileList( VMA(1), VMA(2), VMA(3), args[4] ); return FS_GetFileList( (const char*) VMA(1), (const char*) VMA(2), (char*) VMA(3), args[4] );
case UI_FS_SEEK: case UI_FS_SEEK:
return FS_Seek( args[1], args[2], args[3] ); return FS_Seek( args[1], args[2], args[3] );
case UI_R_REGISTERMODEL: case UI_R_REGISTERMODEL:
return re.RegisterModel( VMA(1) ); return re.RegisterModel( (const char*) VMA(1) );
case UI_R_REGISTERSKIN: case UI_R_REGISTERSKIN:
return re.RegisterSkin( VMA(1) ); return re.RegisterSkin( (const char*) VMA(1) );
case UI_R_REGISTERSHADERNOMIP: case UI_R_REGISTERSHADERNOMIP:
return re.RegisterShaderNoMip( VMA(1) ); return re.RegisterShaderNoMip( (const char*) VMA(1) );
case UI_R_CLEARSCENE: case UI_R_CLEARSCENE:
re.ClearScene(); re.ClearScene();
return 0; return 0;
case UI_R_ADDREFENTITYTOSCENE: case UI_R_ADDREFENTITYTOSCENE:
re.AddRefEntityToScene( VMA(1) ); re.AddRefEntityToScene( (const refEntity_t*) VMA(1) );
return 0; return 0;
case UI_R_ADDPOLYTOSCENE: case UI_R_ADDPOLYTOSCENE:
re.AddPolyToScene( args[1], args[2], VMA(3), 1 ); re.AddPolyToScene( args[1], args[2], (const polyVert_t*) VMA(3), 1 );
return 0; return 0;
case UI_R_ADDLIGHTTOSCENE: case UI_R_ADDLIGHTTOSCENE:
re.AddLightToScene( VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) ); re.AddLightToScene( (const vec_t*) VMA(1), VMF(2), VMF(3), VMF(4), VMF(5) );
return 0; return 0;
case UI_R_RENDERSCENE: case UI_R_RENDERSCENE:
re.RenderScene( VMA(1) ); re.RenderScene( (const refdef_t*) VMA(1) );
return 0; return 0;
case UI_R_SETCOLOR: case UI_R_SETCOLOR:
re.SetColor( VMA(1) ); re.SetColor( (const float*) VMA(1) );
return 0; return 0;
case UI_R_DRAWSTRETCHPIC: case UI_R_DRAWSTRETCHPIC:
@ -886,7 +886,7 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_R_MODELBOUNDS: case UI_R_MODELBOUNDS:
re.ModelBounds( args[1], VMA(2), VMA(3) ); re.ModelBounds( args[1], (vec_t*) VMA(2), (vec_t*) VMA(3) );
return 0; return 0;
case UI_UPDATESCREEN: case UI_UPDATESCREEN:
@ -894,26 +894,26 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_CM_LERPTAG: case UI_CM_LERPTAG:
re.LerpTag( VMA(1), args[2], args[3], args[4], VMF(5), VMA(6) ); re.LerpTag( (orientation_t*) VMA(1), args[2], args[3], args[4], VMF(5), (const char*) VMA(6) );
return 0; return 0;
case UI_S_REGISTERSOUND: case UI_S_REGISTERSOUND:
return S_RegisterSound( VMA(1), args[2] ); return S_RegisterSound( (const char*) VMA(1), (qboolean) args[2] );
case UI_S_STARTLOCALSOUND: case UI_S_STARTLOCALSOUND:
S_StartLocalSound( args[1], args[2] ); S_StartLocalSound( args[1], args[2] );
return 0; return 0;
case UI_KEY_KEYNUMTOSTRINGBUF: case UI_KEY_KEYNUMTOSTRINGBUF:
Key_KeynumToStringBuf( args[1], VMA(2), args[3] ); Key_KeynumToStringBuf( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case UI_KEY_GETBINDINGBUF: case UI_KEY_GETBINDINGBUF:
Key_GetBindingBuf( args[1], VMA(2), args[3] ); Key_GetBindingBuf( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case UI_KEY_SETBINDING: case UI_KEY_SETBINDING:
Key_SetBinding( args[1], VMA(2) ); Key_SetBinding( args[1], (const char*) VMA(2) );
return 0; return 0;
case UI_KEY_ISDOWN: case UI_KEY_ISDOWN:
@ -923,7 +923,7 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return Key_GetOverstrikeMode(); return Key_GetOverstrikeMode();
case UI_KEY_SETOVERSTRIKEMODE: case UI_KEY_SETOVERSTRIKEMODE:
Key_SetOverstrikeMode( args[1] ); Key_SetOverstrikeMode( (qboolean) args[1] );
return 0; return 0;
case UI_KEY_CLEARSTATES: case UI_KEY_CLEARSTATES:
@ -938,19 +938,19 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_GETCLIPBOARDDATA: case UI_GETCLIPBOARDDATA:
GetClipboardData( VMA(1), args[2] ); GetClipboardData( (char*) VMA(1), args[2] );
return 0; return 0;
case UI_GETCLIENTSTATE: case UI_GETCLIENTSTATE:
GetClientState( VMA(1) ); GetClientState( (uiClientState_t*) VMA(1) );
return 0; return 0;
case UI_GETGLCONFIG: case UI_GETGLCONFIG:
CL_GetGlconfig( VMA(1) ); CL_GetGlconfig( (glconfig_t*) VMA(1) );
return 0; return 0;
case UI_GETCONFIGSTRING: case UI_GETCONFIGSTRING:
return GetConfigString( args[1], VMA(2), args[3] ); return GetConfigString( args[1], (char*) VMA(2), args[3] );
case UI_LAN_LOADCACHEDSERVERS: case UI_LAN_LOADCACHEDSERVERS:
LAN_LoadCachedServers(); LAN_LoadCachedServers();
@ -961,10 +961,10 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_LAN_ADDSERVER: case UI_LAN_ADDSERVER:
return LAN_AddServer(args[1], VMA(2), VMA(3)); return LAN_AddServer(args[1], (const char*) VMA(2), (const char*) VMA(3));
case UI_LAN_REMOVESERVER: case UI_LAN_REMOVESERVER:
LAN_RemoveServer(args[1], VMA(2)); LAN_RemoveServer(args[1], (const char*) VMA(2));
return 0; return 0;
case UI_LAN_GETPINGQUEUECOUNT: case UI_LAN_GETPINGQUEUECOUNT:
@ -975,29 +975,29 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_LAN_GETPING: case UI_LAN_GETPING:
LAN_GetPing( args[1], VMA(2), args[3], VMA(4) ); LAN_GetPing( args[1], (char*) VMA(2), args[3], (int*) VMA(4) );
return 0; return 0;
case UI_LAN_GETPINGINFO: case UI_LAN_GETPINGINFO:
LAN_GetPingInfo( args[1], VMA(2), args[3] ); LAN_GetPingInfo( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case UI_LAN_GETSERVERCOUNT: case UI_LAN_GETSERVERCOUNT:
return LAN_GetServerCount(args[1]); return LAN_GetServerCount(args[1]);
case UI_LAN_GETSERVERADDRESSSTRING: case UI_LAN_GETSERVERADDRESSSTRING:
LAN_GetServerAddressString( args[1], args[2], VMA(3), args[4] ); LAN_GetServerAddressString( args[1], args[2], (char*) VMA(3), args[4] );
return 0; return 0;
case UI_LAN_GETSERVERINFO: case UI_LAN_GETSERVERINFO:
LAN_GetServerInfo( args[1], args[2], VMA(3), args[4] ); LAN_GetServerInfo( args[1], args[2], (char*) VMA(3), args[4] );
return 0; return 0;
case UI_LAN_GETSERVERPING: case UI_LAN_GETSERVERPING:
return LAN_GetServerPing( args[1], args[2] ); return LAN_GetServerPing( args[1], args[2] );
case UI_LAN_MARKSERVERVISIBLE: case UI_LAN_MARKSERVERVISIBLE:
LAN_MarkServerVisible( args[1], args[2], args[3] ); LAN_MarkServerVisible( args[1], args[2], (qboolean) args[3] );
return 0; return 0;
case UI_LAN_SERVERISVISIBLE: case UI_LAN_SERVERISVISIBLE:
@ -1011,7 +1011,7 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_LAN_SERVERSTATUS: case UI_LAN_SERVERSTATUS:
return LAN_GetServerStatus( VMA(1), VMA(2), args[3] ); return LAN_GetServerStatus( (char*) VMA(1), (char*) VMA(2), args[3] );
case UI_LAN_COMPARESERVERS: case UI_LAN_COMPARESERVERS:
return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] ); return LAN_CompareServers( args[1], args[2], args[3], args[4], args[5] );
@ -1020,18 +1020,18 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return Hunk_MemoryRemaining(); return Hunk_MemoryRemaining();
case UI_GET_CDKEY: case UI_GET_CDKEY:
CLUI_GetCDKey( VMA(1), args[2] ); CLUI_GetCDKey( (char*) VMA(1), args[2] );
return 0; return 0;
case UI_SET_CDKEY: case UI_SET_CDKEY:
CLUI_SetCDKey( VMA(1) ); CLUI_SetCDKey( (char*) VMA(1) );
return 0; return 0;
case UI_SET_PBCLSTATUS: case UI_SET_PBCLSTATUS:
return 0; return 0;
case UI_R_REGISTERFONT: case UI_R_REGISTERFONT:
re.RegisterFont( VMA(1), args[2], VMA(3)); re.RegisterFont( (const char*) VMA(1), args[2], (fontInfo_t*) VMA(3));
return 0; return 0;
case UI_MEMSET: case UI_MEMSET:
@ -1043,9 +1043,8 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_STRNCPY: case UI_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] ); strncpy( (char*)VMA(1), (const char*)VMA(2), args[3] );
return args[1]; return args[1];
case UI_SIN: case UI_SIN:
return FloatAsInt( sin( VMF(1) ) ); return FloatAsInt( sin( VMF(1) ) );
@ -1065,29 +1064,29 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return FloatAsInt( ceil( VMF(1) ) ); return FloatAsInt( ceil( VMF(1) ) );
case UI_PC_ADD_GLOBAL_DEFINE: case UI_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA(1) ); return botlib_export->PC_AddGlobalDefine( (char*) VMA(1) );
case UI_PC_LOAD_SOURCE: case UI_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA(1) ); return botlib_export->PC_LoadSourceHandle( (const char*) VMA(1) );
case UI_PC_FREE_SOURCE: case UI_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] ); return botlib_export->PC_FreeSourceHandle( args[1] );
case UI_PC_READ_TOKEN: case UI_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) ); return botlib_export->PC_ReadTokenHandle( args[1], (pc_token_t*) VMA(2) );
case UI_PC_SOURCE_FILE_AND_LINE: case UI_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) ); return botlib_export->PC_SourceFileAndLine( args[1], (char*) VMA(2), (int*) VMA(3) );
case UI_S_STOPBACKGROUNDTRACK: case UI_S_STOPBACKGROUNDTRACK:
S_StopBackgroundTrack(); S_StopBackgroundTrack();
return 0; return 0;
case UI_S_STARTBACKGROUNDTRACK: case UI_S_STARTBACKGROUNDTRACK:
S_StartBackgroundTrack( VMA(1), VMA(2)); S_StartBackgroundTrack( (const char*) VMA(1), (const char*) VMA(2));
return 0; return 0;
case UI_REAL_TIME: case UI_REAL_TIME:
return Com_RealTime( VMA(1) ); return Com_RealTime( (qtime_t*) VMA(1) );
case UI_CIN_PLAYCINEMATIC: case UI_CIN_PLAYCINEMATIC:
Com_DPrintf("UI_CIN_PlayCinematic\n"); Com_DPrintf("UI_CIN_PlayCinematic\n");
return CIN_PlayCinematic(VMA(1), args[2], args[3], args[4], args[5], args[6]); return CIN_PlayCinematic( (const char*) VMA(1), args[2], args[3], args[4], args[5], args[6]);
case UI_CIN_STOPCINEMATIC: case UI_CIN_STOPCINEMATIC:
return CIN_StopCinematic(args[1]); return CIN_StopCinematic(args[1]);
@ -1104,11 +1103,11 @@ intptr_t CL_UISystemCalls( intptr_t *args ) {
return 0; return 0;
case UI_R_REMAP_SHADER: case UI_R_REMAP_SHADER:
re.RemapShader( VMA(1), VMA(2), VMA(3) ); re.RemapShader( (const char*) VMA(1), (const char*) VMA(2), (const char*) VMA(3) );
return 0; return 0;
case UI_VERIFY_CDKEY: case UI_VERIFY_CDKEY:
return CL_CDKeyValidate(VMA(1), VMA(2)); return CL_CDKeyValidate( (const char*) VMA(1), (const char*) VMA(2));
@ -1153,7 +1152,7 @@ void CL_InitUI( void ) {
interpret = VMI_BYTECODE; interpret = VMI_BYTECODE;
} }
else { else {
interpret = Cvar_VariableValue( "vm_ui" ); interpret = (vmInterpret_t) (int) Cvar_VariableValue( "vm_ui" );
} }
uivm = VM_Create( "ui", CL_UISystemCalls, interpret ); uivm = VM_Create( "ui", CL_UISystemCalls, interpret );
if ( !uivm ) { if ( !uivm ) {
@ -1179,7 +1178,7 @@ void CL_InitUI( void ) {
qboolean UI_usesUniqueCDKey() { qboolean UI_usesUniqueCDKey() {
if (uivm) { if (uivm) {
return (VM_Call( uivm, UI_HASUNIQUECDKEY) == qtrue); return (qboolean) (VM_Call( uivm, UI_HASUNIQUECDKEY) == qtrue);
} else { } else {
return qfalse; return qfalse;
} }
@ -1197,5 +1196,5 @@ qboolean UI_GameCommand( void ) {
return qfalse; return qfalse;
} }
return VM_Call( uivm, UI_CONSOLE_COMMAND, cls.realtime ); return (qboolean) VM_Call( uivm, UI_CONSOLE_COMMAND, cls.realtime );
} }

4
code/client/snd_adpcm.c
View File

@ -278,7 +278,7 @@ void S_AdpcmGetSamples(sndBuffer *chunk, short *to) {
out = (byte *)chunk->sndChunk; out = (byte *)chunk->sndChunk;
// get samples // get samples
S_AdpcmDecode( out, to, SND_CHUNK_SIZE_BYTE*2, &state ); S_AdpcmDecode( (const char*) out, to, SND_CHUNK_SIZE_BYTE*2, &state );
} }
@ -322,7 +322,7 @@ void S_AdpcmEncodeSound( sfx_t *sfx, short *samples ) {
out = (byte *)chunk->sndChunk; out = (byte *)chunk->sndChunk;
// encode the samples // encode the samples
S_AdpcmEncode( samples + inOffset, out, n, &state ); S_AdpcmEncode( samples + inOffset, (char*) out, n, &state );
inOffset += n; inOffset += n;
count -= n; count -= n;

2
code/client/snd_dma.c
View File

@ -171,7 +171,7 @@ void S_Init( void ) {
if ( r ) { if ( r ) {
s_soundStarted = 1; s_soundStarted = 1;
s_soundMuted = 1; s_soundMuted = (qboolean) 1;
// s_numSfx = 0; // s_numSfx = 0;
Com_Memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH); Com_Memset(sfxHash, 0, sizeof(sfx_t *)*LOOP_HASH);

6
code/client/snd_mem.c
View File

@ -82,9 +82,9 @@ void SND_setup() {
scs = (cv->integer*1536); scs = (cv->integer*1536);
buffer = malloc(scs*sizeof(sndBuffer) ); buffer = (sndBuffer*) malloc(scs*sizeof(sndBuffer));
// allocate the stack based hunk allocator // allocate the stack based hunk allocator
sfxScratchBuffer = malloc(SND_CHUNK_SIZE * sizeof(short) * 4); //Hunk_Alloc(SND_CHUNK_SIZE * sizeof(short) * 4); sfxScratchBuffer = (short*) malloc(SND_CHUNK_SIZE * sizeof(short) * 4); //Hunk_Alloc(SND_CHUNK_SIZE * sizeof(short) * 4);
sfxScratchPointer = NULL; sfxScratchPointer = NULL;
inUse = scs*sizeof(sndBuffer); inUse = scs*sizeof(sndBuffer);
@ -359,7 +359,7 @@ qboolean S_LoadSound( sfx_t *sfx )
Com_DPrintf(S_COLOR_YELLOW "WARNING: %s is not a 22kHz wav file\n", sfx->soundName); Com_DPrintf(S_COLOR_YELLOW "WARNING: %s is not a 22kHz wav file\n", sfx->soundName);
} }
samples = Hunk_AllocateTempMemory(info.samples * sizeof(short) * 2); samples = (short*) Hunk_AllocateTempMemory(info.samples * sizeof(short) * 2);
sfx->lastTimeUsed = Com_Milliseconds()+1; sfx->lastTimeUsed = Com_Milliseconds()+1;

60
code/qcommon/cm_load.c
View File

@ -91,7 +91,7 @@ void CMod_LoadShaders( lump_t *l ) {
dshader_t *in, *out; dshader_t *in, *out;
int i, count; int i, count;
in = (void *)(cmod_base + l->fileofs); in = (dshader_t*) (void *)(cmod_base + l->fileofs);
if (l->filelen % sizeof(*in)) { if (l->filelen % sizeof(*in)) {
Com_Error (ERR_DROP, "CMod_LoadShaders: funny lump size"); Com_Error (ERR_DROP, "CMod_LoadShaders: funny lump size");
} }
@ -100,7 +100,7 @@ void CMod_LoadShaders( lump_t *l ) {
if (count < 1) { if (count < 1) {
Com_Error (ERR_DROP, "Map with no shaders"); Com_Error (ERR_DROP, "Map with no shaders");
} }
cm.shaders = Hunk_Alloc( count * sizeof( *cm.shaders ), h_high ); cm.shaders = (dshader_t*) Hunk_Alloc( count * sizeof( *cm.shaders ), h_high );
cm.numShaders = count; cm.numShaders = count;
Com_Memcpy( cm.shaders, in, count * sizeof( *cm.shaders ) ); Com_Memcpy( cm.shaders, in, count * sizeof( *cm.shaders ) );
@ -124,14 +124,14 @@ void CMod_LoadSubmodels( lump_t *l ) {
int i, j, count; int i, j, count;
int *indexes; int *indexes;
in = (void *)(cmod_base + l->fileofs); in = (dmodel_t*) (void *)(cmod_base + l->fileofs);
if (l->filelen % sizeof(*in)) if (l->filelen % sizeof(*in))
Com_Error (ERR_DROP, "CMod_LoadSubmodels: funny lump size"); Com_Error (ERR_DROP, "CMod_LoadSubmodels: funny lump size");
count = l->filelen / sizeof(*in); count = l->filelen / sizeof(*in);
if (count < 1) if (count < 1)
Com_Error (ERR_DROP, "Map with no models"); Com_Error (ERR_DROP, "Map with no models");
cm.cmodels = Hunk_Alloc( count * sizeof( *cm.cmodels ), h_high ); cm.cmodels = (cmodel_t*) Hunk_Alloc( count * sizeof( *cm.cmodels ), h_high );
cm.numSubModels = count; cm.numSubModels = count;
if ( count > MAX_SUBMODELS ) { if ( count > MAX_SUBMODELS ) {
@ -154,14 +154,14 @@ void CMod_LoadSubmodels( lump_t *l ) {
// make a "leaf" just to hold the model's brushes and surfaces // make a "leaf" just to hold the model's brushes and surfaces
out->leaf.numLeafBrushes = LittleLong( in->numBrushes ); out->leaf.numLeafBrushes = LittleLong( in->numBrushes );
indexes = Hunk_Alloc( out->leaf.numLeafBrushes * 4, h_high ); indexes = (int*) Hunk_Alloc( out->leaf.numLeafBrushes * 4, h_high );
out->leaf.firstLeafBrush = indexes - cm.leafbrushes; out->leaf.firstLeafBrush = indexes - cm.leafbrushes;
for ( j = 0 ; j < out->leaf.numLeafBrushes ; j++ ) { for ( j = 0 ; j < out->leaf.numLeafBrushes ; j++ ) {
indexes[j] = LittleLong( in->firstBrush ) + j; indexes[j] = LittleLong( in->firstBrush ) + j;
} }
out->leaf.numLeafSurfaces = LittleLong( in->numSurfaces ); out->leaf.numLeafSurfaces = LittleLong( in->numSurfaces );
indexes = Hunk_Alloc( out->leaf.numLeafSurfaces * 4, h_high ); indexes = (int*) Hunk_Alloc( out->leaf.numLeafSurfaces * 4, h_high );
out->leaf.firstLeafSurface = indexes - cm.leafsurfaces; out->leaf.firstLeafSurface = indexes - cm.leafsurfaces;
for ( j = 0 ; j < out->leaf.numLeafSurfaces ; j++ ) { for ( j = 0 ; j < out->leaf.numLeafSurfaces ; j++ ) {
indexes[j] = LittleLong( in->firstSurface ) + j; indexes[j] = LittleLong( in->firstSurface ) + j;
@ -182,14 +182,14 @@ void CMod_LoadNodes( lump_t *l ) {
cNode_t *out; cNode_t *out;
int i, j, count; int i, j, count;
in = (void *)(cmod_base + l->fileofs); in = (dnode_t*) (void *)(cmod_base + l->fileofs);
if (l->filelen % sizeof(*in)) if (l->filelen % sizeof(*in))
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
count = l->filelen / sizeof(*in); count = l->filelen / sizeof(*in);
if (count < 1) if (count < 1)
Com_Error (ERR_DROP, "Map has no nodes"); Com_Error (ERR_DROP, "Map has no nodes");
cm.nodes = Hunk_Alloc( count * sizeof( *cm.nodes ), h_high ); cm.nodes = (cNode_t*) Hunk_Alloc( count * sizeof( *cm.nodes ), h_high );
cm.numNodes = count; cm.numNodes = count;
out = cm.nodes; out = cm.nodes;
@ -235,13 +235,13 @@ void CMod_LoadBrushes( lump_t *l ) {
cbrush_t *out; cbrush_t *out;
int i, count; int i, count;
in = (void *)(cmod_base + l->fileofs); in = (dbrush_t*) (void *)(cmod_base + l->fileofs);
if (l->filelen % sizeof(*in)) { if (l->filelen % sizeof(*in)) {
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
} }
count = l->filelen / sizeof(*in); count = l->filelen / sizeof(*in);
cm.brushes = Hunk_Alloc( ( BOX_BRUSHES + count ) * sizeof( *cm.brushes ), h_high ); cm.brushes = (cbrush_t*) Hunk_Alloc( ( BOX_BRUSHES + count ) * sizeof( *cm.brushes ), h_high );
cm.numBrushes = count; cm.numBrushes = count;
out = cm.brushes; out = cm.brushes;
@ -273,7 +273,7 @@ void CMod_LoadLeafs (lump_t *l)
dleaf_t *in; dleaf_t *in;
int count; int count;
in = (void *)(cmod_base + l->fileofs); in = (dleaf_t*) (void *)(cmod_base + l->fileofs);
if (l->filelen % sizeof(*in)) if (l->filelen % sizeof(*in))
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
count = l->filelen / sizeof(*in); count = l->filelen / sizeof(*in);
@ -281,7 +281,7 @@ void CMod_LoadLeafs (lump_t *l)
if (count < 1) if (count < 1)
Com_Error (ERR_DROP, "Map with no leafs"); Com_Error (ERR_DROP, "Map with no leafs");
cm.leafs = Hunk_Alloc( ( BOX_LEAFS + count ) * sizeof( *cm.leafs ), h_high ); cm.leafs = (cLeaf_t*) Hunk_Alloc( ( BOX_LEAFS + count ) * sizeof( *cm.leafs ), h_high );
cm.numLeafs = count; cm.numLeafs = count;
out = cm.leafs; out = cm.leafs;
@ -300,8 +300,8 @@ void CMod_LoadLeafs (lump_t *l)
cm.numAreas = out->area + 1; cm.numAreas = out->area + 1;
} }
cm.areas = Hunk_Alloc( cm.numAreas * sizeof( *cm.areas ), h_high ); cm.areas = (cArea_t*) Hunk_Alloc( cm.numAreas * sizeof( *cm.areas ), h_high );
cm.areaPortals = Hunk_Alloc( cm.numAreas * cm.numAreas * sizeof( *cm.areaPortals ), h_high ); cm.areaPortals = (int*) Hunk_Alloc( cm.numAreas * cm.numAreas * sizeof( *cm.areaPortals ), h_high );
} }
/* /*
@ -317,14 +317,14 @@ void CMod_LoadPlanes (lump_t *l)
int count; int count;
int bits; int bits;
in = (void *)(cmod_base + l->fileofs); in = (dplane_t*) (void *)(cmod_base + l->fileofs);
if (l->filelen % sizeof(*in)) if (l->filelen % sizeof(*in))
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
count = l->filelen / sizeof(*in); count = l->filelen / sizeof(*in);
if (count < 1) if (count < 1)
Com_Error (ERR_DROP, "Map with no planes"); Com_Error (ERR_DROP, "Map with no planes");
cm.planes = Hunk_Alloc( ( BOX_PLANES + count ) * sizeof( *cm.planes ), h_high ); cm.planes = (cplane_t*) Hunk_Alloc( ( BOX_PLANES + count ) * sizeof( *cm.planes ), h_high );
cm.numPlanes = count; cm.numPlanes = count;
out = cm.planes; out = cm.planes;
@ -357,12 +357,12 @@ void CMod_LoadLeafBrushes (lump_t *l)
int *in; int *in;
int count; int count;
in = (void *)(cmod_base + l->fileofs); in = (int*) (void *)(cmod_base + l->fileofs);
if (l->filelen % sizeof(*in)) if (l->filelen % sizeof(*in))
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
count = l->filelen / sizeof(*in); count = l->filelen / sizeof(*in);
cm.leafbrushes = Hunk_Alloc( (count + BOX_BRUSHES) * sizeof( *cm.leafbrushes ), h_high ); cm.leafbrushes = (int*) Hunk_Alloc( (count + BOX_BRUSHES) * sizeof( *cm.leafbrushes ), h_high );
cm.numLeafBrushes = count; cm.numLeafBrushes = count;
out = cm.leafbrushes; out = cm.leafbrushes;
@ -384,12 +384,12 @@ void CMod_LoadLeafSurfaces( lump_t *l )
int *in; int *in;
int count; int count;
in = (void *)(cmod_base + l->fileofs); in = (int*) (void *)(cmod_base + l->fileofs);
if (l->filelen % sizeof(*in)) if (l->filelen % sizeof(*in))
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
count = l->filelen / sizeof(*in); count = l->filelen / sizeof(*in);
cm.leafsurfaces = Hunk_Alloc( count * sizeof( *cm.leafsurfaces ), h_high ); cm.leafsurfaces = (int*) Hunk_Alloc( count * sizeof( *cm.leafsurfaces ), h_high );
cm.numLeafSurfaces = count; cm.numLeafSurfaces = count;
out = cm.leafsurfaces; out = cm.leafsurfaces;
@ -412,13 +412,13 @@ void CMod_LoadBrushSides (lump_t *l)
int count; int count;
int num; int num;
in = (void *)(cmod_base + l->fileofs); in = (dbrushside_t*) (void *)(cmod_base + l->fileofs);
if ( l->filelen % sizeof(*in) ) { if ( l->filelen % sizeof(*in) ) {
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
} }
count = l->filelen / sizeof(*in); count = l->filelen / sizeof(*in);
cm.brushsides = Hunk_Alloc( ( BOX_SIDES + count ) * sizeof( *cm.brushsides ), h_high ); cm.brushsides = (cbrushside_t*) Hunk_Alloc( ( BOX_SIDES + count ) * sizeof( *cm.brushsides ), h_high );
cm.numBrushSides = count; cm.numBrushSides = count;
out = cm.brushsides; out = cm.brushsides;
@ -441,7 +441,7 @@ CMod_LoadEntityString
================= =================
*/ */
void CMod_LoadEntityString( lump_t *l ) { void CMod_LoadEntityString( lump_t *l ) {
cm.entityString = Hunk_Alloc( l->filelen, h_high ); cm.entityString = (char*) Hunk_Alloc( l->filelen, h_high );
cm.numEntityChars = l->filelen; cm.numEntityChars = l->filelen;
Com_Memcpy (cm.entityString, cmod_base + l->fileofs, l->filelen); Com_Memcpy (cm.entityString, cmod_base + l->fileofs, l->filelen);
} }
@ -459,14 +459,14 @@ void CMod_LoadVisibility( lump_t *l ) {
len = l->filelen; len = l->filelen;
if ( !len ) { if ( !len ) {
cm.clusterBytes = ( cm.numClusters + 31 ) & ~31; cm.clusterBytes = ( cm.numClusters + 31 ) & ~31;
cm.visibility = Hunk_Alloc( cm.clusterBytes, h_high ); cm.visibility = (byte*) Hunk_Alloc( cm.clusterBytes, h_high );
Com_Memset( cm.visibility, 255, cm.clusterBytes ); Com_Memset( cm.visibility, 255, cm.clusterBytes );
return; return;
} }
buf = cmod_base + l->fileofs; buf = cmod_base + l->fileofs;
cm.vised = qtrue; cm.vised = qtrue;
cm.visibility = Hunk_Alloc( len, h_high ); cm.visibility = (byte*) Hunk_Alloc( len, h_high );
cm.numClusters = LittleLong( ((int *)buf)[0] ); cm.numClusters = LittleLong( ((int *)buf)[0] );
cm.clusterBytes = LittleLong( ((int *)buf)[1] ); cm.clusterBytes = LittleLong( ((int *)buf)[1] );
Com_Memcpy (cm.visibility, buf + VIS_HEADER, len - VIS_HEADER ); Com_Memcpy (cm.visibility, buf + VIS_HEADER, len - VIS_HEADER );
@ -492,13 +492,13 @@ void CMod_LoadPatches( lump_t *surfs, lump_t *verts ) {
int width, height; int width, height;
int shaderNum; int shaderNum;
in = (void *)(cmod_base + surfs->fileofs); in = (dsurface_t*) (void *)(cmod_base + surfs->fileofs);
if (surfs->filelen % sizeof(*in)) if (surfs->filelen % sizeof(*in))
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
cm.numSurfaces = count = surfs->filelen / sizeof(*in); cm.numSurfaces = count = surfs->filelen / sizeof(*in);
cm.surfaces = Hunk_Alloc( cm.numSurfaces * sizeof( cm.surfaces[0] ), h_high ); cm.surfaces = (cPatch_t**) Hunk_Alloc( cm.numSurfaces * sizeof( cm.surfaces[0] ), h_high );
dv = (void *)(cmod_base + verts->fileofs); dv = (drawVert_t*) (void *)(cmod_base + verts->fileofs);
if (verts->filelen % sizeof(*dv)) if (verts->filelen % sizeof(*dv))
Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size"); Com_Error (ERR_DROP, "MOD_LoadBmodel: funny lump size");
@ -510,7 +510,7 @@ void CMod_LoadPatches( lump_t *surfs, lump_t *verts ) {
} }
// FIXME: check for non-colliding patches // FIXME: check for non-colliding patches
cm.surfaces[ i ] = patch = Hunk_Alloc( sizeof( *patch ), h_high ); cm.surfaces[ i ] = patch = (cPatch_t*) Hunk_Alloc( sizeof( *patch ), h_high );
// load the full drawverts onto the stack // load the full drawverts onto the stack
width = LittleLong( in->patchWidth ); width = LittleLong( in->patchWidth );
@ -597,7 +597,7 @@ void CM_LoadMap( const char *name, qboolean clientload, int *checksum ) {
cm.numLeafs = 1; cm.numLeafs = 1;
cm.numClusters = 1; cm.numClusters = 1;
cm.numAreas = 1; cm.numAreas = 1;
cm.cmodels = Hunk_Alloc( sizeof( *cm.cmodels ), h_high ); cm.cmodels = (cmodel_t*) Hunk_Alloc( sizeof( *cm.cmodels ), h_high );
*checksum = 0; *checksum = 0;
return; return;
} }

30
code/qcommon/cm_patch.c
View File

@ -176,7 +176,7 @@ static qboolean CM_NeedsSubdivision( vec3_t a, vec3_t b, vec3_t c ) {
VectorSubtract( cmid, lmid, delta ); VectorSubtract( cmid, lmid, delta );
dist = VectorLength( delta ); dist = VectorLength( delta );
return dist >= SUBDIVIDE_DISTANCE; return (qboolean) (dist >= SUBDIVIDE_DISTANCE);
} }
/* /*
@ -859,7 +859,7 @@ void CM_AddFacetBevels( facet_t *facet ) {
if ( i == facet->numBorders ) { if ( i == facet->numBorders ) {
if (facet->numBorders > 4 + 6 + 16) Com_Printf("ERROR: too many bevels\n"); if (facet->numBorders > 4 + 6 + 16) Com_Printf("ERROR: too many bevels\n");
facet->borderPlanes[facet->numBorders] = CM_FindPlane2(plane, &flipped); facet->borderPlanes[facet->numBorders] = CM_FindPlane2(plane, &flipped);
facet->borderNoAdjust[facet->numBorders] = 0; facet->borderNoAdjust[facet->numBorders] = (qboolean) 0;
facet->borderInward[facet->numBorders] = flipped; facet->borderInward[facet->numBorders] = flipped;
facet->numBorders++; facet->numBorders++;
} }
@ -927,7 +927,7 @@ void CM_AddFacetBevels( facet_t *facet ) {
facet->borderPlanes[k]) Com_Printf("WARNING: bevel plane already used\n"); facet->borderPlanes[k]) Com_Printf("WARNING: bevel plane already used\n");
} }
facet->borderNoAdjust[facet->numBorders] = 0; facet->borderNoAdjust[facet->numBorders] = (qboolean) 0;
facet->borderInward[facet->numBorders] = flipped; facet->borderInward[facet->numBorders] = flipped;
// //
w2 = CopyWinding(w); w2 = CopyWinding(w);
@ -958,7 +958,7 @@ void CM_AddFacetBevels( facet_t *facet ) {
#ifndef BSPC #ifndef BSPC
//add opposite plane //add opposite plane
facet->borderPlanes[facet->numBorders] = facet->surfacePlane; facet->borderPlanes[facet->numBorders] = facet->surfacePlane;
facet->borderNoAdjust[facet->numBorders] = 0; facet->borderNoAdjust[facet->numBorders] = (qboolean) 0;
facet->borderInward[facet->numBorders] = qtrue; facet->borderInward[facet->numBorders] = qtrue;
facet->numBorders++; facet->numBorders++;
#endif //BSPC #endif //BSPC
@ -1064,13 +1064,13 @@ static void CM_PatchCollideFromGrid( cGrid_t *grid, patchCollide_t *pf ) {
facet->surfacePlane = gridPlanes[i][j][0]; facet->surfacePlane = gridPlanes[i][j][0];
facet->numBorders = 4; facet->numBorders = 4;
facet->borderPlanes[0] = borders[EN_TOP]; facet->borderPlanes[0] = borders[EN_TOP];
facet->borderNoAdjust[0] = noAdjust[EN_TOP]; facet->borderNoAdjust[0] = (qboolean) noAdjust[EN_TOP];
facet->borderPlanes[1] = borders[EN_RIGHT]; facet->borderPlanes[1] = borders[EN_RIGHT];
facet->borderNoAdjust[1] = noAdjust[EN_RIGHT]; facet->borderNoAdjust[1] = (qboolean) noAdjust[EN_RIGHT];
facet->borderPlanes[2] = borders[EN_BOTTOM]; facet->borderPlanes[2] = borders[EN_BOTTOM];
facet->borderNoAdjust[2] = noAdjust[EN_BOTTOM]; facet->borderNoAdjust[2] = (qboolean)noAdjust[EN_BOTTOM];
facet->borderPlanes[3] = borders[EN_LEFT]; facet->borderPlanes[3] = borders[EN_LEFT];
facet->borderNoAdjust[3] = noAdjust[EN_LEFT]; facet->borderNoAdjust[3] = (qboolean) noAdjust[EN_LEFT];
CM_SetBorderInward( facet, grid, gridPlanes, i, j, -1 ); CM_SetBorderInward( facet, grid, gridPlanes, i, j, -1 );
if ( CM_ValidateFacet( facet ) ) { if ( CM_ValidateFacet( facet ) ) {
CM_AddFacetBevels( facet ); CM_AddFacetBevels( facet );
@ -1081,9 +1081,9 @@ static void CM_PatchCollideFromGrid( cGrid_t *grid, patchCollide_t *pf ) {
facet->surfacePlane = gridPlanes[i][j][0]; facet->surfacePlane = gridPlanes[i][j][0];
facet->numBorders = 3; facet->numBorders = 3;
facet->borderPlanes[0] = borders[EN_TOP]; facet->borderPlanes[0] = borders[EN_TOP];
facet->borderNoAdjust[0] = noAdjust[EN_TOP]; facet->borderNoAdjust[0] = (qboolean)noAdjust[EN_TOP];
facet->borderPlanes[1] = borders[EN_RIGHT]; facet->borderPlanes[1] = borders[EN_RIGHT];
facet->borderNoAdjust[1] = noAdjust[EN_RIGHT]; facet->borderNoAdjust[1] = (qboolean)noAdjust[EN_RIGHT];
facet->borderPlanes[2] = gridPlanes[i][j][1]; facet->borderPlanes[2] = gridPlanes[i][j][1];
if ( facet->borderPlanes[2] == -1 ) { if ( facet->borderPlanes[2] == -1 ) {
facet->borderPlanes[2] = borders[EN_BOTTOM]; facet->borderPlanes[2] = borders[EN_BOTTOM];
@ -1106,9 +1106,9 @@ static void CM_PatchCollideFromGrid( cGrid_t *grid, patchCollide_t *pf ) {
facet->surfacePlane = gridPlanes[i][j][1]; facet->surfacePlane = gridPlanes[i][j][1];
facet->numBorders = 3; facet->numBorders = 3;
facet->borderPlanes[0] = borders[EN_BOTTOM]; facet->borderPlanes[0] = borders[EN_BOTTOM];
facet->borderNoAdjust[0] = noAdjust[EN_BOTTOM]; facet->borderNoAdjust[0] = (qboolean)noAdjust[EN_BOTTOM];
facet->borderPlanes[1] = borders[EN_LEFT]; facet->borderPlanes[1] = borders[EN_LEFT];
facet->borderNoAdjust[1] = noAdjust[EN_LEFT]; facet->borderNoAdjust[1] = (qboolean)noAdjust[EN_LEFT];
facet->borderPlanes[2] = gridPlanes[i][j][0]; facet->borderPlanes[2] = gridPlanes[i][j][0];
if ( facet->borderPlanes[2] == -1 ) { if ( facet->borderPlanes[2] == -1 ) {
facet->borderPlanes[2] = borders[EN_TOP]; facet->borderPlanes[2] = borders[EN_TOP];
@ -1128,9 +1128,9 @@ static void CM_PatchCollideFromGrid( cGrid_t *grid, patchCollide_t *pf ) {
// copy the results out // copy the results out
pf->numPlanes = numPlanes; pf->numPlanes = numPlanes;
pf->numFacets = numFacets; pf->numFacets = numFacets;
pf->facets = Hunk_Alloc( numFacets * sizeof( *pf->facets ), h_high ); pf->facets = (facet_t*) Hunk_Alloc( numFacets * sizeof( *pf->facets ), h_high );
Com_Memcpy( pf->facets, facets, numFacets * sizeof( *pf->facets ) ); Com_Memcpy( pf->facets, facets, numFacets * sizeof( *pf->facets ) );
pf->planes = Hunk_Alloc( numPlanes * sizeof( *pf->planes ), h_high ); pf->planes = (patchPlane_t*) Hunk_Alloc( numPlanes * sizeof( *pf->planes ), h_high );
Com_Memcpy( pf->planes, planes, numPlanes * sizeof( *pf->planes ) ); Com_Memcpy( pf->planes, planes, numPlanes * sizeof( *pf->planes ) );
} }
@ -1188,7 +1188,7 @@ struct patchCollide_s *CM_GeneratePatchCollide( int width, int height, vec3_t *p
// we now have a grid of points exactly on the curve // we now have a grid of points exactly on the curve
// the aproximate surface defined by these points will be // the aproximate surface defined by these points will be
// collided against // collided against
pf = Hunk_Alloc( sizeof( *pf ), h_high ); pf = (patchCollide_t*) Hunk_Alloc( sizeof( *pf ), h_high );
ClearBounds( pf->bounds[0], pf->bounds[1] ); ClearBounds( pf->bounds[0], pf->bounds[1] );
for ( i = 0 ; i < grid.width ; i++ ) { for ( i = 0 ; i < grid.width ; i++ ) {
for ( j = 0 ; j < grid.height ; j++ ) { for ( j = 0 ; j < grid.height ; j++ ) {

2
code/qcommon/cm_polylib.c
View File

@ -58,7 +58,7 @@ winding_t *AllocWinding (int points)
c_peak_windings = c_active_windings; c_peak_windings = c_active_windings;
s = sizeof(vec_t)*3*points + sizeof(int); s = sizeof(vec_t)*3*points + sizeof(int);
w = Z_Malloc (s); w = (winding_t*) Z_Malloc (s);
Com_Memset (w, 0, s); Com_Memset (w, 0, s);
return w; return w;
} }

2
code/qcommon/cm_test.c
View File

@ -203,7 +203,7 @@ int CM_BoxBrushes( const vec3_t mins, const vec3_t maxs, cbrush_t **list, int li
VectorCopy( maxs, ll.bounds[1] ); VectorCopy( maxs, ll.bounds[1] );
ll.count = 0; ll.count = 0;
ll.maxcount = listsize; ll.maxcount = listsize;
ll.list = (void *)list; ll.list = (int*) (void *)list;
ll.storeLeafs = CM_StoreBrushes; ll.storeLeafs = CM_StoreBrushes;
ll.lastLeaf = 0; ll.lastLeaf = 0;
ll.overflowed = qfalse; ll.overflowed = qfalse;

4
code/qcommon/cm_trace.c
View File

@ -1197,7 +1197,7 @@ void CM_Trace( trace_t *results, const vec3_t start, const vec3_t end, vec3_t mi
tw.sphere = *sphere; tw.sphere = *sphere;
} }
else { else {
tw.sphere.use = capsule; tw.sphere.use = (qboolean) capsule;
tw.sphere.radius = ( tw.size[1][0] > tw.size[1][2] ) ? tw.size[1][2]: tw.size[1][0]; tw.sphere.radius = ( tw.size[1][0] > tw.size[1][2] ) ? tw.size[1][2]: tw.size[1][0];
tw.sphere.halfheight = tw.size[1][2]; tw.sphere.halfheight = tw.size[1][2];
VectorSet( tw.sphere.offset, 0, 0, tw.size[1][2] - tw.sphere.radius ); VectorSet( tw.sphere.offset, 0, 0, tw.size[1][2] - tw.sphere.radius );
@ -1427,7 +1427,7 @@ void CM_TransformedBoxTrace( trace_t *results, const vec3_t start, const vec3_t
halfwidth = symetricSize[ 1 ][ 0 ]; halfwidth = symetricSize[ 1 ][ 0 ];
halfheight = symetricSize[ 1 ][ 2 ]; halfheight = symetricSize[ 1 ][ 2 ];
sphere.use = capsule; sphere.use = (qboolean) capsule;
sphere.radius = ( halfwidth > halfheight ) ? halfheight : halfwidth; sphere.radius = ( halfwidth > halfheight ) ? halfheight : halfwidth;
sphere.halfheight = halfheight; sphere.halfheight = halfheight;
t = halfheight - sphere.radius; t = halfheight - sphere.radius;

2
code/qcommon/cmd.c
View File

@ -562,7 +562,7 @@ void Cmd_AddCommand( const char *cmd_name, xcommand_t function ) {
} }
// use a small malloc to avoid zone fragmentation // use a small malloc to avoid zone fragmentation
cmd = S_Malloc (sizeof(cmd_function_t)); cmd = (cmd_function_t*) S_Malloc(sizeof(cmd_function_t));
cmd->name = CopyString( cmd_name ); cmd->name = CopyString( cmd_name );
cmd->function = function; cmd->function = function;
cmd->next = cmd_functions; cmd->next = cmd_functions;

34
code/qcommon/common.c
View File

@ -907,7 +907,7 @@ void *Z_TagMallocDebug( int size, int tag, char *label, char *file, int line ) {
void *Z_TagMalloc( int size, int tag ) { void *Z_TagMalloc( int size, int tag ) {
#endif #endif
int extra, allocSize; int extra, allocSize;
memblock_t *start, *rover, *new, *base; memblock_t *start, *rover, *newBlock, *base;
memzone_t *zone; memzone_t *zone;
if (!tag) { if (!tag) {
@ -956,14 +956,14 @@ void *Z_TagMalloc( int size, int tag ) {
extra = base->size - size; extra = base->size - size;
if (extra > MINFRAGMENT) { if (extra > MINFRAGMENT) {
// there will be a free fragment after the allocated block // there will be a free fragment after the allocated block
new = (memblock_t *) ((byte *)base + size ); newBlock = (memblock_t *)((byte *)base + size);
new->size = extra; newBlock->size = extra;
new->tag = 0; // free block newBlock->tag = 0; // free block
new->prev = base; newBlock->prev = base;
new->id = ZONEID; newBlock->id = ZONEID;
new->next = base->next; newBlock->next = base->next;
new->next->prev = new; newBlock->next->prev = newBlock;
base->next = new; base->next = newBlock;
base->size = size; base->size = size;
} }
@ -1148,7 +1148,7 @@ char *CopyString( const char *in ) {
return ((char *)&numberstring[in[0]-'0']) + sizeof(memblock_t); return ((char *)&numberstring[in[0]-'0']) + sizeof(memblock_t);
} }
} }
out = S_Malloc ((int)strlen(in)+1); out = (char*) S_Malloc ((int)strlen(in)+1);
strcpy (out, in); strcpy (out, in);
return out; return out;
} }
@ -1373,7 +1373,7 @@ Com_InitZoneMemory
void Com_InitSmallZoneMemory( void ) { void Com_InitSmallZoneMemory( void ) {
s_smallZoneTotal = 512 * 1024; s_smallZoneTotal = 512 * 1024;
// bk001205 - was malloc // bk001205 - was malloc
smallzone = calloc( s_smallZoneTotal, 1 ); smallzone = (memzone_t*) calloc( s_smallZoneTotal, 1 );
if ( !smallzone ) { if ( !smallzone ) {
Com_Error( ERR_FATAL, "Small zone data failed to allocate %1.1f megs", (float)s_smallZoneTotal / (1024*1024) ); Com_Error( ERR_FATAL, "Small zone data failed to allocate %1.1f megs", (float)s_smallZoneTotal / (1024*1024) );
} }
@ -1394,7 +1394,7 @@ void Com_InitZoneMemory( void ) {
} }
// bk001205 - was malloc // bk001205 - was malloc
mainzone = calloc( s_zoneTotal, 1 ); mainzone = (memzone_t*) calloc( s_zoneTotal, 1 );
if ( !mainzone ) { if ( !mainzone ) {
Com_Error( ERR_FATAL, "Zone data failed to allocate %i megs", s_zoneTotal / (1024*1024) ); Com_Error( ERR_FATAL, "Zone data failed to allocate %i megs", s_zoneTotal / (1024*1024) );
} }
@ -1520,7 +1520,7 @@ void Com_InitHunkMemory( void ) {
// bk001205 - was malloc // bk001205 - was malloc
s_hunkData = calloc( s_hunkTotal + 31, 1 ); s_hunkData = (byte*) calloc( s_hunkTotal + 31, 1 );
if ( !s_hunkData ) { if ( !s_hunkData ) {
Com_Error( ERR_FATAL, "Hunk data failed to allocate %i megs", s_hunkTotal / (1024*1024) ); Com_Error( ERR_FATAL, "Hunk data failed to allocate %i megs", s_hunkTotal / (1024*1024) );
} }
@ -1856,9 +1856,9 @@ void Hunk_Trash( void ) {
Hunk_SwapBanks(); Hunk_SwapBanks();
if ( hunk_permanent == &hunk_low ) { if ( hunk_permanent == &hunk_low ) {
buf = (void *)(s_hunkData + hunk_permanent->permanent); buf = (char*) (void *)(s_hunkData + hunk_permanent->permanent);
} else { } else {
buf = (void *)(s_hunkData + s_hunkTotal - hunk_permanent->permanent ); buf = (char*) (void *)(s_hunkData + s_hunkTotal - hunk_permanent->permanent );
} }
length = hunk_permanent->permanent; length = hunk_permanent->permanent;
@ -2097,7 +2097,7 @@ int Com_EventLoop( void ) {
case SE_NONE: case SE_NONE:
break; break;
case SE_KEY: case SE_KEY:
CL_KeyEvent( ev.evValue, ev.evValue2, ev.evTime ); CL_KeyEvent( ev.evValue, (qboolean) ev.evValue2, ev.evTime );
break; break;
case SE_CHAR: case SE_CHAR:
CL_CharEvent( ev.evValue ); CL_CharEvent( ev.evValue );
@ -3244,7 +3244,7 @@ static void keyConcatArgs( void ) {
static void ConcatRemaining( const char *src, const char *start ) { static void ConcatRemaining( const char *src, const char *start ) {
char *str; char *str;
str = strstr(src, start); str = (char*) strstr(src, start);
if (!str) { if (!str) {
keyConcatArgs(); keyConcatArgs();
return; return;

32
code/qcommon/files.c
View File

@ -322,7 +322,7 @@ FS_Initialized
*/ */
qboolean FS_Initialized() { qboolean FS_Initialized() {
return (fs_searchpaths != NULL); return (qboolean) (fs_searchpaths != NULL);
} }
/* /*
@ -540,7 +540,7 @@ static void FS_CopyFile( char *fromOSPath, char *toOSPath ) {
// we are using direct malloc instead of Z_Malloc here, so it // we are using direct malloc instead of Z_Malloc here, so it
// probably won't work on a mac... Its only for developers anyway... // probably won't work on a mac... Its only for developers anyway...
buf = malloc( len ); buf = (byte*) malloc( len );
if (fread( buf, 1, len, f ) != len) if (fread( buf, 1, len, f ) != len)
Com_Error( ERR_FATAL, "Short read in FS_Copyfiles()\n" ); Com_Error( ERR_FATAL, "Short read in FS_Copyfiles()\n" );
fclose( f ); fclose( f );
@ -950,11 +950,11 @@ qboolean FS_FilenameCompare( const char *s1, const char *s2 ) {
} }
if (c1 != c2) { if (c1 != c2) {
return -1; // strings not equal return (qboolean) -1; // strings not equal
} }
} while (c1); } while (c1);
return 0; // strings are equal return (qboolean) 0; // strings are equal
} }
/* /*
@ -970,7 +970,7 @@ char *FS_ShiftedStrStr(const char *string, const char *substring, int shift) {
buf[i] = substring[i] + shift; buf[i] = substring[i] + shift;
} }
buf[i] = '\0'; buf[i] = '\0';
return strstr(string, buf); return (char*) strstr(string, buf);
} }
/* /*
@ -1537,7 +1537,7 @@ int FS_ReadFile( const char *qpath, void **buffer ) {
return len; return len;
} }
buf = Hunk_AllocateTempMemory(len+1); buf = (byte*) Hunk_AllocateTempMemory(len+1);
*buffer = buf; *buffer = buf;
r = FS_Read( buf, len, com_journalDataFile ); r = FS_Read( buf, len, com_journalDataFile );
@ -1586,7 +1586,7 @@ int FS_ReadFile( const char *qpath, void **buffer ) {
fs_loadCount++; fs_loadCount++;
fs_loadStack++; fs_loadStack++;
buf = Hunk_AllocateTempMemory(len+1); buf = (byte*) Hunk_AllocateTempMemory(len+1);
*buffer = buf; *buffer = buf;
FS_Read (buf, len, h); FS_Read (buf, len, h);
@ -1711,9 +1711,9 @@ static pack_t *FS_LoadZipFile( char *zipfile, const char *basename )
unzGoToNextFile(uf); unzGoToNextFile(uf);
} }
buildBuffer = Z_Malloc( (gi.number_entry * sizeof( fileInPack_t )) + len ); buildBuffer = (fileInPack_t*) Z_Malloc( (gi.number_entry * sizeof( fileInPack_t )) + len );
namePtr = ((char *) buildBuffer) + gi.number_entry * sizeof( fileInPack_t ); namePtr = ((char *) buildBuffer) + gi.number_entry * sizeof( fileInPack_t );
fs_headerLongs = Z_Malloc( gi.number_entry * sizeof(int) ); fs_headerLongs = (int*) Z_Malloc( gi.number_entry * sizeof(int) );
// get the hash table size from the number of files in the zip // get the hash table size from the number of files in the zip
// because lots of custom pk3 files have less than 32 or 64 files // because lots of custom pk3 files have less than 32 or 64 files
@ -1723,7 +1723,7 @@ static pack_t *FS_LoadZipFile( char *zipfile, const char *basename )
} }
} }
pack = Z_Malloc( sizeof( pack_t ) + i * sizeof(fileInPack_t *) ); pack = (pack_t*) Z_Malloc( sizeof( pack_t ) + i * sizeof(fileInPack_t *) );
pack->hashSize = i; pack->hashSize = i;
pack->hashTable = (fileInPack_t **) (((char *) pack) + sizeof( pack_t )); pack->hashTable = (fileInPack_t **) (((char *) pack) + sizeof( pack_t ));
for(i = 0; i < pack->hashSize; i++) { for(i = 0; i < pack->hashSize; i++) {
@ -1956,7 +1956,7 @@ char **FS_ListFilteredFiles( const char *path, const char *extension, char *filt
return NULL; return NULL;
} }
listCopy = Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) ); listCopy = (char**) Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) );
for ( i = 0 ; i < nfiles ; i++ ) { for ( i = 0 ; i < nfiles ; i++ ) {
listCopy[i] = list[i]; listCopy[i] = list[i];
} }
@ -2071,7 +2071,7 @@ static char** Sys_ConcatenateFileLists( char **list0, char **list1, char **list2
totalLength += Sys_CountFileList(list2); totalLength += Sys_CountFileList(list2);
/* Create new list. */ /* Create new list. */
dst = cat = Z_Malloc( ( totalLength + 1 ) * sizeof( char* ) ); dst = cat = (char**) Z_Malloc( ( totalLength + 1 ) * sizeof( char* ) );
/* Copy over lists. */ /* Copy over lists. */
if (list0) if (list0)
@ -2327,7 +2327,7 @@ void FS_SortFileList(char **filelist, int numfiles) {
int i, j, k, numsortedfiles; int i, j, k, numsortedfiles;
char **sortedlist; char **sortedlist;
sortedlist = Z_Malloc( ( numfiles + 1 ) * sizeof( *sortedlist ) ); sortedlist = (char**) Z_Malloc( ( numfiles + 1 ) * sizeof( *sortedlist ) );
sortedlist[0] = NULL; sortedlist[0] = NULL;
numsortedfiles = 0; numsortedfiles = 0;
for (i = 0; i < numfiles; i++) { for (i = 0; i < numfiles; i++) {
@ -2480,8 +2480,8 @@ static void FS_AddGameDirectory( const char *path, const char *dir ) {
// //
// add the directory to the search path // add the directory to the search path
// //
search = Z_Malloc (sizeof(searchpath_t)); search = (searchpath_t*) Z_Malloc (sizeof(searchpath_t));
search->dir = Z_Malloc( sizeof( *search->dir ) ); search->dir = (directory_t*) Z_Malloc( sizeof( *search->dir ) );
Q_strncpyz( search->dir->path, path, sizeof( search->dir->path ) ); Q_strncpyz( search->dir->path, path, sizeof( search->dir->path ) );
Q_strncpyz( search->dir->gamedir, dir, sizeof( search->dir->gamedir ) ); Q_strncpyz( search->dir->gamedir, dir, sizeof( search->dir->gamedir ) );
@ -2512,7 +2512,7 @@ static void FS_AddGameDirectory( const char *path, const char *dir ) {
// store the game name for downloading // store the game name for downloading
strcpy(pak->pakGamename, dir); strcpy(pak->pakGamename, dir);
search = Z_Malloc (sizeof(searchpath_t)); search = (searchpath_t*) Z_Malloc (sizeof(searchpath_t));
search->pack = pak; search->pack = pak;
search->next = fs_searchpaths; search->next = fs_searchpaths;
fs_searchpaths = search; fs_searchpaths = search;

2
code/qcommon/md4.c
View File

@ -267,7 +267,7 @@ for (i = 0, j = 0; j < len; i++, j += 4)
//=================================================================== //===================================================================
unsigned Com_BlockChecksum (void *buffer, int length) unsigned Com_BlockChecksum (const void *buffer, int length)
{ {
int digest[4]; int digest[4];
unsigned val; unsigned val;

4
code/qcommon/msg.c
View File

@ -569,7 +569,7 @@ delta functions with keys
============================================================================= =============================================================================
*/ */
int kbitmask[32] = { unsigned int kbitmask[32] = {
0x00000001, 0x00000003, 0x00000007, 0x0000000F, 0x00000001, 0x00000003, 0x00000007, 0x0000000F,
0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF, 0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF, 0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
@ -591,7 +591,7 @@ void MSG_WriteDeltaKey( msg_t *msg, int key, int oldV, int newV, int bits ) {
int MSG_ReadDeltaKey( msg_t *msg, int key, int oldV, int bits ) { int MSG_ReadDeltaKey( msg_t *msg, int key, int oldV, int bits ) {
if ( MSG_ReadBits( msg, 1 ) ) { if ( MSG_ReadBits( msg, 1 ) ) {
return MSG_ReadBits( msg, bits ) ^ (key & kbitmask[bits]); return MSG_ReadBits( msg, bits ) ^ (key & (int)kbitmask[bits]);
} }
return oldV; return oldV;
} }

2
code/qcommon/net_chan.c
View File

@ -544,7 +544,7 @@ qboolean NET_CompareAdr (netadr_t a, netadr_t b)
qboolean NET_IsLocalAddress( netadr_t adr ) { qboolean NET_IsLocalAddress( netadr_t adr ) {
return adr.type == NA_LOOPBACK; return (qboolean) (adr.type == NA_LOOPBACK);
} }

9
code/qcommon/unzip.c
View File

@ -2472,7 +2472,12 @@ struct inflate_blocks_state {
#define LOAD {LOADIN LOADOUT} #define LOAD {LOADIN LOADOUT}
/* masks for lower bits (size given to avoid silly warnings with Visual C++) */ /* masks for lower bits (size given to avoid silly warnings with Visual C++) */
static uInt inflate_mask[17]; //static uInt inflate_mask[17];
static uInt inflate_mask[17] = {
0x0000,
0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};
/* copy as much as possible from the sliding window to the output area */ /* copy as much as possible from the sliding window to the output area */
static int inflate_flush OF(( static int inflate_flush OF((
@ -2849,11 +2854,13 @@ int inflate_blocks_sync_point(inflate_blocks_statef *s)
/* And'ing with mask[n] masks the lower n bits */ /* And'ing with mask[n] masks the lower n bits */
/*
static uInt inflate_mask[17] = { static uInt inflate_mask[17] = {
0x0000, 0x0000,
0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
}; };
*/
/* copy as much as possible from the sliding window to the output area */ /* copy as much as possible from the sliding window to the output area */

8
code/qcommon/vm.c
View File

@ -228,7 +228,7 @@ void VM_LoadSymbols( vm_t *vm ) {
break; break;
} }
chars = (int)strlen( token ); chars = (int)strlen( token );
sym = Hunk_Alloc( sizeof( *sym ) + chars, h_high ); sym = (vmSymbol_t*) Hunk_Alloc( sizeof( *sym ) + chars, h_high );
*prev = sym; *prev = sym;
prev = &sym->next; prev = &sym->next;
sym->next = NULL; sym->next = NULL;
@ -442,7 +442,7 @@ vm_t *VM_Create( const char *module, intptr_t (*systemCalls)(intptr_t *),
dataLength = 1 << i; dataLength = 1 << i;
// allocate zero filled space for initialized and uninitialized data // allocate zero filled space for initialized and uninitialized data
vm->dataBase = Hunk_Alloc( dataLength, h_high ); vm->dataBase = (byte*) Hunk_Alloc( dataLength, h_high );
vm->dataMask = dataLength - 1; vm->dataMask = dataLength - 1;
// copy the intialized data // copy the intialized data
@ -455,7 +455,7 @@ vm_t *VM_Create( const char *module, intptr_t (*systemCalls)(intptr_t *),
// allocate space for the jump targets, which will be filled in by the compile/prep functions // allocate space for the jump targets, which will be filled in by the compile/prep functions
vm->instructionPointersLength = header->instructionCount * 4; vm->instructionPointersLength = header->instructionCount * 4;
vm->instructionPointers = Hunk_Alloc( vm->instructionPointersLength, h_high ); vm->instructionPointers = (int*) Hunk_Alloc( vm->instructionPointersLength, h_high );
// copy or compile the instructions // copy or compile the instructions
vm->codeLength = header->codeLength; vm->codeLength = header->codeLength;
@ -672,7 +672,7 @@ void VM_VmProfile_f( void ) {
return; return;
} }
sorted = Z_Malloc( vm->numSymbols * sizeof( *sorted ) ); sorted = (vmSymbol_t**) Z_Malloc( vm->numSymbols * sizeof( *sorted ) );
sorted[0] = vm->symbols; sorted[0] = vm->symbols;
total = sorted[0]->profileCount; total = sorted[0]->profileCount;
for ( i = 1 ; i < vm->numSymbols ; i++ ) { for ( i = 1 ; i < vm->numSymbols ; i++ ) {

2
code/qcommon/vm_interpreted.c
View File

@ -159,7 +159,7 @@ void VM_PrepareInterpreter( vm_t *vm, vmHeader_t *header ) {
int instruction; int instruction;
int *codeBase; int *codeBase;
vm->codeBase = Hunk_Alloc( vm->codeLength*4, h_high ); // we're now int aligned vm->codeBase = (byte*) Hunk_Alloc( vm->codeLength*4, h_high ); // we're now int aligned
// memcpy( vm->codeBase, (byte *)header + header->codeOffset, vm->codeLength ); // memcpy( vm->codeBase, (byte *)header + header->codeOffset, vm->codeLength );
// we don't need to translate the instructions, but we still need // we don't need to translate the instructions, but we still need

2
code/server/sv_bot.c
View File

@ -524,7 +524,7 @@ void SV_BotInitBotLib(void) {
if (debugpolygons) Z_Free(debugpolygons); if (debugpolygons) Z_Free(debugpolygons);
bot_maxdebugpolys = Cvar_VariableIntegerValue("bot_maxdebugpolys"); bot_maxdebugpolys = Cvar_VariableIntegerValue("bot_maxdebugpolys");
debugpolygons = Z_Malloc(sizeof(bot_debugpoly_t) * bot_maxdebugpolys); debugpolygons = (bot_debugpoly_t*) Z_Malloc(sizeof(bot_debugpoly_t)* bot_maxdebugpolys);
botlib_import.Print = BotImport_Print; botlib_import.Print = BotImport_Print;
botlib_import.Trace = BotImport_Trace; botlib_import.Trace = BotImport_Trace;

2
code/server/sv_ccmds.c
View File

@ -299,7 +299,7 @@ static void SV_MapRestart_f( void ) {
SV_AddServerCommand( client, "map_restart\n" ); SV_AddServerCommand( client, "map_restart\n" );
// connect the client again, without the firstTime flag // connect the client again, without the firstTime flag
denied = VM_ExplicitArgPtr( gvm, VM_Call( gvm, GAME_CLIENT_CONNECT, i, qfalse, isBot ) ); denied = (char*) VM_ExplicitArgPtr( gvm, VM_Call( gvm, GAME_CLIENT_CONNECT, i, qfalse, isBot ) );
if ( denied ) { if ( denied ) {
// this generally shouldn't happen, because the client // this generally shouldn't happen, because the client
// was connected before the level change // was connected before the level change

9
code/server/sv_client.c
View File

@ -423,8 +423,7 @@ gotnewcl:
denied = VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, qtrue, qfalse ); // firstTime = qtrue denied = VM_Call( gvm, GAME_CLIENT_CONNECT, clientNum, qtrue, qfalse ); // firstTime = qtrue
if ( denied ) { if ( denied ) {
// we can't just use VM_ArgPtr, because that is only valid inside a VM_Call // we can't just use VM_ArgPtr, because that is only valid inside a VM_Call
const char* str = VM_ExplicitArgPtr( gvm, denied ); const char* str = (const char*)VM_ExplicitArgPtr( gvm, denied );
NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", str ); NET_OutOfBandPrint( NS_SERVER, from, "print\n%s\n", str );
Com_DPrintf ("Game rejected a connection: %s.\n", str); Com_DPrintf ("Game rejected a connection: %s.\n", str);
return; return;
@ -822,7 +821,7 @@ void SV_WriteDownloadToClient( client_t *cl , msg_t *msg )
curindex = (cl->downloadCurrentBlock % MAX_DOWNLOAD_WINDOW); curindex = (cl->downloadCurrentBlock % MAX_DOWNLOAD_WINDOW);
if (!cl->downloadBlocks[curindex]) if (!cl->downloadBlocks[curindex])
cl->downloadBlocks[curindex] = Z_Malloc( MAX_DOWNLOAD_BLKSIZE ); cl->downloadBlocks[curindex] = (unsigned char*) Z_Malloc( MAX_DOWNLOAD_BLKSIZE );
cl->downloadBlockSize[curindex] = FS_Read( cl->downloadBlocks[curindex], MAX_DOWNLOAD_BLKSIZE, cl->download ); cl->downloadBlockSize[curindex] = FS_Read( cl->downloadBlocks[curindex], MAX_DOWNLOAD_BLKSIZE, cl->download );
@ -960,9 +959,9 @@ static void SV_VerifyPaks_f( client_t *cl ) {
bGood = qtrue; bGood = qtrue;
nChkSum1 = nChkSum2 = 0; nChkSum1 = nChkSum2 = 0;
// we run the game, so determine which cgame and ui the client "should" be running // we run the game, so determine which cgame and ui the client "should" be running
bGood = (FS_FileIsInPAK("vm/cgame.qvm", &nChkSum1) == 1); bGood = (qboolean) (FS_FileIsInPAK("vm/cgame.qvm", &nChkSum1) == 1);
if (bGood) if (bGood)
bGood = (FS_FileIsInPAK("vm/ui.qvm", &nChkSum2) == 1); bGood = (qboolean) (FS_FileIsInPAK("vm/ui.qvm", &nChkSum2) == 1);
nClientPaks = Cmd_Argc(); nClientPaks = Cmd_Argc();

225
code/server/sv_game.c
View File

@ -319,10 +319,10 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
case G_MILLISECONDS: case G_MILLISECONDS:
return Sys_Milliseconds(); return Sys_Milliseconds();
case G_CVAR_REGISTER: case G_CVAR_REGISTER:
Cvar_Register( VMA(1), VMA(2), VMA(3), args[4] ); Cvar_Register( (vmCvar_t*) VMA(1), (const char*) VMA(2), (const char*) VMA(3), args[4] );
return 0; return 0;
case G_CVAR_UPDATE: case G_CVAR_UPDATE:
Cvar_Update( VMA(1) ); Cvar_Update( (vmCvar_t*) VMA(1) );
return 0; return 0;
case G_CVAR_SET: case G_CVAR_SET:
Cvar_Set( (const char *)VMA(1), (const char *)VMA(2) ); Cvar_Set( (const char *)VMA(1), (const char *)VMA(2) );
@ -330,19 +330,19 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
case G_CVAR_VARIABLE_INTEGER_VALUE: case G_CVAR_VARIABLE_INTEGER_VALUE:
return Cvar_VariableIntegerValue( (const char *)VMA(1) ); return Cvar_VariableIntegerValue( (const char *)VMA(1) );
case G_CVAR_VARIABLE_STRING_BUFFER: case G_CVAR_VARIABLE_STRING_BUFFER:
Cvar_VariableStringBuffer( VMA(1), VMA(2), args[3] ); Cvar_VariableStringBuffer( (const char*) VMA(1), (char*) VMA(2), args[3] );
return 0; return 0;
case G_ARGC: case G_ARGC:
return Cmd_Argc(); return Cmd_Argc();
case G_ARGV: case G_ARGV:
Cmd_ArgvBuffer( args[1], VMA(2), args[3] ); Cmd_ArgvBuffer( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case G_SEND_CONSOLE_COMMAND: case G_SEND_CONSOLE_COMMAND:
Cbuf_ExecuteText( args[1], VMA(2) ); Cbuf_ExecuteText( args[1], (const char*) VMA(2) );
return 0; return 0;
case G_FS_FOPEN_FILE: case G_FS_FOPEN_FILE:
return FS_FOpenFileByMode( VMA(1), VMA(2), args[3] ); return FS_FOpenFileByMode( (const char*) VMA(1), (fileHandle_t*) VMA(2), (fsMode_t) args[3] );
case G_FS_READ: case G_FS_READ:
FS_Read2( VMA(1), args[2], args[3] ); FS_Read2( VMA(1), args[2], args[3] );
return 0; return 0;
@ -353,64 +353,64 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
FS_FCloseFile( args[1] ); FS_FCloseFile( args[1] );
return 0; return 0;
case G_FS_GETFILELIST: case G_FS_GETFILELIST:
return FS_GetFileList( VMA(1), VMA(2), VMA(3), args[4] ); return FS_GetFileList( (const char*) VMA(1), (const char*) VMA(2), (char*) VMA(3), args[4] );
case G_FS_SEEK: case G_FS_SEEK:
return FS_Seek( args[1], args[2], args[3] ); return FS_Seek( args[1], args[2], args[3] );
case G_LOCATE_GAME_DATA: case G_LOCATE_GAME_DATA:
SV_LocateGameData( VMA(1), args[2], args[3], VMA(4), args[5] ); SV_LocateGameData( (sharedEntity_t*) VMA(1), args[2], args[3], (playerState_t*) VMA(4), args[5] );
return 0; return 0;
case G_DROP_CLIENT: case G_DROP_CLIENT:
SV_GameDropClient( args[1], VMA(2) ); SV_GameDropClient( args[1], (const char*) VMA(2) );
return 0; return 0;
case G_SEND_SERVER_COMMAND: case G_SEND_SERVER_COMMAND:
SV_GameSendServerCommand( args[1], VMA(2) ); SV_GameSendServerCommand( args[1], (const char*) VMA(2) );
return 0; return 0;
case G_LINKENTITY: case G_LINKENTITY:
SV_LinkEntity( VMA(1) ); SV_LinkEntity( (sharedEntity_t*) VMA(1) );
return 0; return 0;
case G_UNLINKENTITY: case G_UNLINKENTITY:
SV_UnlinkEntity( VMA(1) ); SV_UnlinkEntity( (sharedEntity_t*) VMA(1) );
return 0; return 0;
case G_ENTITIES_IN_BOX: case G_ENTITIES_IN_BOX:
return SV_AreaEntities( VMA(1), VMA(2), VMA(3), args[4] ); return SV_AreaEntities( (const vec_t*) VMA(1), (const vec_t*) VMA(2), (int*) VMA(3), args[4] );
case G_ENTITY_CONTACT: case G_ENTITY_CONTACT:
return SV_EntityContact( VMA(1), VMA(2), VMA(3), /*int capsule*/ qfalse ); return SV_EntityContact((vec_t*) VMA(1), (vec_t*) VMA(2), (const sharedEntity_t*) (3), /*int capsule*/ qfalse);
case G_ENTITY_CONTACTCAPSULE: case G_ENTITY_CONTACTCAPSULE:
return SV_EntityContact( VMA(1), VMA(2), VMA(3), /*int capsule*/ qtrue ); return SV_EntityContact( (vec_t*) VMA(1), (vec_t*) VMA(2), (const sharedEntity_t*) VMA(3), /*int capsule*/ qtrue );
case G_TRACE: case G_TRACE:
SV_Trace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qfalse ); SV_Trace((trace_t*)VMA(1), (const vec_t*)VMA(2), (vec_t*) VMA(3), (vec_t*)VMA(4), (const vec_t*) VMA(5), args[6], args[7], /*int capsule*/ qfalse);
return 0; return 0;
case G_TRACECAPSULE: case G_TRACECAPSULE:
SV_Trace( VMA(1), VMA(2), VMA(3), VMA(4), VMA(5), args[6], args[7], /*int capsule*/ qtrue ); SV_Trace((trace_t*)VMA(1), (const vec_t*)VMA(2), (vec_t*)VMA(3), (vec_t*)VMA(4), (const vec_t*)VMA(5), args[6], args[7], /*int capsule*/ qtrue);
return 0; return 0;
case G_POINT_CONTENTS: case G_POINT_CONTENTS:
return SV_PointContents( VMA(1), args[2] ); return SV_PointContents( (const vec_t*) VMA(1), args[2] );
case G_SET_BRUSH_MODEL: case G_SET_BRUSH_MODEL:
SV_SetBrushModel( VMA(1), VMA(2) ); SV_SetBrushModel( (sharedEntity_t*) (1), (const char*) VMA(2) );
return 0; return 0;
case G_IN_PVS: case G_IN_PVS:
return SV_inPVS( VMA(1), VMA(2) ); return SV_inPVS( (const vec_t*) VMA(1), (const vec_t*) VMA(2) );
case G_IN_PVS_IGNORE_PORTALS: case G_IN_PVS_IGNORE_PORTALS:
return SV_inPVSIgnorePortals( VMA(1), VMA(2) ); return SV_inPVSIgnorePortals( (const vec_t*) VMA(1), (const vec_t*) VMA(2) );
case G_SET_CONFIGSTRING: case G_SET_CONFIGSTRING:
SV_SetConfigstring( args[1], VMA(2) ); SV_SetConfigstring( args[1], (const char*) VMA(2) );
return 0; return 0;
case G_GET_CONFIGSTRING: case G_GET_CONFIGSTRING:
SV_GetConfigstring( args[1], VMA(2), args[3] ); SV_GetConfigstring( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case G_SET_USERINFO: case G_SET_USERINFO:
SV_SetUserinfo( args[1], VMA(2) ); SV_SetUserinfo( args[1], (const char*) VMA(2) );
return 0; return 0;
case G_GET_USERINFO: case G_GET_USERINFO:
SV_GetUserinfo( args[1], VMA(2), args[3] ); SV_GetUserinfo( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case G_GET_SERVERINFO: case G_GET_SERVERINFO:
SV_GetServerinfo( VMA(1), args[2] ); SV_GetServerinfo( (char*) VMA(1), args[2] );
return 0; return 0;
case G_ADJUST_AREA_PORTAL_STATE: case G_ADJUST_AREA_PORTAL_STATE:
SV_AdjustAreaPortalState( VMA(1), args[2] ); SV_AdjustAreaPortalState( (sharedEntity_t*) (1), (qboolean) args[2] );
return 0; return 0;
case G_AREAS_CONNECTED: case G_AREAS_CONNECTED:
return CM_AreasConnected( args[1], args[2] ); return CM_AreasConnected( args[1], args[2] );
@ -422,14 +422,14 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
return 0; return 0;
case G_GET_USERCMD: case G_GET_USERCMD:
SV_GetUsercmd( args[1], VMA(2) ); SV_GetUsercmd( args[1], (usercmd_t*) VMA(2) );
return 0; return 0;
case G_GET_ENTITY_TOKEN: case G_GET_ENTITY_TOKEN:
{ {
const char *s; const char *s;
s = COM_Parse( &sv.entityParsePoint ); s = COM_Parse( &sv.entityParsePoint );
Q_strncpyz( VMA(1), s, args[2] ); Q_strncpyz( (char*) VMA(1), s, args[2] );
if ( !sv.entityParsePoint && !s[0] ) { if ( !sv.entityParsePoint && !s[0] ) {
return qfalse; return qfalse;
} else { } else {
@ -438,14 +438,14 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
} }
case G_DEBUG_POLYGON_CREATE: case G_DEBUG_POLYGON_CREATE:
return BotImport_DebugPolygonCreate( args[1], args[2], VMA(3) ); return BotImport_DebugPolygonCreate( args[1], args[2], (vec3_t*) VMA(3) );
case G_DEBUG_POLYGON_DELETE: case G_DEBUG_POLYGON_DELETE:
BotImport_DebugPolygonDelete( args[1] ); BotImport_DebugPolygonDelete( args[1] );
return 0; return 0;
case G_REAL_TIME: case G_REAL_TIME:
return Com_RealTime( VMA(1) ); return Com_RealTime( (qtime_t*) VMA(1) );
case G_SNAPVECTOR: case G_SNAPVECTOR:
Sys_SnapVector( VMA(1) ); Sys_SnapVector( (float*) VMA(1) );
return 0; return 0;
//==================================== //====================================
@ -455,100 +455,100 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
case BOTLIB_SHUTDOWN: case BOTLIB_SHUTDOWN:
return SV_BotLibShutdown(); return SV_BotLibShutdown();
case BOTLIB_LIBVAR_SET: case BOTLIB_LIBVAR_SET:
return botlib_export->BotLibVarSet( VMA(1), VMA(2) ); return botlib_export->BotLibVarSet( (char*) VMA(1), (char*) VMA(2) );
case BOTLIB_LIBVAR_GET: case BOTLIB_LIBVAR_GET:
return botlib_export->BotLibVarGet( VMA(1), VMA(2), args[3] ); return botlib_export->BotLibVarGet( (char*) VMA(1), (char*) VMA(2), args[3] );
case BOTLIB_PC_ADD_GLOBAL_DEFINE: case BOTLIB_PC_ADD_GLOBAL_DEFINE:
return botlib_export->PC_AddGlobalDefine( VMA(1) ); return botlib_export->PC_AddGlobalDefine( (char*) VMA(1) );
case BOTLIB_PC_LOAD_SOURCE: case BOTLIB_PC_LOAD_SOURCE:
return botlib_export->PC_LoadSourceHandle( VMA(1) ); return botlib_export->PC_LoadSourceHandle( (const char*) VMA(1) );
case BOTLIB_PC_FREE_SOURCE: case BOTLIB_PC_FREE_SOURCE:
return botlib_export->PC_FreeSourceHandle( args[1] ); return botlib_export->PC_FreeSourceHandle( args[1] );
case BOTLIB_PC_READ_TOKEN: case BOTLIB_PC_READ_TOKEN:
return botlib_export->PC_ReadTokenHandle( args[1], VMA(2) ); return botlib_export->PC_ReadTokenHandle( args[1], (pc_token_t*) VMA(2) );
case BOTLIB_PC_SOURCE_FILE_AND_LINE: case BOTLIB_PC_SOURCE_FILE_AND_LINE:
return botlib_export->PC_SourceFileAndLine( args[1], VMA(2), VMA(3) ); return botlib_export->PC_SourceFileAndLine( args[1], (char*) VMA(2), (int*) VMA(3) );
case BOTLIB_START_FRAME: case BOTLIB_START_FRAME:
return botlib_export->BotLibStartFrame( VMF(1) ); return botlib_export->BotLibStartFrame( VMF(1) );
case BOTLIB_LOAD_MAP: case BOTLIB_LOAD_MAP:
return botlib_export->BotLibLoadMap( VMA(1) ); return botlib_export->BotLibLoadMap( (const char*) VMA(1) );
case BOTLIB_UPDATENTITY: case BOTLIB_UPDATENTITY:
return botlib_export->BotLibUpdateEntity( args[1], VMA(2) ); return botlib_export->BotLibUpdateEntity( args[1], (bot_entitystate_t*) VMA(2) );
case BOTLIB_TEST: case BOTLIB_TEST:
return botlib_export->Test( args[1], VMA(2), VMA(3), VMA(4) ); return botlib_export->Test( args[1], (char*) VMA(2), (vec_t*) VMA(3), (vec_t*) VMA(4) );
case BOTLIB_GET_SNAPSHOT_ENTITY: case BOTLIB_GET_SNAPSHOT_ENTITY:
return SV_BotGetSnapshotEntity( args[1], args[2] ); return SV_BotGetSnapshotEntity( args[1], args[2] );
case BOTLIB_GET_CONSOLE_MESSAGE: case BOTLIB_GET_CONSOLE_MESSAGE:
return SV_BotGetConsoleMessage( args[1], VMA(2), args[3] ); return SV_BotGetConsoleMessage( args[1], (char*) VMA(2), args[3] );
case BOTLIB_USER_COMMAND: case BOTLIB_USER_COMMAND:
SV_ClientThink( &svs.clients[args[1]], VMA(2) ); SV_ClientThink( &svs.clients[args[1]], (usercmd_t*) VMA(2) );
return 0; return 0;
case BOTLIB_AAS_BBOX_AREAS: case BOTLIB_AAS_BBOX_AREAS:
return botlib_export->aas.AAS_BBoxAreas( VMA(1), VMA(2), VMA(3), args[4] ); return botlib_export->aas.AAS_BBoxAreas( (vec_t*) VMA(1), (vec_t*) VMA(2), (int*) VMA(3), args[4] );
case BOTLIB_AAS_AREA_INFO: case BOTLIB_AAS_AREA_INFO:
return botlib_export->aas.AAS_AreaInfo( args[1], VMA(2) ); return botlib_export->aas.AAS_AreaInfo( args[1], (aas_areainfo_s*) VMA(2) );
case BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL: case BOTLIB_AAS_ALTERNATIVE_ROUTE_GOAL:
return botlib_export->aas.AAS_AlternativeRouteGoals( VMA(1), args[2], VMA(3), args[4], args[5], VMA(6), args[7], args[8] ); return botlib_export->aas.AAS_AlternativeRouteGoals( (vec_t*) VMA(1), args[2], (vec_t*) VMA(3), args[4], args[5], (aas_altroutegoal_s*) VMA(6), args[7], args[8] );
case BOTLIB_AAS_ENTITY_INFO: case BOTLIB_AAS_ENTITY_INFO:
botlib_export->aas.AAS_EntityInfo( args[1], VMA(2) ); botlib_export->aas.AAS_EntityInfo( args[1], (aas_entityinfo_s*) VMA(2) );
return 0; return 0;
case BOTLIB_AAS_INITIALIZED: case BOTLIB_AAS_INITIALIZED:
return botlib_export->aas.AAS_Initialized(); return botlib_export->aas.AAS_Initialized();
case BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX: case BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX:
botlib_export->aas.AAS_PresenceTypeBoundingBox( args[1], VMA(2), VMA(3) ); botlib_export->aas.AAS_PresenceTypeBoundingBox( args[1], (vec_t*) VMA(2), (vec_t*) VMA(3) );
return 0; return 0;
case BOTLIB_AAS_TIME: case BOTLIB_AAS_TIME:
return FloatAsInt( botlib_export->aas.AAS_Time() ); return FloatAsInt( botlib_export->aas.AAS_Time() );
case BOTLIB_AAS_POINT_AREA_NUM: case BOTLIB_AAS_POINT_AREA_NUM:
return botlib_export->aas.AAS_PointAreaNum( VMA(1) ); return botlib_export->aas.AAS_PointAreaNum((vec_t*) VMA(1));
case BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX: case BOTLIB_AAS_POINT_REACHABILITY_AREA_INDEX:
return botlib_export->aas.AAS_PointReachabilityAreaIndex( VMA(1) ); return botlib_export->aas.AAS_PointReachabilityAreaIndex((vec_t*) VMA(1));
case BOTLIB_AAS_TRACE_AREAS: case BOTLIB_AAS_TRACE_AREAS:
return botlib_export->aas.AAS_TraceAreas( VMA(1), VMA(2), VMA(3), VMA(4), args[5] ); return botlib_export->aas.AAS_TraceAreas((vec_t*)VMA(1), (vec_t*) VMA(2), (int*) VMA(3), (vec3_t*) VMA(4), args[5]);
case BOTLIB_AAS_POINT_CONTENTS: case BOTLIB_AAS_POINT_CONTENTS:
return botlib_export->aas.AAS_PointContents( VMA(1) ); return botlib_export->aas.AAS_PointContents((vec_t*) VMA(1));
case BOTLIB_AAS_NEXT_BSP_ENTITY: case BOTLIB_AAS_NEXT_BSP_ENTITY:
return botlib_export->aas.AAS_NextBSPEntity( args[1] ); return botlib_export->aas.AAS_NextBSPEntity( args[1] );
case BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY: case BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY:
return botlib_export->aas.AAS_ValueForBSPEpairKey( args[1], VMA(2), VMA(3), args[4] ); return botlib_export->aas.AAS_ValueForBSPEpairKey( args[1], (char*) VMA(2), (char*) VMA(3), args[4] );
case BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY: case BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY:
return botlib_export->aas.AAS_VectorForBSPEpairKey( args[1], VMA(2), VMA(3) ); return botlib_export->aas.AAS_VectorForBSPEpairKey(args[1], (char*)VMA(2), (vec_t*) VMA(3));
case BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY: case BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY:
return botlib_export->aas.AAS_FloatForBSPEpairKey( args[1], VMA(2), VMA(3) ); return botlib_export->aas.AAS_FloatForBSPEpairKey( args[1], (char*) VMA(2), (float*) VMA(3) );
case BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY: case BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY:
return botlib_export->aas.AAS_IntForBSPEpairKey( args[1], VMA(2), VMA(3) ); return botlib_export->aas.AAS_IntForBSPEpairKey( args[1], (char*) VMA(2), (int*) VMA(3) );
case BOTLIB_AAS_AREA_REACHABILITY: case BOTLIB_AAS_AREA_REACHABILITY:
return botlib_export->aas.AAS_AreaReachability( args[1] ); return botlib_export->aas.AAS_AreaReachability( args[1] );
case BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA: case BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA:
return botlib_export->aas.AAS_AreaTravelTimeToGoalArea( args[1], VMA(2), args[3], args[4] ); return botlib_export->aas.AAS_AreaTravelTimeToGoalArea(args[1], (vec_t*) VMA(2), args[3], args[4]);
case BOTLIB_AAS_ENABLE_ROUTING_AREA: case BOTLIB_AAS_ENABLE_ROUTING_AREA:
return botlib_export->aas.AAS_EnableRoutingArea( args[1], args[2] ); return botlib_export->aas.AAS_EnableRoutingArea( args[1], args[2] );
case BOTLIB_AAS_PREDICT_ROUTE: case BOTLIB_AAS_PREDICT_ROUTE:
return botlib_export->aas.AAS_PredictRoute( VMA(1), args[2], VMA(3), args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11] ); return botlib_export->aas.AAS_PredictRoute((aas_predictroute_s*)VMA(1), args[2], (vec_t*) VMA(3), args[4], args[5], args[6], args[7], args[8], args[9], args[10], args[11]);
case BOTLIB_AAS_SWIMMING: case BOTLIB_AAS_SWIMMING:
return botlib_export->aas.AAS_Swimming( VMA(1) ); return botlib_export->aas.AAS_Swimming((vec_t*) VMA(1));
case BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT: case BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT:
return botlib_export->aas.AAS_PredictClientMovement( VMA(1), args[2], VMA(3), args[4], args[5], return botlib_export->aas.AAS_PredictClientMovement((aas_clientmove_s*)VMA(1), args[2], (vec_t*) VMA(3), args[4], args[5],
VMA(6), VMA(7), args[8], args[9], VMF(10), args[11], args[12], args[13] ); (vec_t*)VMA(6), (vec_t*) VMA(7), args[8], args[9], VMF(10), args[11], args[12], args[13]);
case BOTLIB_EA_SAY: case BOTLIB_EA_SAY:
botlib_export->ea.EA_Say( args[1], VMA(2) ); botlib_export->ea.EA_Say( args[1], (char*) VMA(2) );
return 0; return 0;
case BOTLIB_EA_SAY_TEAM: case BOTLIB_EA_SAY_TEAM:
botlib_export->ea.EA_SayTeam( args[1], VMA(2) ); botlib_export->ea.EA_SayTeam( args[1], (char*) VMA(2) );
return 0; return 0;
case BOTLIB_EA_COMMAND: case BOTLIB_EA_COMMAND:
botlib_export->ea.EA_Command( args[1], VMA(2) ); botlib_export->ea.EA_Command( args[1], (char*) VMA(2) );
return 0; return 0;
case BOTLIB_EA_ACTION: case BOTLIB_EA_ACTION:
@ -601,24 +601,24 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
botlib_export->ea.EA_DelayedJump( args[1] ); botlib_export->ea.EA_DelayedJump( args[1] );
return 0; return 0;
case BOTLIB_EA_MOVE: case BOTLIB_EA_MOVE:
botlib_export->ea.EA_Move( args[1], VMA(2), VMF(3) ); botlib_export->ea.EA_Move(args[1], (vec_t*) VMA(2), VMF(3));
return 0; return 0;
case BOTLIB_EA_VIEW: case BOTLIB_EA_VIEW:
botlib_export->ea.EA_View( args[1], VMA(2) ); botlib_export->ea.EA_View(args[1], (vec_t*) VMA(2));
return 0; return 0;
case BOTLIB_EA_END_REGULAR: case BOTLIB_EA_END_REGULAR:
botlib_export->ea.EA_EndRegular( args[1], VMF(2) ); botlib_export->ea.EA_EndRegular( args[1], VMF(2) );
return 0; return 0;
case BOTLIB_EA_GET_INPUT: case BOTLIB_EA_GET_INPUT:
botlib_export->ea.EA_GetInput( args[1], VMF(2), VMA(3) ); botlib_export->ea.EA_GetInput( args[1], VMF(2), (bot_input_t*) VMA(3) );
return 0; return 0;
case BOTLIB_EA_RESET_INPUT: case BOTLIB_EA_RESET_INPUT:
botlib_export->ea.EA_ResetInput( args[1] ); botlib_export->ea.EA_ResetInput( args[1] );
return 0; return 0;
case BOTLIB_AI_LOAD_CHARACTER: case BOTLIB_AI_LOAD_CHARACTER:
return botlib_export->ai.BotLoadCharacter( VMA(1), VMF(2) ); return botlib_export->ai.BotLoadCharacter( (char*) VMA(1), VMF(2) );
case BOTLIB_AI_FREE_CHARACTER: case BOTLIB_AI_FREE_CHARACTER:
botlib_export->ai.BotFreeCharacter( args[1] ); botlib_export->ai.BotFreeCharacter( args[1] );
return 0; return 0;
@ -631,7 +631,7 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
case BOTLIB_AI_CHARACTERISTIC_BINTEGER: case BOTLIB_AI_CHARACTERISTIC_BINTEGER:
return botlib_export->ai.Characteristic_BInteger( args[1], args[2], args[3], args[4] ); return botlib_export->ai.Characteristic_BInteger( args[1], args[2], args[3], args[4] );
case BOTLIB_AI_CHARACTERISTIC_STRING: case BOTLIB_AI_CHARACTERISTIC_STRING:
botlib_export->ai.Characteristic_String( args[1], args[2], VMA(3), args[4] ); botlib_export->ai.Characteristic_String( args[1], args[2], (char*) VMA(3), args[4] );
return 0; return 0;
case BOTLIB_AI_ALLOC_CHAT_STATE: case BOTLIB_AI_ALLOC_CHAT_STATE:
@ -640,50 +640,50 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
botlib_export->ai.BotFreeChatState( args[1] ); botlib_export->ai.BotFreeChatState( args[1] );
return 0; return 0;
case BOTLIB_AI_QUEUE_CONSOLE_MESSAGE: case BOTLIB_AI_QUEUE_CONSOLE_MESSAGE:
botlib_export->ai.BotQueueConsoleMessage( args[1], args[2], VMA(3) ); botlib_export->ai.BotQueueConsoleMessage( args[1], args[2], (char*) VMA(3) );
return 0; return 0;
case BOTLIB_AI_REMOVE_CONSOLE_MESSAGE: case BOTLIB_AI_REMOVE_CONSOLE_MESSAGE:
botlib_export->ai.BotRemoveConsoleMessage( args[1], args[2] ); botlib_export->ai.BotRemoveConsoleMessage( args[1], args[2] );
return 0; return 0;
case BOTLIB_AI_NEXT_CONSOLE_MESSAGE: case BOTLIB_AI_NEXT_CONSOLE_MESSAGE:
return botlib_export->ai.BotNextConsoleMessage( args[1], VMA(2) ); return botlib_export->ai.BotNextConsoleMessage( args[1], (bot_consolemessage_s*) VMA(2) );
case BOTLIB_AI_NUM_CONSOLE_MESSAGE: case BOTLIB_AI_NUM_CONSOLE_MESSAGE:
return botlib_export->ai.BotNumConsoleMessages( args[1] ); return botlib_export->ai.BotNumConsoleMessages( args[1] );
case BOTLIB_AI_INITIAL_CHAT: case BOTLIB_AI_INITIAL_CHAT:
botlib_export->ai.BotInitialChat( args[1], VMA(2), args[3], VMA(4), VMA(5), VMA(6), VMA(7), VMA(8), VMA(9), VMA(10), VMA(11) ); botlib_export->ai.BotInitialChat( args[1], (char*) VMA(2), args[3], (char*) VMA(4), (char*) VMA(5), (char*) VMA(6), (char*) VMA(7), (char*) VMA(8), (char*) VMA(9), (char*) VMA(10), (char*) VMA(11) );
return 0; return 0;
case BOTLIB_AI_NUM_INITIAL_CHATS: case BOTLIB_AI_NUM_INITIAL_CHATS:
return botlib_export->ai.BotNumInitialChats( args[1], VMA(2) ); return botlib_export->ai.BotNumInitialChats( args[1], (char*) VMA(2) );
case BOTLIB_AI_REPLY_CHAT: case BOTLIB_AI_REPLY_CHAT:
return botlib_export->ai.BotReplyChat( args[1], VMA(2), args[3], args[4], VMA(5), VMA(6), VMA(7), VMA(8), VMA(9), VMA(10), VMA(11), VMA(12) ); return botlib_export->ai.BotReplyChat( args[1], (char*) VMA(2), args[3], args[4], (char*) VMA(5), (char*) VMA(6), (char*) VMA(7), (char*) VMA(8), (char*) VMA(9), (char*) VMA(10), (char*) VMA(11), (char*) VMA(12) );
case BOTLIB_AI_CHAT_LENGTH: case BOTLIB_AI_CHAT_LENGTH:
return botlib_export->ai.BotChatLength( args[1] ); return botlib_export->ai.BotChatLength( args[1] );
case BOTLIB_AI_ENTER_CHAT: case BOTLIB_AI_ENTER_CHAT:
botlib_export->ai.BotEnterChat( args[1], args[2], args[3] ); botlib_export->ai.BotEnterChat( args[1], args[2], args[3] );
return 0; return 0;
case BOTLIB_AI_GET_CHAT_MESSAGE: case BOTLIB_AI_GET_CHAT_MESSAGE:
botlib_export->ai.BotGetChatMessage( args[1], VMA(2), args[3] ); botlib_export->ai.BotGetChatMessage( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case BOTLIB_AI_STRING_CONTAINS: case BOTLIB_AI_STRING_CONTAINS:
return botlib_export->ai.StringContains( VMA(1), VMA(2), args[3] ); return botlib_export->ai.StringContains((char*)VMA(1), (char*) VMA(2), args[3]);
case BOTLIB_AI_FIND_MATCH: case BOTLIB_AI_FIND_MATCH:
return botlib_export->ai.BotFindMatch( VMA(1), VMA(2), args[3] ); return botlib_export->ai.BotFindMatch((char*) VMA(1), (bot_match_s*) VMA(2), args[3]);
case BOTLIB_AI_MATCH_VARIABLE: case BOTLIB_AI_MATCH_VARIABLE:
botlib_export->ai.BotMatchVariable( VMA(1), args[2], VMA(3), args[4] ); botlib_export->ai.BotMatchVariable( (bot_match_s*) VMA(1), args[2], (char*) VMA(3), args[4] );
return 0; return 0;
case BOTLIB_AI_UNIFY_WHITE_SPACES: case BOTLIB_AI_UNIFY_WHITE_SPACES:
botlib_export->ai.UnifyWhiteSpaces( VMA(1) ); botlib_export->ai.UnifyWhiteSpaces((char*) VMA(1));
return 0; return 0;
case BOTLIB_AI_REPLACE_SYNONYMS: case BOTLIB_AI_REPLACE_SYNONYMS:
botlib_export->ai.BotReplaceSynonyms( VMA(1), args[2] ); botlib_export->ai.BotReplaceSynonyms((char*) VMA(1), args[2]);
return 0; return 0;
case BOTLIB_AI_LOAD_CHAT_FILE: case BOTLIB_AI_LOAD_CHAT_FILE:
return botlib_export->ai.BotLoadChatFile( args[1], VMA(2), VMA(3) ); return botlib_export->ai.BotLoadChatFile(args[1], (char*)VMA(2), (char*) VMA(3));
case BOTLIB_AI_SET_CHAT_GENDER: case BOTLIB_AI_SET_CHAT_GENDER:
botlib_export->ai.BotSetChatGender( args[1], args[2] ); botlib_export->ai.BotSetChatGender( args[1], args[2] );
return 0; return 0;
case BOTLIB_AI_SET_CHAT_NAME: case BOTLIB_AI_SET_CHAT_NAME:
botlib_export->ai.BotSetChatName( args[1], VMA(2), args[3] ); botlib_export->ai.BotSetChatName(args[1], (char*) VMA(2), args[3]);
return 0; return 0;
case BOTLIB_AI_RESET_GOAL_STATE: case BOTLIB_AI_RESET_GOAL_STATE:
@ -696,7 +696,7 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
botlib_export->ai.BotRemoveFromAvoidGoals( args[1], args[2] ); botlib_export->ai.BotRemoveFromAvoidGoals( args[1], args[2] );
return 0; return 0;
case BOTLIB_AI_PUSH_GOAL: case BOTLIB_AI_PUSH_GOAL:
botlib_export->ai.BotPushGoal( args[1], VMA(2) ); botlib_export->ai.BotPushGoal(args[1], (bot_goal_s*) VMA(2));
return 0; return 0;
case BOTLIB_AI_POP_GOAL: case BOTLIB_AI_POP_GOAL:
botlib_export->ai.BotPopGoal( args[1] ); botlib_export->ai.BotPopGoal( args[1] );
@ -711,26 +711,26 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
botlib_export->ai.BotDumpGoalStack( args[1] ); botlib_export->ai.BotDumpGoalStack( args[1] );
return 0; return 0;
case BOTLIB_AI_GOAL_NAME: case BOTLIB_AI_GOAL_NAME:
botlib_export->ai.BotGoalName( args[1], VMA(2), args[3] ); botlib_export->ai.BotGoalName( args[1], (char*) VMA(2), args[3] );
return 0; return 0;
case BOTLIB_AI_GET_TOP_GOAL: case BOTLIB_AI_GET_TOP_GOAL:
return botlib_export->ai.BotGetTopGoal( args[1], VMA(2) ); return botlib_export->ai.BotGetTopGoal( args[1], (bot_goal_s*) VMA(2) );
case BOTLIB_AI_GET_SECOND_GOAL: case BOTLIB_AI_GET_SECOND_GOAL:
return botlib_export->ai.BotGetSecondGoal( args[1], VMA(2) ); return botlib_export->ai.BotGetSecondGoal(args[1], (bot_goal_s*) VMA(2));
case BOTLIB_AI_CHOOSE_LTG_ITEM: case BOTLIB_AI_CHOOSE_LTG_ITEM:
return botlib_export->ai.BotChooseLTGItem( args[1], VMA(2), VMA(3), args[4] ); return botlib_export->ai.BotChooseLTGItem( args[1], (vec_t*) VMA(2), (int*) VMA(3), args[4] );
case BOTLIB_AI_CHOOSE_NBG_ITEM: case BOTLIB_AI_CHOOSE_NBG_ITEM:
return botlib_export->ai.BotChooseNBGItem( args[1], VMA(2), VMA(3), args[4], VMA(5), VMF(6) ); return botlib_export->ai.BotChooseNBGItem( args[1], (vec_t*) VMA(2), (int*) VMA(3), args[4], (bot_goal_s*) VMA(5), VMF(6) );
case BOTLIB_AI_TOUCHING_GOAL: case BOTLIB_AI_TOUCHING_GOAL:
return botlib_export->ai.BotTouchingGoal( VMA(1), VMA(2) ); return botlib_export->ai.BotTouchingGoal((vec_t*)VMA(1), (bot_goal_s*) VMA(2));
case BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE: case BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE:
return botlib_export->ai.BotItemGoalInVisButNotVisible( args[1], VMA(2), VMA(3), VMA(4) ); return botlib_export->ai.BotItemGoalInVisButNotVisible(args[1], (vec_t*)VMA(2), (vec_t*)VMA(3), (bot_goal_s*) VMA(4));
case BOTLIB_AI_GET_LEVEL_ITEM_GOAL: case BOTLIB_AI_GET_LEVEL_ITEM_GOAL:
return botlib_export->ai.BotGetLevelItemGoal( args[1], VMA(2), VMA(3) ); return botlib_export->ai.BotGetLevelItemGoal(args[1], (char*)VMA(2), (bot_goal_s*) VMA(3));
case BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL: case BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL:
return botlib_export->ai.BotGetNextCampSpotGoal( args[1], VMA(2) ); return botlib_export->ai.BotGetNextCampSpotGoal(args[1], (bot_goal_s*) VMA(2));
case BOTLIB_AI_GET_MAP_LOCATION_GOAL: case BOTLIB_AI_GET_MAP_LOCATION_GOAL:
return botlib_export->ai.BotGetMapLocationGoal( VMA(1), VMA(2) ); return botlib_export->ai.BotGetMapLocationGoal((char*)VMA(1), (bot_goal_s*) VMA(2));
case BOTLIB_AI_AVOID_GOAL_TIME: case BOTLIB_AI_AVOID_GOAL_TIME:
return FloatAsInt( botlib_export->ai.BotAvoidGoalTime( args[1], args[2] ) ); return FloatAsInt( botlib_export->ai.BotAvoidGoalTime( args[1], args[2] ) );
case BOTLIB_AI_SET_AVOID_GOAL_TIME: case BOTLIB_AI_SET_AVOID_GOAL_TIME:
@ -743,7 +743,7 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
botlib_export->ai.BotUpdateEntityItems(); botlib_export->ai.BotUpdateEntityItems();
return 0; return 0;
case BOTLIB_AI_LOAD_ITEM_WEIGHTS: case BOTLIB_AI_LOAD_ITEM_WEIGHTS:
return botlib_export->ai.BotLoadItemWeights( args[1], VMA(2) ); return botlib_export->ai.BotLoadItemWeights( args[1], (char*) VMA(2) );
case BOTLIB_AI_FREE_ITEM_WEIGHTS: case BOTLIB_AI_FREE_ITEM_WEIGHTS:
botlib_export->ai.BotFreeItemWeights( args[1] ); botlib_export->ai.BotFreeItemWeights( args[1] );
return 0; return 0;
@ -751,7 +751,7 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
botlib_export->ai.BotInterbreedGoalFuzzyLogic( args[1], args[2], args[3] ); botlib_export->ai.BotInterbreedGoalFuzzyLogic( args[1], args[2], args[3] );
return 0; return 0;
case BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC: case BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC:
botlib_export->ai.BotSaveGoalFuzzyLogic( args[1], VMA(2) ); botlib_export->ai.BotSaveGoalFuzzyLogic( args[1], (char*) VMA(2) );
return 0; return 0;
case BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC: case BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC:
botlib_export->ai.BotMutateGoalFuzzyLogic( args[1], VMF(2) ); botlib_export->ai.BotMutateGoalFuzzyLogic( args[1], VMF(2) );
@ -766,13 +766,13 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
botlib_export->ai.BotResetMoveState( args[1] ); botlib_export->ai.BotResetMoveState( args[1] );
return 0; return 0;
case BOTLIB_AI_ADD_AVOID_SPOT: case BOTLIB_AI_ADD_AVOID_SPOT:
botlib_export->ai.BotAddAvoidSpot( args[1], VMA(2), VMF(3), args[4] ); botlib_export->ai.BotAddAvoidSpot( args[1], (vec_t*) VMA(2), VMF(3), args[4] );
return 0; return 0;
case BOTLIB_AI_MOVE_TO_GOAL: case BOTLIB_AI_MOVE_TO_GOAL:
botlib_export->ai.BotMoveToGoal( VMA(1), args[2], VMA(3), args[4] ); botlib_export->ai.BotMoveToGoal((bot_moveresult_s*)VMA(1), args[2], (bot_goal_s*) VMA(3), args[4]);
return 0; return 0;
case BOTLIB_AI_MOVE_IN_DIRECTION: case BOTLIB_AI_MOVE_IN_DIRECTION:
return botlib_export->ai.BotMoveInDirection( args[1], VMA(2), VMF(3), args[4] ); return botlib_export->ai.BotMoveInDirection( args[1], (vec_t*) VMA(2), VMF(3), args[4] );
case BOTLIB_AI_RESET_AVOID_REACH: case BOTLIB_AI_RESET_AVOID_REACH:
botlib_export->ai.BotResetAvoidReach( args[1] ); botlib_export->ai.BotResetAvoidReach( args[1] );
return 0; return 0;
@ -780,27 +780,27 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
botlib_export->ai.BotResetLastAvoidReach( args[1] ); botlib_export->ai.BotResetLastAvoidReach( args[1] );
return 0; return 0;
case BOTLIB_AI_REACHABILITY_AREA: case BOTLIB_AI_REACHABILITY_AREA:
return botlib_export->ai.BotReachabilityArea( VMA(1), args[2] ); return botlib_export->ai.BotReachabilityArea( (vec_t*) VMA(1), args[2] );
case BOTLIB_AI_MOVEMENT_VIEW_TARGET: case BOTLIB_AI_MOVEMENT_VIEW_TARGET:
return botlib_export->ai.BotMovementViewTarget( args[1], VMA(2), args[3], VMF(4), VMA(5) ); return botlib_export->ai.BotMovementViewTarget(args[1], (bot_goal_s*) VMA(2), args[3], VMF(4), (vec_t*) VMA(5));
case BOTLIB_AI_PREDICT_VISIBLE_POSITION: case BOTLIB_AI_PREDICT_VISIBLE_POSITION:
return botlib_export->ai.BotPredictVisiblePosition( VMA(1), args[2], VMA(3), args[4], VMA(5) ); return botlib_export->ai.BotPredictVisiblePosition((vec_t*)VMA(1), args[2], (bot_goal_s*) VMA(3), args[4], (vec_t*) VMA(5));
case BOTLIB_AI_ALLOC_MOVE_STATE: case BOTLIB_AI_ALLOC_MOVE_STATE:
return botlib_export->ai.BotAllocMoveState(); return botlib_export->ai.BotAllocMoveState();
case BOTLIB_AI_FREE_MOVE_STATE: case BOTLIB_AI_FREE_MOVE_STATE:
botlib_export->ai.BotFreeMoveState( args[1] ); botlib_export->ai.BotFreeMoveState( args[1] );
return 0; return 0;
case BOTLIB_AI_INIT_MOVE_STATE: case BOTLIB_AI_INIT_MOVE_STATE:
botlib_export->ai.BotInitMoveState( args[1], VMA(2) ); botlib_export->ai.BotInitMoveState( args[1], (bot_initmove_s*) VMA(2) );
return 0; return 0;
case BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON: case BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON:
return botlib_export->ai.BotChooseBestFightWeapon( args[1], VMA(2) ); return botlib_export->ai.BotChooseBestFightWeapon( args[1], (int*) VMA(2) );
case BOTLIB_AI_GET_WEAPON_INFO: case BOTLIB_AI_GET_WEAPON_INFO:
botlib_export->ai.BotGetWeaponInfo( args[1], args[2], VMA(3) ); botlib_export->ai.BotGetWeaponInfo( args[1], args[2], (weaponinfo_s*) VMA(3) );
return 0; return 0;
case BOTLIB_AI_LOAD_WEAPON_WEIGHTS: case BOTLIB_AI_LOAD_WEAPON_WEIGHTS:
return botlib_export->ai.BotLoadWeaponWeights( args[1], VMA(2) ); return botlib_export->ai.BotLoadWeaponWeights( args[1], (char*) VMA(2) );
case BOTLIB_AI_ALLOC_WEAPON_STATE: case BOTLIB_AI_ALLOC_WEAPON_STATE:
return botlib_export->ai.BotAllocWeaponState(); return botlib_export->ai.BotAllocWeaponState();
case BOTLIB_AI_FREE_WEAPON_STATE: case BOTLIB_AI_FREE_WEAPON_STATE:
@ -811,7 +811,7 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
return 0; return 0;
case BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION: case BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION:
return botlib_export->ai.GeneticParentsAndChildSelection(args[1], VMA(2), VMA(3), VMA(4), VMA(5)); return botlib_export->ai.GeneticParentsAndChildSelection(args[1], (float*) VMA(2), (int*) VMA(3), (int*) VMA(4), (int*) VMA(5));
case TRAP_MEMSET: case TRAP_MEMSET:
Com_Memset( VMA(1), args[2], args[3] ); Com_Memset( VMA(1), args[2], args[3] );
@ -822,9 +822,8 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
return 0; return 0;
case TRAP_STRNCPY: case TRAP_STRNCPY:
strncpy( VMA(1), VMA(2), args[3] ); strncpy( (char*)VMA(1), (const char*)VMA(2), args[3] );
return args[1]; return args[1];
case TRAP_SIN: case TRAP_SIN:
return FloatAsInt( sin( VMF(1) ) ); return FloatAsInt( sin( VMF(1) ) );
@ -838,15 +837,15 @@ intptr_t SV_GameSystemCalls( intptr_t *args ) {
return FloatAsInt( sqrt( VMF(1) ) ); return FloatAsInt( sqrt( VMF(1) ) );
case TRAP_MATRIXMULTIPLY: case TRAP_MATRIXMULTIPLY:
MatrixMultiply( VMA(1), VMA(2), VMA(3) ); MatrixMultiply((float(*)[3]) VMA(1), (float(*)[3]) VMA(2), (float(*)[3]) VMA(3));
return 0; return 0;
case TRAP_ANGLEVECTORS: case TRAP_ANGLEVECTORS:
AngleVectors( VMA(1), VMA(2), VMA(3), VMA(4) ); AngleVectors( (const vec_t*) VMA(1), (vec_t*) VMA(2), (vec_t*) VMA(3), (vec_t*) VMA(4) );
return 0; return 0;
case TRAP_PERPENDICULARVECTOR: case TRAP_PERPENDICULARVECTOR:
PerpendicularVector( VMA(1), VMA(2) ); PerpendicularVector( (vec_t*) VMA(1), (vec_t*) VMA(2) );
return 0; return 0;
case TRAP_FLOOR: case TRAP_FLOOR:
@ -950,7 +949,7 @@ void SV_InitGameProgs( void ) {
} }
// load the dll or bytecode // load the dll or bytecode
gvm = VM_Create( "qagame", SV_GameSystemCalls, Cvar_VariableValue( "vm_game" ) ); gvm = VM_Create( "qagame", SV_GameSystemCalls, (vmInterpret_t) (int) Cvar_VariableValue( "vm_game" ) );
if ( !gvm ) { if ( !gvm ) {
Com_Error( ERR_FATAL, "VM_Create on game failed" ); Com_Error( ERR_FATAL, "VM_Create on game failed" );
} }
@ -971,6 +970,6 @@ qboolean SV_GameCommand( void ) {
return qfalse; return qfalse;
} }
return VM_Call( gvm, GAME_CONSOLE_COMMAND ); return (qboolean) VM_Call( gvm, GAME_CONSOLE_COMMAND );
} }

10
code/server/sv_init.c
View File

@ -222,7 +222,7 @@ void SV_Startup( void ) {
} }
SV_BoundMaxClients( 1 ); SV_BoundMaxClients( 1 );
svs.clients = Z_Malloc (sizeof(client_t) * sv_maxclients->integer ); svs.clients = (client_t*) Z_Malloc (sizeof(client_t) * sv_maxclients->integer );
if ( com_dedicated->integer ) { if ( com_dedicated->integer ) {
svs.numSnapshotEntities = sv_maxclients->integer * PACKET_BACKUP * 64; svs.numSnapshotEntities = sv_maxclients->integer * PACKET_BACKUP * 64;
} else { } else {
@ -264,7 +264,7 @@ void SV_ChangeMaxClients( void ) {
return; return;
} }
oldClients = Hunk_AllocateTempMemory( count * sizeof(client_t) ); oldClients = (client_t*) Hunk_AllocateTempMemory( count * sizeof(client_t) );
// copy the clients to hunk memory // copy the clients to hunk memory
for ( i = 0 ; i < count ; i++ ) { for ( i = 0 ; i < count ; i++ ) {
if ( svs.clients[i].state >= CS_CONNECTED ) { if ( svs.clients[i].state >= CS_CONNECTED ) {
@ -279,7 +279,7 @@ void SV_ChangeMaxClients( void ) {
Z_Free( svs.clients ); Z_Free( svs.clients );
// allocate new clients // allocate new clients
svs.clients = Z_Malloc ( sv_maxclients->integer * sizeof(client_t) ); svs.clients = (client_t*) Z_Malloc ( sv_maxclients->integer * sizeof(client_t) );
Com_Memset( svs.clients, 0, sv_maxclients->integer * sizeof(client_t) ); Com_Memset( svs.clients, 0, sv_maxclients->integer * sizeof(client_t) );
// copy the clients over // copy the clients over
@ -384,7 +384,7 @@ void SV_SpawnServer( char *server, qboolean killBots ) {
FS_ClearPakReferences(0); FS_ClearPakReferences(0);
// allocate the snapshot entities on the hunk // allocate the snapshot entities on the hunk
svs.snapshotEntities = Hunk_Alloc( sizeof(entityState_t)*svs.numSnapshotEntities, h_high ); svs.snapshotEntities = (entityState_t*) Hunk_Alloc( sizeof(entityState_t)*svs.numSnapshotEntities, h_high );
svs.nextSnapshotEntities = 0; svs.nextSnapshotEntities = 0;
// toggle the server bit so clients can detect that a // toggle the server bit so clients can detect that a
@ -464,7 +464,7 @@ void SV_SpawnServer( char *server, qboolean killBots ) {
} }
// connect the client again // connect the client again
denied = VM_ExplicitArgPtr( gvm, VM_Call( gvm, GAME_CLIENT_CONNECT, i, qfalse, isBot ) ); // firstTime = qfalse denied = (char*) VM_ExplicitArgPtr( gvm, VM_Call( gvm, GAME_CLIENT_CONNECT, i, qfalse, isBot ) ); // firstTime = qfalse
if ( denied ) { if ( denied ) {
// this generally shouldn't happen, because the client // this generally shouldn't happen, because the client
// was connected before the level change // was connected before the level change

2
code/server/sv_main.c
View File

@ -506,7 +506,7 @@ void SV_ConnectionlessPacket( netadr_t from, msg_t *msg ) {
MSG_BeginReadingOOB( msg ); MSG_BeginReadingOOB( msg );
MSG_ReadLong( msg ); // skip the -1 marker MSG_ReadLong( msg ); // skip the -1 marker
if (!Q_strncmp("connect", &msg->data[4], 7)) { if (!Q_strncmp("connect", (const char*) &msg->data[4], 7)) {
Huff_Decompress(msg, 12); Huff_Decompress(msg, 12);
} }

8
code/server/sv_net_chan.c
View File

@ -48,11 +48,11 @@ static void SV_Netchan_Encode( client_t *client, msg_t *msg ) {
msg->bit = 0; msg->bit = 0;
msg->readcount = 0; msg->readcount = 0;
msg->oob = 0; msg->oob = (qboolean) 0;
reliableAcknowledge = MSG_ReadLong(msg); reliableAcknowledge = MSG_ReadLong(msg);
msg->oob = soob; msg->oob = (qboolean) soob;
msg->bit = sbit; msg->bit = sbit;
msg->readcount = srdc; msg->readcount = srdc;
@ -96,13 +96,13 @@ static void SV_Netchan_Decode( client_t *client, msg_t *msg ) {
sbit = msg->bit; sbit = msg->bit;
soob = msg->oob; soob = msg->oob;
msg->oob = 0; msg->oob = (qboolean) 0;
serverId = MSG_ReadLong(msg); serverId = MSG_ReadLong(msg);
messageAcknowledge = MSG_ReadLong(msg); messageAcknowledge = MSG_ReadLong(msg);
reliableAcknowledge = MSG_ReadLong(msg); reliableAcknowledge = MSG_ReadLong(msg);
msg->oob = soob; msg->oob = (qboolean) soob;
msg->bit = sbit; msg->bit = sbit;
msg->readcount = srdc; msg->readcount = srdc;

7
code/server/sv_world.c
View File

@ -583,7 +583,12 @@ void SV_ClipMoveToEntities( moveclip_t *clip ) {
trace.entityNum = touch->s.number; trace.entityNum = touch->s.number;
clip->trace = trace; clip->trace = trace;
clip->trace.startsolid |= oldStart;
//clip->trace.startsolid |= oldStart;
if (oldStart == qtrue) {
clip->trace.startsolid = qtrue;
}
} }
} }
} }

4
code/win32/vs/quake3.vcxproj
View File

@ -123,6 +123,7 @@
<WarningLevel>Level3</WarningLevel> <WarningLevel>Level3</WarningLevel>
<SuppressStartupBanner>true</SuppressStartupBanner> <SuppressStartupBanner>true</SuppressStartupBanner>
<DebugInformationFormat>EditAndContinue</DebugInformationFormat> <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
<CompileAs>CompileAsCpp</CompileAs>
</ClCompile> </ClCompile>
<ResourceCompile> <ResourceCompile>
<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
@ -161,6 +162,7 @@
<WarningLevel>Level3</WarningLevel> <WarningLevel>Level3</WarningLevel>
<SuppressStartupBanner>true</SuppressStartupBanner> <SuppressStartupBanner>true</SuppressStartupBanner>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat> <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
<CompileAs>CompileAsCpp</CompileAs>
</ClCompile> </ClCompile>
<ResourceCompile> <ResourceCompile>
<PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
@ -201,6 +203,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking> <FunctionLevelLinking>true</FunctionLevelLinking>
<WarningLevel>Level4</WarningLevel> <WarningLevel>Level4</WarningLevel>
<SuppressStartupBanner>true</SuppressStartupBanner> <SuppressStartupBanner>true</SuppressStartupBanner>
<CompileAs>CompileAsCpp</CompileAs>
</ClCompile> </ClCompile>
<ResourceCompile> <ResourceCompile>
<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
@ -236,6 +239,7 @@
<FunctionLevelLinking>true</FunctionLevelLinking> <FunctionLevelLinking>true</FunctionLevelLinking>
<WarningLevel>Level4</WarningLevel> <WarningLevel>Level4</WarningLevel>
<SuppressStartupBanner>true</SuppressStartupBanner> <SuppressStartupBanner>true</SuppressStartupBanner>
<CompileAs>CompileAsCpp</CompileAs>
</ClCompile> </ClCompile>
<ResourceCompile> <ResourceCompile>
<PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>

4
code/win32/win_input.c
View File

@ -279,7 +279,7 @@ qboolean IN_InitDIMouse( void ) {
} }
if (!pDirectInputCreate) { if (!pDirectInputCreate) {
pDirectInputCreate = (long (__stdcall *)(void *,unsigned long ,struct IDirectInputA ** ,struct IUnknown *)) pDirectInputCreate = (HRESULT (__stdcall *)(HINSTANCE,DWORD ,struct IDirectInputA ** ,struct IUnknown *))
GetProcAddress(hInstDI,"DirectInputCreateA"); GetProcAddress(hInstDI,"DirectInputCreateA");
if (!pDirectInputCreate) { if (!pDirectInputCreate) {
@ -297,7 +297,7 @@ qboolean IN_InitDIMouse( void ) {
} }
// obtain an interface to the system mouse device. // obtain an interface to the system mouse device.
hr = IDirectInput_CreateDevice(g_pdi, &GUID_SysMouse, &g_pMouse, NULL); hr = IDirectInput_CreateDevice(g_pdi, GUID_SysMouse, &g_pMouse, NULL);
if (FAILED(hr)) { if (FAILED(hr)) {
Com_Printf ("Couldn't open DI mouse device\n"); Com_Printf ("Couldn't open DI mouse device\n");

14
code/win32/win_main.c
View File

@ -305,7 +305,7 @@ char **Sys_ListFiles( const char *directory, const char *extension, char *filter
if (!nfiles) if (!nfiles)
return NULL; return NULL;
listCopy = Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) ); listCopy = (char**) Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) );
for ( i = 0 ; i < nfiles ; i++ ) { for ( i = 0 ; i < nfiles ; i++ ) {
listCopy[i] = list[i]; listCopy[i] = list[i];
} }
@ -358,7 +358,7 @@ char **Sys_ListFiles( const char *directory, const char *extension, char *filter
return NULL; return NULL;
} }
listCopy = Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) ); listCopy = (char**) Z_Malloc( ( nfiles + 1 ) * sizeof( *listCopy ) );
for ( i = 0 ; i < nfiles ; i++ ) { for ( i = 0 ; i < nfiles ; i++ ) {
listCopy[i] = list[i]; listCopy[i] = list[i];
} }
@ -475,8 +475,8 @@ char *Sys_GetClipboardData( void ) {
HANDLE hClipboardData; HANDLE hClipboardData;
if ( ( hClipboardData = GetClipboardData( CF_TEXT ) ) != 0 ) { if ( ( hClipboardData = GetClipboardData( CF_TEXT ) ) != 0 ) {
if ( ( cliptext = GlobalLock( hClipboardData ) ) != 0 ) { if ( ( cliptext = (char*) GlobalLock( hClipboardData ) ) != 0 ) {
data = Z_Malloc( GlobalSize( hClipboardData ) + 1 ); data = (char*) Z_Malloc( GlobalSize( hClipboardData ) + 1 );
Q_strncpyz( data, cliptext, GlobalSize( hClipboardData ) ); Q_strncpyz( data, cliptext, GlobalSize( hClipboardData ) );
GlobalUnlock( hClipboardData ); GlobalUnlock( hClipboardData );
@ -507,7 +507,7 @@ void Sys_UnloadDll( void *dllHandle ) {
if ( !dllHandle ) { if ( !dllHandle ) {
return; return;
} }
if ( !FreeLibrary( dllHandle ) ) { if ( !FreeLibrary( (HMODULE) dllHandle ) ) {
Com_Error (ERR_FATAL, "Sys_UnloadDll FreeLibrary failed"); Com_Error (ERR_FATAL, "Sys_UnloadDll FreeLibrary failed");
} }
} }
@ -972,7 +972,7 @@ sysEvent_t Sys_GetEvent( void ) {
int len; int len;
len = (int)strlen( s ) + 1; len = (int)strlen( s ) + 1;
b = Z_Malloc( len ); b = (char*)Z_Malloc( len );
Q_strncpyz( b, s, len-1 ); Q_strncpyz( b, s, len-1 );
Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b ); Sys_QueEvent( 0, SE_CONSOLE, 0, 0, len, b );
} }
@ -986,7 +986,7 @@ sysEvent_t Sys_GetEvent( void ) {
// copy out to a seperate buffer for qeueing // copy out to a seperate buffer for qeueing
// the readcount stepahead is for SOCKS support // the readcount stepahead is for SOCKS support
len = sizeof( netadr_t ) + netmsg.cursize - netmsg.readcount; len = sizeof( netadr_t ) + netmsg.cursize - netmsg.readcount;
buf = Z_Malloc( len ); buf = (netadr_t*) Z_Malloc( len );
*buf = adr; *buf = adr;
memcpy( buf+1, &netmsg.data[netmsg.readcount], netmsg.cursize - netmsg.readcount ); memcpy( buf+1, &netmsg.data[netmsg.readcount], netmsg.cursize - netmsg.readcount );
Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf ); Sys_QueEvent( 0, SE_PACKET, 0, 0, len, buf );

26
code/win32/win_net.c
View File

@ -198,7 +198,7 @@ qboolean Sys_StringToSockaddr( const char *s, struct sockaddr *sadr ) {
*(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(s); *(int *)&((struct sockaddr_in *)sadr)->sin_addr = inet_addr(s);
} else { } else {
if( ( h = gethostbyname( s ) ) == 0 ) { if( ( h = gethostbyname( s ) ) == 0 ) {
return 0; return (qboolean) 0;
} }
*(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0]; *(int *)&((struct sockaddr_in *)sadr)->sin_addr = *(int *)h->h_addr_list[0];
} }
@ -261,7 +261,7 @@ qboolean Sys_GetPacket( netadr_t *net_from, msg_t *net_message ) {
fromlen = sizeof(from); fromlen = sizeof(from);
recvfromCount++; // performance check recvfromCount++; // performance check
ret = recvfrom( net_socket, net_message->data, net_message->maxsize, 0, (struct sockaddr *)&from, &fromlen ); ret = recvfrom( net_socket, (char*) net_message->data, net_message->maxsize, 0, (struct sockaddr *)&from, &fromlen );
if (ret == SOCKET_ERROR) if (ret == SOCKET_ERROR)
{ {
err = WSAGetLastError(); err = WSAGetLastError();
@ -354,7 +354,7 @@ void Sys_SendPacket( int length, const void *data, netadr_t to ) {
ret = sendto( net_socket, socksBuf, length+10, 0, &socksRelayAddr, sizeof(socksRelayAddr) ); ret = sendto( net_socket, socksBuf, length+10, 0, &socksRelayAddr, sizeof(socksRelayAddr) );
} }
else { else {
ret = sendto( net_socket, data, length, 0, &addr, sizeof(addr) ); ret = sendto( net_socket, (const char*) data, length, 0, &addr, sizeof(addr) );
} }
if( ret == SOCKET_ERROR ) { if( ret == SOCKET_ERROR ) {
int err = WSAGetLastError(); int err = WSAGetLastError();
@ -488,7 +488,7 @@ int NET_IPSocket( char *net_interface, int port ) {
} }
// make it non-blocking // make it non-blocking
if( ioctlsocket( newsocket, FIONBIO, &_true ) == SOCKET_ERROR ) { if( ioctlsocket( newsocket, FIONBIO, &(u_long&)_true ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: UDP_OpenSocket: ioctl FIONBIO: %s\n", NET_ErrorString() ); Com_Printf( "WARNING: UDP_OpenSocket: ioctl FIONBIO: %s\n", NET_ErrorString() );
return 0; return 0;
} }
@ -515,7 +515,7 @@ int NET_IPSocket( char *net_interface, int port ) {
address.sin_family = AF_INET; address.sin_family = AF_INET;
if( bind( newsocket, (void *)&address, sizeof(address) ) == SOCKET_ERROR ) { if( bind( newsocket, (const sockaddr*) (void *)&address, sizeof(address) ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: UDP_OpenSocket: bind: %s\n", NET_ErrorString() ); Com_Printf( "WARNING: UDP_OpenSocket: bind: %s\n", NET_ErrorString() );
closesocket( newsocket ); closesocket( newsocket );
return 0; return 0;
@ -590,14 +590,14 @@ void NET_OpenSocks( int port ) {
if ( rfc1929 ) { if ( rfc1929 ) {
buf[2] = 2; // method #2 - method id #02: username/password buf[2] = 2; // method #2 - method id #02: username/password
} }
if ( send( socks_socket, buf, len, 0 ) == SOCKET_ERROR ) { if ( send( socks_socket, (const char*) buf, len, 0 ) == SOCKET_ERROR ) {
err = WSAGetLastError(); err = WSAGetLastError();
Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() ); Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
return; return;
} }
// get the response // get the response
len = recv( socks_socket, buf, 64, 0 ); len = recv( socks_socket, (char*) buf, 64, 0 );
if ( len == SOCKET_ERROR ) { if ( len == SOCKET_ERROR ) {
err = WSAGetLastError(); err = WSAGetLastError();
Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() ); Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
@ -637,14 +637,14 @@ void NET_OpenSocks( int port ) {
} }
// send it // send it
if ( send( socks_socket, buf, 3 + ulen + plen, 0 ) == SOCKET_ERROR ) { if ( send( socks_socket, (const char*) buf, 3 + ulen + plen, 0 ) == SOCKET_ERROR ) {
err = WSAGetLastError(); err = WSAGetLastError();
Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() ); Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
return; return;
} }
// get the response // get the response
len = recv( socks_socket, buf, 64, 0 ); len = recv( socks_socket, (char*) buf, 64, 0 );
if ( len == SOCKET_ERROR ) { if ( len == SOCKET_ERROR ) {
err = WSAGetLastError(); err = WSAGetLastError();
Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() ); Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
@ -667,14 +667,14 @@ void NET_OpenSocks( int port ) {
buf[3] = 1; // address type: IPV4 buf[3] = 1; // address type: IPV4
*(int *)&buf[4] = INADDR_ANY; *(int *)&buf[4] = INADDR_ANY;
*(short *)&buf[8] = htons( (short)port ); // port *(short *)&buf[8] = htons( (short)port ); // port
if ( send( socks_socket, buf, 10, 0 ) == SOCKET_ERROR ) { if ( send( socks_socket, (const char*) buf, 10, 0 ) == SOCKET_ERROR ) {
err = WSAGetLastError(); err = WSAGetLastError();
Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() ); Com_Printf( "NET_OpenSocks: send: %s\n", NET_ErrorString() );
return; return;
} }
// get the response // get the response
len = recv( socks_socket, buf, 64, 0 ); len = recv( socks_socket, (char*) buf, 64, 0 );
if( len == SOCKET_ERROR ) { if( len == SOCKET_ERROR ) {
err = WSAGetLastError(); err = WSAGetLastError();
Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() ); Com_Printf( "NET_OpenSocks: recv: %s\n", NET_ErrorString() );
@ -799,7 +799,7 @@ int NET_IPXSocket( int port ) {
} }
// make it non-blocking // make it non-blocking
if( ioctlsocket( newsocket, FIONBIO, &_true ) == SOCKET_ERROR ) { if( ioctlsocket( newsocket, FIONBIO, &(u_long&)_true ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: IPX_Socket: ioctl FIONBIO: %s\n", NET_ErrorString() ); Com_Printf( "WARNING: IPX_Socket: ioctl FIONBIO: %s\n", NET_ErrorString() );
return 0; return 0;
} }
@ -820,7 +820,7 @@ int NET_IPXSocket( int port ) {
address.sa_socket = htons( (short)port ); address.sa_socket = htons( (short)port );
} }
if( bind( newsocket, (void *)&address, sizeof(address) ) == SOCKET_ERROR ) { if( bind( newsocket, (const sockaddr*) (void *)&address, sizeof(address) ) == SOCKET_ERROR ) {
Com_Printf( "WARNING: IPX_Socket: bind: %s\n", NET_ErrorString() ); Com_Printf( "WARNING: IPX_Socket: bind: %s\n", NET_ErrorString() );
closesocket( newsocket ); closesocket( newsocket );
return 0; return 0;

11
code/win32/win_snd.c
View File

@ -22,6 +22,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
#include <float.h> #include <float.h>
#include "../client/snd_local.h" #include "../client/snd_local.h"
#define CINTERFACE
#include "win_local.h" #include "win_local.h"
HRESULT (WINAPI *pDirectSoundCreate)(GUID FAR *lpGUID, LPDIRECTSOUND FAR *lplpDS, IUnknown FAR *pUnkOuter); HRESULT (WINAPI *pDirectSoundCreate)(GUID FAR *lpGUID, LPDIRECTSOUND FAR *lplpDS, IUnknown FAR *pUnkOuter);
@ -117,7 +118,7 @@ Returns false if failed
qboolean SNDDMA_Init(void) { qboolean SNDDMA_Init(void) {
memset ((void *)&dma, 0, sizeof (dma)); memset ((void *)&dma, 0, sizeof (dma));
dsound_init = 0; dsound_init = (qboolean) 0;
CoInitialize(NULL); CoInitialize(NULL);
@ -160,9 +161,9 @@ int SNDDMA_InitDS ()
use8 = 1; use8 = 1;
// Create IDirectSound using the primary sound device // Create IDirectSound using the primary sound device
if( FAILED( hresult = CoCreateInstance(&CLSID_DirectSound8, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectSound8, (void **)&pDS))) { if( FAILED( hresult = CoCreateInstance(CLSID_DirectSound8, NULL, CLSCTX_INPROC_SERVER, IID_IDirectSound8, (void **)&pDS))) {
use8 = 0; use8 = 0;
if( FAILED( hresult = CoCreateInstance(&CLSID_DirectSound, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectSound, (void **)&pDS))) { if( FAILED( hresult = CoCreateInstance(CLSID_DirectSound, NULL, CLSCTX_INPROC_SERVER, IID_IDirectSound, (void **)&pDS))) {
Com_Printf ("failed\n"); Com_Printf ("failed\n");
SNDDMA_Shutdown (); SNDDMA_Shutdown ();
return qfalse; return qfalse;
@ -331,8 +332,8 @@ void SNDDMA_BeginPainting( void ) {
reps = 0; reps = 0;
dma.buffer = NULL; dma.buffer = NULL;
while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, &pbuf, &locksize, while ((hresult = pDSBuf->lpVtbl->Lock(pDSBuf, 0, gSndBufSize, (LPVOID*) &pbuf, &locksize,
&pbuf2, &dwSize2, 0)) != DS_OK) (LPVOID*) &pbuf2, &dwSize2, 0)) != DS_OK)
{ {
if (hresult != DSERR_BUFFERLOST) if (hresult != DSERR_BUFFERLOST)
{ {

4
code/win32/win_syscon.c
View File

@ -182,7 +182,7 @@ static LRESULT WINAPI ConWndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lP
case WM_TIMER: case WM_TIMER:
if ( wParam == 1 ) if ( wParam == 1 )
{ {
s_timePolarity = !s_timePolarity; s_timePolarity = (qboolean) !s_timePolarity;
if ( s_wcd.hwndErrorBox ) if ( s_wcd.hwndErrorBox )
{ {
InvalidateRect( s_wcd.hwndErrorBox, NULL, FALSE ); InvalidateRect( s_wcd.hwndErrorBox, NULL, FALSE );
@ -248,7 +248,7 @@ void Sys_CreateConsole( void )
wc.hInstance = g_wv.hInstance; wc.hInstance = g_wv.hInstance;
wc.hIcon = LoadIcon( g_wv.hInstance, MAKEINTRESOURCE(IDI_ICON1)); wc.hIcon = LoadIcon( g_wv.hInstance, MAKEINTRESOURCE(IDI_ICON1));
wc.hCursor = LoadCursor (NULL,IDC_ARROW); wc.hCursor = LoadCursor (NULL,IDC_ARROW);
wc.hbrBackground = (void *)COLOR_WINDOW; wc.hbrBackground = (HBRUSH) (void *)COLOR_WINDOW;
wc.lpszMenuName = 0; wc.lpszMenuName = 0;
wc.lpszClassName = DEDCLASS; wc.lpszClassName = DEDCLASS;

6
code/win32/win_wndproc.c
View File

@ -86,7 +86,7 @@ VID_AppActivate
*/ */
static void VID_AppActivate(BOOL fActive, BOOL minimize) static void VID_AppActivate(BOOL fActive, BOOL minimize)
{ {
g_wv.isMinimized = minimize; g_wv.isMinimized = (qboolean) minimize;
Com_DPrintf("VID_AppActivate: %i\n", fActive ); Com_DPrintf("VID_AppActivate: %i\n", fActive );
@ -280,7 +280,7 @@ LONG WINAPI MainWndProc (
else else
{ {
Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, K_MWHEELUP, flip, 0, NULL ); Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, K_MWHEELUP, flip, 0, NULL );
flip = !flip; flip = (qboolean) !flip;
} }
} }
} }
@ -296,7 +296,7 @@ LONG WINAPI MainWndProc (
else else
{ {
Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, K_MWHEELDOWN, flip, 0, NULL ); Sys_QueEvent( g_wv.sysMsgTime, SE_KEY, K_MWHEELDOWN, flip, 0, NULL );
flip = !flip; flip = (qboolean) !flip;
} }
} }
} }