pelya
1103 lines
48 KiB
C++
1103 lines
48 KiB
C++
/*
|
|
* Copyright (C) 2006, 2007 Ronald Lamprecht
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "lev/PersistentIndex.hh"
|
|
#include "lev/Proxy.hh"
|
|
#include "lev/RatingManager.hh"
|
|
#include "errors.hh"
|
|
#include "gui/ErrorMenu.hh"
|
|
#include "main.hh"
|
|
#include "nls.hh"
|
|
#include "file.hh"
|
|
#include "options.hh"
|
|
#include "oxyd.hh"
|
|
#include "LocalToXML.hh"
|
|
#include "utilXML.hh"
|
|
#include "Utf8ToXML.hh"
|
|
#include "XMLtoUtf8.hh"
|
|
#include "ecl_system.hh"
|
|
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <set>
|
|
#include <xercesc/dom/DOM.hpp>
|
|
#include <xercesc/util/XMLException.hpp>
|
|
#include <xercesc/util/XMLDouble.hpp>
|
|
#include <xercesc/util/XMLString.hpp>
|
|
#include <xercesc/util/XMLUniDefs.hpp>
|
|
#include <xercesc/framework/MemBufInputSource.hpp>
|
|
#include <xercesc/framework/Wrapper4InputSource.hpp>
|
|
#include <xercesc/util/XercesVersion.hpp>
|
|
#if _XERCES_VERSION < 30000
|
|
#include <xercesc/framework/LocalFileFormatTarget.hpp>
|
|
#endif
|
|
|
|
using namespace std;
|
|
XERCES_CPP_NAMESPACE_USE
|
|
|
|
namespace enigma { namespace lev {
|
|
Variation::Variation(controlType ctrlValue, scoreUnitType unitValue,
|
|
std::string targetValue) : ctrl (ctrlValue),
|
|
unit (unitValue), target (targetValue) {
|
|
}
|
|
|
|
bool Variation::operator == (const Variation& otherVar) {
|
|
return ctrl == otherVar.ctrl && unit == otherVar.unit &&
|
|
target == otherVar.target && extensions == otherVar.extensions;
|
|
}
|
|
|
|
PersistentIndex * PersistentIndex::historyIndex = NULL;
|
|
std::vector<PersistentIndex *> PersistentIndex::indexCandidates;
|
|
|
|
void PersistentIndex::checkCandidate(PersistentIndex * candidate) {
|
|
if (candidate->getName().empty() ||
|
|
candidate->getCompatibility() > ENIGMACOMPATIBITLITY) {
|
|
delete candidate;
|
|
} else {
|
|
// check if new Index is an update of another
|
|
for (int i = 0; i < indexCandidates.size(); i++) {
|
|
if (indexCandidates[i]->getName() != candidate->getName()) {
|
|
continue;
|
|
} else if (indexCandidates[i]->getRelease() != candidate->getRelease() ||
|
|
indexCandidates[i]->getRevision() >= candidate->getRevision()) {
|
|
delete candidate;
|
|
return;
|
|
} else {
|
|
// it is an update
|
|
delete indexCandidates[i];
|
|
indexCandidates[i] = candidate;
|
|
return;
|
|
}
|
|
}
|
|
indexCandidates.push_back(candidate);
|
|
}
|
|
}
|
|
|
|
void PersistentIndex::registerPersistentIndices(bool onlySystemIndices) {
|
|
DirIter * dirIter;
|
|
DirEntry dirEntry;
|
|
|
|
// SysemPath: register dirs and zips with xml-indices
|
|
std::vector<std::string> sysPaths = app.systemFS->getPaths();
|
|
std::set<std::string> candidates;
|
|
std::set<std::string> candidates2;
|
|
for (int i = 0; i < sysPaths.size(); i++) {
|
|
dirIter = DirIter::instance(sysPaths[i] + "/levels");
|
|
while (dirIter->get_next(dirEntry)) {
|
|
if (dirEntry.is_dir && dirEntry.name != "." && dirEntry.name != ".." &&
|
|
dirEntry.name != ".svn" && dirEntry.name != "enigma_cross") {
|
|
candidates.insert(dirEntry.name);
|
|
}
|
|
else {
|
|
std::string::size_type zipPos = dirEntry.name.rfind(".zip");
|
|
if (zipPos != std::string::npos && zipPos == dirEntry.name.size() - 4) {
|
|
candidates.insert(dirEntry.name.substr(0, dirEntry.name.size() - 4));
|
|
}
|
|
}
|
|
}
|
|
delete dirIter;
|
|
}
|
|
|
|
for (std::set<std::string>::iterator i = candidates.begin();
|
|
i != candidates.end(); i++) {
|
|
// register the index just on the system path even if the
|
|
// user has an update on his path. We need to know the release to
|
|
// decide if a user copy is an update
|
|
PersistentIndex * anIndex = new PersistentIndex(*i, true);
|
|
anIndex->isUserOwned = false;
|
|
Log << "precheck: " << *i << "\n";
|
|
checkCandidate(anIndex);
|
|
}
|
|
|
|
//add system cross indices
|
|
for (int i = 0; i < sysPaths.size(); i++) {
|
|
dirIter = DirIter::instance(sysPaths[i] + "/levels/enigma_cross");
|
|
while (dirIter->get_next(dirEntry)) {
|
|
if (!dirEntry.is_dir && dirEntry.name.size() > 4 &&
|
|
(dirEntry.name.rfind(".xml") == dirEntry.name.size() - 4)) {
|
|
PersistentIndex * anIndex = new PersistentIndex("enigma_cross", true,
|
|
INDEX_DEFAULT_PACK_LOCATION, "", dirEntry.name);
|
|
anIndex->isUserOwned = false;
|
|
checkCandidate(anIndex);
|
|
}
|
|
}
|
|
}
|
|
delete dirIter;
|
|
|
|
if (onlySystemIndices)
|
|
return;
|
|
|
|
// UserPath: register dirs and zips with xml-indices excl auto
|
|
dirIter = DirIter::instance(app.userPath + "/levels");
|
|
while (dirIter->get_next(dirEntry)) {
|
|
if (dirEntry.is_dir && dirEntry.name != "." && dirEntry.name != ".." &&
|
|
dirEntry.name != ".svn" && dirEntry.name != "auto" &&
|
|
dirEntry.name != "cross" && dirEntry.name != "enigma_cross" &&
|
|
dirEntry.name != "legacy_dat") {
|
|
candidates2.insert(dirEntry.name);
|
|
}
|
|
else {
|
|
std::string::size_type zipPos = dirEntry.name.rfind(".zip");
|
|
if (zipPos != std::string::npos && zipPos == dirEntry.name.size() - 4) {
|
|
candidates2.insert(dirEntry.name.substr(0, dirEntry.name.size() - 4));
|
|
}
|
|
}
|
|
}
|
|
delete dirIter;
|
|
|
|
candidates2.insert("");
|
|
#ifdef __MINGW32__
|
|
// eliminate logical duplicates as Windows does not distinguish
|
|
// upper and lower case filenames but we can have e.g. an uppercase zip
|
|
// and a lower case dir
|
|
candidates2 = ecl::UniqueFilenameSet(candidates2);
|
|
#endif
|
|
for (std::set<std::string>::iterator i = candidates2.begin();
|
|
i != candidates2.end(); i++) {
|
|
PersistentIndex * anIndex = new PersistentIndex(*i, false);
|
|
checkCandidate(anIndex);
|
|
}
|
|
|
|
//add user cross indices
|
|
dirIter = DirIter::instance(app.userPath + "/levels/cross");
|
|
while (dirIter->get_next(dirEntry)) {
|
|
if (!dirEntry.is_dir && dirEntry.name.size() > 4 &&
|
|
(dirEntry.name.rfind(".xml") == dirEntry.name.size() - 4)) {
|
|
PersistentIndex * anIndex = new PersistentIndex("cross", false,
|
|
INDEX_DEFAULT_PACK_LOCATION, "", dirEntry.name);
|
|
checkCandidate(anIndex);
|
|
}
|
|
}
|
|
delete dirIter;
|
|
|
|
for (int i = 0; i < indexCandidates.size(); i++) {
|
|
Index::registerIndex(indexCandidates[i]);
|
|
}
|
|
|
|
// register auto not yet registered new files
|
|
PersistentIndex * autoIndex = new PersistentIndex("auto", false,
|
|
INDEX_AUTO_PACK_LOCATION, INDEX_AUTO_PACK_NAME);
|
|
autoIndex->isEditable = false;
|
|
dirIter = DirIter::instance(app.userPath + "/levels/auto");
|
|
while (dirIter->get_next(dirEntry)) {
|
|
if( !dirEntry.is_dir) {
|
|
if (dirEntry.name.size() > 4 && (
|
|
(dirEntry.name.rfind(".xml") == dirEntry.name.size() - 4) ||
|
|
(dirEntry.name.rfind(".lua") == dirEntry.name.size() - 4))) {
|
|
Proxy * newProxy = Proxy::autoRegisterLevel("auto",
|
|
dirEntry.name.substr(0, dirEntry.name.size() - 4));
|
|
if (newProxy != NULL) {
|
|
// first check that the proxy is not in the index
|
|
// - may occur if the level is stored as .xml and .lua in the folder
|
|
if (!autoIndex->containsProxy(newProxy)) {
|
|
// it is new, add it
|
|
autoIndex->appendProxy(newProxy);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
delete dirIter;
|
|
Index::registerIndex(autoIndex);
|
|
|
|
// check if history is available - else generate a new index
|
|
Index * foundHistory = Index::findIndex("History");
|
|
if ( foundHistory != NULL) {
|
|
historyIndex = dynamic_cast<PersistentIndex *>(foundHistory);
|
|
} else {
|
|
historyIndex = new PersistentIndex("cross", false, INDEX_HISTORY_PACK_LOCATION,
|
|
INDEX_HISTORY_PACK_NAME, "history.xml");
|
|
Index::registerIndex(historyIndex);
|
|
}
|
|
historyIndex->isEditable = false;
|
|
}
|
|
|
|
void PersistentIndex::addCurrentToHistory() {
|
|
Variation var;
|
|
Proxy * curProxy = Index::getCurrentProxy();
|
|
// remember all but commandline absolute and relative paths
|
|
if (curProxy->getNormPathType() != Proxy::pt_absolute) {
|
|
PersistentIndex * curIndex = dynamic_cast<PersistentIndex *>(Index::getCurrentIndex());
|
|
if (curIndex != NULL)
|
|
var = curIndex->getVariation(curIndex->getCurrentPosition());
|
|
historyIndex->insertProxy(0, curProxy, false, var.ctrl, var.unit,
|
|
var.target, var.extensions);
|
|
if (historyIndex->size() > 100)
|
|
historyIndex->erase(historyIndex->size() - 1);
|
|
historyIndex->setCurrentPosition(0); // last played is always current in history
|
|
}
|
|
}
|
|
|
|
PersistentIndex::PersistentIndex(std::string thePackPath, bool systemOnly,
|
|
double defaultLocation, std::string anIndexName,
|
|
std::string theIndexFilename, std::string aGroupName) :
|
|
Index(anIndexName, aGroupName, defaultLocation), packPath (thePackPath),
|
|
indexFilename(theIndexFilename), isModified (false),
|
|
isUserOwned (true), isEditable (true), release (1), revision (1),
|
|
compatibility (1.00), doc(NULL) {
|
|
// Log << "PersistentIndex AddLevelPack " << thePackPath << " - " << anIndexName << " - " << indexDefaultLocation <<"\n";
|
|
load(systemOnly);
|
|
}
|
|
|
|
void PersistentIndex::load(bool systemOnly, bool update) {
|
|
if (doc != NULL) {
|
|
doc->release();
|
|
doc = NULL;
|
|
}
|
|
// auto and new levelpacks are not loadable
|
|
if (packPath == " " || packPath == "auto")
|
|
return; // as long as Auto is not editable
|
|
|
|
std::auto_ptr<std::istream> isptr;
|
|
ByteVec indexCode;
|
|
std::string errMessage;
|
|
absIndexPath = "";
|
|
std::string relIndexPath = "levels/" + packPath + "/" + indexFilename;
|
|
if ((!systemOnly && app.resourceFS->findFile(relIndexPath, absIndexPath, isptr)) ||
|
|
(systemOnly && app.systemFS->findFile(relIndexPath, absIndexPath, isptr))) {
|
|
// preload index file or zipped index
|
|
if (isptr.get() != NULL) {
|
|
// zipped file
|
|
Readfile (*isptr, indexCode);
|
|
} else {
|
|
// plain file
|
|
std::basic_ifstream<char> ifs(absIndexPath.c_str(), ios::binary | ios::in);
|
|
Readfile(ifs, indexCode);
|
|
}
|
|
try {
|
|
std::ostringstream errStream;
|
|
app.domParserErrorHandler->resetErrors();
|
|
app.domParserErrorHandler->reportToOstream(&errStream);
|
|
app.domParserSchemaResolver->resetResolver();
|
|
app.domParserSchemaResolver->addSchemaId("index.xsd","index.xsd");
|
|
if (update) {
|
|
// local xml file or URL
|
|
doc = app.domParser->parseURI(indexUrl.c_str());
|
|
} else {
|
|
// preloaded xml or zipped xml
|
|
#if _XERCES_VERSION >= 30000
|
|
std::auto_ptr<DOMLSInput> domInputIndexSource ( new Wrapper4InputSource(
|
|
new MemBufInputSource(reinterpret_cast<const XMLByte *>(&(indexCode[0])),
|
|
indexCode.size(), absIndexPath.c_str(), false)));
|
|
doc = app.domParser->parse(domInputIndexSource.get());
|
|
#else
|
|
std::auto_ptr<Wrapper4InputSource> domInputIndexSource ( new Wrapper4InputSource(
|
|
new MemBufInputSource(reinterpret_cast<const XMLByte *>(&(indexCode[0])),
|
|
indexCode.size(), absIndexPath.c_str(), false)));
|
|
doc = app.domParser->parse(*domInputIndexSource);
|
|
#endif
|
|
}
|
|
|
|
if (doc != NULL && !app.domParserErrorHandler->getSawErrors()) {
|
|
infoElem = reinterpret_cast<DOMElement *>(doc->getElementsByTagName(
|
|
Utf8ToXML("info").x_str())->item(0));
|
|
updateElem = reinterpret_cast<DOMElement *>(doc->getElementsByTagName(
|
|
Utf8ToXML("update").x_str())->item(0));
|
|
levelsElem = reinterpret_cast<DOMElement *>(doc->getElementsByTagName(
|
|
Utf8ToXML("levels").x_str())->item(0));
|
|
}
|
|
|
|
if(app.domParserErrorHandler->getSawErrors()) {
|
|
errMessage = errStream.str();
|
|
}
|
|
app.domParserErrorHandler->reportToNull(); // do not report to errStream any more
|
|
}
|
|
catch (...) {
|
|
errMessage = "Unexpected XML Exception on load of index\n";
|
|
}
|
|
if (!errMessage.empty()) {
|
|
Log << errMessage; // make long error messages readable
|
|
std::string message;
|
|
if (update) {
|
|
message = _("Error on update of levelpack index: \n");
|
|
message += absIndexPath + "\n\n";
|
|
message += _("Note: the current version will be reloaded!\n\n");
|
|
message += errMessage;
|
|
} else {
|
|
if (doc != NULL) {
|
|
doc->release(); // empty or errornous doc
|
|
doc = NULL;
|
|
}
|
|
message = _("Error on registration of levelpack index: \n");
|
|
message += absIndexPath + "\n\n";
|
|
message += _("Note: the levelpack will not show up!\n\n");
|
|
message += errMessage;
|
|
}
|
|
gui::ErrorMenu m(message, N_("Continue"));
|
|
m.manage();
|
|
if (update) {
|
|
load(systemOnly, false); // reload local version
|
|
}
|
|
return;
|
|
} else if (doc != NULL) {
|
|
//TODO check if an updated index exists for system packs
|
|
loadDoc();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PersistentIndex::loadDoc() {
|
|
if (doc != NULL) {
|
|
clear(); // allow a reload of an index
|
|
indexName = XMLtoUtf8(infoElem->getAttribute(
|
|
Utf8ToXML("title").x_str())).c_str();
|
|
indexGroup = XMLtoUtf8(infoElem->getAttribute(
|
|
Utf8ToXML("group").x_str())).c_str();
|
|
defaultGroup = indexGroup;
|
|
owner = XMLtoUtf8(infoElem->getAttribute(
|
|
Utf8ToXML("owner").x_str())).c_str();
|
|
release = XMLString::parseInt(infoElem->getAttribute(
|
|
Utf8ToXML("release").x_str()));
|
|
revision = XMLString::parseInt(infoElem->getAttribute(
|
|
Utf8ToXML("revision").x_str()));
|
|
XMLDouble * result = new XMLDouble(infoElem->getAttribute(
|
|
Utf8ToXML("enigma").x_str()));
|
|
compatibility = result->getValue();
|
|
delete result;
|
|
result = new XMLDouble(infoElem->getAttribute(
|
|
Utf8ToXML("location").x_str()));
|
|
indexDefaultLocation = result->getValue();
|
|
indexLocation = indexDefaultLocation;
|
|
delete result;
|
|
|
|
if (updateElem != NULL) {
|
|
indexUrl = XMLtoUtf8(updateElem->getAttribute(
|
|
Utf8ToXML("indexurl").x_str())).c_str();
|
|
}
|
|
DOMNodeList *levelList = levelsElem->getElementsByTagName(
|
|
Utf8ToXML("level").x_str());
|
|
std::set<std::string> knownAttributes;
|
|
knownAttributes.insert("_seq");
|
|
knownAttributes.insert("_title");
|
|
knownAttributes.insert("_xpath");
|
|
knownAttributes.insert("id");
|
|
knownAttributes.insert("author");
|
|
knownAttributes.insert("score");
|
|
knownAttributes.insert("rel");
|
|
knownAttributes.insert("rev");
|
|
knownAttributes.insert("easy");
|
|
knownAttributes.insert("ctrl");
|
|
knownAttributes.insert("unit");
|
|
knownAttributes.insert("target");
|
|
for (int i = 0, l = levelList->getLength(); i < l; i++) {
|
|
DOMElement *levelElem = reinterpret_cast<DOMElement *>(levelList->item(i));
|
|
std::string path = XMLtoUtf8(levelElem->getAttribute(
|
|
Utf8ToXML("_xpath").x_str())).c_str();
|
|
std::string id = XMLtoUtf8(levelElem->getAttribute(
|
|
Utf8ToXML("id").x_str())).c_str();
|
|
std::string title = XMLtoUtf8(levelElem->getAttribute(
|
|
Utf8ToXML("_title").x_str())).c_str();
|
|
std::string author = XMLtoUtf8(levelElem->getAttribute(
|
|
Utf8ToXML("author").x_str())).c_str();
|
|
int scoreVersion = XMLString::parseInt(levelElem->getAttribute(
|
|
Utf8ToXML("score").x_str()));
|
|
int releaseVersion = XMLString::parseInt(levelElem->getAttribute(
|
|
Utf8ToXML("rel").x_str()));
|
|
int revisionVersion = XMLString::parseInt(levelElem->getAttribute(
|
|
Utf8ToXML("rev").x_str()));
|
|
bool hasEasymodeFlag = boolValue(levelElem->getAttribute(
|
|
Utf8ToXML("easy").x_str()));
|
|
Proxy * newProxy = Proxy::registerLevel(path, packPath, id, title,
|
|
author, scoreVersion, releaseVersion, hasEasymodeFlag,
|
|
GAMET_ENIGMA, STATUS_RELEASED, revisionVersion);
|
|
Variation var;
|
|
std::string controlString = XMLtoUtf8(levelElem->getAttribute(
|
|
Utf8ToXML("ctrl").x_str())).c_str();
|
|
if (controlString == "balance")
|
|
var.ctrl = balance;
|
|
else if (controlString == "key")
|
|
var.ctrl = key;
|
|
else if (controlString == "other")
|
|
var.ctrl = other;
|
|
std::string txt = XMLtoUtf8(levelElem->getAttribute(
|
|
Utf8ToXML("unit").x_str())).c_str();
|
|
if (txt == "number")
|
|
var.unit = number;
|
|
else
|
|
// default
|
|
var.unit = duration;
|
|
var.target = XMLtoUtf8(levelElem->getAttribute(
|
|
Utf8ToXML("target").x_str())).c_str();
|
|
DOMNamedNodeMap * attrMap = levelElem->getAttributes();
|
|
for (int j = 0, k = attrMap->getLength(); j < k; j++) {
|
|
DOMAttr * levelAttr = reinterpret_cast<DOMAttr *>(attrMap->item(j));
|
|
std::string attrName = XMLtoUtf8(levelAttr->getName()).c_str();
|
|
if (knownAttributes.find(attrName) == knownAttributes.end()) {
|
|
Log << "PersistentIndex Load unknown Attribut: " << attrName << "\n";
|
|
var.extensions[attrName]= XMLtoUtf8(levelAttr->getValue()).c_str();
|
|
}
|
|
|
|
}
|
|
appendProxy(newProxy, var.ctrl, var.unit, var.target, var.extensions);
|
|
}
|
|
}
|
|
}
|
|
|
|
PersistentIndex::~PersistentIndex() {
|
|
if (doc != NULL)
|
|
doc->release();
|
|
}
|
|
|
|
std::string PersistentIndex::getPackPath() {
|
|
return packPath;
|
|
}
|
|
|
|
bool PersistentIndex::setName(std::string newName) {
|
|
if (findIndex(newName) != NULL)
|
|
return false; // do not allow duplicate names
|
|
|
|
// substitute spaces by underscores
|
|
std::string fileName = newName;
|
|
std::string::size_type pos = fileName.find_first_of(' ', 0);
|
|
while (pos != std::string::npos) {
|
|
fileName.replace(pos, 1,"_");
|
|
pos = fileName.find_first_of(' ', pos+1);
|
|
}
|
|
|
|
if (packPath == " " || (packPath == "cross" && indexFilename == INDEX_STD_FILENAME)) {
|
|
// generate usabale path name and check it it usable
|
|
if (fileName == "cross" || fileName == "enigma_cross" ||
|
|
fileName == "legacy_dat" || fileName == "auto" ||
|
|
fileName == "history") {
|
|
return false;
|
|
}
|
|
// check if the name would conflict with existing files
|
|
std::auto_ptr<std::istream> isptr; // dummy
|
|
absIndexPath = "";
|
|
std::string relIndexPath1 = "levels/" + fileName + "/" + INDEX_STD_FILENAME;
|
|
std::string relIndexPath2 = "levels/cross/" + fileName + ".xml";
|
|
if (app.resourceFS->findFile(relIndexPath1, absIndexPath, isptr) ||
|
|
app.resourceFS->findFile(relIndexPath2, absIndexPath, isptr)) {
|
|
return false;
|
|
}
|
|
if (packPath == " ") {
|
|
packPath = fileName;
|
|
indexFilename = INDEX_STD_FILENAME;
|
|
} else
|
|
indexFilename = fileName + ".xml";
|
|
}
|
|
|
|
if (!getName().empty())
|
|
renameIndex(newName); // Index maps
|
|
else
|
|
// a new unregistered levelpack is named the first time - just set the name
|
|
indexName = newName;
|
|
return true;
|
|
}
|
|
|
|
bool PersistentIndex::isUpdatable() {
|
|
return (updateElem != NULL) && !indexUrl.empty();
|
|
}
|
|
|
|
bool PersistentIndex::isCross() {
|
|
return packPath == "cross" || packPath == "enigma_cross";
|
|
}
|
|
|
|
void PersistentIndex::markNewAsCross(){
|
|
if (packPath == " ")
|
|
packPath = "cross";
|
|
}
|
|
|
|
std::string PersistentIndex::getOwner() {
|
|
return owner;
|
|
}
|
|
|
|
void PersistentIndex::setOwner(std::string newOwner) {
|
|
owner = newOwner;
|
|
}
|
|
|
|
int PersistentIndex::getRelease() {
|
|
return release;
|
|
}
|
|
|
|
void PersistentIndex::setRelease(int newRelease) {
|
|
release = newRelease;
|
|
}
|
|
|
|
int PersistentIndex::getRevision() {
|
|
return revision;
|
|
}
|
|
|
|
void PersistentIndex::setRevision(int newRevision) {
|
|
revision = newRevision;
|
|
}
|
|
|
|
double PersistentIndex::getCompatibility() {
|
|
return compatibility;
|
|
}
|
|
|
|
void PersistentIndex::setCompatibility(double newCompatibility) {
|
|
compatibility = newCompatibility;
|
|
}
|
|
|
|
bool PersistentIndex::isUserEditable() {
|
|
return isEditable && (isUserOwned || WizardMode);
|
|
}
|
|
|
|
void PersistentIndex::clear() {
|
|
proxies.clear();
|
|
variations.clear();
|
|
currentPosition = 0;
|
|
}
|
|
|
|
void PersistentIndex::appendProxy(Proxy * newLevel, controlType varCtrl,
|
|
scoreUnitType varUnit, std::string varTarget,
|
|
std::map<std::string, std::string> varExtensions) {
|
|
proxies.push_back(newLevel);
|
|
|
|
Variation var(varCtrl, varUnit, varTarget);
|
|
var.extensions = varExtensions;
|
|
variations.push_back(var);
|
|
}
|
|
|
|
void PersistentIndex::insertProxy(int pos, Proxy * newLevel, bool allowDuplicates,
|
|
controlType varCtrl, scoreUnitType varUnit, std::string varTarget,
|
|
std::map<std::string, std::string> varExtensions) {
|
|
// TODO Assert pos >= size
|
|
|
|
Variation var(varCtrl, varUnit, varTarget);
|
|
var.extensions = varExtensions;
|
|
|
|
std::vector<Proxy *>::iterator itProxy = proxies.begin();
|
|
std::vector<Variation>::iterator itVar = variations.begin();
|
|
if (!allowDuplicates) {
|
|
// delete duplicates
|
|
while (itProxy != proxies.end()) {
|
|
if (*itProxy == newLevel && *itVar == var) {
|
|
// Log << "History Duplicat found\n";
|
|
itProxy = proxies.erase(itProxy);
|
|
itVar = variations.erase(itVar);
|
|
}
|
|
if (itProxy != proxies.end())
|
|
itProxy++; itVar++;
|
|
}
|
|
}
|
|
|
|
itProxy = proxies.begin();
|
|
itVar = variations.begin();
|
|
for (int i = 0; i < pos; i++) {
|
|
itProxy++; itVar++;
|
|
}
|
|
proxies.insert(itProxy, newLevel);
|
|
variations.insert(itVar, var);
|
|
}
|
|
|
|
Variation PersistentIndex::getVariation(int pos) {
|
|
// TODO Assert pos
|
|
return variations[pos];
|
|
}
|
|
|
|
void PersistentIndex::erase(int pos) {
|
|
std::vector<Proxy *>::iterator itProxy = proxies.begin();
|
|
std::vector<Variation>::iterator itVar = variations.begin();
|
|
for (int i = 0; i < pos; i++) {
|
|
itProxy++; itVar++;
|
|
}
|
|
proxies.erase(itProxy);
|
|
variations.erase(itVar);
|
|
}
|
|
|
|
void PersistentIndex::exchange(int pos1, int pos2) {
|
|
Proxy * proxy = proxies[pos1];
|
|
proxies[pos1] = proxies[pos2];
|
|
proxies[pos2] = proxy;
|
|
Variation var = variations[pos1];
|
|
variations[pos1] = variations[pos2];
|
|
variations[pos2] = var;
|
|
if (getCurrentPosition() == pos1)
|
|
setCurrentPosition(pos2);
|
|
else if (getCurrentPosition() == pos2)
|
|
setCurrentPosition(pos1);
|
|
}
|
|
|
|
bool PersistentIndex::isSource(Proxy * aProxy) {
|
|
std::string proxyPath = aProxy->getNormLevelPath();
|
|
if (proxyPath[0] == '#')
|
|
// Oxyd reference
|
|
return false;
|
|
else if (packPath.empty()) {
|
|
// old levelpack on levels directory
|
|
if (proxyPath.find('/') == std::string::npos)
|
|
return true;
|
|
else
|
|
return false;
|
|
} else {
|
|
if (proxyPath.find(packPath + "/") == 0)
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool PersistentIndex::save(bool allowOverwrite) {
|
|
bool result = true;
|
|
|
|
if (doc == NULL) {
|
|
std::string errMessage;
|
|
std::string indexTemplatePath;
|
|
if (app.systemFS->findFile( "schemas/index.xml" , indexTemplatePath)) {
|
|
try {
|
|
std::ostringstream errStream;
|
|
app.domParserErrorHandler->resetErrors();
|
|
app.domParserErrorHandler->reportToOstream(&errStream);
|
|
app.domParserSchemaResolver->resetResolver();
|
|
app.domParserSchemaResolver->addSchemaId("index.xsd","index.xsd");
|
|
doc = app.domParser->parseURI(indexTemplatePath.c_str());
|
|
if (doc != NULL && !app.domParserErrorHandler->getSawErrors()) {
|
|
infoElem = reinterpret_cast<DOMElement *>(doc->getElementsByTagName(
|
|
Utf8ToXML("info").x_str())->item(0));
|
|
levelsElem = reinterpret_cast<DOMElement *>(doc->getElementsByTagName(
|
|
Utf8ToXML("levels").x_str())->item(0));
|
|
}
|
|
if(app.domParserErrorHandler->getSawErrors()) {
|
|
errMessage = errStream.str();
|
|
}
|
|
app.domParserErrorHandler->reportToNull(); // do not report to errStream any more
|
|
}
|
|
catch (...) {
|
|
errMessage = "Unexpected XML Exception on load of index\n";
|
|
}
|
|
if (!errMessage.empty()) {
|
|
if (doc != NULL) {
|
|
doc->release(); // empty or errornous doc
|
|
doc = NULL;
|
|
}
|
|
Log << errMessage; // make long error messages readable
|
|
return false;
|
|
}
|
|
} else
|
|
// TODO add error handling
|
|
return false;
|
|
}
|
|
|
|
//
|
|
|
|
infoElem->setAttribute( Utf8ToXML("title").x_str(),
|
|
Utf8ToXML(&indexName).x_str());
|
|
infoElem->setAttribute( Utf8ToXML("group").x_str(),
|
|
Utf8ToXML(&defaultGroup).x_str());
|
|
infoElem->setAttribute( Utf8ToXML("owner").x_str(),
|
|
Utf8ToXML(&owner).x_str());
|
|
infoElem->setAttribute( Utf8ToXML("release").x_str(),
|
|
Utf8ToXML(ecl::strf("%d",release)).x_str());
|
|
infoElem->setAttribute( Utf8ToXML("revision").x_str(),
|
|
Utf8ToXML(ecl::strf("%d",revision)).x_str());
|
|
infoElem->setAttribute( Utf8ToXML("enigma").x_str(),
|
|
Utf8ToXML(ecl::strf("%.2f",compatibility)).x_str());
|
|
infoElem->setAttribute( Utf8ToXML("location").x_str(),
|
|
Utf8ToXML(ecl::strf("%g",indexDefaultLocation)).x_str());
|
|
DOMNodeList *levelsChildList = levelsElem->getChildNodes();
|
|
int levelsChildCount = levelsChildList->getLength();
|
|
// delete no more used level elements
|
|
for (int i = 0; i < levelsChildCount; i++) {
|
|
// delete all elements of list, as the list is dynamically updated -
|
|
// we can not recycle level elements as they may be reordered and
|
|
// their attributes are not identical
|
|
levelsElem->removeChild(levelsChildList->item(0));
|
|
}
|
|
DOMElement * levelElem;
|
|
// add level elements
|
|
for (int i = 0; i < size(); i++) {
|
|
// add a new element
|
|
levelElem = doc->createElement(Utf8ToXML("level").x_str());
|
|
levelsElem->appendChild(levelElem); // insert it at the end
|
|
|
|
Proxy * level = getProxy(i);
|
|
// convert Proxy normLevelPath to pack local path ./* if possible
|
|
std::string xpath = level->getNormLevelPath();
|
|
if (xpath.find(packPath + "/") == 0)
|
|
xpath = "." + xpath.substr(packPath.size());
|
|
else if (packPath.empty() && xpath.find("/") == std::string::npos)
|
|
xpath = "./" + xpath;
|
|
levelElem->setAttribute( Utf8ToXML("_xpath").x_str(),
|
|
Utf8ToXML(xpath).x_str());
|
|
levelElem->setAttribute( Utf8ToXML("id").x_str(),
|
|
Utf8ToXML(level->getId()).x_str());
|
|
levelElem->setAttribute( Utf8ToXML("_title").x_str(),
|
|
Utf8ToXML(level->getTitle()).x_str());
|
|
levelElem->setAttribute( Utf8ToXML("author").x_str(),
|
|
Utf8ToXML(level->getAuthor()).x_str());
|
|
levelElem->setAttribute( Utf8ToXML("score").x_str(),
|
|
Utf8ToXML(ecl::strf("%d",level->getScoreVersion())).x_str());
|
|
levelElem->setAttribute( Utf8ToXML("rel").x_str(),
|
|
Utf8ToXML(ecl::strf("%d",level->getReleaseVersion())).x_str());
|
|
levelElem->setAttribute( Utf8ToXML("rev").x_str(),
|
|
Utf8ToXML(ecl::strf("%d",level->getRevisionNumber())).x_str());
|
|
levelElem->setAttribute( Utf8ToXML("easy").x_str(),
|
|
Utf8ToXML(level->hasEasymode() ? "true" : "false").x_str());
|
|
std::string control;
|
|
switch (variations[i].ctrl) {
|
|
case lev::force:
|
|
control = "force"; break;
|
|
case lev::balance:
|
|
control = "balance"; break;
|
|
case lev::key:
|
|
control = "key"; break;
|
|
default:
|
|
control = "other"; break;
|
|
}
|
|
levelElem->setAttribute( Utf8ToXML("ctrl").x_str(),
|
|
Utf8ToXML(control).x_str());
|
|
std::string unit;
|
|
switch (variations[i].unit) {
|
|
case lev::duration:
|
|
unit = "duration"; break;
|
|
case lev::number:
|
|
unit = "number"; break;
|
|
}
|
|
levelElem->setAttribute( Utf8ToXML("unit").x_str(),
|
|
Utf8ToXML(unit).x_str());
|
|
levelElem->setAttribute( Utf8ToXML("target").x_str(),
|
|
Utf8ToXML(variations[i].target).x_str());
|
|
for (std::map<std::string, std::string>::iterator j= variations[i].extensions.begin();
|
|
j != variations[i].extensions.end(); j++) {
|
|
// Log << "Persistent save extension: " << (*j).first << " - " << (*j).second << "\n";
|
|
levelElem->setAttribute( Utf8ToXML((*j).first).x_str(),
|
|
Utf8ToXML((*j).second).x_str());
|
|
}
|
|
}
|
|
|
|
// update the sequence number of the levels
|
|
DOMNodeList *levList = levelsElem->getElementsByTagName(
|
|
Utf8ToXML("level").x_str());
|
|
for (int i = 0, l = levList-> getLength(); i < l; i++) {
|
|
DOMElement *levElem = reinterpret_cast<DOMElement *>(levList->item(i));
|
|
levElem->setAttribute( Utf8ToXML("_seq").x_str(),
|
|
Utf8ToXML(ecl::strf("%d",i+1)).x_str());
|
|
}
|
|
|
|
stripIgnorableWhitespace(doc->getDocumentElement());
|
|
|
|
std::string path = app.userPath + "/levels/" + packPath + "/" + indexFilename;
|
|
if (allowOverwrite || !ecl::FileExists(path)) {
|
|
try {
|
|
// auto-create the directory if necessary
|
|
std::string directory;
|
|
if (ecl::split_path (path, &directory, 0) && !ecl::FolderExists(directory)) {
|
|
ecl::FolderCreate (directory);
|
|
}
|
|
|
|
#if _XERCES_VERSION >= 30000
|
|
result = app.domSer->writeToURI(doc, LocalToXML(& path).x_str());
|
|
#else
|
|
XMLFormatTarget *myFormTarget = new LocalFileFormatTarget(path.c_str());
|
|
result = app.domSer->writeNode(myFormTarget, *doc);
|
|
delete myFormTarget; // flush
|
|
#endif
|
|
}
|
|
catch (const XMLException& toCatch) {
|
|
char* message = XMLString::transcode(toCatch.getMessage());
|
|
cerr << "Exception on save of index: "
|
|
<< message << "\n";
|
|
XMLString::release(&message);
|
|
result = false;
|
|
}
|
|
catch (const DOMException& toCatch) {
|
|
char* message = XMLString::transcode(toCatch.msg);
|
|
cerr << "Exception on save of index: "
|
|
<< message << "\n";
|
|
XMLString::release(&message);
|
|
result = false;
|
|
}
|
|
catch (...) {
|
|
cerr << "Unexpected exception on save of index\n" ;
|
|
result = false;
|
|
}
|
|
if (!result)
|
|
Log << "Index save fault on " << path << " \n";
|
|
else
|
|
Log << "Index save " << path << " o.k.\n";
|
|
} else
|
|
result = false;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
PersistentIndex::PersistentIndex(std::istream *legacyIndexStream,
|
|
std::string thePackPath, bool isZip, std::string anIndexName,
|
|
std::string theIndexFilename) :
|
|
Index(anIndexName, INDEX_DEFAULT_GROUP, Index::getNextUserLocation()),
|
|
indexFilename(theIndexFilename), isModified (false),
|
|
isUserOwned (true), isEditable (true), release (1), revision (1),
|
|
compatibility (1.00), doc(NULL) {
|
|
Log << "PersistentIndex convert 0.92 index " << thePackPath << " - " << anIndexName <<"\n";
|
|
lev::RatingManager *theRatingMgr = lev::RatingManager::instance();
|
|
|
|
// prepare Proxy coding of pack path -
|
|
if (thePackPath == "levels")
|
|
packPath = "";
|
|
else {
|
|
// cut off leading "levels/"
|
|
packPath = thePackPath.substr(7);
|
|
}
|
|
|
|
int linenumber = 0;
|
|
try {
|
|
std::string line;
|
|
while (std::getline(*legacyIndexStream, line)) {
|
|
using namespace std;
|
|
using namespace ecl;
|
|
|
|
string filename = ""; //< Filename of the level (exl. extension)
|
|
string indexname = ""; //< The name used in the options file,
|
|
// empty string -> use filename entry
|
|
string name = ""; //< Complete name of the level
|
|
string author = ""; //< Author of the level
|
|
int revision = 1; //< Revision # of this level
|
|
bool has_easymode = false; //< whether level has an easymode
|
|
int par_time_easy = -1 ; //< Best time in seconds (for easy mode)
|
|
int par_time_normal = -1; //< Best time in seconds (for normal mode)
|
|
string par_time_easy_by = ""; //< player name(s) for 'best_time_easy'
|
|
string par_time_normal_by = ""; //< same for 'best_time_normal'
|
|
int par_moves = -1; //< Minimum moves to solve level
|
|
int intelligence = 0;
|
|
int dexterity = 0;
|
|
int patience = 0;
|
|
int knowledge = 0 ;
|
|
int speed = 0;
|
|
|
|
++linenumber;
|
|
|
|
const char *wspace = " \t";
|
|
size_t p = line.find_first_not_of(wspace);
|
|
|
|
if (p == string::npos || line.at(p) != '{')
|
|
continue;
|
|
|
|
// found a level description
|
|
|
|
int par_time = -1;
|
|
string par_time_by;
|
|
string par_moves_by;
|
|
|
|
++p;
|
|
while (true) {
|
|
string tag;
|
|
string content;
|
|
|
|
// ugly parser code starts here.
|
|
// - it parses 'tag = content' or 'tag = "content"'
|
|
// - '\"' is allowed in '"content"'
|
|
// - whitespace is ignored
|
|
// - sets message and breaks while loop in case of error
|
|
size_t tag_start = line.find_first_not_of(wspace, p);
|
|
Assert <XLevelPackInit> (tag_start != string::npos, "Expected tag or '}'");
|
|
if (line.at(tag_start) == '}') break; // line done
|
|
|
|
size_t equal = line.find('=', tag_start);
|
|
Assert <XLevelPackInit> (equal != string::npos, "'=' expected");
|
|
Assert <XLevelPackInit> (equal != tag_start, "empty tag");
|
|
|
|
size_t tag_end = line.find_last_not_of(wspace, equal-1);
|
|
tag = line.substr(tag_start, tag_end-tag_start+1);
|
|
|
|
size_t content_start = line.find_first_not_of(wspace, equal+1);
|
|
if (line.at(content_start) == '\"') { // content in ""
|
|
size_t oquote = line.find('\"', content_start+1);
|
|
bool have_escapes = false;
|
|
while (oquote != string::npos && line.at(oquote-1) == '\\') { // step over \"
|
|
oquote = line.find('\"', oquote+1);
|
|
have_escapes = true;
|
|
}
|
|
Assert <XLevelPackInit> (oquote != string::npos, "unmatched quote");
|
|
content = line.substr(content_start+1, oquote-content_start-1);
|
|
if (have_escapes) {
|
|
size_t esc;
|
|
while ((esc = content.find("\\\"")) != string::npos)
|
|
content.replace(esc, 2, "\"");
|
|
}
|
|
p = oquote+1;
|
|
}
|
|
else { // content w/o ""
|
|
size_t content_end = line.find_first_of(" \t}", content_start);
|
|
Assert <XLevelPackInit> (content_end != string::npos, "expected space or } behind content");
|
|
content = line.substr(content_start, content_end-content_start);
|
|
p = content_end;
|
|
}
|
|
|
|
if (tag == "file") filename = content;
|
|
else if (tag == "indexname")indexname = content;
|
|
else if (tag == "name") name = content;
|
|
else if (tag == "author") author = content;
|
|
else if (tag == "revision") revision = atoi(content.c_str());
|
|
else if (tag == "easymode") has_easymode = (content == "1");
|
|
else if (tag == "int") intelligence = atoi(content.c_str());
|
|
else if (tag == "dex") dexterity = atoi(content.c_str());
|
|
else if (tag == "pat") patience = atoi(content.c_str());
|
|
else if (tag == "kno") knowledge = atoi(content.c_str());
|
|
else if (tag == "spe") speed = atoi(content.c_str());
|
|
else if (tag == "par_time") parsePar(content, par_time, par_time_by);
|
|
else if (tag == "par_time_easy") parsePar(content, par_time_easy, par_time_easy_by);
|
|
else if (tag == "par_time_normal") parsePar(content, par_time_normal, par_time_normal_by);
|
|
else if (tag == "par_moves") parsePar(content, par_moves, par_moves_by);
|
|
// else if (tag == "hint1") hint1 = content;
|
|
// else if (tag == "hint2") hint2 = content;
|
|
else
|
|
throw XLevelPackInit(strf("unknown tag '%s'", tag.c_str()));
|
|
}
|
|
|
|
Assert <XLevelPackInit> (filename.length() != 0,
|
|
"mandatory tag 'file' missing");
|
|
|
|
if (has_easymode) {
|
|
Assert <XLevelPackInit> (par_time == -1,
|
|
"'par_time' not allowed when easymode=1 "
|
|
"(use 'par_time_easy' and 'par_time_normal')");
|
|
}
|
|
else {
|
|
Assert <XLevelPackInit> (par_time_normal==-1 && par_time_easy==-1,
|
|
"'par_time_easy' and 'par_time_normal' are not allowed when easymode=0 (use 'par_time')");
|
|
par_time_easy = par_time_normal = par_time;
|
|
par_time_easy_by = par_time_normal_by = par_time_by;
|
|
}
|
|
|
|
// correct filename for zip
|
|
if (isZip) {
|
|
Log << "Zip " << thePackPath << " - " <<packPath << " - " << indexname << "\n";
|
|
if (filename.find('/') == std::string::npos) {
|
|
// it is an old zip file with plain levelnames as filename
|
|
if (indexname.empty()) {
|
|
// keep id
|
|
indexname = filename;
|
|
}
|
|
// add the zip basename to get the complete path to the level
|
|
filename = packPath + "/" + filename;
|
|
}
|
|
} else if (linenumber == 1 && packPath.empty()) {
|
|
// a std index.txt on levels dir - we need to guess location of pack
|
|
// we take the dir of the first level
|
|
std::string::size_type n = filename.rfind('/');
|
|
if (n != std::string::npos) {
|
|
packPath = filename.substr(0, n);
|
|
// Log << "Index convert pack '" << anIndexName << "' - guess pack directory is '"
|
|
// << packPath << "'\n";
|
|
}
|
|
}
|
|
|
|
// register Proxy
|
|
appendProxy(Proxy::registerLevel(filename, packPath,
|
|
(indexname.empty() ? filename : indexname), name, author,
|
|
revision, revision, has_easymode, GAMET_ENIGMA));
|
|
theRatingMgr->registerRating((indexname.empty() ? filename : indexname),
|
|
revision, intelligence, dexterity, patience, knowledge, speed,
|
|
par_time_easy, par_time_easy_by, par_time_normal, par_time_normal_by);
|
|
|
|
}
|
|
} catch (const XLevelPackInit &e) {
|
|
std::string xerror = ecl::strf("in line %i: %s", linenumber, e.what());
|
|
throw XLevelPackInit (xerror);
|
|
}
|
|
|
|
// convert to XML
|
|
|
|
updateFromProxies();
|
|
|
|
// save but do not overwrite existing index.xml - would be a second conversion,
|
|
// but the user may already have modified the index.xml
|
|
save(false);
|
|
}
|
|
|
|
void PersistentIndex::parsePar(const string& par, int& par_value, std::string& par_text)
|
|
{
|
|
// 'par' is in format "value,text"
|
|
// The value is stored in 'par_value' and the text in 'par_text'.
|
|
using namespace std;
|
|
using namespace ecl;
|
|
|
|
size_t comma = par.find(',');
|
|
Assert<XLevelPackInit> (comma!=string::npos, "Comma expected in par");
|
|
|
|
string value = par.substr(0, comma);
|
|
par_text = par.substr(comma+1);
|
|
par_value = atoi(value.c_str());
|
|
}
|
|
|
|
void AddLevelPack (const char *init_file, const char *indexName) {
|
|
// Log << "Index AddLevelPack " << init_file << "\n";
|
|
if (Index::findIndex(indexName) == NULL) {
|
|
std::string absPath;
|
|
if (app.resourceFS->findFile(init_file, absPath)) {
|
|
try {
|
|
std::string path = init_file;
|
|
std::string dir = "";
|
|
std::string filename = "";
|
|
ecl::split_path(path, &dir, &filename);
|
|
std::ifstream is(absPath.c_str());
|
|
|
|
if (!is)
|
|
throw XLevelPackInit ("Cannot open index file");
|
|
Index::registerIndex(new PersistentIndex(&is, dir, false, indexName));
|
|
} catch (const XLevelPackInit &e) {
|
|
Log << e.get_string() << "\n";
|
|
}
|
|
} else {
|
|
Log << "Could not find level index file `" << init_file << "'\n";
|
|
}
|
|
} else {
|
|
// Log << "Ignored index file `" << init_file << "' - already converted to XML\n";
|
|
}
|
|
}
|
|
|
|
void AddZippedLevelPack (const char *zipfile) {
|
|
// Log << "Index AddZippedLevelPack " << zipfile << "\n";
|
|
using namespace std;
|
|
using namespace ecl;
|
|
string absPath;
|
|
if (app.resourceFS->findFile (zipfile, absPath)) {
|
|
// the index file as it would be for a unpacked zip
|
|
std::string zf = zipfile;
|
|
std::string dir = zf.substr(0, zf.rfind('.'));
|
|
std::string indexfile = dir + "/index.txt";
|
|
try {
|
|
auto_ptr<istream> isptr;
|
|
std::string dummy;
|
|
if(!app.resourceFS->findFile(indexfile, dummy, isptr))
|
|
throw XLevelPackInit ("No index in level pack: ");
|
|
|
|
istream &is = *isptr;
|
|
|
|
string line;
|
|
std::string indexName;
|
|
if (getline(is, line)) {
|
|
// we read the index in binary mode and have to strip of the \n for
|
|
// windows
|
|
if (line[line.size()-1] = '\n') {
|
|
line.resize(line.size()-1);
|
|
}
|
|
indexName = line;
|
|
|
|
// check if already loaded
|
|
|
|
Index::registerIndex(new PersistentIndex(isptr.get(), dir, true, indexName));
|
|
}
|
|
else {
|
|
throw XLevelPackInit ("Invalid level pack: " + indexName);
|
|
}
|
|
}
|
|
catch (std::exception &) {
|
|
throw XLevelPackInit ("Error reading from .zip file: " + indexfile);
|
|
}
|
|
} else {
|
|
enigma::Log << "Could not find zip file `" << zipfile << "'\n";
|
|
}
|
|
}
|
|
|
|
}} // namespace enigma::lev
|