/*****************************************************************************
* FUNCTION
* btmtk_fs_rename
* DESCRIPTION
*
* PARAMETERS
* srcName [IN]
* destName [IN]
* RETURNS
*
*****************************************************************************/
S32 btmtk_fs_rename(const U8 *srcName, const U8 *destName)
{
#ifdef BTMTK_ON_WISE
/*----------------------------------------------------------------*/
/* Local Variables */
/*----------------------------------------------------------------*/
U16 ucs2_buf[FS_MAX_PATH_LEN] = {0};
/*----------------------------------------------------------------*/
/* Code Body */
/*----------------------------------------------------------------*/
bt_asc_str_n_to_ucs2_str((S8 *)pathBuf, (S8 *)srcName, FS_MAX_PATH_LEN * sizeof(U16));
bt_asc_str_n_to_ucs2_str((S8 *)ucs2_buf, (S8 *)destName, FS_MAX_PATH_LEN * sizeof(U16));
result = FS_Rename(srcName, destName);
return translateFileError(result);
#else /* BTMTK_ON_WISE */
U8 pathBuf2[FS_MAX_PATH_LEN] = {0};
translateFilePath(srcName, (U8 *)pathBuf);
translateFilePath(destName, pathBuf2);
#if defined(BTMTK_ON_LINUX)
if (rename((char *)pathBuf, (char*)pathBuf2) == 0)
#else
if (FALSE != MoveFileA((char *)pathBuf, pathBuf2))
#endif
{
return BTMTK_FS_OK;
}
return BTMTK_FS_ERR;
#endif /* BTMTK_ON_WISE */
}
void StorageArchiveLogSegmentJob::Execute()
{
Buffer dest;
Buffer cmdline;
if (ReadBuffer::Cmp(script, "$archive") == 0)
{
Log_Message("Archiving log segment %U...", logSegment->GetLogSegmentID());
dest.Write(env->archivePath);
dest.Appendf("log.%020U.%020U", logSegment->GetTrackID(), logSegment->GetLogSegmentID());
dest.NullTerminate();
FS_Rename(logSegment->filename.GetBuffer(), dest.GetBuffer());
}
else if (ReadBuffer::Cmp(script, "$delete") == 0)
{
Log_Message("Deleting archive log segment %U/%U...",
logSegment->GetTrackID(), logSegment->GetLogSegmentID());
StorageFileDeleter::Delete(logSegment->filename.GetBuffer());
}
else
{
Log_Message("Executing script on archive log segment %U (%s)...",
logSegment->GetLogSegmentID(), script);
EvalScriptVariables();
ShellExec(command.GetBuffer());
}
}
/*********************************************************************
*
* _RenameFile
*/
static int _RenameFile (const char *sOldFilename, const char *sNewFilename) {
char acAbsOldFilename[MAX_PATH];
char acAbsNewFilename[MAX_PATH];
_InitIfRequired(); // Perform automatic initialisation so that explicit call to FS_Init is not required
_ConvertPath(sOldFilename, acAbsOldFilename, sizeof(acAbsOldFilename));
_ConvertPath(sNewFilename, acAbsNewFilename, sizeof(acAbsNewFilename));
return FS_Rename(acAbsOldFilename, acAbsNewFilename);
}
/*
===============
SV_ShutdownGameProgs
Called every time a map changes
===============
*/
void SV_ShutdownGameProgs(void) {
if(!gvm) {
return;
}
VM_Call(gvm, GAME_SHUTDOWN, false);
VM_Free(gvm);
gvm = NULL;
if ( sv_newGameShlib->string[0] ) {
FS_Rename( sv_newGameShlib->string, "game" DLL_EXT);
Cvar_Set( "sv_newGameShlib", "" );
}
}
/*
====================
SV_GameSystemCalls
The module is making a system call
====================
*/
intptr_t SV_GameSystemCalls(intptr_t * args) {
switch (args[0]) {
case G_PRINT:
Com_Printf("%s", (char *)VMA(1));
return 0;
case G_ERROR:
Com_Error(ERR_DROP, "%s", (char *)VMA(1));
return 0;
case G_MILLISECONDS:
return Sys_Milliseconds();
case G_CVAR_REGISTER:
Cvar_Register((vmCvar_t*)VMA(1), (char*)VMA(2), (char*)VMA(3), args[4]);
return 0;
case G_CVAR_UPDATE:
Cvar_Update((vmCvar_t*)VMA(1));
return 0;
case G_CVAR_SET:
Cvar_Set((const char *)VMA(1), (const char *)VMA(2));
return 0;
case G_CVAR_VARIABLE_INTEGER_VALUE:
return Cvar_VariableIntegerValue((const char *)VMA(1));
case G_CVAR_VARIABLE_STRING_BUFFER:
Cvar_VariableStringBuffer((char *)VMA(1), (char*)VMA(2), args[3]);
return 0;
case G_CVAR_LATCHEDVARIABLESTRINGBUFFER:
Cvar_LatchedVariableStringBuffer((char *)VMA(1), (char*)VMA(2), args[3]);
return 0;
case G_ARGC:
return Cmd_Argc();
case G_ARGV:
Cmd_ArgvBuffer(args[1], (char*)VMA(2), args[3]);
return 0;
case G_SEND_CONSOLE_COMMAND:
Cbuf_ExecuteText(args[1], (char *)VMA(2));
return 0;
case G_FS_FOPEN_FILE:
return FS_FOpenFileByMode((char *)VMA(1), (fileHandle_t*)VMA(2), (fsMode_t)args[3]);
case G_FS_READ:
FS_Read2(VMA(1), args[2], args[3]);
return 0;
case G_FS_WRITE:
return FS_Write(VMA(1), args[2], args[3]);
case G_FS_RENAME:
FS_Rename((char *)VMA(1), (char *)VMA(2));
return 0;
case G_FS_FCLOSE_FILE:
FS_FCloseFile(args[1]);
return 0;
case G_FS_GETFILELIST:
return FS_GetFileList((char *)VMA(1), (char *)VMA(2), (char*)VMA(3), args[4]);
case G_LOCATE_GAME_DATA:
SV_LocateGameData((sharedEntity_t*)VMA(1), args[2], args[3], (playerState_t*)VMA(4), args[5]);
return 0;
case G_DROP_CLIENT:
SV_GameDropClient(args[1], (char*)VMA(2), args[3]);
return 0;
case G_SEND_SERVER_COMMAND:
SV_GameSendServerCommand(args[1], (char*)VMA(2));
return 0;
case G_LINKENTITY:
SV_LinkEntity((sharedEntity_t*)VMA(1));
return 0;
case G_UNLINKENTITY:
SV_UnlinkEntity((sharedEntity_t*)VMA(1));
return 0;
case G_ENTITIES_IN_BOX:
return SV_AreaEntities((float*)VMA(1), (float*)VMA(2), (int*)VMA(3), args[4]);
case G_ENTITY_CONTACT:
return SV_EntityContact((float*)VMA(1), (float*)VMA(2), (sharedEntity_t*)VMA(3), TT_AABB);
case G_ENTITY_CONTACTCAPSULE:
return SV_EntityContact((float*)VMA(1), (float*)VMA(2), (sharedEntity_t*)VMA(3), TT_CAPSULE);
case G_TRACE:
SV_Trace((trace_t*)VMA(1), (float*)VMA(2), (float*)VMA(3), (float*)VMA(4), (float*)VMA(5), args[6], args[7], TT_AABB);
return 0;
case G_TRACECAPSULE:
SV_Trace((trace_t*)VMA(1), (float*)VMA(2), (float*)VMA(3), (float*)VMA(4), (float*)VMA(5), args[6], args[7], TT_CAPSULE);
return 0;
case G_POINT_CONTENTS:
return SV_PointContents((float*)VMA(1), args[2]);
case G_SET_BRUSH_MODEL:
SV_SetBrushModel((sharedEntity_t*)VMA(1), (char*)VMA(2));
return 0;
case G_IN_PVS:
return SV_inPVS((float*)VMA(1), (float*)VMA(2));
case G_IN_PVS_IGNORE_PORTALS:
return SV_inPVSIgnorePortals((float*)VMA(1), (float*)VMA(2));
case G_SET_CONFIGSTRING:
SV_SetConfigstring(args[1], (char*)VMA(2));
return 0;
case G_GET_CONFIGSTRING:
SV_GetConfigstring(args[1], (char*)VMA(2), args[3]);
return 0;
case G_SET_CONFIGSTRING_RESTRICTIONS:
SV_SetConfigstringRestrictions( args[1], (clientList_t*)VMA(2) );
return 0;
case G_SET_USERINFO:
SV_SetUserinfo(args[1], (char*)VMA(2));
return 0;
case G_GET_USERINFO:
SV_GetUserinfo(args[1], (char*)VMA(2), args[3]);
return 0;
case G_GET_SERVERINFO:
SV_GetServerinfo((char*)VMA(1), args[2]);
return 0;
case G_ADJUST_AREA_PORTAL_STATE:
SV_AdjustAreaPortalState((sharedEntity_t*)VMA(1),(bool)args[2]);
return 0;
case G_AREAS_CONNECTED:
return CM_AreasConnected(args[1], args[2]);
case G_UPDATE_SHARED_CONFIG:
SV_UpdateSharedConfig( args[1], (char*)VMA(2) );
return 0;
case G_BOT_ALLOCATE_CLIENT:
return SV_BotAllocateClient(args[1]);
case G_BOT_FREE_CLIENT:
SV_BotFreeClient(args[1]);
return 0;
case G_GET_USERCMD:
SV_GetUsercmd(args[1], (usercmd_t*)VMA(2));
return 0;
case G_GET_ENTITY_TOKEN: {
const char *s;
s = COM_Parse(&sv.entityParsePoint);
Q_strncpyz((char*)VMA(1), s, args[2]);
if(!sv.entityParsePoint && !s[0]) {
return false;
} else {
return true;
}
}
case G_DEBUG_POLYGON_CREATE:
return BotImport_DebugPolygonCreate(args[1], args[2], (vec3_t*)VMA(3));
case G_DEBUG_POLYGON_DELETE:
BotImport_DebugPolygonDelete(args[1]);
return 0;
case G_REAL_TIME:
return Com_RealTime((qtime_t*)VMA(1));
case G_SNAPVECTOR:
Q_SnapVector((float*)VMA(1));
return 0;
case G_SEND_GAMESTAT:
SV_MasterGameStat( (char*)VMA(1) );
return 0;
case G_ADDCOMMAND:
Cmd_AddCommand( (char*)VMA(1), NULL, (char*)VMA(3) );
return 0;
case G_REMOVECOMMAND:
Cmd_RemoveCommand( (char*)VMA(1) );
return 0;
case G_GETTAG:
return SV_GetTag(args[1], args[2], (char*)VMA(3), (orientation_t*)VMA(4));
case G_REGISTERTAG:
return SV_LoadTag((char*)VMA(1));
case G_REGISTERSOUND:
return S_RegisterSound((char*)VMA(1), (bool)args[2]);
case G_GET_SOUND_LENGTH:
return S_GetSoundLength(args[1]);
case G_PARSE_ADD_GLOBAL_DEFINE:
return Parse_AddGlobalDefine( (char*)VMA(1) );
case G_PARSE_LOAD_SOURCE:
return Parse_LoadSourceHandle( (char*)VMA(1) );
case G_PARSE_FREE_SOURCE:
return Parse_FreeSourceHandle( args[1] );
case G_PARSE_READ_TOKEN:
return Parse_ReadTokenHandle( args[1], (pc_token_t*)VMA(2) );
case G_PARSE_SOURCE_FILE_AND_LINE:
return Parse_SourceFileAndLine( args[1], (char*)VMA(2), (int*)VMA(3) );
case BOTLIB_SETUP:
return SV_BotLibSetup();
case BOTLIB_SHUTDOWN:
return SV_BotLibShutdown();
case BOTLIB_LIBVAR_SET:
return botlib_export->BotLibVarSet((char*)VMA(1), (char*)VMA(2));
case BOTLIB_LIBVAR_GET:
return botlib_export->BotLibVarGet((char*)VMA(1), (char*)VMA(2), args[3]);
case BOTLIB_PC_ADD_GLOBAL_DEFINE:
return Parse_AddGlobalDefine( (char*)VMA(1) );
case BOTLIB_PC_LOAD_SOURCE:
return Parse_LoadSourceHandle((char*)VMA(1));
case BOTLIB_PC_FREE_SOURCE:
return Parse_FreeSourceHandle(args[1]);
case BOTLIB_PC_READ_TOKEN:
return Parse_ReadTokenHandle(args[1], (pc_token_t*)VMA(2));
case BOTLIB_PC_SOURCE_FILE_AND_LINE:
return Parse_SourceFileAndLine(args[1], (char*)VMA(2), (int*)VMA(3));
case BOTLIB_PC_UNREAD_TOKEN:
Parse_UnreadLastTokenHandle(args[1]);
return 0;
case BOTLIB_START_FRAME:
return botlib_export->BotLibStartFrame(VMF(1));
case BOTLIB_LOAD_MAP:
return botlib_export->BotLibLoadMap((char*)VMA(1));
case BOTLIB_UPDATENTITY:
return botlib_export->BotLibUpdateEntity(args[1], (bot_entitystate_t*)VMA(2));
case BOTLIB_TEST:
return botlib_export->Test( args[1], (char*)VMA(2), (float*)VMA(3), (float*)VMA(4) );
case BOTLIB_GET_SNAPSHOT_ENTITY:
return SV_BotGetSnapshotEntity(args[1], args[2]);
case BOTLIB_GET_CONSOLE_MESSAGE:
return SV_BotGetConsoleMessage(args[1], (char*)VMA(2), args[3]);
case BOTLIB_USER_COMMAND:
SV_ClientThink(&svs.clients[args[1]], (usercmd_t*)VMA(2));
return 0;
case BOTLIB_AAS_ENTITY_INFO:
botlib_export->aas.AAS_EntityInfo(args[1], (aas_entityinfo_s*)VMA(2));
return 0;
case BOTLIB_AAS_INITIALIZED:
return botlib_export->aas.AAS_Initialized();
case BOTLIB_AAS_PRESENCE_TYPE_BOUNDING_BOX:
botlib_export->aas.AAS_PresenceTypeBoundingBox( args[1], (float*)VMA(2), (float*)VMA(3) );
return 0;
case BOTLIB_AAS_TIME:
return FloatAsInt(botlib_export->aas.AAS_Time());
case BOTLIB_AAS_SETCURRENTWORLD:
botlib_export->aas.AAS_SetCurrentWorld(args[1]);
return 0;
case BOTLIB_AAS_POINT_AREA_NUM:
return botlib_export->aas.AAS_PointAreaNum( (float*)VMA(1) );
case BOTLIB_AAS_TRACE_AREAS:
return botlib_export->aas.AAS_TraceAreas( (float*)VMA(1), (float*)VMA(2), (int*)VMA(3), (vec3_t*)VMA(4), args[5] );
case BOTLIB_AAS_BBOX_AREAS:
return botlib_export->aas.AAS_BBoxAreas( (float*)VMA(1), (float*)VMA(2), (int*)VMA(3), args[4] );
case BOTLIB_AAS_AREA_CENTER:
botlib_export->aas.AAS_AreaCenter(args[1], (float*)VMA(2));
return 0;
case BOTLIB_AAS_AREA_WAYPOINT:
return botlib_export->aas.AAS_AreaWaypoint(args[1], (float*)VMA(2));
case BOTLIB_AAS_POINT_CONTENTS:
return botlib_export->aas.AAS_PointContents((float*)VMA(1));
case BOTLIB_AAS_NEXT_BSP_ENTITY:
return botlib_export->aas.AAS_NextBSPEntity(args[1]);
case BOTLIB_AAS_VALUE_FOR_BSP_EPAIR_KEY:
return botlib_export->aas.AAS_ValueForBSPEpairKey(args[1], (char*)VMA(2), (char*)VMA(3), args[4]);
case BOTLIB_AAS_VECTOR_FOR_BSP_EPAIR_KEY:
return botlib_export->aas.AAS_VectorForBSPEpairKey(args[1], (char*)VMA(2), (float*)VMA(3));
case BOTLIB_AAS_FLOAT_FOR_BSP_EPAIR_KEY:
return botlib_export->aas.AAS_FloatForBSPEpairKey(args[1], (char*)VMA(2), (float*)VMA(3));
case BOTLIB_AAS_INT_FOR_BSP_EPAIR_KEY:
return botlib_export->aas.AAS_IntForBSPEpairKey(args[1], (char*)VMA(2), (int*)VMA(3));
case BOTLIB_AAS_AREA_REACHABILITY:
return botlib_export->aas.AAS_AreaReachability(args[1]);
case BOTLIB_AAS_AREA_LADDER:
return botlib_export->aas.AAS_AreaLadder(args[1]);
case BOTLIB_AAS_AREA_TRAVEL_TIME_TO_GOAL_AREA:
return botlib_export->aas.AAS_AreaTravelTimeToGoalArea(args[1], (float*)VMA(2), args[3], args[4]);
case BOTLIB_AAS_SWIMMING:
return botlib_export->aas.AAS_Swimming((float*)VMA(1));
case BOTLIB_AAS_PREDICT_CLIENT_MOVEMENT:
return botlib_export->aas.AAS_PredictClientMovement((aas_clientmove_s*)VMA(1), args[2], (float*)VMA(3), args[4], args[5], (float*)VMA(6), (float*)VMA(7), args[8], args[9], VMF(10), args[11], args[12], args[13]);
case BOTLIB_AAS_RT_SHOWROUTE:
botlib_export->aas.AAS_RT_ShowRoute((float*)VMA(1), args[2], args[3]);
return 0;
case BOTLIB_AAS_NEARESTHIDEAREA:
return botlib_export->aas.AAS_NearestHideArea(args[1], (float*)VMA(2), args[3], args[4], (float*)VMA(5), args[6], args[7], VMF(8), (float*)VMA(9));
case BOTLIB_AAS_LISTAREASINRANGE:
return botlib_export->aas.AAS_ListAreasInRange((float*)VMA(1), args[2], VMF(3), args[4], (vec3_t*)VMA(5), args[6]);
case BOTLIB_AAS_AVOIDDANGERAREA:
return botlib_export->aas.AAS_AvoidDangerArea((float*)VMA(1), args[2], (float*)VMA(3), args[4], VMF(5), args[6]);
case BOTLIB_AAS_RETREAT:
return botlib_export->aas.AAS_Retreat((int*)VMA(1), args[2], (float*)VMA(3), args[4], (float*)VMA(5), args[6], VMF(7), VMF(8), args[9]);
case BOTLIB_AAS_ALTROUTEGOALS:
return botlib_export->aas.AAS_AlternativeRouteGoals((float*)VMA(1), (float*)VMA(2), args[3], (aas_altroutegoal_t*)VMA(4), args[5], args[6]);
case BOTLIB_AAS_SETAASBLOCKINGENTITY:
botlib_export->aas.AAS_SetAASBlockingEntity((float*)VMA(1), (float*)VMA(2), args[3]);
return 0;
case BOTLIB_AAS_RECORDTEAMDEATHAREA:
botlib_export->aas.AAS_RecordTeamDeathArea((float*)VMA(1), args[2], args[3], args[4], args[5]);
return 0;
case BOTLIB_EA_SAY:
botlib_export->ea.EA_Say(args[1], (char*)VMA(2));
return 0;
case BOTLIB_EA_SAY_TEAM:
botlib_export->ea.EA_SayTeam(args[1], (char*)VMA(2));
return 0;
case BOTLIB_EA_USE_ITEM:
botlib_export->ea.EA_UseItem(args[1], (char*)VMA(2));
return 0;
case BOTLIB_EA_DROP_ITEM:
botlib_export->ea.EA_DropItem(args[1], (char*)VMA(2));
return 0;
case BOTLIB_EA_USE_INV:
botlib_export->ea.EA_UseInv(args[1], (char*)VMA(2));
return 0;
case BOTLIB_EA_DROP_INV:
botlib_export->ea.EA_DropInv(args[1], (char*)VMA(2));
return 0;
case BOTLIB_EA_GESTURE:
botlib_export->ea.EA_Gesture(args[1]);
return 0;
case BOTLIB_EA_COMMAND:
botlib_export->ea.EA_Command(args[1], (char*)VMA(2));
return 0;
case BOTLIB_EA_SELECT_WEAPON:
botlib_export->ea.EA_SelectWeapon(args[1], args[2]);
return 0;
case BOTLIB_EA_TALK:
botlib_export->ea.EA_Talk(args[1]);
return 0;
case BOTLIB_EA_ATTACK:
botlib_export->ea.EA_Attack(args[1]);
return 0;
case BOTLIB_EA_RELOAD:
botlib_export->ea.EA_Reload(args[1]);
return 0;
case BOTLIB_EA_USE:
botlib_export->ea.EA_Use(args[1]);
return 0;
case BOTLIB_EA_RESPAWN:
botlib_export->ea.EA_Respawn(args[1]);
return 0;
case BOTLIB_EA_JUMP:
botlib_export->ea.EA_Jump(args[1]);
return 0;
case BOTLIB_EA_DELAYED_JUMP:
botlib_export->ea.EA_DelayedJump(args[1]);
return 0;
case BOTLIB_EA_CROUCH:
botlib_export->ea.EA_Crouch(args[1]);
return 0;
case BOTLIB_EA_WALK:
botlib_export->ea.EA_Walk(args[1]);
return 0;
case BOTLIB_EA_MOVE_UP:
botlib_export->ea.EA_MoveUp(args[1]);
return 0;
case BOTLIB_EA_MOVE_DOWN:
botlib_export->ea.EA_MoveDown(args[1]);
return 0;
case BOTLIB_EA_MOVE_FORWARD:
botlib_export->ea.EA_MoveForward(args[1]);
return 0;
case BOTLIB_EA_MOVE_BACK:
botlib_export->ea.EA_MoveBack(args[1]);
return 0;
case BOTLIB_EA_MOVE_LEFT:
botlib_export->ea.EA_MoveLeft(args[1]);
return 0;
case BOTLIB_EA_MOVE_RIGHT:
botlib_export->ea.EA_MoveRight(args[1]);
return 0;
case BOTLIB_EA_MOVE:
botlib_export->ea.EA_Move(args[1], (float*)VMA(2), VMF(3));
return 0;
case BOTLIB_EA_VIEW:
botlib_export->ea.EA_View(args[1], (float*)VMA(2));
return 0;
case BOTLIB_EA_PRONE:
botlib_export->ea.EA_Prone(args[1]);
return 0;
case BOTLIB_EA_END_REGULAR:
botlib_export->ea.EA_EndRegular(args[1], VMF(2));
return 0;
case BOTLIB_EA_GET_INPUT:
botlib_export->ea.EA_GetInput(args[1], VMF(2), (bot_input_t*)VMA(3));
return 0;
case BOTLIB_EA_RESET_INPUT:
botlib_export->ea.EA_ResetInput(args[1], (bot_input_t*)VMA(2));
return 0;
case BOTLIB_AI_LOAD_CHARACTER:
return botlib_export->ai.BotLoadCharacter((char*)VMA(1), args[2]);
case BOTLIB_AI_FREE_CHARACTER:
botlib_export->ai.BotFreeCharacter(args[1]);
return 0;
case BOTLIB_AI_CHARACTERISTIC_FLOAT:
return FloatAsInt(botlib_export->ai.Characteristic_Float(args[1], args[2]));
case BOTLIB_AI_CHARACTERISTIC_BFLOAT:
return FloatAsInt(botlib_export->ai.Characteristic_BFloat(args[1], args[2], VMF(3), VMF(4)));
case BOTLIB_AI_CHARACTERISTIC_INTEGER:
return botlib_export->ai.Characteristic_Integer(args[1], args[2]);
case BOTLIB_AI_CHARACTERISTIC_BINTEGER:
return botlib_export->ai.Characteristic_BInteger(args[1], args[2], args[3], args[4]);
case BOTLIB_AI_CHARACTERISTIC_STRING:
botlib_export->ai.Characteristic_String(args[1], args[2], (char*)VMA(3), args[4]);
return 0;
case BOTLIB_AI_ALLOC_CHAT_STATE:
return botlib_export->ai.BotAllocChatState();
case BOTLIB_AI_FREE_CHAT_STATE:
botlib_export->ai.BotFreeChatState(args[1]);
return 0;
case BOTLIB_AI_QUEUE_CONSOLE_MESSAGE:
botlib_export->ai.BotQueueConsoleMessage(args[1], args[2], (char*)VMA(3));
return 0;
case BOTLIB_AI_REMOVE_CONSOLE_MESSAGE:
botlib_export->ai.BotRemoveConsoleMessage(args[1], args[2]);
return 0;
case BOTLIB_AI_NEXT_CONSOLE_MESSAGE:
return botlib_export->ai.BotNextConsoleMessage(args[1], (bot_consolemessage_s*)VMA(2));
case BOTLIB_AI_NUM_CONSOLE_MESSAGE:
return botlib_export->ai.BotNumConsoleMessages(args[1]);
case BOTLIB_AI_INITIAL_CHAT:
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;
case BOTLIB_AI_NUM_INITIAL_CHATS:
return botlib_export->ai.BotNumInitialChats(args[1], (char*)VMA(2));
case BOTLIB_AI_REPLY_CHAT:
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:
return botlib_export->ai.BotChatLength(args[1]);
case BOTLIB_AI_ENTER_CHAT:
botlib_export->ai.BotEnterChat(args[1], args[2], args[3]);
return 0;
case BOTLIB_AI_GET_CHAT_MESSAGE:
botlib_export->ai.BotGetChatMessage(args[1], (char*)VMA(2), args[3]);
return 0;
case BOTLIB_AI_STRING_CONTAINS:
return botlib_export->ai.StringContains((char*)VMA(1), (char*)VMA(2), args[3]);
case BOTLIB_AI_FIND_MATCH:
return botlib_export->ai.BotFindMatch((char*)VMA(1), (bot_match_s*)VMA(2), args[3]);
case BOTLIB_AI_MATCH_VARIABLE:
botlib_export->ai.BotMatchVariable((bot_match_s*)VMA(1), args[2], (char*)VMA(3), args[4]);
return 0;
case BOTLIB_AI_UNIFY_WHITE_SPACES:
botlib_export->ai.UnifyWhiteSpaces((char*)VMA(1));
return 0;
case BOTLIB_AI_REPLACE_SYNONYMS:
botlib_export->ai.BotReplaceSynonyms((char*)VMA(1), args[2]);
return 0;
case BOTLIB_AI_LOAD_CHAT_FILE:
return botlib_export->ai.BotLoadChatFile(args[1], (char*)VMA(2), (char*)VMA(3));
case BOTLIB_AI_SET_CHAT_GENDER:
botlib_export->ai.BotSetChatGender(args[1], args[2]);
return 0;
case BOTLIB_AI_SET_CHAT_NAME:
botlib_export->ai.BotSetChatName(args[1], (char*)VMA(2));
return 0;
case BOTLIB_AI_RESET_GOAL_STATE:
botlib_export->ai.BotResetGoalState(args[1]);
return 0;
case BOTLIB_AI_RESET_AVOID_GOALS:
botlib_export->ai.BotResetAvoidGoals(args[1]);
return 0;
case BOTLIB_AI_REMOVE_FROM_AVOID_GOALS:
botlib_export->ai.BotRemoveFromAvoidGoals(args[1], args[2]);
return 0;
case BOTLIB_AI_PUSH_GOAL:
botlib_export->ai.BotPushGoal(args[1], (bot_goal_s*)VMA(2));
return 0;
case BOTLIB_AI_POP_GOAL:
botlib_export->ai.BotPopGoal(args[1]);
return 0;
case BOTLIB_AI_EMPTY_GOAL_STACK:
botlib_export->ai.BotEmptyGoalStack(args[1]);
return 0;
case BOTLIB_AI_DUMP_AVOID_GOALS:
botlib_export->ai.BotDumpAvoidGoals(args[1]);
return 0;
case BOTLIB_AI_DUMP_GOAL_STACK:
botlib_export->ai.BotDumpGoalStack(args[1]);
return 0;
case BOTLIB_AI_GOAL_NAME:
botlib_export->ai.BotGoalName(args[1], (char*)VMA(2), args[3]);
return 0;
case BOTLIB_AI_GET_TOP_GOAL:
return botlib_export->ai.BotGetTopGoal(args[1], (bot_goal_s*)VMA(2));
case BOTLIB_AI_GET_SECOND_GOAL:
return botlib_export->ai.BotGetSecondGoal(args[1], (bot_goal_s*)VMA(2));
case BOTLIB_AI_CHOOSE_LTG_ITEM:
return botlib_export->ai.BotChooseLTGItem(args[1], (float*)VMA(2), (int*)VMA(3), args[4]);
case BOTLIB_AI_CHOOSE_NBG_ITEM:
return botlib_export->ai.BotChooseNBGItem(args[1], (float*)VMA(2), (int*)VMA(3), args[4], (bot_goal_s*)VMA(5), VMF(6));
case BOTLIB_AI_TOUCHING_GOAL:
return botlib_export->ai.BotTouchingGoal((float*)VMA(1), (bot_goal_s*)VMA(2));
case BOTLIB_AI_ITEM_GOAL_IN_VIS_BUT_NOT_VISIBLE:
return botlib_export->ai.BotItemGoalInVisButNotVisible(args[1], (float*)VMA(2), (float*)VMA(3), (bot_goal_s*)VMA(4));
case BOTLIB_AI_GET_LEVEL_ITEM_GOAL:
return botlib_export->ai.BotGetLevelItemGoal(args[1], (char*)VMA(2), (bot_goal_s*)VMA(3));
case BOTLIB_AI_GET_NEXT_CAMP_SPOT_GOAL:
return botlib_export->ai.BotGetNextCampSpotGoal(args[1], (bot_goal_s*)VMA(2));
case BOTLIB_AI_GET_MAP_LOCATION_GOAL:
return botlib_export->ai.BotGetMapLocationGoal((char*)VMA(1), (bot_goal_s*)VMA(2));
case BOTLIB_AI_AVOID_GOAL_TIME:
return FloatAsInt(botlib_export->ai.BotAvoidGoalTime(args[1], args[2]));
case BOTLIB_AI_INIT_LEVEL_ITEMS:
botlib_export->ai.BotInitLevelItems();
return 0;
case BOTLIB_AI_UPDATE_ENTITY_ITEMS:
botlib_export->ai.BotUpdateEntityItems();
return 0;
case BOTLIB_AI_LOAD_ITEM_WEIGHTS:
return botlib_export->ai.BotLoadItemWeights(args[1], (char*)VMA(2));
case BOTLIB_AI_FREE_ITEM_WEIGHTS:
botlib_export->ai.BotFreeItemWeights(args[1]);
return 0;
case BOTLIB_AI_INTERBREED_GOAL_FUZZY_LOGIC:
botlib_export->ai.BotInterbreedGoalFuzzyLogic(args[1], args[2], args[3]);
return 0;
case BOTLIB_AI_SAVE_GOAL_FUZZY_LOGIC:
botlib_export->ai.BotSaveGoalFuzzyLogic(args[1], (char*)VMA(2));
return 0;
case BOTLIB_AI_MUTATE_GOAL_FUZZY_LOGIC:
botlib_export->ai.BotMutateGoalFuzzyLogic(args[1], VMF(2));
return 0;
case BOTLIB_AI_ALLOC_GOAL_STATE:
return botlib_export->ai.BotAllocGoalState(args[1]);
case BOTLIB_AI_FREE_GOAL_STATE:
botlib_export->ai.BotFreeGoalState(args[1]);
return 0;
case BOTLIB_AI_RESET_MOVE_STATE:
botlib_export->ai.BotResetMoveState(args[1]);
return 0;
case BOTLIB_AI_MOVE_TO_GOAL:
botlib_export->ai.BotMoveToGoal((bot_moveresult_s*)VMA(1), args[2], (bot_goal_s*)VMA(3), args[4]);
return 0;
case BOTLIB_AI_MOVE_IN_DIRECTION:
return botlib_export->ai.BotMoveInDirection(args[1], (float*)VMA(2), VMF(3), args[4]);
case BOTLIB_AI_RESET_AVOID_REACH:
botlib_export->ai.BotResetAvoidReach(args[1]);
return 0;
case BOTLIB_AI_RESET_LAST_AVOID_REACH:
botlib_export->ai.BotResetLastAvoidReach(args[1]);
return 0;
case BOTLIB_AI_REACHABILITY_AREA:
return botlib_export->ai.BotReachabilityArea((float*)VMA(1), args[2]);
case BOTLIB_AI_MOVEMENT_VIEW_TARGET:
return botlib_export->ai.BotMovementViewTarget(args[1], (bot_goal_s*)VMA(2), args[3], VMF(4), (float*)VMA(5));
case BOTLIB_AI_PREDICT_VISIBLE_POSITION:
return botlib_export->ai.BotPredictVisiblePosition((float*)VMA(1), args[2], (bot_goal_s*)VMA(3), args[4], (vec_t*)VMA(5));
case BOTLIB_AI_ALLOC_MOVE_STATE:
return botlib_export->ai.BotAllocMoveState();
case BOTLIB_AI_FREE_MOVE_STATE:
botlib_export->ai.BotFreeMoveState(args[1]);
return 0;
case BOTLIB_AI_INIT_MOVE_STATE:
botlib_export->ai.BotInitMoveState(args[1], (bot_initmove_s*)VMA(2));
return 0;
case BOTLIB_AI_INIT_AVOID_REACH:
botlib_export->ai.BotInitAvoidReach(args[1]);
return 0;
case BOTLIB_AI_CHOOSE_BEST_FIGHT_WEAPON:
return botlib_export->ai.BotChooseBestFightWeapon(args[1], (int*)VMA(2));
case BOTLIB_AI_GET_WEAPON_INFO:
botlib_export->ai.BotGetWeaponInfo(args[1], args[2], (weaponinfo_s*)VMA(3));
return 0;
case BOTLIB_AI_LOAD_WEAPON_WEIGHTS:
return botlib_export->ai.BotLoadWeaponWeights(args[1], (char*)VMA(2));
case BOTLIB_AI_ALLOC_WEAPON_STATE:
return botlib_export->ai.BotAllocWeaponState();
case BOTLIB_AI_FREE_WEAPON_STATE:
botlib_export->ai.BotFreeWeaponState(args[1]);
return 0;
case BOTLIB_AI_RESET_WEAPON_STATE:
botlib_export->ai.BotResetWeaponState(args[1]);
return 0;
case BOTLIB_AI_GENETIC_PARENTS_AND_CHILD_SELECTION:
return botlib_export->ai.GeneticParentsAndChildSelection(args[1], (float*)VMA(2), (int*)VMA(3), (int*)VMA(4), (int*)VMA(5));
case G_ADD_PHYSICS_ENTITY:
#ifdef USE_PHYSICS
CMod_PhysicsAddEntity((sharedEntity_t*)VMA(1));
#endif
return 0;
case G_ADD_PHYSICS_STATIC:
#ifdef USE_PHYSICS
CMod_PhysicsAddStatic((sharedEntity_t*)VMA(1));
#endif
return 0;
case TRAP_MEMSET:
memset(VMA(1), args[2], args[3]);
return 0;
case TRAP_MEMCPY:
memcpy(VMA(1), VMA(2), args[3]);
return 0;
case TRAP_STRNCPY:
return (intptr_t)strncpy( (char*)VMA( 1 ), (char*)VMA( 2 ), args[3] );
case TRAP_SIN:
return FloatAsInt(sin(VMF(1)));
case TRAP_COS:
return FloatAsInt(cos(VMF(1)));
case TRAP_ATAN2:
return FloatAsInt(atan2(VMF(1), VMF(2)));
case TRAP_SQRT:
return FloatAsInt(sqrt(VMF(1)));
case TRAP_MATRIXMULTIPLY:
AxisMultiply((vec3_t*)VMA(1), (vec3_t*)VMA(2), (vec3_t*)VMA(3));
return 0;
case TRAP_ANGLEVECTORS:
AngleVectors((vec_t*)VMA(1), (vec_t*)VMA(2), (vec_t*)VMA(3), (vec_t*)VMA(4));
return 0;
case TRAP_PERPENDICULARVECTOR:
PerpendicularVector((vec_t*)VMA(1), (vec_t*)VMA(2));
return 0;
case TRAP_FLOOR:
return FloatAsInt(floor(VMF(1)));
case TRAP_CEIL:
return FloatAsInt(ceil(VMF(1)));
case G_SENDMESSAGE:
SV_SendBinaryMessage(args[1], (char*)VMA(2), args[3]);
return 0;
case G_MESSAGESTATUS:
return SV_BinaryMessageStatus(args[1]);
#if defined(ET_MYSQL)
case G_SQL_RUNQUERY:
return OW_RunQuery( (char*)VMA(1) );
case G_SQL_FINISHQUERY:
OW_FinishQuery( args[1] );
return 0;
case G_SQL_NEXTROW:
return OW_NextRow( args[1] );
case G_SQL_ROWCOUNT:
return OW_RowCount( args[1] );
case G_SQL_GETFIELDBYID:
OW_GetFieldByID( args[1], args[2], (char*)VMA(3), args[4] );
return 0;
case G_SQL_GETFIELDBYNAME:
OW_GetFieldByName( args[1], (char*)VMA(2), (char*)VMA(3), args[4] );
return 0;
case G_SQL_GETFIELDBYID_INT:
return OW_GetFieldByID_int( args[1], args[2] );
case G_SQL_GETFIELDBYNAME_INT:
return OW_GetFieldByName_int( args[1], (char*)VMA(2) );
case G_SQL_FIELDCOUNT:
return OW_FieldCount( args[1] );
case G_SQL_CLEANSTRING:
OW_CleanString( (char*)VMA(1), (char*)VMA(2), args[3] );
return 0;
#endif
case G_RSA_GENMSG:
return SV_RSAGenMsg( (char*)VMA(1), (char*)VMA(2), (char*)VMA(3) );
default:
Com_Error( ERR_DROP, "Bad game system trap: %ld", (long int) args[0] );
}
return -1;
}
/* <2a974> ../engine/hashpak.c:598 */
void HPAK_RemoveLump(char *pakname, resource_t *pResource)
{
FileHandle_t fp;
FileHandle_t tmp;
char szTempName[MAX_PATH];
char szOriginalName[MAX_PATH];
hash_pack_directory_t olddir;
hash_pack_directory_t newdir;
hash_pack_entry_t *oldentry;
hash_pack_entry_t *newentry;
int n;
int i;
if (pakname == NULL || *pakname == '\0' || pResource == NULL)
{
Con_Printf(__FUNCTION__ ": Invalid arguments\n");
return;
}
HPAK_FlushHostQueue();
#ifdef REHLDS_FIXES
Q_strncpy(szOriginalName, pakname, ARRAYSIZE(szOriginalName) - 1);
szOriginalName[ARRAYSIZE(szOriginalName) - 1] = 0;
COM_DefaultExtension(szOriginalName, HASHPAK_EXTENSION);
#else
//TODO: Not sure why Cmd_Argv(1) is used since function receives pakname parameter
char name[MAX_PATH];
Q_snprintf(name, ARRAYSIZE(name), "%s", Cmd_Argv(1));
COM_DefaultExtension(name, HASHPAK_EXTENSION);
Q_strncpy(szOriginalName, name, ARRAYSIZE(szOriginalName) - 1);
szOriginalName[ARRAYSIZE(szOriginalName) - 1] = 0;
#endif // REHLDS_FIXES
fp = FS_Open(szOriginalName, "rb");
if (!fp)
{
Con_Printf("Error: couldn't open HPAK file %s for removal.\n", szOriginalName);
return;
}
COM_StripExtension(szOriginalName, szTempName);
COM_DefaultExtension(szTempName, ".hp2");
tmp = FS_Open(szTempName, "w+b");
if (!tmp)
{
FS_Close(fp);
Con_Printf("ERROR: couldn't create %s.\n", szTempName);
return;
}
FS_Seek(fp, 0, FILESYSTEM_SEEK_HEAD);
FS_Seek(tmp, 0, FILESYSTEM_SEEK_HEAD);
FS_Read(&hash_pack_header, sizeof(hash_pack_header_t), 1, fp);
FS_Write(&hash_pack_header, sizeof(hash_pack_header_t), 1, tmp);
if (Q_strncmp(hash_pack_header.szFileStamp, "HPAK", sizeof(hash_pack_header.szFileStamp)))
{
FS_Close(fp);
FS_Close(tmp);
FS_Unlink(szTempName);
Con_Printf("%s is not an HPAK file\n", szOriginalName);
return;
}
if (hash_pack_header.version != HASHPAK_VERSION)
{
FS_Close(fp);
FS_Close(tmp);
FS_Unlink(szTempName);
Con_Printf("ERROR: HPAK version outdated\n");
return;
}
FS_Seek(fp, hash_pack_header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD);
FS_Read(&olddir.nEntries, 4, 1, fp);
if (olddir.nEntries < 1 || (unsigned int)olddir.nEntries > MAX_FILE_ENTRIES)
{
FS_Close(fp);
FS_Close(tmp);
FS_Unlink(szTempName);
Con_Printf("ERROR: HPAK had bogus # of directory entries: %i\n", olddir.nEntries);
return;
}
if (olddir.nEntries == 1)
{
FS_Close(fp);
FS_Close(tmp);
FS_Unlink(szOriginalName);
FS_Unlink(szTempName);
Con_Printf("Removing final lump from HPAK, deleting HPAK:\n %s\n", szOriginalName);
return;
}
olddir.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * olddir.nEntries);
FS_Read(olddir.p_rgEntries, sizeof(hash_pack_entry_t) * olddir.nEntries, 1, fp);
newdir.nEntries = olddir.nEntries - 1;
newdir.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * newdir.nEntries);
if (!HPAK_FindResource(&olddir, pResource->rgucMD5_hash, NULL))
{
FS_Close(fp);
FS_Close(tmp);
FS_Unlink(szTempName);
Mem_Free(olddir.p_rgEntries);
Mem_Free(newdir.p_rgEntries);
Con_Printf("ERROR: HPAK doesn't contain specified lump: %s\n", pResource->szFileName);
return;
}
Con_Printf("Removing %s from HPAK %s.\n", pResource->szFileName, szOriginalName);
for (i = 0, n = 0; i < olddir.nEntries; i++)
{
oldentry = &olddir.p_rgEntries[i];
if (Q_memcmp(olddir.p_rgEntries[i].resource.rgucMD5_hash, pResource->rgucMD5_hash, 16))
{
newentry = &newdir.p_rgEntries[n++];
Q_memcpy(newentry, oldentry, sizeof(hash_pack_entry_t));
newentry->nOffset = FS_Tell(tmp);
FS_Seek(fp, oldentry->nOffset, FILESYSTEM_SEEK_HEAD);
COM_CopyFileChunk(tmp, fp, newentry->nFileLength);
}
}
hash_pack_header.nDirectoryOffset = FS_Tell(tmp);
FS_Write(&newdir.nEntries, 4, 1, tmp);
for (i = 0; i < newdir.nEntries; i++)
FS_Write(&newdir.p_rgEntries[i], sizeof(hash_pack_entry_t), 1, tmp);
FS_Seek(tmp, 0, FILESYSTEM_SEEK_HEAD);
FS_Write(&hash_pack_header, sizeof(hash_pack_header_t), 1, tmp);
FS_Close(fp);
FS_Close(tmp);
FS_Unlink(szOriginalName);
FS_Rename(szTempName, szOriginalName);
Mem_Free(olddir.p_rgEntries);
Mem_Free(newdir.p_rgEntries);
}
/* <2a494> ../engine/hashpak.c:322 */
void HPAK_AddLump(qboolean bUseQueue, char *pakname, struct resource_s *pResource, void *pData, FileHandle_t fpSource)
{
FileHandle_t iRead;
FileHandle_t iWrite;
char name[MAX_PATH];
char szTempName[MAX_PATH];
char szOriginalName[MAX_PATH];
hash_pack_directory_t olddirectory;
hash_pack_directory_t newdirectory;
hash_pack_entry_t *pNewEntry;
byte md5[16];
MD5Context_t ctx;
byte *pDiskData;
if (pakname == NULL)
{
Con_Printf("HPAK_AddLump called with invalid arguments: no .pak filename\n");
return;
}
if (!pResource)
{
Con_Printf("HPAK_AddLump called with invalid arguments: no lump to add\n");
return;
}
if (!pData && !fpSource)
{
Con_Printf("HPAK_AddLump called with invalid arguments: no file handle\n");
return;
}
if (pResource->nDownloadSize < 1024 || (unsigned int)pResource->nDownloadSize > MAX_FILE_SIZE)
{
Con_Printf("HPAK_AddLump called with bogus lump, size: %i\n", pResource->nDownloadSize);
return;
}
Q_memset(&ctx, 0, sizeof(MD5Context_t));
MD5Init(&ctx);
if (pData)
MD5Update(&ctx, (byte *)pData, pResource->nDownloadSize);
else
{
pDiskData = (byte *)Mem_Malloc(pResource->nDownloadSize + 1);
Q_memset(pDiskData, 0, pResource->nDownloadSize);
FS_Read(pDiskData, pResource->nDownloadSize, 1, fpSource);
FS_Seek(fpSource, FS_Tell(fpSource), FILESYSTEM_SEEK_HEAD);
MD5Update(&ctx, pDiskData, pResource->nDownloadSize);
Mem_Free(pDiskData);
}
MD5Final(md5, &ctx);
if (Q_memcmp(pResource->rgucMD5_hash, md5, sizeof(md5)) != 0)
{
Con_Printf("HPAK_AddLump called with bogus lump, md5 mismatch\n");
Con_Printf("Purported: %s\n", MD5_Print(pResource->rgucMD5_hash));
Con_Printf("Actual : %s\n", MD5_Print(md5));
Con_Printf("Ignoring lump addition\n");
return;
}
if (bUseQueue)
{
HPAK_AddToQueue(pakname, pResource, pData, fpSource);
return;
}
Q_snprintf(name, ARRAYSIZE(name), "%s", pakname);
#ifdef REHLDS_FIXES
name[ARRAYSIZE(name) - 1] = 0;
#endif // REHLDS_FIXES
COM_DefaultExtension(name, HASHPAK_EXTENSION);
COM_FixSlashes(name);
Q_strncpy(szOriginalName, name, ARRAYSIZE(szOriginalName) - 1);
szOriginalName[ARRAYSIZE(szOriginalName) - 1] = 0;
iRead = FS_Open(name, "rb");
if (!iRead)
{
HPAK_CreatePak(pakname, pResource, pData, fpSource);
return;
}
COM_StripExtension(name, szTempName);
COM_DefaultExtension(szTempName, ".hp2");
iWrite = FS_Open(szTempName, "w+b");
if (!iWrite)
{
FS_Close(iRead);
Con_Printf("ERROR: couldn't open %s.\n", szTempName);
return;
}
FS_Read(&hash_pack_header, sizeof(hash_pack_header_t), 1, iRead);
if (hash_pack_header.version != HASHPAK_VERSION)
{
FS_Close(iRead);
FS_Close(iWrite);
FS_Unlink(szTempName);
Con_Printf("Invalid .hpk version in HPAK_AddLump\n");
return;
}
FS_Seek(iRead, 0, FILESYSTEM_SEEK_HEAD);
COM_CopyFileChunk(iWrite, iRead, FS_Size(iRead));
FS_Seek(iRead, hash_pack_header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD);
FS_Read(&olddirectory.nEntries, 4, 1, iRead);
if (olddirectory.nEntries < 1 || (unsigned int)olddirectory.nEntries > MAX_FILE_ENTRIES)
{
FS_Close(iRead);
FS_Close(iWrite);
FS_Unlink(szTempName);
Con_Printf("ERROR: .hpk had bogus # of directory entries: %i\n", olddirectory.nEntries);
return;
}
olddirectory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * olddirectory.nEntries);
FS_Read(olddirectory.p_rgEntries, sizeof(hash_pack_entry_t) * olddirectory.nEntries, 1, iRead);
FS_Close(iRead);
if (HPAK_FindResource(&olddirectory, pResource->rgucMD5_hash, NULL) != FALSE)
{
FS_Close(iWrite);
FS_Unlink(szTempName);
Mem_Free(olddirectory.p_rgEntries);
return;
}
newdirectory.nEntries = olddirectory.nEntries + 1;
newdirectory.p_rgEntries = (hash_pack_entry_t *)Mem_Malloc(sizeof(hash_pack_entry_t) * newdirectory.nEntries);
Q_memset(newdirectory.p_rgEntries, 0, sizeof(hash_pack_entry_t) * newdirectory.nEntries);
Q_memcpy(newdirectory.p_rgEntries, olddirectory.p_rgEntries, sizeof(hash_pack_entry_t) * olddirectory.nEntries);
pNewEntry = NULL;
for (int i = 0; i < olddirectory.nEntries; i++)
{
if (Q_memcmp(pResource->rgucMD5_hash, olddirectory.p_rgEntries[i].resource.rgucMD5_hash, 16) >= 0)
{
pNewEntry = &newdirectory.p_rgEntries[i];
#ifndef REHLDS_FIXES
while (i < olddirectory.nEntries)
{
Q_memcpy(&newdirectory.p_rgEntries[i + 1], &olddirectory.p_rgEntries[i], sizeof(hash_pack_entry_t));
i++;
}
#else
Q_memcpy(&newdirectory.p_rgEntries[i + 1], &olddirectory.p_rgEntries[i], (olddirectory.nEntries - i) * sizeof(hash_pack_entry_t));
#endif
break;
}
}
if (pNewEntry == NULL)
{
pNewEntry = &newdirectory.p_rgEntries[newdirectory.nEntries - 1];
}
Q_memset(pNewEntry, 0, sizeof(hash_pack_entry_t));
FS_Seek(iWrite, hash_pack_header.nDirectoryOffset, FILESYSTEM_SEEK_HEAD);
Q_memcpy(&pNewEntry->resource, pResource, sizeof(resource_t));
pNewEntry->nOffset = FS_Tell(iWrite);
pNewEntry->nFileLength = pResource->nDownloadSize;
if (pData)
FS_Write(pData, pResource->nDownloadSize, 1, iWrite);
else COM_CopyFileChunk(iWrite, fpSource, pResource->nDownloadSize);
hash_pack_header.nDirectoryOffset = FS_Tell(iWrite);
FS_Write(&newdirectory.nEntries, 4, 1, iWrite);
for (int j = 0; j < newdirectory.nEntries; j++)
FS_Write(&newdirectory.p_rgEntries[j], sizeof(hash_pack_entry_t), 1, iWrite);
if (newdirectory.p_rgEntries)
Mem_Free(newdirectory.p_rgEntries);
if (olddirectory.p_rgEntries)
Mem_Free(olddirectory.p_rgEntries);
FS_Seek(iWrite, 0, FILESYSTEM_SEEK_HEAD);
FS_Write(&hash_pack_header, sizeof(hash_pack_header_t), 1, iWrite);
FS_Close(iWrite);
FS_Unlink(szOriginalName);
FS_Rename(szTempName, szOriginalName);
}
void HPAK_RemoveLump( const char *name, resource_t *resource )
{
string read_path;
string save_path;
file_t *f1, *f2;
hpak_container_t hpak_read;
hpak_container_t hpak_save;
int i, j;
if( !name || !name[0] || !resource )
return;
HPAK_FlushHostQueue();
Q_strncpy( read_path, name, sizeof( read_path ));
FS_StripExtension( read_path );
FS_DefaultExtension( read_path, ".hpk" );
f1 = FS_Open( read_path, "rb", false );
if( !f1 )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s couldn't open.\n", read_path );
return;
}
Q_strncpy( save_path, read_path, sizeof( save_path ));
FS_StripExtension( save_path );
FS_DefaultExtension( save_path, ".hp2" );
f2 = FS_Open( save_path, "w+b", false );
if( !f2 )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s couldn't open.\n", save_path );
FS_Close( f1 );
return;
}
FS_Seek( f1, 0, SEEK_SET );
FS_Seek( f2, 0, SEEK_SET );
// header copy
FS_Read( f1, &hash_pack_header, sizeof( hpak_header_t ));
FS_Write( f2, &hash_pack_header, sizeof( hpak_header_t ));
if( hash_pack_header.ident != IDCUSTOMHEADER || hash_pack_header.version != IDCUSTOM_VERSION )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s has invalid header.\n", read_path );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( save_path ); // delete temp file
return;
}
FS_Seek( f1, hash_pack_header.seek, SEEK_SET );
FS_Read( f1, &hpak_read.count, sizeof( hpak_read.count ));
if( hpak_read.count < 1 || hpak_read.count > MAX_FILES_IN_WAD )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s has invalid number of lumps.\n", read_path );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( save_path ); // delete temp file
return;
}
if( hpak_read.count == 1 )
{
MsgDev( D_ERROR, "HPAK_RemoveLump: %s only has one element, so it's not deleted.\n", read_path );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( read_path );
FS_Delete( save_path );
return;
}
hpak_save.count = hpak_read.count - 1;
hpak_read.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpak_read.count );
hpak_save.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpak_save.count );
FS_Read( f1, hpak_read.dirs, sizeof( hpak_dir_t ) * hpak_read.count );
if( !HPAK_FindResource( &hpak_read, resource->rgucMD5_hash, NULL ))
{
MsgDev( D_ERROR, "HPAK_RemoveLump: Couldn't find the lump %s in hpak %s.n", resource->szFileName, read_path );
Mem_Free( hpak_read.dirs );
Mem_Free( hpak_save.dirs );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( save_path );
return;
}
MsgDev( D_INFO, "Removing lump %s from %s.\n", resource->szFileName, read_path );
// If there's a collision, we've just corrupted this hpak.
for( i = 0, j = 0; i < hpak_read.count; i++ )
{
if( !Q_memcmp( hpak_read.dirs[i].DirectoryResource.rgucMD5_hash, resource->rgucMD5_hash, 16 ))
continue;
hpak_save.dirs[j] = hpak_read.dirs[i];
hpak_save.dirs[j].seek = FS_Tell( f2 );
FS_Seek( f1, hpak_read.dirs[j].seek, SEEK_SET );
HPAK_FileCopy( f2, f1, hpak_save.dirs[j].size );
j++;
}
hash_pack_header.seek = FS_Tell( f2 );
FS_Write( f2, &hpak_save.count, ( hpak_save.count ));
for( i = 0; i < hpak_save.count; i++ )
{
FS_Write( f2, &hpak_save.dirs[i], sizeof( hpak_dir_t ));
}
FS_Seek( f2, 0, SEEK_SET );
FS_Write( f2, &hash_pack_header, sizeof( hpak_header_t ));
Mem_Free( hpak_read.dirs );
Mem_Free( hpak_save.dirs );
FS_Close( f1 );
FS_Close( f2 );
FS_Delete( read_path );
FS_Rename( save_path, read_path );
}
void HPAK_AddLump( qboolean add_to_queue, const char *name, resource_t *DirEnt, byte *data, file_t *f )
{
int i, position, length;
string pakname1, pakname2;
char md5[16];
MD5Context_t MD5_Hash;
hpak_container_t hpak1, hpak2;
file_t *f1, *f2;
hpak_dir_t *dirs;
byte *temp;
if( !name || !name[0] )
{
MsgDev( D_ERROR, "HPAK_AddLump: NULL name\n" );
return;
}
if( !DirEnt )
{
MsgDev( D_ERROR, "HPAK_AddLump: invalid lump\n" );
return;
}
if( data == NULL && f == NULL )
{
MsgDev( D_ERROR, "HPAK_AddLump: missing lump data\n" );
return;
}
if( DirEnt->nDownloadSize < 1024 || DirEnt->nDownloadSize > 131072 )
{
MsgDev( D_ERROR, "HPAK_AddLump: invalid size %s\n", Q_pretifymem( DirEnt->nDownloadSize, 2 ));
return;
}
// hash it
Q_memset( &MD5_Hash, 0, sizeof( MD5Context_t ));
MD5Init( &MD5_Hash );
if( data == NULL )
{
// there are better ways
position = FS_Tell( f );
temp = Z_Malloc( DirEnt->nDownloadSize );
FS_Read( f, temp, DirEnt->nDownloadSize );
FS_Seek( f, position, SEEK_SET );
MD5Update( &MD5_Hash, temp, DirEnt->nDownloadSize );
Mem_Free( temp );
}
else
{
MD5Update( &MD5_Hash, data, DirEnt->nDownloadSize );
}
MD5Final( md5, &MD5_Hash );
if( Q_memcmp( md5, DirEnt->rgucMD5_hash, 0x10 ))
{
MsgDev( D_ERROR, "HPAK_AddLump: bad checksum for %s. Ignored\n", DirEnt->szFileName );
return;
}
if( add_to_queue )
{
HPAK_AddToQueue( name, DirEnt, data, f );
return;
}
Q_strncpy( pakname1, name, sizeof( pakname1 ));
FS_StripExtension( pakname1 );
FS_DefaultExtension( pakname1, ".hpk" );
f1 = FS_Open( pakname1, "rb", false );
if( !f1 )
{
// create new pack
HPAK_CreatePak( name, DirEnt, data, f );
return;
}
Q_strncpy( pakname2, pakname1, sizeof( pakname2 ));
FS_StripExtension( pakname2 );
FS_DefaultExtension( pakname2, ".hp2" );
f2 = FS_Open( pakname2, "w+b", false );
if( !f2 )
{
MsgDev( D_ERROR, "HPAK_AddLump: couldn't open %s.\n", pakname2 );
FS_Close( f1 );
return;
}
// load headers
FS_Read( f1, &hash_pack_header, sizeof( hpak_header_t ));
if( hash_pack_header.version != IDCUSTOM_VERSION )
{
// we don't check the HPAK bit for some reason.
MsgDev( D_ERROR, "HPAK_AddLump: %s does not have a valid header.\n", pakname2 );
FS_Close( f1 );
FS_Close( f2 );
}
length = FS_FileLength( f1 );
HPAK_FileCopy( f2, f1, length );
FS_Seek( f1, hash_pack_header.seek, SEEK_SET );
FS_Read( f1, &hpak1.count, sizeof( hpak1.count ));
if( hpak1.count < 1 || hpak1.count > MAX_FILES_IN_WAD )
{
MsgDev( D_ERROR, "HPAK_AddLump: %s contain too many lumps.\n", pakname1 );
FS_Close( f1 );
FS_Close( f2 );
return;
}
// load the data
hpak1.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpak1.count );
FS_Read( f1, hpak1.dirs, sizeof( hpak_dir_t ) * hpak1.count );
FS_Close( f1 );
if( HPAK_FindResource( &hpak1, DirEnt->rgucMD5_hash, NULL ))
{
Mem_Free( hpak1.dirs );
FS_Close( f2 );
}
// make a new container
hpak2.count = hpak1.count;
hpak2.dirs = Z_Malloc( sizeof( hpak_dir_t ) * hpak2.count );
Q_memcpy( hpak2.dirs, hpak1.dirs, hpak1.count );
for( i = 0, dirs = NULL; i < hpak1.count; i++ )
{
if( Q_memcmp( hpak1.dirs[i].DirectoryResource.rgucMD5_hash, DirEnt->rgucMD5_hash, 16 ) < 0 )
{
dirs = &hpak1.dirs[i];
while( i < hpak1.count )
{
hpak2.dirs[i+1] = hpak1.dirs[i];
i++;
}
break;
}
}
if( dirs == NULL ) dirs = &hpak2.dirs[hpak2.count-1];
Q_memset( dirs, 0, sizeof( hpak_dir_t ));
FS_Seek( f2, hash_pack_header.seek, SEEK_SET );
dirs->DirectoryResource = *DirEnt;
dirs->seek = FS_Tell( f2 );
dirs->size = DirEnt->nDownloadSize;
if( !data ) HPAK_FileCopy( f2, f, dirs->size );
else FS_Write( f2, data, dirs->size );
hash_pack_header.seek = FS_Tell( f2 );
FS_Write( f2, &hpak2.count, sizeof( hpak2.count ));
for( i = 0; i < hpak2.count; i++ )
{
FS_Write( f2, &hpak2.dirs[i], sizeof( hpak_dir_t ));
}
// finalize
Mem_Free( hpak1.dirs );
Mem_Free( hpak2.dirs );
FS_Seek( f2, 0, SEEK_SET );
FS_Write( f2, &hash_pack_header, sizeof( hpak_header_t ));
FS_Close( f2 );
FS_Delete( pakname1 );
FS_Rename( pakname2, pakname1 );
}
void FS_SV_Rename(const char* from, const char* to)
{
FS_Rename(from, to);
}
static void CLQW_ParseDownload( QMsg& message ) {
// read the data
int size = message.ReadShort();
int percent = message.ReadByte();
if ( clc.demoplaying ) {
if ( size > 0 ) {
message.readcount += size;
}
return; // not in demo playback
}
if ( size == -1 ) {
common->Printf( "File not found.\n" );
if ( clc.download ) {
common->Printf( "cls.download shouldn't have been set\n" );
FS_FCloseFile( clc.download );
clc.download = 0;
}
CLQW_RequestNextDownload();
return;
}
// open the file if not opened yet
if ( !clc.download ) {
if ( String::NCmp( clc.downloadTempName, "skins/", 6 ) ) {
clc.download = FS_FOpenFileWrite( clc.downloadTempName );
} else {
char name[ 1024 ];
sprintf( name, "qw/%s", clc.downloadTempName );
clc.download = FS_SV_FOpenFileWrite( name );
}
if ( !clc.download ) {
message.readcount += size;
common->Printf( "Failed to open %s\n", clc.downloadTempName );
CLQW_RequestNextDownload();
return;
}
}
FS_Write( message._data + message.readcount, size, clc.download );
message.readcount += size;
if ( percent != 100 ) {
// change display routines by zoid
// request next block
clc.downloadPercent = percent;
CL_AddReliableCommand( "nextdl" );
} else {
FS_FCloseFile( clc.download );
// rename the temp file to it's final name
if ( String::Cmp( clc.downloadTempName, clc.downloadName ) ) {
if ( String::NCmp( clc.downloadTempName,"skins/",6 ) ) {
FS_Rename( clc.downloadTempName, clc.downloadName );
} else {
char oldn[ MAX_OSPATH ];
sprintf( oldn, "qw/%s", clc.downloadTempName );
char newn[ MAX_OSPATH ];
sprintf( newn, "qw/%s", clc.downloadName );
FS_SV_Rename( oldn, newn );
}
}
clc.download = 0;
clc.downloadPercent = 0;
// get another file if needed
CLQW_RequestNextDownload();
}
}
