/* MapEditorWindow::loadMapScripts
* Loads any scripts from [map] into the script editor
*******************************************************************/
void MapEditorWindow::loadMapScripts(Archive::mapdesc_t map)
{
// Don't bother if no scripting language specified
if (theGameConfiguration->scriptLanguage().IsEmpty())
{
// Hide script editor
wxAuiManager* m_mgr = wxAuiManager::GetManager(this);
wxAuiPaneInfo& p_inf = m_mgr->GetPane("script_editor");
p_inf.Show(false);
m_mgr->Update();
return;
}
// Don't bother if new map
if (!map.head)
{
panel_script_editor->openScripts(NULL, NULL);
return;
}
// Check for pk3 map
if (map.archive)
{
WadArchive* wad = new WadArchive();
wad->open(map.head->getMCData());
vector<Archive::mapdesc_t> maps = wad->detectMaps();
if (!maps.empty())
{
loadMapScripts(maps[0]);
wad->close();
delete wad;
return;
}
}
// Go through map entries
ArchiveEntry* entry = map.head->nextEntry();
ArchiveEntry* scripts = NULL;
ArchiveEntry* compiled = NULL;
while (entry && entry != map.end->nextEntry())
{
// Check for SCRIPTS/BEHAVIOR
if (theGameConfiguration->scriptLanguage() == "acs_hexen" ||
theGameConfiguration->scriptLanguage() == "acs_zdoom")
{
if (S_CMPNOCASE(entry->getName(), "SCRIPTS"))
scripts = entry;
if (S_CMPNOCASE(entry->getName(), "BEHAVIOR"))
compiled = entry;
}
// Next entry
entry = entry->nextEntry();
}
// Open scripts/compiled if found
panel_script_editor->openScripts(scripts, compiled);
}
/* EntryOperations::openMapDB2
* Opens the map at [entry] with Doom Builder 2, including all open
* resource archives. Sets up a FileMonitor to update the map in the
* archive if any changes are made to it in DB2
*******************************************************************/
bool EntryOperations::openMapDB2(ArchiveEntry* entry)
{
#ifdef __WXMSW__ // Windows only
string path = path_db2;
if (path.IsEmpty())
{
// Check for DB2 location registry key
wxRegKey key(wxRegKey::HKLM, "SOFTWARE\\CodeImp\\Doom Builder");
key.QueryValue("Location", path);
// Can't proceed if DB2 isn't installed
if (path.IsEmpty())
{
wxMessageBox("Doom Builder 2 must be installed to use this feature.", "Doom Builder 2 Not Found");
return false;
}
// Add default executable name
path += "\\Builder.exe";
}
// Get map info for entry
Archive::mapdesc_t map = entry->getParent()->getMapInfo(entry);
// Check valid map
if (map.format == MAP_UNKNOWN)
return false;
// Export the map to a temp .wad file
string filename = appPath(entry->getParent()->getFilename(false) + "-" + entry->getName(true) + ".wad", DIR_TEMP);
filename.Replace("/", "-");
if (map.archive)
{
entry->exportFile(filename);
entry->lock();
}
else
{
// Write map entries to temporary wad archive
if (map.head)
{
WadArchive archive;
// Add map entries to archive
ArchiveEntry* e = map.head;
while (true)
{
archive.addEntry(e, "", true);
e->lock();
if (e == map.end) break;
e = e->nextEntry();
}
// Write archive to file
archive.save(filename);
}
}
// Generate Doom Builder command line
string cmd = S_FMT("%s \"%s\" -map %s", path, filename, entry->getName());
// Add base resource archive to command line
Archive* base = theArchiveManager->baseResourceArchive();
if (base)
{
if (base->getType() == ARCHIVE_WAD)
cmd += S_FMT(" -resource wad \"%s\"", base->getFilename());
else if (base->getType() == ARCHIVE_ZIP)
cmd += S_FMT(" -resource pk3 \"%s\"", base->getFilename());
}
// Add resource archives to command line
for (int a = 0; a < theArchiveManager->numArchives(); ++a)
{
Archive* archive = theArchiveManager->getArchive(a);
// Check archive type (only wad and zip supported by db2)
if (archive->getType() == ARCHIVE_WAD)
cmd += S_FMT(" -resource wad \"%s\"", archive->getFilename());
else if (archive->getType() == ARCHIVE_ZIP)
cmd += S_FMT(" -resource pk3 \"%s\"", archive->getFilename());
}
// Run DB2
FileMonitor* fm = new DB2MapFileMonitor(filename, entry->getParent(), entry->getName(true));
wxExecute(cmd, wxEXEC_ASYNC, fm->getProcess());
return true;
#else
return false;
#endif//__WXMSW__
}
/* WadArchive::detectMaps
* Searches for any maps in the wad and adds them to the map list
*******************************************************************/
vector<Archive::mapdesc_t> WadArchive::detectMaps()
{
vector<mapdesc_t> maps;
// Go through all lumps
ArchiveEntry* entry = getEntry(0);
bool lastentryismapentry = false;
while (entry)
{
// UDMF format map check ********************************************************
// Check for UDMF format map lump (TEXTMAP lump)
if (entry->getName() == "TEXTMAP" && entry->prevEntry())
{
// Get map info
mapdesc_t md = getMapInfo(entry->prevEntry());
// Add to map list
if (md.head != NULL)
{
entry = md.end;
maps.push_back(md);
}
// Current index is ENDMAP, we don't want to check for a doom/hexen format
// map so just go to the next index and continue the loop
entry = entry->nextEntry();
continue;
}
// Doom/Hexen format map check **************************************************
// TODO maybe get rid of code duplication by calling getMapInfo() here too?
// Array to keep track of what doom/hexen map lumps have been found
uint8_t existing_map_lumps[NUMMAPLUMPS];
memset(existing_map_lumps, 0, NUMMAPLUMPS);
// Check if the current lump is a doom/hexen map lump
bool maplump_found = false;
for (int a = 0; a < 5; a++)
{
// Compare with all base map lump names
if (S_CMP(entry->getName(), map_lumps[a]))
{
maplump_found = true;
existing_map_lumps[a] = 1;
break;
}
}
// If we've found what might be a map
if (maplump_found && entry->prevEntry())
{
// Save map header entry
ArchiveEntry* header_entry = entry->prevEntry();
// Check off map lumps until we find a non-map lump
bool done = false;
while (!done)
{
// Loop will end if no map lump is found
done = true;
// Compare with all map lump names
for (int a = 0; a < NUMMAPLUMPS; a++)
{
// Compare with all base map lump names
if (S_CMP(entry->getName(), map_lumps[a]))
{
existing_map_lumps[a] = 1;
done = false;
break;
}
}
// If we're at the end of the wad, exit the loop
if (!entry->nextEntry())
{
lastentryismapentry = true;
break;
}
// Go to next lump if there is one
if (!lastentryismapentry) entry = entry->nextEntry();
}
// Go back to the lump just after the last map lump found, but only if we actually moved
if (!lastentryismapentry) entry = entry->prevEntry();
// Check that we have all the required map lumps: VERTEXES, LINEDEFS, SIDEDEFS, THINGS & SECTORS
if (!memchr(existing_map_lumps, 0, 5))
{
// Get map info
mapdesc_t md;
md.head = header_entry; // Header lump
md.name = header_entry->getName(); // Map title
md.end = lastentryismapentry ? // End lump
entry : entry->prevEntry();
// If BEHAVIOR lump exists, it's a hexen format map
if (existing_map_lumps[LUMP_BEHAVIOR])
md.format = MAP_HEXEN;
// If LEAFS, LIGHTS and MACROS exist, it's a doom 64 format map
else if (existing_map_lumps[LUMP_LEAFS] && existing_map_lumps[LUMP_LIGHTS]
&& existing_map_lumps[LUMP_MACROS])
md.format = MAP_DOOM64;
// Otherwise it's doom format
else
md.format = MAP_DOOM;
// Add map info to the maps list
maps.push_back(md);
}
}
// Embedded WAD check (for Doom 64)
if (entry->getType()->getFormat() == "archive_wad")
{
// Detect map format (probably kinda slow but whatever, no better way to do it really)
Archive* tempwad = new WadArchive();
tempwad->open(entry);
vector<mapdesc_t> emaps = tempwad->detectMaps();
if (emaps.size() > 0)
{
mapdesc_t md;
md.head = entry;
md.end = entry;
md.archive = true;
md.name = entry->getName(true).Upper();
md.format = emaps[0].format;
maps.push_back(md);
}
delete tempwad;
entry->unlock();
}
// Not a UDMF or Doom/Hexen map lump, go to next lump
entry = entry->nextEntry();
}
// Set all map header entries to ETYPE_MAP type
for (size_t a = 0; a < maps.size(); a++)
if (!maps[a].archive)
maps[a].head->setType(EntryType::mapMarkerType());
// Update entry map format hints
for (unsigned a = 0; a < maps.size(); a++)
{
string format;
if (maps[a].format == MAP_DOOM)
format = "doom";
else if (maps[a].format == MAP_DOOM64)
format = "doom64";
else if (maps[a].format == MAP_HEXEN)
format = "hexen";
else
format = "udmf";
ArchiveEntry* entry = maps[a].head;
while (entry && entry != maps[a].end->nextEntry())
{
entry->exProp("MapFormat") = format;
entry = entry->nextEntry();
}
}
return maps;
}
/* WadArchive::getMapInfo
* Returns the mapdesc_t information about the map beginning at
* [maphead]. If [maphead] is not really a map header entry, an
* invalid mapdesc_t will be returned (mapdesc_t::head == NULL)
*******************************************************************/
Archive::mapdesc_t WadArchive::getMapInfo(ArchiveEntry* maphead)
{
mapdesc_t map;
if (!maphead)
return map;
// Check for embedded wads (e.g., Doom 64 maps)
if (maphead->getType()->getFormat() == "archive_wad")
{
map.archive = true;
map.head = maphead;
map.end = maphead;
map.name = maphead->getName();
return map;
}
// Check for UDMF format map
if (S_CMPNOCASE(maphead->nextEntry()->getName(), "TEXTMAP"))
{
// Get map info
map.head = maphead;
map.name = maphead->getName();
map.format = MAP_UDMF;
// All entries until we find ENDMAP
ArchiveEntry* entry = maphead->nextEntry();
while (true)
{
if (!entry || S_CMPNOCASE(entry->getName(), "ENDMAP"))
break;
// Check for unknown map lumps
bool known = false;
for (unsigned a = 0; a < NUMMAPLUMPS; a++)
{
if (S_CMPNOCASE(entry->getName(), map_lumps[a]))
{
known = true;
a = NUMMAPLUMPS;
}
}
if (!known)
map.unk.push_back(entry);
// Next entry
entry = entry->nextEntry();
}
// If we got to the end before we found ENDMAP, something is wrong
if (!entry)
return mapdesc_t();
// Set end entry
map.end = entry;
return map;
}
// Check for doom/hexen format map
uint8_t existing_map_lumps[NUMMAPLUMPS];
memset(existing_map_lumps, 0, NUMMAPLUMPS);
ArchiveEntry* entry = maphead->nextEntry();
while (entry)
{
// Check that the entry is a valid map-related entry
bool mapentry = false;
for (unsigned a = 0; a < NUMMAPLUMPS; a++)
{
if (S_CMPNOCASE(entry->getName(), map_lumps[a]))
{
mapentry = true;
existing_map_lumps[a] = 1;
break;
}
else if (a == LUMP_GL_HEADER)
{
string name = maphead->getName(true);
name.Prepend("GL_");
if (S_CMPNOCASE(entry->getName(), name))
{
mapentry = true;
existing_map_lumps[a] = 1;
break;
}
}
}
// If it wasn't a map entry, exit this loop
if (!mapentry)
{
entry = entry->prevEntry();
break;
}
// If we've reached the end of the archive, exit this loop
if (!entry->nextEntry())
break;
// Go to next entry
entry = entry->nextEntry();
}
// Check for the required map entries
for (unsigned a = 0; a < 5; a++)
{
if (existing_map_lumps[a] == 0)
return mapdesc_t();
}
// Setup map info
map.head = maphead;
map.end = entry;
map.name = maphead->getName();
// If BEHAVIOR lump exists, it's a hexen format map
if (existing_map_lumps[LUMP_BEHAVIOR])
map.format = MAP_HEXEN;
// If LEAFS, LIGHTS and MACROS exist, it's a doom 64 format map
else if (existing_map_lumps[LUMP_LEAFS] && existing_map_lumps[LUMP_LIGHTS]
&& existing_map_lumps[LUMP_MACROS])
map.format = MAP_DOOM64;
// Otherwise it's doom format
else
map.format = MAP_DOOM;
return map;
}
/* WadArchive::findAll
* Returns all entries matching the search criteria in [options]
*******************************************************************/
vector<ArchiveEntry*> WadArchive::findAll(search_options_t& options)
{
// Init search variables
ArchiveEntry* start = getEntry(0);
ArchiveEntry* end = NULL;
options.match_name = options.match_name.Lower();
vector<ArchiveEntry*> ret;
// "graphics" namespace is the global namespace in a wad
if (options.match_namespace == "graphics")
options.match_namespace = "";
// Check for namespace to search
if (!options.match_namespace.IsEmpty())
{
// Find matching namespace
bool ns_found = false;
for (unsigned a = 0; a < namespaces.size(); a++)
{
if (namespaces[a].name == options.match_namespace)
{
start = namespaces[a].start->nextEntry();
end = namespaces[a].end;
ns_found = true;
break;
}
}
// Return none if namespace not found
if (!ns_found)
return ret;
}
ArchiveEntry* entry = start;
while (entry != end)
{
// Check type
if (options.match_type)
{
if (entry->getType() == EntryType::unknownType())
{
if (!options.match_type->isThisType(entry))
{
entry = entry->nextEntry();
continue;
}
}
else if (options.match_type != entry->getType())
{
entry = entry->nextEntry();
continue;
}
}
// Check name
if (!options.match_name.IsEmpty())
{
// Force case insensitivity
options.match_name.MakeLower();
if (!options.match_name.Matches(entry->getName().Lower()))
{
entry = entry->nextEntry();
continue;
}
}
// Entry passed all checks so far, so we found a match
ret.push_back(entry);
entry = entry->nextEntry();
}
// Return search result
return ret;
}
/* MapPreviewCanvas::openMap
* Opens a map from a mapdesc_t
*******************************************************************/
bool MapPreviewCanvas::openMap(Archive::mapdesc_t map)
{
// All errors = invalid map
Global::error = "Invalid map";
// Check if this map is a pk3 map
bool map_archive = false;
if (map.archive)
{
map_archive = true;
// Attempt to open entry as wad archive
temp_archive = new WadArchive();
if (!temp_archive->open(map.head))
{
delete temp_archive;
return false;
}
// Detect maps
vector<Archive::mapdesc_t> maps = temp_archive->detectMaps();
// Set map if there are any in the archive
if (maps.size() > 0)
map = maps[0];
else
return false;
}
// Parse UDMF map
if (map.format == MAP_UDMF)
{
ArchiveEntry* udmfdata = NULL;
for (ArchiveEntry* mapentry = map.head; mapentry != map.end; mapentry = mapentry->nextEntry())
{
// Check entry type
if (mapentry->getType() == EntryType::getType("udmf_textmap"))
{
udmfdata = mapentry;
break;
}
}
if (udmfdata == NULL)
return false;
// Start parsing
Tokenizer tz;
tz.openMem(udmfdata->getData(), udmfdata->getSize(), map.head->getName());
// Get first token
string token = tz.getToken();
size_t vertcounter = 0, linecounter = 0, thingcounter = 0;
while (!token.IsEmpty())
{
if (!token.CmpNoCase("namespace"))
{
// skip till we reach the ';'
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
else if (!token.CmpNoCase("vertex"))
{
// Get X and Y properties
bool gotx = false;
bool goty = false;
double x = 0.;
double y = 0.;
do
{
token = tz.getToken();
if (!token.CmpNoCase("x") || !token.CmpNoCase("y"))
{
bool isx = !token.CmpNoCase("x");
token = tz.getToken();
if (token.Cmp("="))
{
wxLogMessage("Bad syntax for vertex %i in UDMF map data", vertcounter);
return false;
}
if (isx) x = tz.getDouble(), gotx = true;
else y = tz.getDouble(), goty = true;
// skip to end of declaration after each key
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
}
while (token.Cmp("}"));
if (gotx && goty)
addVertex(x, y);
else
{
wxLogMessage("Wrong vertex %i in UDMF map data", vertcounter);
return false;
}
vertcounter++;
}
else if (!token.CmpNoCase("linedef"))
{
bool special = false;
bool twosided = false;
bool gotv1 = false, gotv2 = false;
size_t v1 = 0, v2 = 0;
do
{
token = tz.getToken();
if (!token.CmpNoCase("v1") || !token.CmpNoCase("v2"))
{
bool isv1 = !token.CmpNoCase("v1");
token = tz.getToken();
if (token.Cmp("="))
{
wxLogMessage("Bad syntax for linedef %i in UDMF map data", linecounter);
return false;
}
if (isv1) v1 = tz.getInteger(), gotv1 = true;
else v2 = tz.getInteger(), gotv2 = true;
// skip to end of declaration after each key
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
else if (!token.CmpNoCase("special"))
{
special = true;
// skip to end of declaration after each key
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
else if (!token.CmpNoCase("sideback"))
{
twosided = true;
// skip to end of declaration after each key
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
}
while (token.Cmp("}"));
if (gotv1 && gotv2)
addLine(v1, v2, twosided, special);
else
{
wxLogMessage("Wrong line %i in UDMF map data", linecounter);
return false;
}
linecounter++;
}
else if (S_CMPNOCASE(token, "thing"))
{
// Get X and Y properties
bool gotx = false;
bool goty = false;
double x = 0.;
double y = 0.;
do
{
token = tz.getToken();
if (!token.CmpNoCase("x") || !token.CmpNoCase("y"))
{
bool isx = !token.CmpNoCase("x");
token = tz.getToken();
if (token.Cmp("="))
{
wxLogMessage("Bad syntax for thing %i in UDMF map data", vertcounter);
return false;
}
if (isx) x = tz.getDouble(), gotx = true;
else y = tz.getDouble(), goty = true;
// skip to end of declaration after each key
do { token = tz.getToken(); } while (token.Cmp(";"));
}
} while (token.Cmp("}"));
if (gotx && goty)
addThing(x, y);
else
{
wxLogMessage("Wrong thing %i in UDMF map data", vertcounter);
return false;
}
vertcounter++;
}
else
{
// Check for side or sector definition (increase counts)
if (S_CMPNOCASE(token, "sidedef"))
n_sides++;
else if (S_CMPNOCASE(token, "sector"))
n_sectors++;
// map preview ignores sidedefs, sectors, comments,
// unknown fields, etc. so skip to end of block
do { token = tz.getToken(); }
while (token.Cmp("}"));
}
// Iterate to next token
token = tz.getToken();
}
}
// Non-UDMF map
if (map.format != MAP_UDMF)
{
// Read vertices (required)
if (!readVertices(map.head, map.end, map.format))
return false;
// Read linedefs (required)
if (!readLines(map.head, map.end, map.format))
return false;
// Read things
if (map.format != MAP_UDMF)
readThings(map.head, map.end, map.format);
// Read sides & sectors (count only)
ArchiveEntry* sidedefs = NULL;
ArchiveEntry* sectors = NULL;
while (map.head)
{
// Check entry type
if (map.head->getType() == EntryType::getType("map_sidedefs"))
sidedefs = map.head;
if (map.head->getType() == EntryType::getType("map_sectors"))
sectors = map.head;
// Exit loop if we've reached the end of the map entries
if (map.head == map.end)
break;
else
map.head = map.head->nextEntry();
}
if (sidedefs && sectors)
{
// Doom64 map
if (map.format != MAP_DOOM64)
{
n_sides = sidedefs->getSize() / 30;
n_sectors = sectors->getSize() / 26;
}
// Doom/Hexen map
else
{
n_sides = sidedefs->getSize() / 12;
n_sectors = sectors->getSize() / 16;
}
}
}
// Clean up
if (map_archive)
{
temp_archive->close();
delete temp_archive;
temp_archive = NULL;
}
// Refresh map
Refresh();
return true;
}
/* MapEditorWindow::openMap
* Opens [map] in the editor
*******************************************************************/
bool MapEditorWindow::openMap(Archive::mapdesc_t map)
{
// If a map is currently open and modified, prompt to save changes
if (editor.getMap().isModified())
{
wxMessageDialog md(this, S_FMT("Save changes to map %s?", currentMapDesc().name), "Unsaved Changes", wxYES_NO | wxCANCEL);
int answer = md.ShowModal();
if (answer == wxID_YES)
saveMap();
else if (answer == wxID_CANCEL)
return true;
}
// Show blank map
this->Show(true);
map_canvas->Refresh();
Layout();
Update();
Refresh();
// Clear current map data
for (unsigned a = 0; a < map_data.size(); a++)
delete map_data[a];
map_data.clear();
// Get map parent archive
Archive* archive = NULL;
if (map.head)
{
archive = map.head->getParent();
// Load map data
if (map.archive)
{
WadArchive temp;
temp.open(map.head->getMCData());
for (unsigned a = 0; a < temp.numEntries(); a++)
map_data.push_back(new ArchiveEntry(*(temp.getEntry(a))));
}
else
{
ArchiveEntry* entry = map.head;
while (entry)
{
bool end = (entry == map.end);
map_data.push_back(new ArchiveEntry(*entry));
entry = entry->nextEntry();
if (end)
break;
}
}
}
// Set texture manager archive
tex_man.setArchive(archive);
// Clear current map
closeMap();
// Attempt to open map
theSplashWindow->show("Loading Map", true, this);
bool ok = editor.openMap(map);
theSplashWindow->hide();
// Show window if opened ok
if (ok)
{
mdesc_current = map;
// Read DECORATE definitions if any
theGameConfiguration->parseDecorateDefs(theArchiveManager->baseResourceArchive());
for (int i = 0; i < theArchiveManager->numArchives(); ++i)
theGameConfiguration->parseDecorateDefs(theArchiveManager->getArchive(i));
// Load scripts if any
loadMapScripts(map);
// Lock map entries
lockMapEntries();
// Reset map checks panel
panel_checks->reset();
map_canvas->viewFitToMap(true);
map_canvas->Refresh();
// Set window title
if (archive)
SetTitle(S_FMT("SLADE - %s of %s", map.name, archive->getFilename(false)));
else
SetTitle(S_FMT("SLADE - %s (UNSAVED)", map.name));
// Create backup
if (map.head && !backup_manager->writeBackup(map_data, map.head->getTopParent()->getFilename(false), map.head->getName(true)))
LOG_MESSAGE(1, "Warning: Failed to backup map data");
}
return ok;
}
/* MapPreviewCanvas::openMap
* Opens a map from a mapdesc_t
*******************************************************************/
bool MapPreviewCanvas::openMap(Archive::mapdesc_t map)
{
// All errors = invalid map
Global::error = "Invalid map";
// Check if this map is a pk3 map
bool map_archive = false;
if (map.archive)
{
map_archive = true;
// Attempt to open entry as wad archive
temp_archive = new WadArchive();
if (!temp_archive->open(map.head))
{
delete temp_archive;
return false;
}
// Detect maps
vector<Archive::mapdesc_t> maps = temp_archive->detectMaps();
// Set map if there are any in the archive
if (maps.size() > 0)
map = maps[0];
else
return false;
}
// Parse UDMF map
if (map.format == MAP_UDMF)
{
ArchiveEntry* udmfdata = NULL;
for (ArchiveEntry* mapentry = map.head; mapentry != map.end; mapentry = mapentry->nextEntry())
{
// Check entry type
if (mapentry->getType() == EntryType::getType("udmf_textmap"))
{
udmfdata = mapentry;
break;
}
}
if (udmfdata == NULL)
return false;
// Start parsing
Tokenizer tz;
tz.openMem(udmfdata->getData(), udmfdata->getSize(), map.head->getName());
// Get first token
string token = tz.getToken();
size_t vertcounter = 0, linecounter = 0;
while (!token.IsEmpty())
{
if (!token.CmpNoCase("namespace"))
{
// skip till we reach the ';'
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
else if (!token.CmpNoCase("vertex"))
{
// Get X and Y properties
bool gotx = false;
bool goty = false;
double x = 0.;
double y = 0.;
do
{
token = tz.getToken();
if (!token.CmpNoCase("x") || !token.CmpNoCase("y"))
{
bool isx = !token.CmpNoCase("x");
token = tz.getToken();
if (token.Cmp("="))
{
wxLogMessage("Bad syntax for vertex %i in UDMF map data", vertcounter);
return false;
}
if (isx) x = tz.getDouble(), gotx = true;
else y = tz.getDouble(), goty = true;
// skip to end of declaration after each key
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
}
while (token.Cmp("}"));
if (gotx && goty)
addVertex(x, y);
else
{
wxLogMessage("Wrong vertex %i in UDMF map data", vertcounter);
return false;
}
vertcounter++;
}
else if (!token.CmpNoCase("linedef"))
{
bool special = false;
bool twosided = false;
bool gotv1 = false, gotv2 = false;
size_t v1 = 0, v2 = 0;
do
{
token = tz.getToken();
if (!token.CmpNoCase("v1") || !token.CmpNoCase("v2"))
{
bool isv1 = !token.CmpNoCase("v1");
token = tz.getToken();
if (token.Cmp("="))
{
wxLogMessage("Bad syntax for linedef %i in UDMF map data", linecounter);
return false;
}
if (isv1) v1 = tz.getInteger(), gotv1 = true;
else v2 = tz.getInteger(), gotv2 = true;
// skip to end of declaration after each key
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
else if (!token.CmpNoCase("special"))
{
special = true;
// skip to end of declaration after each key
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
else if (!token.CmpNoCase("sideback"))
{
twosided = true;
// skip to end of declaration after each key
do { token = tz.getToken(); }
while (token.Cmp(";"));
}
}
while (token.Cmp("}"));
if (gotv1 && gotv2)
addLine(v1, v2, twosided, special);
else
{
wxLogMessage("Wrong line %i in UDMF map data", linecounter);
return false;
}
linecounter++;
}
else
{
// map preview ignores things, sidedefs, sectors, comments,
// unknown fields, etc. so skip to end of block
do { token = tz.getToken(); }
while (token.Cmp("}"));
}
// Iterate to next token
token = tz.getToken();
}
}
// Read vertices
if (map.format == MAP_DOOM || map.format == MAP_HEXEN || map.format == MAP_DOOM64)
{
// Find VERTEXES entry
ArchiveEntry* mapentry = map.head;
ArchiveEntry* vertexes = NULL;
while (mapentry)
{
// Check entry type
if (mapentry->getType() == EntryType::getType("map_vertexes"))
{
vertexes = mapentry;
break;
}
// Exit loop if we've reached the end of the map entries
if (mapentry == map.end)
break;
else
mapentry = mapentry->nextEntry();
}
// Can't open a map without vertices
if (!vertexes)
return false;
// Read vertex data
MemChunk& mc = vertexes->getMCData();
mc.seek(0, SEEK_SET);
if (map.format == MAP_DOOM64)
{
doom64vertex_t v;
while (1)
{
// Read vertex
if (!mc.read(&v, 8))
break;
// Add vertex
addVertex((double)v.x/65536, (double)v.y/65536);
}
}
else
{
doomvertex_t v;
while (1)
{
// Read vertex
if (!mc.read(&v, 4))
break;
// Add vertex
addVertex((double)v.x, (double)v.y);
}
}
}
// Read linedefs
if (map.format == MAP_DOOM || map.format == MAP_HEXEN || map.format == MAP_DOOM64)
{
// Find LINEDEFS entry
ArchiveEntry* mapentry = map.head;
ArchiveEntry* linedefs = NULL;
while (mapentry)
{
// Check entry type
if (mapentry->getType() == EntryType::getType("map_linedefs"))
{
linedefs = mapentry;
break;
}
// Exit loop if we've reached the end of the map entries
if (mapentry == map.end)
break;
else
mapentry = mapentry->nextEntry();
}
// Can't open a map without linedefs
if (!linedefs)
return false;
// Read line data
MemChunk& mc = linedefs->getMCData();
mc.seek(0, SEEK_SET);
if (map.format == MAP_DOOM)
{
while (1)
{
// Read line
doomline_t l;
if (!mc.read(&l, sizeof(doomline_t)))
break;
// Check properties
bool special = false;
bool twosided = false;
if (l.side2 != 0xFFFF)
twosided = true;
if (l.type > 0)
special = true;
// Add line
addLine(l.vertex1, l.vertex2, twosided, special);
}
}
else if (map.format == MAP_DOOM64)
{
while (1)
{
// Read line
doom64line_t l;
if (!mc.read(&l, sizeof(doom64line_t)))
break;
// Check properties
bool macro = false;
bool special = false;
bool twosided = false;
if (l.side2 != 0xFFFF)
twosided = true;
if (l.type > 0)
{
if (l.type & 0x100)
macro = true;
else special = true;
}
// Add line
addLine(l.vertex1, l.vertex2, twosided, special, macro);
}
}
else if (map.format == MAP_HEXEN)
{
while (1)
{
// Read line
hexenline_t l;
if (!mc.read(&l, sizeof(hexenline_t)))
break;
// Check properties
bool special = false;
bool twosided = false;
if (l.side2 != 0xFFFF)
twosided = true;
if (l.type > 0)
special = true;
// Add line
addLine(l.vertex1, l.vertex2, twosided, special);
}
}
}
// Clean up
if (map_archive)
{
temp_archive->close();
delete temp_archive;
temp_archive = NULL;
}
// Refresh map
Refresh();
return true;
}