void MRU_Activate (std::size_t index)
{
char text[1024];
strcpy(text, MRU_GetText(index));
if (file_readable(text)) //\todo Test 'map load succeeds' instead of 'file is readable'.
{
MRU_AddFile (text);
Map_RegionOff();
Map_Free();
Map_LoadFile (text);
}
else
{
MRU_used--;
for (std::size_t i = index; i < MRU_used; i++)
MRU_SetText (i, MRU_GetText (i+1));
if (MRU_used == 0)
{
gtk_label_set_text(GTK_LABEL(GTK_BIN(MRU_items[0])->child), "Recent Files");
gtk_widget_set_sensitive(GTK_WIDGET(MRU_items[0]), FALSE);
}
else
{
gtk_widget_hide(GTK_WIDGET(MRU_items[MRU_used]));
}
}
}
/*
=======================================================================================================================
Map_New
=======================================================================================================================
*/
void Map_New(void) {
common->Printf("Map_New\n");
Map_Free();
Patch_Cleanup();
g_Inspectors->entityDlg.SetEditEntity ( NULL );
world_entity = Entity_New();
world_entity->brushes.onext = world_entity->brushes.oprev = &world_entity->brushes;
SetKeyValue(world_entity, "classname", "worldspawn");
world_entity->eclass = Eclass_ForName("worldspawn", true);
g_pParentWnd->GetCamera()->Camera().angles[YAW] = 0;
g_pParentWnd->GetCamera()->Camera().angles[PITCH] = 0;
VectorCopy(vec3_origin, g_pParentWnd->GetCamera()->Camera().origin);
g_pParentWnd->GetCamera()->Camera().origin[2] = 48;
VectorCopy(vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
Map_RestoreBetween();
Sys_UpdateWindows(W_ALL);
mapModified = 0;
g_qeglobals.mapVersion = MAP_VERSION;
}
/*
===========
Map_New
===========
*/
void Map_New( void ){
Sys_Printf( "Map_New\n" );
Map_Free();
strcpy( currentmap, "unnamed.map" );
Sys_SetTitle( currentmap );
world_entity = (entity_s*)qmalloc( sizeof( *world_entity ) );
world_entity->brushes.onext =
world_entity->brushes.oprev = &world_entity->brushes;
SetKeyValue( world_entity, "classname", "worldspawn" );
world_entity->eclass = Eclass_ForName( "worldspawn", true );
g_pParentWnd->GetCamWnd()->Camera()->angles[YAW] = 0;
g_pParentWnd->GetCamWnd()->Camera()->angles[PITCH] = 0;
VectorCopy( vec3_origin, g_pParentWnd->GetCamWnd()->Camera()->origin );
g_pParentWnd->GetCamWnd()->Camera()->origin[2] = 48;
VectorCopy( vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin() );
Map_RestoreBetween();
Group_Init();
Sys_UpdateWindows( W_ALL );
modified = false;
}
static void FreeSimpleMap(MapType ** map)
{
if ((map != NULL) && (*map != NULL))
{
Map_FreeValues(*map);
Map_Free(map);
}
}
static void FreeValues(MapType ** valuesMap)
{
if ((valuesMap != NULL) && (*valuesMap != NULL))
{
Map_ForEach(*valuesMap, FreeValue, NULL);
Map_Free(valuesMap);
}
}
void ListFile_FreeMap(PLISTFILE_MAP pListMap)
{
if(pListMap != NULL)
{
if(pListMap->pNameMap != NULL)
Map_Free(pListMap->pNameMap);
CASC_FREE(pListMap);
}
}
static void WowHandler_Close(TRootHandler_WoW6 * pRootHandler)
{
if(pRootHandler != NULL)
{
Array_Free(&pRootHandler->FileTable);
Map_Free(pRootHandler->pRootMap);
CASC_FREE(pRootHandler);
}
}
static void D3Handler_Close(TRootHandler_Diablo3 * pRootHandler)
{
if(pRootHandler != NULL)
{
// Free the file map
Map_Free(pRootHandler->pRootMap);
// Free the array of the file entries and file names
Array_Free(&pRootHandler->FileTable);
Array_Free(&pRootHandler->FileNames);
// Free the root file itself
CASC_FREE(pRootHandler);
}
}
AwaError AwaServerListClientsOperation_Free(AwaServerListClientsOperation ** operation)
{
AwaError result = AwaError_OperationInvalid;
if ((operation != NULL) && (*operation != NULL))
{
ServerResponse_Free(&(*operation)->ServerResponse);
ServerOperation_Free(&(*operation)->ServerOperation);
Map_FreeValues((*operation)->ClientResponseMap);
Map_Free(&((*operation)->ClientResponseMap));
LogFree("AwaServerListClientsOperation", *operation);
Awa_MemSafeFree(*operation);
*operation = NULL;
result = AwaError_Success;
}
return result;
}
AwaError AwaClientSubscribeOperation_Free(AwaClientSubscribeOperation ** operation)
{
AwaError result = AwaError_OperationInvalid;
if (operation != NULL && *operation != NULL)
{
OperationCommon_Free(&(*operation)->Common);
Map_ForEach((*operation)->Subscribers, RemoveSubscriptionLinkToOperation, *operation);
Map_Free(&(*operation)->Subscribers);
if ((*operation)->Response != NULL)
{
SubscribeResponse_Free(&(*operation)->Response);
}
LogFree("AwaClientSubscribeOperation", *operation);
Awa_MemSafeFree(*operation);
*operation = NULL;
result = AwaError_Success;
}
return result;
}
AwaError AwaServerSession_Free(AwaServerSession ** session)
{
AwaError result = AwaError_Success;
if ((session != NULL) && (*session != NULL))
{
SessionCommon_Free(&((*session)->SessionCommon));
(*session)->SessionCommon = NULL;
Map_ForEach((*session)->Observers, RemoveObservationLinkToSession, NULL);
Map_Free(&(*session)->Observers);
Queue_Free(&((*session)->NotificationQueue));
// Free the session itself
LogFree("AwaServerSession", *session);
Awa_MemSafeFree(*session);
*session = NULL;
}
else
{
result = LogErrorWithEnum(AwaError_SessionInvalid, "Session is NULL");
}
return result;
}
/*
================
Map_LoadFile
================
*/
void Map_LoadFile (char *filename)
{
char *buf;
entity_t *ent;
char temp[1024];
Sys_BeginWait ();
Select_Deselect();
//SetInspectorMode(W_CONSOLE);
QE_ConvertDOSToUnixName( temp, filename );
Sys_Printf ("Map_LoadFile: %s\n", temp );
Map_Free ();
//++timo FIXME: maybe even easier to have Group_Init called from Map_Free?
Group_Init();
g_qeglobals.d_parsed_brushes = 0;
strcpy (currentmap, filename);
if (LoadFile (filename, (void **)&buf) != -1)
{
StartTokenParsing (buf);
g_qeglobals.d_num_entities = 0;
// Timo
// will be used in Entity_Parse to detect if a conversion between brush formats is needed
g_qeglobals.bNeedConvert = false;
g_qeglobals.bOldBrushes = false;
g_qeglobals.bPrimitBrushes = false;
while (1)
{
ent = Entity_Parse (false, &active_brushes);
if (!ent)
break;
if (!strcmp(ValueForKey (ent, "classname"), "worldspawn"))
{
if (world_entity)
Sys_Printf ("WARNING: multiple worldspawn\n");
world_entity = ent;
}
else if (!strcmp(ValueForKey (ent, "classname"), "group_info"))
{
// it's a group thing!
Group_Add(ent);
Entity_Free(ent);
}
else
{
// add the entity to the end of the entity list
ent->next = &entities;
ent->prev = entities.prev;
entities.prev->next = ent;
entities.prev = ent;
g_qeglobals.d_num_entities++;
}
}
}
free (buf);
if (!world_entity)
{
Sys_Printf ("No worldspawn in map.\n");
Map_New ();
return;
}
Sys_Printf ("--- LoadMapFile ---\n");
Sys_Printf ("%s\n", temp );
Sys_Printf ("%5i brushes\n", g_qeglobals.d_parsed_brushes );
Sys_Printf ("%5i entities\n", g_qeglobals.d_num_entities);
Map_RestoreBetween ();
Sys_Printf ("Map_BuildAllDisplayLists\n");
Map_BuildBrushData();
// reset the "need conversion" flag
// conversion to the good format done in Map_BuildBrushData
g_qeglobals.bNeedConvert=false;
//
// move the view to a start position
//
ent = AngledEntity();
g_pParentWnd->GetCamera()->Camera().angles[PITCH] = 0;
if (ent)
{
GetVectorForKey (ent, "origin", g_pParentWnd->GetCamera()->Camera().origin);
GetVectorForKey (ent, "origin", g_pParentWnd->GetXYWnd()->GetOrigin());
g_pParentWnd->GetCamera()->Camera().angles[YAW] = FloatForKey (ent, "angle");
}
else
{
g_pParentWnd->GetCamera()->Camera().angles[YAW] = 0;
VectorCopy (vec3_origin, g_pParentWnd->GetCamera()->Camera().origin);
VectorCopy (vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
}
Map_RegionOff ();
modified = false;
Sys_SetTitle (temp);
Texture_ShowInuse ();
Sys_EndWait();
Sys_UpdateWindows (W_ALL);
}
int RootHandler_CreateDiablo3(TCascStorage * hs, LPBYTE pbRootFile, DWORD cbRootFile)
{
TRootHandler_Diablo3 * pRootHandler;
PCASC_MAP pPackageMap = NULL;
LPBYTE pbRootFileEnd = pbRootFile + cbRootFile;
LPBYTE pbPackagesDat = NULL;
DWORD dwTotalFileCount;
DWORD cbPackagesDat = 0;
int nError;
// Allocate the root handler object
hs->pRootHandler = pRootHandler = CASC_ALLOC(TRootHandler_Diablo3, 1);
if(pRootHandler == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
// Fill-in the handler functions
memset(pRootHandler, 0, sizeof(TRootHandler_Diablo3));
pRootHandler->Insert = (ROOT_INSERT)D3Handler_Insert;
pRootHandler->Search = (ROOT_SEARCH)D3Handler_Search;
pRootHandler->EndSearch = (ROOT_ENDSEARCH)D3Handler_EndSearch;
pRootHandler->GetKey = (ROOT_GETKEY)D3Handler_GetKey;
pRootHandler->Close = (ROOT_CLOSE)D3Handler_Close;
pRootHandler->GetFileId = (ROOT_GETFILEID)D3Handler_GetFileId;
// Fill-in the flags
pRootHandler->dwRootFlags |= ROOT_FLAG_HAS_NAMES;
// Scan the total number of files in the root directories
// Reserve space for extra files
dwTotalFileCount = ScanDirectoryFile(hs, pbRootFile, pbRootFileEnd);
if(dwTotalFileCount == 0)
return ERROR_FILE_CORRUPT;
dwTotalFileCount += CASC_EXTRA_FILES;
// Allocate the global linear file table
// Note: This is about 18 MB of memory for Diablo III PTR build 30013
nError = Array_Create(&pRootHandler->FileTable, CASC_FILE_ENTRY, dwTotalFileCount);
if(nError != ERROR_SUCCESS)
return nError;
// Allocate global buffer for file names.
// The size of the buffer was taken from Diablo III build 30013
nError = Array_Create(&pRootHandler->FileNames, char, 0x01000000);
if(nError != ERROR_SUCCESS)
return nError;
// Create map of ROOT_ENTRY -> FileEntry
pRootHandler->pRootMap = Map_Create(dwTotalFileCount, sizeof(ULONGLONG), FIELD_OFFSET(CASC_FILE_ENTRY, FileNameHash));
if(pRootHandler->pRootMap == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
// Parse the ROOT file and insert all entries in the file table
nError = ParseDirectoryFile(pRootHandler, pbRootFile, pbRootFileEnd, DIABLO3_INVALID_INDEX);
if(nError == ERROR_SUCCESS)
{
size_t dwRootEntries = pRootHandler->FileTable.ItemCount;
// We expect the number of level-0 to be less than maximum
assert(dwRootEntries < DIABLO3_MAX_SUBDIRS);
// Now parse the all root items and load them
for(DWORD i = 0; i < dwRootEntries; i++)
{
PCASC_FILE_ENTRY pRootEntry = (PCASC_FILE_ENTRY)Array_ItemAt(&pRootHandler->FileTable, i);
// Load the entire file to memory
pbRootFile = LoadFileToMemory(hs, pRootEntry->EncodingKey.Value, &cbRootFile);
if(pbRootFile != NULL)
{
nError = ParseDirectoryFile(pRootHandler, pbRootFile, pbRootFile + cbRootFile, i);
CASC_FREE(pbRootFile);
}
}
}
// Note: The file "Base\Data_D3\PC\Misc\Packages.dat" contains the names
// of the files (without level-0 and level-1 directory). We can use these
// names for supplying the missing extensions
if(nError == ERROR_SUCCESS)
{
// Load the entire file to memory
pbPackagesDat = LoadFileToMemory(hs, "Base\\Data_D3\\PC\\Misc\\Packages.dat", &cbPackagesDat);
if(pbPackagesDat != NULL)
{
pPackageMap = CreatePackageMap(pbPackagesDat, pbPackagesDat + cbPackagesDat);
}
}
// Vast majorify of files at this moment don't have names.
// We can load the Base\CoreTOC.dat file in order
// to get directory asset indexes, file names and extensions
if(nError == ERROR_SUCCESS)
{
LPBYTE pbCoreTOC;
DWORD cbCoreTOC = 0;
// Load the entire file to memory
pbCoreTOC = LoadFileToMemory(hs, "Base\\CoreTOC.dat", &cbCoreTOC);
if(pbCoreTOC != NULL)
{
ParseCoreTOC(pRootHandler, pPackageMap, pbCoreTOC, pbCoreTOC + cbCoreTOC);
CASC_FREE(pbCoreTOC);
}
}
// Free the packages map
if(pPackageMap != NULL)
Map_Free(pPackageMap);
if(pbPackagesDat != NULL)
CASC_FREE(pbPackagesDat);
return nError;
}
/*
================
Map_LoadFile
================
*/
void Map_LoadFile( const char *filename ){
clock_t start, finish;
double elapsed_time;
start = clock();
Sys_BeginWait();
Select_Deselect();
/*!
\todo FIXME TTimo why is this commented out?
stability issues maybe? or duplicate feature?
forcing to show the console during map load was a good thing IMO
*/
//SetInspectorMode(W_CONSOLE);
Sys_Printf( "Loading map from %s\n", filename );
Map_Free();
//++timo FIXME: maybe even easier to have Group_Init called from Map_Free?
Group_Init();
g_qeglobals.d_num_entities = 0;
g_qeglobals.d_parsed_brushes = 0;
// cancel the map loading process
// used when conversion between standard map format and BP format is required and the user cancels the process
g_bCancel_Map_LoadFile = false;
strcpy( currentmap, filename );
g_bScreenUpdates = false; // leo: avoid redraws while loading the map (see fenris:1952)
// prepare to let the map module do the parsing
FileStream file;
const char* type = strrchr( filename,'.' );
if ( type != NULL ) {
type++;
}
// NOTE TTimo opening has binary doesn't make a lot of sense
// but opening as text confuses the scriptlib parser
// this may be a problem if we "rb" and use the XML parser, might have an incompatibility
if ( file.Open( filename, "rb" ) ) {
Map_Import( &file, type );
}
else{
Sys_FPrintf( SYS_ERR, "ERROR: failed to open %s for read\n", filename );
}
file.Close();
g_bScreenUpdates = true;
if ( g_bCancel_Map_LoadFile ) {
Sys_Printf( "Map_LoadFile canceled\n" );
Map_New();
Sys_EndWait();
return;
}
if ( !world_entity ) {
Sys_Printf( "No worldspawn in map.\n" );
Map_New();
Sys_EndWait();
return;
}
finish = clock();
elapsed_time = (double)( finish - start ) / CLOCKS_PER_SEC;
Sys_Printf( "--- LoadMapFile ---\n" );
Sys_Printf( "%s\n", filename );
Sys_Printf( "%5i brushes\n", g_qeglobals.d_parsed_brushes );
Sys_Printf( "%5i entities\n", g_qeglobals.d_num_entities );
Sys_Printf( "%5.2f second(s) load time\n", elapsed_time );
Sys_EndWait();
Map_RestoreBetween();
//
// move the view to a start position
//
Map_StartPosition();
Map_RegionOff();
modified = false;
Sys_SetTitle( filename );
Texture_ShowInuse();
QERApp_SortActiveShaders();
Sys_UpdateWindows( W_ALL );
}
void Map_Init(){
Map_Free();
}
AwaServerSession * AwaServerSession_New(void)
{
AwaServerSession * session = Awa_MemAlloc(sizeof(*session));
if (session != NULL)
{
memset(session, 0, sizeof(*session));
session->SessionCommon = SessionCommon_New(SessionType_Server);
if (session->SessionCommon != NULL)
{
session->Observers = Map_New();
if (session->Observers != NULL)
{
session->NotificationQueue = Queue_New();
if (session->NotificationQueue != NULL)
{
session->ServerEventsCallbackInfo = ServerEventsCallbackInfo_New();
if (session->ServerEventsCallbackInfo != NULL)
{
LogNew("AwaServerSession", session);
}
else
{
LogErrorWithEnum(AwaError_OutOfMemory, "Could not create server events");
Queue_Free(&session->NotificationQueue);
Map_Free(&session->Observers);
SessionCommon_Free(&session->SessionCommon);
Awa_MemSafeFree(session);
session = NULL;
}
}
else
{
LogErrorWithEnum(AwaError_OutOfMemory, "Could not create notification queue");
Map_Free(&session->Observers);
SessionCommon_Free(&session->SessionCommon);
Awa_MemSafeFree(session);
session = NULL;
}
}
else
{
LogErrorWithEnum(AwaError_OutOfMemory, "Could not create observer list");
SessionCommon_Free(&session->SessionCommon);
Awa_MemSafeFree(session);
session = NULL;
}
}
else
{
LogErrorWithEnum(AwaError_OutOfMemory, "Could not create common session");
SessionCommon_Free(&session->SessionCommon);
Awa_MemSafeFree(session);
session = NULL;
}
}
else
{
LogErrorWithEnum(AwaError_OutOfMemory, "Could not create ServerSession");
}
return session;
}
/*
=======================================================================================================================
Map_LoadFile
=======================================================================================================================
*/
void Map_LoadFile(const char *filename) {
entity_t *ent;
CWaitDlg dlg;
idStr fileStr, status;
idMapFile mapfile;
Sys_BeginWait();
Select_Deselect();
dlg.AllowCancel( true );
idStr( filename ).ExtractFileName( fileStr );
sprintf( status, "Loading %s...", fileStr.c_str() );
dlg.SetWindowText( status );
sprintf( status, "Reading file %s...", fileStr.c_str() );
dlg.SetText( status );
// SetInspectorMode(W_CONSOLE);
fileStr = filename;
fileStr.BackSlashesToSlashes();
common->Printf( "Map_LoadFile: %s\n", fileStr.c_str() );
Map_Free();
g_qeglobals.d_parsed_brushes = 0;
strcpy( currentmap, filename );
if(mapfile.Parse(filename, true, true)) {
g_qeglobals.bNeedConvert = false;
g_qeglobals.bOldBrushes = false;
g_qeglobals.bPrimitBrushes = false;
g_qeglobals.mapVersion = 1.0;
long lastUpdate = 0;
int count = mapfile.GetNumEntities();
for (int i = 0; i < count; i++) {
idMapEntity *mapent = mapfile.GetEntity(i);
if (mapent) {
idStr classname = mapent->epairs.GetString("classname");
// Update 20 times a second
if ( (GetTickCount() - lastUpdate) > 50 ) {
lastUpdate = GetTickCount();
sprintf(status, "Loading entity %i (%s)...", i, classname.c_str());
dlg.SetText(status);
}
if ( dlg.CancelPressed() ) {
Sys_Status("Map load cancelled.\n");
Map_New();
return;
}
if (classname == "worldspawn") {
world_entity = EntityFromMapEntity(mapent, &dlg);
Entity_PostParse(world_entity, &active_brushes);
} else {
ent = EntityFromMapEntity(mapent, &dlg);
Entity_PostParse(ent, &active_brushes);
Entity_Name(ent, true);
// add the entity to the end of the entity list
ent->next = &entities;
ent->prev = entities.prev;
entities.prev->next = ent;
entities.prev = ent;
g_qeglobals.d_num_entities++;
}
}
}
}
if (!world_entity) {
Sys_Status("No worldspawn in map.\n");
Map_New();
return;
}
common->Printf("--- LoadMapFile ---\n");
common->Printf("%s\n", fileStr.c_str());
common->Printf("%5i brushes\n", g_qeglobals.d_parsed_brushes);
common->Printf("%5i entities\n", g_qeglobals.d_num_entities);
dlg.SetText("Restoring Between");
Map_RestoreBetween();
dlg.SetText("Building Brush Data");
common->Printf("Map_BuildAllDisplayLists\n");
Map_BuildBrushData();
//
// reset the "need conversion" flag conversion to the good format done in
// Map_BuildBrushData
//
g_qeglobals.bNeedConvert = false;
// move the view to a start position
ent = AngledEntity();
g_pParentWnd->GetCamera()->Camera().angles[PITCH] = 0;
if (ent) {
GetVectorForKey(ent, "origin", g_pParentWnd->GetCamera()->Camera().origin);
GetVectorForKey(ent, "origin", g_pParentWnd->GetXYWnd()->GetOrigin());
g_pParentWnd->GetCamera()->Camera().angles[YAW] = FloatForKey(ent, "angle");
}
else {
g_pParentWnd->GetCamera()->Camera().angles[YAW] = 0;
VectorCopy(vec3_origin, g_pParentWnd->GetCamera()->Camera().origin);
VectorCopy(vec3_origin, g_pParentWnd->GetXYWnd()->GetOrigin());
}
Map_RegionOff();
mapModified = 0;
if (GetFileAttributes(filename) & FILE_ATTRIBUTE_READONLY) {
fileStr += " (read only) ";
}
Sys_SetTitle(fileStr);
Texture_ShowInuse();
if (g_pParentWnd->GetCamera()->GetRenderMode()) {
g_pParentWnd->GetCamera()->BuildRendererState();
}
Sys_EndWait();
Sys_UpdateWindows(W_ALL);
}