WINTERMUTE: Avoid starting up the engine to perform detection.

engines/wintermute/base/base_file_manager.cpp

@@ -27,8 +27,6 @@
  */
 
 #include "engines/wintermute/base/base_file_manager.h"
-#include "engines/wintermute/utils/string_util.h"
-#include "engines/wintermute/utils/path_util.h"
 #include "engines/wintermute/base/file/base_disk_file.h"
 #include "engines/wintermute/base/file/base_save_thumb_file.h"
 #include "engines/wintermute/base/file/base_file_entry.h"
@@ -37,9 +35,8 @@
 #include "engines/wintermute/base/file/base_resources.h"
 #include "engines/wintermute/base/base_registry.h"
 #include "engines/wintermute/base/base_game.h"
-#include "engines/wintermute/dcpackage.h"
+#include "engines/wintermute/base/file/dcpackage.h"
 #include "engines/wintermute/utils/utils.h"
-#include "engines/wintermute/platform_osystem.h"
 #include "engines/wintermute/wintermute.h"
 #include "common/str.h"
 #include "common/textconsole.h"
@@ -58,12 +55,11 @@ namespace WinterMute {
 //////////////////////////////////////////////////////////////////////
 
 //////////////////////////////////////////////////////////////////////
-BaseFileManager::BaseFileManager(BaseGame *inGame): BaseClass(inGame) {
+BaseFileManager::BaseFileManager(BaseGame *inGame) : _gameRef(inGame) {
 	initPaths();
 	registerPackages();
 }
 
-
 //////////////////////////////////////////////////////////////////////
 BaseFileManager::~BaseFileManager() {
 	cleanup();
@@ -207,6 +203,9 @@ bool BaseFileManager::reloadPaths() {
 #define TEMP_BUFFER_SIZE 32768
 //////////////////////////////////////////////////////////////////////////
 bool BaseFileManager::initPaths() {
+	if (!_gameRef) // This function only works when the game-registry is loaded
+		return STATUS_FAILED;
+
 	AnsiString pathList;
 	int numPaths;
 
@@ -506,6 +505,8 @@ Common::SeekableReadStream *BaseFileManager::openFileRaw(const Common::String &f
 	Common::SeekableReadStream *ret = NULL;
 
 	if (scumm_strnicmp(filename.c_str(), "savegame:", 9) == 0) {
+		if (!_gameRef)
+			error("Attempt to load filename: %s without BaseGame-object, this is unsupported", filename.c_str());
 		BaseSaveThumbFile *SaveThumbFile = new BaseSaveThumbFile(_gameRef);
 		if (DID_SUCCEED(SaveThumbFile->open(filename))) {
 			ret = SaveThumbFile->getMemStream();

engines/wintermute/base/base_file_manager.h

@@ -29,20 +29,17 @@
 #ifndef WINTERMUTE_BFILEMANAGER_H
 #define WINTERMUTE_BFILEMANAGER_H
 
-#include "engines/wintermute/base/base.h"
-#include "engines/wintermute/base/file/base_package.h"
 #include "common/archive.h"
 #include "common/str.h"
 #include "common/fs.h"
-
-namespace Common {
-class File;
-}
+#include "common/file.h"
 
 namespace WinterMute {
 class BaseFile;
 class BaseFileEntry;
-class BaseFileManager: BaseClass {
+class BaseGame;
+class BasePackage;
+class BaseFileManager {
 public:
 	bool cleanup();
 
@@ -77,6 +74,7 @@ private:
 	bool findPackageSignature(Common::SeekableReadStream *f, uint32 *offset);
 	bool registerPackage(Common::FSNode package, const Common::String &filename = "", bool searchSignature = false);
 //	bool registerPackage(const Common::String &filename, bool searchSignature = false);
+	BaseGame *_gameRef;
 	Common::Array<BasePackage *> _packages;
 	Common::Array<Common::SeekableReadStream *> _openFiles;
 	Common::HashMap<Common::String, BaseFileEntry *> _files;

engines/wintermute/base/file/base_package.cpp

@@ -57,10 +57,10 @@ BasePackage::~BasePackage() {
 
 //////////////////////////////////////////////////////////////////////////
 bool BasePackage::open() {
-	if (_file) return STATUS_OK;
+	if (_file) return true;
 	else {
 		_file = getFilePointer();
-		return _file ? STATUS_OK : STATUS_FAILED;
+		return _file ? true : false;
 	}
 }
 
@@ -69,18 +69,18 @@ bool BasePackage::open() {
 bool BasePackage::close() {
 	delete _file;
 	_file = NULL;
-	return STATUS_OK;
+	return true;
 }
 
 
 //////////////////////////////////////////////////////////////////////////
 bool BasePackage::read(Common::SeekableReadStream *file, uint32 offset, byte *buffer, uint32 size) {
 	bool ret;
-	if (DID_FAIL(ret = open())) return ret;
+	if (!(ret = open())) return ret;
 	else {
-		if (file->seek(offset, SEEK_SET)) return STATUS_FAILED;
-		if (file->read(buffer, size) != 1) return STATUS_FAILED;
-		else return STATUS_OK;
+		if (file->seek(offset, SEEK_SET)) return false;
+		if (file->read(buffer, size) != 1) return false;
+		else return true;
 	}
 }
 

engines/wintermute/base/gfx/base_image.cpp

@@ -82,14 +82,14 @@ bool BaseImage::loadFile(const Common::String &filename) {
 	}
 	_filename = filename;
 	Common::SeekableReadStream *file = _fileManager->openFile(filename.c_str());
-	if (!file) return STATUS_FAILED;
+	if (!file) return false;
 
 	_decoder->loadStream(*file);
 	_surface = _decoder->getSurface();
 	_palette = _decoder->getPalette();
 	_fileManager->closeFile(file);
 
-	return STATUS_OK;
+	return true;
 }
 
 byte BaseImage::getAlphaAt(int x, int y) {
@@ -113,7 +113,7 @@ bool BaseImage::saveBMPFile(const char *filename) {
 	if (FreeImage_Save(FIF_BMP, _bitmap, filename)) return STATUS_OK;
 	else return STATUS_FAILED;
 #endif
-	return STATUS_FAILED;
+	return false;
 }
 
 
@@ -133,7 +133,7 @@ bool BaseImage::resize(int newWidth, int newHeight) {
 		return STATUS_OK;
 	} else return STATUS_FAILED;
 #endif
-	return STATUS_FAILED;
+	return false;
 }
 
 
@@ -258,7 +258,7 @@ bool BaseImage::copyFrom(BaseImage *origImage, int newWidth, int newHeight) {
 		_deletableSurface = NULL;
 	}
 	_surface = _deletableSurface = temp.scale(newWidth, newHeight);
-	return STATUS_OK;
+	return true;
 }
 
 } // end of namespace WinterMute

engines/wintermute/wintermute.cpp

@@ -343,15 +343,51 @@ void WinterMuteEngine::deinit() {
 bool WinterMuteEngine::getGameInfo(const Common::FSList &fslist, Common::String &name, Common::String &caption) {
 	bool retVal = false;
 	caption = name = "(invalid)";
-	
+	Common::SeekableReadStream *stream = NULL;
 	// Quick-fix, instead of possibly breaking the persistence-system, let's just roll with it
-	WinterMuteEngine *engine = new WinterMuteEngine();
-	
-	engine->_game->initialize1();
-	engine->_game->_fileManager->registerPackages(fslist);
-	if (engine->_game->loadSettings("startup.settings")) {
+	BaseFileManager *fileMan = new BaseFileManager();
+	fileMan->registerPackages(fslist);
+	stream = fileMan->openFile("startup.settings", false, false);
+
+	// The process is as follows: Check the "GAME=" tag in startup.settings, to decide where the
+	// game-settings are (usually "default.game"), then look into the game-settings to find
+	// the NAME = and CAPTION = tags, to use them to generate a gameid and extras-field
+
+	Common::String settingsGameFile = "default.game";
+	// If the stream-open failed, lets at least attempt to open the default game file afterwards
+	// so, we don't call it a failure yet.
+	if (stream) {
+		while (!stream->eos() && !stream->err()) {
+			Common::String line = stream->readLine();
+			line.trim(); // Get rid of indentation
+			// Expect "SETTINGS {" or comment, or empty line
+			if (line.size() == 0 || line[0] == ';' || (line.contains("{")))
+				continue;
+			else {
+				// We are looking for "GAME ="
+				Common::StringTokenizer token(line, "=");
+				Common::String key = token.nextToken();
+				Common::String value = token.nextToken();
+				if (value.size() == 0)
+					continue;
+				if (value[0] == '\"')
+					value.deleteChar(0);
+				else
+					continue;
+				if (value.lastChar() == '\"')
+					value.deleteLastChar();
+				if (key == "GAME") {
+					settingsGameFile = value;
+					break;
+				}
+			}
+		}
+	}
+
+	delete stream;
+	stream = fileMan->openFile(settingsGameFile, false, false);
+	if (stream) {
 		// We do some manual parsing here, as the engine needs gfx to be initalized to do that.
-		Common::SeekableReadStream *stream = engine->_game->_fileManager->openFile((engine->_game->_settingsGameFile ? engine->_game->_settingsGameFile : "default.game"), false, false);
 		while (!stream->eos() && !stream->err()) {
 			Common::String line = stream->readLine();
 			line.trim(); // Get rid of indentation
@@ -381,7 +417,7 @@ bool WinterMuteEngine::getGameInfo(const Common::FSList &fslist, Common::String
 		}
 		delete stream;
 	}
-	delete engine;
+	delete fileMan;
 	return retVal;
 }