2012-04-19 16:48:48 +00:00
|
|
|
/* ScummVM - Graphic Adventure Engine
|
|
|
|
*
|
|
|
|
* ScummVM is the legal property of its developers, whose names
|
|
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
|
|
* file distributed with this source distribution.
|
|
|
|
*
|
|
|
|
* 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.
|
2012-05-11 14:03:59 +00:00
|
|
|
|
2012-04-19 16:48:48 +00:00
|
|
|
* 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.
|
2012-05-11 14:03:59 +00:00
|
|
|
|
2012-04-19 16:48:48 +00:00
|
|
|
* 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 "common/scummsys.h"
|
|
|
|
|
|
|
|
#include "common/config-manager.h"
|
|
|
|
#include "common/debug.h"
|
|
|
|
#include "common/debug-channels.h"
|
|
|
|
#include "common/error.h"
|
|
|
|
#include "common/EventRecorder.h"
|
|
|
|
#include "common/file.h"
|
|
|
|
#include "common/fs.h"
|
|
|
|
|
|
|
|
#include "engines/util.h"
|
2012-06-01 23:17:46 +00:00
|
|
|
#include "engines/wintermute/Ad/AdGame.h"
|
2012-03-06 16:29:40 +00:00
|
|
|
#include "engines/wintermute/wintermute.h"
|
2012-03-13 17:07:41 +00:00
|
|
|
#include "engines/wintermute/PlatformSDL.h"
|
2012-06-15 16:45:28 +00:00
|
|
|
#include "engines/wintermute/Base/BRegistry.h"
|
|
|
|
|
|
|
|
#include "engines/wintermute/Base/BSoundMgr.h"
|
|
|
|
#include "engines/wintermute/Base/scriptables/ScEngine.h"
|
2012-04-19 16:48:48 +00:00
|
|
|
|
|
|
|
namespace WinterMute {
|
2012-05-11 14:03:59 +00:00
|
|
|
|
2012-06-15 16:56:16 +00:00
|
|
|
WinterMuteEngine *g_wintermute;
|
|
|
|
|
2012-05-11 14:03:59 +00:00
|
|
|
WinterMuteEngine::WinterMuteEngine(OSystem *syst)
|
2012-04-19 16:48:48 +00:00
|
|
|
: Engine(syst) {
|
2012-05-11 14:03:59 +00:00
|
|
|
// Put your engine in a sane state, but do nothing big yet;
|
|
|
|
// in particular, do not load data from files; rather, if you
|
|
|
|
// need to do such things, do them from init().
|
|
|
|
|
|
|
|
// Do not initialize graphics here
|
|
|
|
|
|
|
|
// However this is the place to specify all default directories
|
|
|
|
const Common::FSNode gameDataDir(ConfMan.get("path"));
|
|
|
|
//SearchMan.addSubDirectoryMatching(gameDataDir, "sound");
|
|
|
|
|
|
|
|
// Here is the right place to set up the engine specific debug channels
|
2012-06-25 13:26:33 +00:00
|
|
|
DebugMan.addDebugChannel(kWinterMuteDebugLog, "enginelog", "Covers the same output as the log-file in WME");
|
|
|
|
DebugMan.addDebugChannel(kWinterMuteDebugSaveGame, "savegame", "Savegames");
|
2012-05-11 14:03:59 +00:00
|
|
|
|
|
|
|
// Don't forget to register your random source
|
|
|
|
_rnd = new Common::RandomSource("WinterMute");
|
|
|
|
|
|
|
|
debug("WinterMuteEngine::WinterMuteEngine");
|
2012-06-15 16:45:28 +00:00
|
|
|
_game = NULL;
|
2012-06-15 16:56:16 +00:00
|
|
|
|
|
|
|
g_wintermute = this;
|
2012-06-25 13:13:34 +00:00
|
|
|
_classReg = NULL;
|
2012-05-11 14:03:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
WinterMuteEngine::~WinterMuteEngine() {
|
|
|
|
debug("WinterMuteEngine::~WinterMuteEngine");
|
|
|
|
|
|
|
|
// Dispose your resources here
|
|
|
|
delete _rnd;
|
|
|
|
|
|
|
|
// Remove all of our debug levels here
|
|
|
|
DebugMan.clearAllDebugChannels();
|
|
|
|
}
|
|
|
|
|
2012-06-19 00:30:40 +00:00
|
|
|
bool WinterMuteEngine::hasFeature(EngineFeature f) const {
|
|
|
|
switch (f) {
|
|
|
|
case kSupportsRTL:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-05-11 14:03:59 +00:00
|
|
|
Common::Error WinterMuteEngine::run() {
|
|
|
|
// Initialize graphics using following:
|
|
|
|
Graphics::PixelFormat format(4, 8, 8, 8, 8, 24, 16, 8, 0);
|
|
|
|
initGraphics(800, 600, false, &format);
|
2012-05-12 04:56:00 +00:00
|
|
|
if (g_system->getScreenFormat() != format) {
|
|
|
|
error("Wintermute currently REQUIRES 32bpp");
|
|
|
|
}
|
2012-05-11 14:03:59 +00:00
|
|
|
// You could use backend transactions directly as an alternative,
|
|
|
|
// but it isn't recommended, until you want to handle the error values
|
|
|
|
// from OSystem::endGFXTransaction yourself.
|
|
|
|
// This is just an example template:
|
|
|
|
//_system->beginGFXTransaction();
|
|
|
|
// // This setup the graphics mode according to users seetings
|
|
|
|
// initCommonGFX(false);
|
|
|
|
//
|
|
|
|
// // Specify dimensions of game graphics window.
|
|
|
|
// // In this example: 320x200
|
|
|
|
// _system->initSize(320, 200);
|
|
|
|
//FIXME: You really want to handle
|
|
|
|
//OSystem::kTransactionSizeChangeFailed here
|
|
|
|
//_system->endGFXTransaction();
|
|
|
|
|
|
|
|
// Create debugger console. It requires GFX to be initialized
|
|
|
|
_console = new Console(this);
|
|
|
|
|
|
|
|
// Additional setup.
|
|
|
|
debug("WinterMuteEngine::init");
|
|
|
|
|
|
|
|
// Your main even loop should be (invoked from) here.
|
|
|
|
debug("WinterMuteEngine::go: Hello, World!");
|
|
|
|
|
2012-06-25 13:26:33 +00:00
|
|
|
DebugMan.enableDebugChannel("enginelog");
|
2012-05-11 14:03:59 +00:00
|
|
|
// This test will show up if -d1 and --debugflags=example are specified on the commandline
|
2012-06-25 13:26:33 +00:00
|
|
|
debugC(1, kWinterMuteDebugLog, "Engine Debug-LOG enabled");
|
|
|
|
debugC(2, kWinterMuteDebugSaveGame , "Savegame debugging-enabled");
|
2012-05-11 14:03:59 +00:00
|
|
|
|
|
|
|
int ret = 1;
|
2012-06-15 16:45:28 +00:00
|
|
|
|
|
|
|
ret = init();
|
2012-05-11 14:03:59 +00:00
|
|
|
|
|
|
|
if (ret == 0) {
|
2012-06-15 16:45:28 +00:00
|
|
|
ret = messageLoop();
|
2012-04-19 16:48:48 +00:00
|
|
|
}
|
2012-06-25 13:13:34 +00:00
|
|
|
deinit();
|
2012-05-11 14:03:59 +00:00
|
|
|
return Common::kNoError;
|
|
|
|
}
|
|
|
|
|
2012-06-15 16:45:28 +00:00
|
|
|
int WinterMuteEngine::init() {
|
2012-06-25 13:13:34 +00:00
|
|
|
_classReg = new CSysClassRegistry();
|
|
|
|
_classReg->registerClasses();
|
|
|
|
|
2012-06-15 16:45:28 +00:00
|
|
|
_game = new CAdGame;
|
|
|
|
if (!_game) return 1;
|
2012-07-08 23:35:53 +00:00
|
|
|
CBPlatform::initialize(_game, 0, NULL);
|
2012-06-15 16:45:28 +00:00
|
|
|
|
2012-06-21 16:49:30 +00:00
|
|
|
bool windowedMode = !ConfMan.getBool("fullscreen");
|
2012-06-15 16:45:28 +00:00
|
|
|
|
|
|
|
// parse command line
|
|
|
|
char *SaveGame = NULL;
|
|
|
|
/* for (int i = 0; i < argc; i++) {
|
|
|
|
strcpy(param, argv[i]);
|
|
|
|
|
|
|
|
if (scumm_stricmp(param, "-project") == 0) {
|
|
|
|
if (argc > i) strcpy(param, argv[i + 1]);
|
|
|
|
else param[0] = '\0';
|
|
|
|
|
|
|
|
if (strcmp(param, "") != 0) {
|
|
|
|
char *IniDir = CBUtils::GetPath(param);
|
|
|
|
char *IniName = CBUtils::GetFilename(param);
|
|
|
|
|
|
|
|
// switch to ini's dir
|
|
|
|
warning("TODO: Place ini-files somewhere");
|
|
|
|
// chdir(IniDir);
|
|
|
|
|
|
|
|
// set ini name
|
|
|
|
sprintf(param, "./%s", IniName);
|
|
|
|
_game->_registry->SetIniName(param);
|
|
|
|
|
|
|
|
delete [] IniDir;
|
|
|
|
delete [] IniName;
|
|
|
|
}
|
|
|
|
} else if (scumm_stricmp(param, "-windowed") == 0) windowedMode = true;
|
|
|
|
}*/
|
|
|
|
|
|
|
|
|
2012-07-08 18:07:01 +00:00
|
|
|
if (_game->_registry->readBool("Debug", "DebugMode")) _game->DEBUG_DebugEnable("./wme.log");
|
2012-06-15 16:45:28 +00:00
|
|
|
|
2012-07-08 18:07:01 +00:00
|
|
|
_game->_dEBUG_ShowFPS = _game->_registry->readBool("Debug", "ShowFPS");
|
2012-06-15 16:45:28 +00:00
|
|
|
|
2012-07-08 18:07:01 +00:00
|
|
|
if (_game->_registry->readBool("Debug", "DisableSmartCache")) {
|
2012-06-15 16:45:28 +00:00
|
|
|
_game->LOG(0, "Smart cache is DISABLED");
|
|
|
|
_game->_smartCache = false;
|
|
|
|
}
|
|
|
|
|
2012-07-08 18:07:01 +00:00
|
|
|
/* bool AllowDirectDraw = _game->_registry->readBool("Debug", "AllowDirectDraw", false);*/
|
2012-06-15 16:45:28 +00:00
|
|
|
|
|
|
|
// load general game settings
|
2012-07-03 02:52:18 +00:00
|
|
|
_game->initialize1();
|
2012-06-15 16:45:28 +00:00
|
|
|
|
|
|
|
|
2012-07-09 01:27:21 +00:00
|
|
|
if (DID_FAIL(_game->loadSettings("startup.settings"))) {
|
2012-06-15 16:45:28 +00:00
|
|
|
_game->LOG(0, "Error loading game settings.");
|
|
|
|
delete _game;
|
|
|
|
_game = NULL;
|
|
|
|
|
|
|
|
warning("Some of the essential files are missing. Please reinstall.");
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2012-07-03 02:52:18 +00:00
|
|
|
_game->initialize2();
|
2012-06-15 16:45:28 +00:00
|
|
|
|
2012-07-04 11:15:47 +00:00
|
|
|
_game->getDebugMgr()->onGameInit();
|
2012-07-08 21:51:47 +00:00
|
|
|
_game->_scEngine->loadBreakpoints();
|
2012-06-15 16:45:28 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
2012-07-09 01:27:21 +00:00
|
|
|
ERRORCODE ret;
|
2012-06-15 16:45:28 +00:00
|
|
|
|
|
|
|
// initialize the renderer
|
2012-06-26 00:27:33 +00:00
|
|
|
ret = _game->_renderer->initRenderer(_game->_settingsResWidth, _game->_settingsResHeight, windowedMode);
|
2012-07-09 01:27:21 +00:00
|
|
|
if (DID_FAIL(ret)) {
|
2012-06-15 16:45:28 +00:00
|
|
|
_game->LOG(ret, "Error initializing renderer. Exiting.");
|
|
|
|
|
|
|
|
delete _game;
|
|
|
|
_game = NULL;
|
|
|
|
return 3;
|
|
|
|
}
|
|
|
|
|
2012-07-03 02:52:18 +00:00
|
|
|
_game->initialize3();
|
2012-06-15 16:45:28 +00:00
|
|
|
|
|
|
|
#ifdef __IPHONEOS__
|
|
|
|
SDL_AddEventWatch(CBPlatform::SDLEventWatcher, NULL);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// initialize sound manager (non-fatal if we fail)
|
|
|
|
ret = _game->_soundMgr->initialize();
|
2012-07-09 01:27:21 +00:00
|
|
|
if (DID_FAIL(ret)) {
|
2012-06-15 16:45:28 +00:00
|
|
|
_game->LOG(ret, "Sound is NOT available.");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// load game
|
2012-07-08 23:35:53 +00:00
|
|
|
uint32 DataInitStart = CBPlatform::getTime();
|
2012-06-15 16:45:28 +00:00
|
|
|
|
2012-07-09 01:27:21 +00:00
|
|
|
if (DID_FAIL(_game->loadFile(_game->_settingsGameFile ? _game->_settingsGameFile : "default.game"))) {
|
2012-06-15 16:45:28 +00:00
|
|
|
_game->LOG(ret, "Error loading game file. Exiting.");
|
|
|
|
delete _game;
|
|
|
|
_game = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
2012-07-04 11:15:47 +00:00
|
|
|
_game->setWindowTitle();
|
2012-06-15 16:45:28 +00:00
|
|
|
_game->_renderer->_ready = true;
|
|
|
|
_game->_miniUpdateEnabled = true;
|
|
|
|
|
2012-07-08 23:35:53 +00:00
|
|
|
_game->LOG(0, "Engine initialized in %d ms", CBPlatform::getTime() - DataInitStart);
|
2012-06-15 16:45:28 +00:00
|
|
|
_game->LOG(0, "");
|
|
|
|
|
2012-06-19 00:02:20 +00:00
|
|
|
if (ConfMan.hasKey("save_slot")) {
|
|
|
|
int slot = ConfMan.getInt("save_slot");
|
|
|
|
Common::String str = Common::String::format("save00%d.DirtySplitSav", slot);
|
2012-07-04 11:15:47 +00:00
|
|
|
_game->loadGame(str.c_str());
|
2012-06-19 00:02:20 +00:00
|
|
|
}
|
2012-06-15 16:45:28 +00:00
|
|
|
|
|
|
|
if (SaveGame) {
|
2012-07-04 11:15:47 +00:00
|
|
|
_game->loadGame(SaveGame);
|
2012-06-15 16:45:28 +00:00
|
|
|
delete [] SaveGame;
|
|
|
|
}
|
|
|
|
|
|
|
|
// all set, ready to go
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int WinterMuteEngine::messageLoop() {
|
|
|
|
bool done = false;
|
2012-06-28 00:08:33 +00:00
|
|
|
|
|
|
|
uint32 prevTime = _system->getMillis();
|
|
|
|
uint32 time = _system->getMillis();
|
|
|
|
uint32 diff = 0;
|
|
|
|
|
|
|
|
const uint32 maxFPS = 25;
|
2012-07-09 00:50:15 +00:00
|
|
|
const uint32 frameTime = (uint32)((1.0/maxFPS) * 1000);
|
2012-06-15 16:45:28 +00:00
|
|
|
while (!done) {
|
|
|
|
Common::Event event;
|
|
|
|
while (_system->getEventManager()->pollEvent(event)) {
|
2012-07-08 23:35:53 +00:00
|
|
|
CBPlatform::handleEvent(&event);
|
2012-06-15 16:45:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (_game && _game->_renderer->_active && _game->_renderer->_ready) {
|
2012-07-04 11:15:47 +00:00
|
|
|
_game->displayContent();
|
|
|
|
_game->displayQuickMsg();
|
2012-06-28 00:08:33 +00:00
|
|
|
|
2012-07-04 11:15:47 +00:00
|
|
|
_game->displayDebugInfo();
|
2012-06-28 00:08:33 +00:00
|
|
|
|
|
|
|
time = _system->getMillis();
|
|
|
|
diff = time - prevTime;
|
|
|
|
if (frameTime > diff) // Avoid overflows
|
|
|
|
_system->delayMillis(frameTime - diff);
|
|
|
|
|
2012-06-15 16:45:28 +00:00
|
|
|
// ***** flip
|
2012-06-26 00:27:33 +00:00
|
|
|
if (!_game->_suspendedRendering) _game->_renderer->flip();
|
2012-07-04 11:15:47 +00:00
|
|
|
if (_game->_loading) _game->loadGame(_game->_scheduledLoadSlot);
|
2012-06-28 00:08:33 +00:00
|
|
|
prevTime = time;
|
2012-06-15 16:45:28 +00:00
|
|
|
}
|
|
|
|
if (_game->_quitting) break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_game) {
|
|
|
|
// remember previous window position
|
|
|
|
/*
|
|
|
|
if(_game->_renderer && _game->_renderer->_windowed)
|
|
|
|
{
|
|
|
|
if(!::IsIconic(_game->_renderer->_window))
|
|
|
|
{
|
|
|
|
int PosX = _game->_renderer->_windowRect.left;
|
|
|
|
int PosY = _game->_renderer->_windowRect.top;
|
|
|
|
PosX -= _game->_renderer->_monitorRect.left;
|
|
|
|
PosY -= _game->_renderer->_monitorRect.top;
|
|
|
|
|
2012-07-08 18:07:01 +00:00
|
|
|
_game->_registry->writeInt("Video", "WindowPosX", PosX);
|
|
|
|
_game->_registry->writeInt("Video", "WindowPosY", PosY);
|
2012-06-15 16:45:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
delete _game;
|
|
|
|
_game = NULL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-25 13:13:34 +00:00
|
|
|
void WinterMuteEngine::deinit() {
|
|
|
|
delete _classReg;
|
|
|
|
}
|
|
|
|
|
2012-06-15 17:19:09 +00:00
|
|
|
uint32 WinterMuteEngine::randInt(int from, int to) {
|
|
|
|
return _rnd->getRandomNumberRng(from, to);
|
|
|
|
}
|
|
|
|
|
2012-06-01 11:51:06 +00:00
|
|
|
} // End of namespace WinterMute
|