2011-06-10 05:45:18 +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.
|
|
|
|
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This code is based on original Soltys source code
|
|
|
|
* Copyright (c) 1994-1995 Janus B. Wisniewski and L.K. Avalon
|
|
|
|
*/
|
|
|
|
|
2011-06-29 11:17:07 +00:00
|
|
|
#include "common/scummsys.h"
|
2011-08-06 05:29:49 +00:00
|
|
|
#include "common/endian.h"
|
2011-07-05 10:26:34 +00:00
|
|
|
#include "common/memstream.h"
|
2011-07-09 23:44:46 +00:00
|
|
|
#include "common/savefile.h"
|
2011-07-05 10:26:34 +00:00
|
|
|
#include "common/serializer.h"
|
2011-07-13 11:04:44 +00:00
|
|
|
#include "common/str.h"
|
2011-07-16 08:33:20 +00:00
|
|
|
#include "graphics/palette.h"
|
|
|
|
#include "graphics/scaler.h"
|
|
|
|
#include "graphics/thumbnail.h"
|
2011-06-28 22:35:21 +00:00
|
|
|
#include "cge/general.h"
|
|
|
|
#include "cge/sound.h"
|
|
|
|
#include "cge/vga13h.h"
|
|
|
|
#include "cge/snail.h"
|
|
|
|
#include "cge/text.h"
|
|
|
|
#include "cge/game.h"
|
2011-07-02 06:19:36 +00:00
|
|
|
#include "cge/events.h"
|
2011-06-28 22:35:21 +00:00
|
|
|
#include "cge/talk.h"
|
|
|
|
#include "cge/vmenu.h"
|
|
|
|
#include "cge/cge_main.h"
|
|
|
|
#include "cge/cge.h"
|
2011-07-13 11:04:44 +00:00
|
|
|
#include "cge/walk.h"
|
2011-07-29 08:02:32 +00:00
|
|
|
#include "cge/sound.h"
|
2011-06-11 20:35:21 +00:00
|
|
|
|
2011-06-10 20:57:09 +00:00
|
|
|
namespace CGE {
|
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
uint16 _stklen = (kStackSize * 2);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
Vga *_vga;
|
2011-07-04 06:15:56 +00:00
|
|
|
System *_sys;
|
2011-06-28 22:35:21 +00:00
|
|
|
Sprite *_pocLight;
|
2011-07-02 08:38:25 +00:00
|
|
|
EventManager *_eventManager;
|
2011-07-02 06:46:31 +00:00
|
|
|
Keyboard *_keyboard;
|
2011-07-08 06:21:35 +00:00
|
|
|
Mouse *_mouse;
|
2011-07-20 23:56:40 +00:00
|
|
|
Sprite *_pocket[kPocketNX];
|
2011-06-28 22:35:21 +00:00
|
|
|
Sprite *_sprite;
|
2011-09-14 06:15:30 +00:00
|
|
|
Sprite *_miniScene;
|
2011-06-28 22:35:21 +00:00
|
|
|
Sprite *_shadow;
|
2011-07-09 23:57:19 +00:00
|
|
|
HorizLine *_horzLine;
|
2011-07-03 09:28:22 +00:00
|
|
|
InfoLine *_infoLine;
|
2011-09-14 06:15:30 +00:00
|
|
|
SceneLight *_sceneLight;
|
2011-07-03 09:28:22 +00:00
|
|
|
InfoLine *_debugLine;
|
2011-06-21 17:38:16 +00:00
|
|
|
|
2011-07-02 16:20:41 +00:00
|
|
|
Snail *_snail;
|
|
|
|
Snail *_snail_;
|
2011-06-22 06:11:18 +00:00
|
|
|
|
2011-07-29 08:02:32 +00:00
|
|
|
Fx *_fx;
|
|
|
|
Sound *_sound;
|
2011-09-13 22:10:59 +00:00
|
|
|
ResourceManager *_resman;
|
2011-09-09 16:24:11 +00:00
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
const char *savegameStr = "SCUMMVM_CGE";
|
2011-06-09 06:20:53 +00:00
|
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
2011-09-05 22:43:40 +00:00
|
|
|
const Dac g_stdPal[] = {// R G B
|
|
|
|
{ 0, 60, 0}, // 198
|
|
|
|
{ 0, 104, 0}, // 199
|
|
|
|
{ 20, 172, 0}, // 200
|
|
|
|
{ 82, 82, 0}, // 201
|
|
|
|
{ 0, 132, 82}, // 202
|
|
|
|
{ 132, 173, 82}, // 203
|
|
|
|
{ 82, 0, 0}, // 204
|
|
|
|
{ 206, 0, 24}, // 205
|
|
|
|
{ 255, 33, 33}, // 206
|
|
|
|
{ 123, 41, 0}, // 207
|
|
|
|
{ 0, 41, 0}, // 208
|
|
|
|
{ 0, 0, 82}, // 209
|
|
|
|
{ 132, 0, 0}, // 210
|
|
|
|
{ 255, 0, 0}, // 211
|
|
|
|
{ 255, 66, 66}, // 212
|
|
|
|
{ 148, 66, 16}, // 213
|
|
|
|
{ 0, 82, 0}, // 214
|
|
|
|
{ 0, 0, 132}, // 215
|
|
|
|
{ 173, 0, 0}, // 216
|
|
|
|
{ 255, 49, 0}, // 217
|
|
|
|
{ 255, 99, 99}, // 218
|
|
|
|
{ 181, 107, 49}, // 219
|
|
|
|
{ 0, 132, 0}, // 220
|
|
|
|
{ 0, 0, 255}, // 221
|
|
|
|
{ 173, 41, 0}, // 222
|
|
|
|
{ 255, 82, 0}, // 223
|
|
|
|
{ 255, 132, 132}, // 224
|
|
|
|
{ 214, 148, 74}, // 225
|
|
|
|
{ 41, 214, 0}, // 226
|
|
|
|
{ 0, 82, 173}, // 227
|
|
|
|
{ 255, 214, 0}, // 228
|
|
|
|
{ 247, 132, 49}, // 229
|
|
|
|
{ 255, 165, 165}, // 230
|
|
|
|
{ 239, 198, 123}, // 231
|
|
|
|
{ 173, 214, 0}, // 232
|
|
|
|
{ 0, 132, 214}, // 233
|
|
|
|
{ 57, 57, 57}, // 234
|
|
|
|
{ 247, 189, 74}, // 235
|
|
|
|
{ 255, 198, 198}, // 236
|
|
|
|
{ 255, 239, 173}, // 237
|
|
|
|
{ 214, 255, 173}, // 238
|
|
|
|
{ 82, 173, 255}, // 239
|
|
|
|
{ 107, 107, 107}, // 240
|
|
|
|
{ 247, 222, 99}, // 241
|
|
|
|
{ 255, 0, 255}, // 242
|
|
|
|
{ 255, 132, 255}, // 243
|
|
|
|
{ 132, 132, 173}, // 244
|
|
|
|
{ 148, 247, 255}, // 245
|
|
|
|
{ 148, 148, 148}, // 246
|
|
|
|
{ 82, 0, 82}, // 247
|
|
|
|
{ 112, 68, 112}, // 248
|
|
|
|
{ 176, 88, 144}, // 249
|
|
|
|
{ 214, 132, 173}, // 250
|
|
|
|
{ 206, 247, 255}, // 251
|
|
|
|
{ 198, 198, 198}, // 252
|
|
|
|
{ 0, 214, 255}, // 253
|
|
|
|
{ 96, 224, 96 }, // 254
|
|
|
|
{ 255, 255, 255}, // 255
|
|
|
|
};
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-15 05:58:31 +00:00
|
|
|
char *CGEEngine::mergeExt(char *buf, const char *name, const char *ext) {
|
|
|
|
strcpy(buf, name);
|
|
|
|
char *dot = strrchr(buf, '.');
|
|
|
|
if (!dot)
|
|
|
|
strcat(buf, ext);
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
int CGEEngine::takeEnum(const char **tab, const char *text) {
|
|
|
|
const char **e;
|
|
|
|
if (text) {
|
|
|
|
for (e = tab; *e; e++) {
|
|
|
|
if (scumm_stricmp(text, *e) == 0) {
|
|
|
|
return e - tab;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int CGEEngine::newRandom(int range) {
|
|
|
|
if (!range)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return ((CGEEngine *)g_engine)->_randomSource.getRandomNumber(range - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGEEngine::sndSetVolume() {
|
|
|
|
// USeless for ScummVM
|
|
|
|
}
|
|
|
|
|
2011-07-09 23:44:46 +00:00
|
|
|
void CGEEngine::syncHeader(Common::Serializer &s) {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::syncHeader(s)");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
int i;
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-05 10:26:34 +00:00
|
|
|
s.syncAsUint16LE(_now);
|
|
|
|
s.syncAsUint16LE(_oldLev);
|
|
|
|
s.syncAsUint16LE(_demoText);
|
2011-07-30 22:52:35 +00:00
|
|
|
for (i = 0; i < 5; i++)
|
2011-07-05 10:26:34 +00:00
|
|
|
s.syncAsUint16LE(_game);
|
|
|
|
s.syncAsSint16LE(i); // unused VGA::Mono variable
|
|
|
|
s.syncAsUint16LE(_music);
|
|
|
|
s.syncBytes(_volume, 2);
|
2011-07-30 22:52:35 +00:00
|
|
|
for (i = 0; i < 4; i++)
|
2011-07-05 10:26:34 +00:00
|
|
|
s.syncAsUint16LE(_flag[i]);
|
|
|
|
|
2011-07-30 13:43:49 +00:00
|
|
|
if (s.isLoading()) {
|
2011-09-14 06:15:30 +00:00
|
|
|
// Reset scene values
|
|
|
|
initSceneValues();
|
2011-07-30 13:43:49 +00:00
|
|
|
}
|
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
for (i = 0; i < kSceneMax; i++) {
|
2011-09-06 21:14:49 +00:00
|
|
|
s.syncAsSint16LE(_heroXY[i].x);
|
|
|
|
s.syncAsUint16LE(_heroXY[i].y);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-09-14 06:15:30 +00:00
|
|
|
for (i = 0; i < 1 + kSceneMax; i++) {
|
2011-07-05 10:26:34 +00:00
|
|
|
s.syncAsByte(_barriers[i]._horz);
|
|
|
|
s.syncAsByte(_barriers[i]._vert);
|
|
|
|
}
|
2011-07-30 22:52:35 +00:00
|
|
|
for (i = 0; i < kPocketNX; i++)
|
2011-07-05 10:26:34 +00:00
|
|
|
s.syncAsUint16LE(_pocref[i]);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-09 23:44:46 +00:00
|
|
|
if (s.isSaving()) {
|
|
|
|
// Write checksum
|
2011-08-02 19:47:56 +00:00
|
|
|
int checksum = kSavegameCheckSum;
|
2011-07-09 23:44:46 +00:00
|
|
|
s.syncAsUint16LE(checksum);
|
|
|
|
} else {
|
|
|
|
// Read checksum and validate it
|
|
|
|
uint16 checksum;
|
|
|
|
s.syncAsUint16LE(checksum);
|
2011-08-02 19:47:56 +00:00
|
|
|
if (checksum != kSavegameCheckSum)
|
2011-07-22 09:54:46 +00:00
|
|
|
error("%s", _text->getText(kBadSVG));
|
2011-07-09 23:44:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
bool CGEEngine::loadGame(int slotNumber, SavegameHeader *header, bool tiny) {
|
2011-07-30 13:43:49 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::loadgame(%d, header, %s)", slotNumber, tiny ? "true" : "false");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
Common::MemoryReadStream *readStream;
|
|
|
|
SavegameHeader saveHeader;
|
2011-07-09 23:44:46 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
if (slotNumber == -1) {
|
|
|
|
// Loading the data for the initial game state
|
2011-08-02 19:47:56 +00:00
|
|
|
kSavegame0File file = kSavegame0File(kSavegame0Name);
|
2011-07-16 08:33:20 +00:00
|
|
|
int size = file.size();
|
|
|
|
byte *dataBuffer = (byte *)malloc(size);
|
|
|
|
file.read(dataBuffer, size);
|
|
|
|
readStream = new Common::MemoryReadStream(dataBuffer, size, DisposeAfterUse::YES);
|
2011-07-09 23:44:46 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
} else {
|
|
|
|
// Open up the savgame file
|
|
|
|
Common::String slotName = generateSaveName(slotNumber);
|
|
|
|
Common::InSaveFile *saveFile = g_system->getSavefileManager()->openForLoading(slotName);
|
|
|
|
|
|
|
|
// Read the data into a data buffer
|
|
|
|
int size = saveFile->size();
|
|
|
|
byte *dataBuffer = (byte *)malloc(size);
|
|
|
|
saveFile->read(dataBuffer, size);
|
|
|
|
readStream = new Common::MemoryReadStream(dataBuffer, size, DisposeAfterUse::YES);
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
// Check to see if it's a ScummVM savegame or not
|
2011-08-02 19:47:56 +00:00
|
|
|
char buffer[kSavegameStrSize + 1];
|
|
|
|
readStream->read(buffer, kSavegameStrSize + 1);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
if (strncmp(buffer, savegameStr, kSavegameStrSize + 1) != 0) {
|
2011-07-16 08:33:20 +00:00
|
|
|
// It's not, so rewind back to the start
|
|
|
|
readStream->seek(0);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
if (header)
|
|
|
|
// Header wanted where none exists, so return false
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
// Found header
|
|
|
|
if (!readSavegameHeader(readStream, saveHeader)) {
|
|
|
|
delete readStream;
|
|
|
|
return false;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
if (header) {
|
|
|
|
*header = saveHeader;
|
|
|
|
delete readStream;
|
|
|
|
return true;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-07-16 08:33:20 +00:00
|
|
|
|
|
|
|
// Delete the thumbnail
|
2011-08-10 10:41:39 +00:00
|
|
|
saveHeader.thumbnail->free();
|
2011-07-16 08:33:20 +00:00
|
|
|
delete saveHeader.thumbnail;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
2011-07-28 13:35:12 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
// Get in the savegame
|
|
|
|
syncGame(readStream, NULL, tiny);
|
|
|
|
|
|
|
|
delete readStream;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns true if a given savegame exists
|
|
|
|
*/
|
|
|
|
bool CGEEngine::savegameExists(int slotNumber) {
|
|
|
|
Common::String slotName = generateSaveName(slotNumber);
|
|
|
|
|
|
|
|
Common::InSaveFile *saveFile = g_system->getSavefileManager()->openForLoading(slotName);
|
|
|
|
bool result = saveFile != NULL;
|
|
|
|
delete saveFile;
|
|
|
|
return result;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
/**
|
|
|
|
* Support method that generates a savegame name
|
|
|
|
* @param slot Slot number
|
|
|
|
*/
|
|
|
|
Common::String CGEEngine::generateSaveName(int slot) {
|
|
|
|
return Common::String::format("%s.%03d", _targetName.c_str(), slot);
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-16 11:12:19 +00:00
|
|
|
Common::Error CGEEngine::loadGameState(int slot) {
|
|
|
|
// Clear current game activity
|
2011-09-14 06:15:30 +00:00
|
|
|
sceneDown();
|
2011-08-10 10:41:39 +00:00
|
|
|
resetGame();
|
2011-07-16 11:12:19 +00:00
|
|
|
|
|
|
|
// Load the game
|
|
|
|
loadGame(slot, NULL);
|
2011-09-14 06:15:30 +00:00
|
|
|
_snail->addCom(kSnLevel, -1, _oldLev, &_sceneLight);
|
|
|
|
_sceneLight->gotoxy(kSceneX + ((_now - 1) % kSceneNx) * kSceneDx + kSceneSX,
|
|
|
|
kSceneY + ((_now - 1) / kSceneNx) * kSceneDy + kSceneSY);
|
|
|
|
sceneUp();
|
2011-07-16 11:12:19 +00:00
|
|
|
|
|
|
|
return Common::kNoError;
|
|
|
|
}
|
|
|
|
|
2011-08-10 10:41:39 +00:00
|
|
|
void CGEEngine::resetGame() {
|
|
|
|
_vga->_spareQ->clear();
|
|
|
|
}
|
|
|
|
|
2011-07-16 11:12:19 +00:00
|
|
|
Common::Error CGEEngine::saveGameState(int slot, const Common::String &desc) {
|
2011-09-14 06:15:30 +00:00
|
|
|
sceneDown();
|
2011-08-10 09:33:08 +00:00
|
|
|
_oldLev = _lev;
|
|
|
|
|
|
|
|
// Write out the user's progress
|
2011-07-16 11:12:19 +00:00
|
|
|
saveGame(slot, desc);
|
2011-08-10 09:33:08 +00:00
|
|
|
|
|
|
|
// Reload the scene
|
2011-09-14 06:15:30 +00:00
|
|
|
sceneUp();
|
2011-08-10 09:33:08 +00:00
|
|
|
|
2011-07-16 11:12:19 +00:00
|
|
|
return Common::kNoError;
|
|
|
|
}
|
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
void CGEEngine::saveGame(int slotNumber, const Common::String &desc) {
|
|
|
|
// Set up the serializer
|
|
|
|
Common::String slotName = generateSaveName(slotNumber);
|
|
|
|
Common::OutSaveFile *saveFile = g_system->getSavefileManager()->openForSaving(slotName);
|
|
|
|
|
|
|
|
// Write out the ScummVM savegame header
|
|
|
|
SavegameHeader header;
|
|
|
|
header.saveName = desc;
|
2011-08-02 19:47:56 +00:00
|
|
|
header.version = kSavegameVersion;
|
2011-07-16 08:33:20 +00:00
|
|
|
writeSavegameHeader(saveFile, header);
|
|
|
|
|
|
|
|
// Write out the data of the savegame
|
2011-08-31 22:22:20 +00:00
|
|
|
syncGame(NULL, saveFile, false);
|
2011-07-16 08:33:20 +00:00
|
|
|
|
|
|
|
// Finish writing out game data
|
|
|
|
saveFile->finalize();
|
|
|
|
delete saveFile;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
void CGEEngine::writeSavegameHeader(Common::OutSaveFile *out, SavegameHeader &header) {
|
|
|
|
// Write out a savegame header
|
2011-08-02 19:47:56 +00:00
|
|
|
out->write(savegameStr, kSavegameStrSize + 1);
|
2011-07-16 08:33:20 +00:00
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
out->writeByte(kSavegameVersion);
|
2011-07-16 08:33:20 +00:00
|
|
|
|
|
|
|
// Write savegame name
|
|
|
|
out->write(header.saveName.c_str(), header.saveName.size() + 1);
|
|
|
|
|
|
|
|
// Get the active palette
|
|
|
|
uint8 thumbPalette[256 * 3];
|
|
|
|
g_system->getPaletteManager()->grabPalette(thumbPalette, 0, 256);
|
|
|
|
|
|
|
|
// Create a thumbnail and save it
|
|
|
|
Graphics::Surface *thumb = new Graphics::Surface();
|
2011-07-16 11:12:19 +00:00
|
|
|
Graphics::Surface *s = _vga->_page[0];
|
2011-07-20 23:56:40 +00:00
|
|
|
::createThumbnail(thumb, (const byte *)s->pixels, kScrWidth, kScrHeight, thumbPalette);
|
2011-07-16 08:33:20 +00:00
|
|
|
Graphics::saveThumbnail(*out, *thumb);
|
2011-08-06 06:08:47 +00:00
|
|
|
thumb->free();
|
2011-07-16 08:33:20 +00:00
|
|
|
delete thumb;
|
|
|
|
|
|
|
|
// Write out the save date/time
|
|
|
|
TimeDate td;
|
|
|
|
g_system->getTimeAndDate(td);
|
|
|
|
out->writeSint16LE(td.tm_year + 1900);
|
|
|
|
out->writeSint16LE(td.tm_mon + 1);
|
|
|
|
out->writeSint16LE(td.tm_mday);
|
|
|
|
out->writeSint16LE(td.tm_hour);
|
|
|
|
out->writeSint16LE(td.tm_min);
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
void CGEEngine::syncGame(Common::SeekableReadStream *readStream, Common::WriteStream *writeStream, bool tiny) {
|
|
|
|
Common::Serializer s(readStream, writeStream);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
if (s.isSaving()) {
|
2011-08-19 14:04:10 +00:00
|
|
|
for (int i = 0; i < kPocketNX; i++) {
|
2011-08-06 03:34:33 +00:00
|
|
|
register Sprite *pocSpr = _pocket[i];
|
|
|
|
_pocref[i] = (pocSpr) ? pocSpr->_ref : -1;
|
2011-07-16 08:33:20 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-27 16:01:06 +00:00
|
|
|
// Skip Digital and Midi volumes, useless under ScummVM
|
2011-07-24 21:42:03 +00:00
|
|
|
_volume[0] = 0;
|
|
|
|
_volume[1] = 0;
|
2011-07-16 08:33:20 +00:00
|
|
|
}
|
2011-07-09 23:44:46 +00:00
|
|
|
|
|
|
|
// Synchronise header data
|
|
|
|
syncHeader(s);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-16 08:33:20 +00:00
|
|
|
if (s.isSaving()) {
|
|
|
|
// Loop through saving the sprite data
|
2011-08-19 14:04:10 +00:00
|
|
|
for (Sprite *spr = _vga->_spareQ->first(); spr; spr = spr->_next) {
|
2011-08-31 22:22:20 +00:00
|
|
|
if (!s.err())
|
2011-07-16 08:33:20 +00:00
|
|
|
spr->sync(s);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Loading game
|
2011-07-29 08:02:32 +00:00
|
|
|
if (_soundOk == 1 && _mode == 0) {
|
2011-08-27 16:01:06 +00:00
|
|
|
// Skip Digital and Midi volumes, useless under ScummVM
|
2011-07-16 08:33:20 +00:00
|
|
|
sndSetVolume();
|
|
|
|
}
|
|
|
|
|
2011-08-27 21:54:18 +00:00
|
|
|
if (!tiny) { // load sprites & pocket
|
2011-07-16 08:33:20 +00:00
|
|
|
while (readStream->pos() < readStream->size()) {
|
|
|
|
Sprite S(this, NULL);
|
|
|
|
S.sync(s);
|
|
|
|
|
|
|
|
S._prev = S._next = NULL;
|
2011-08-19 14:04:10 +00:00
|
|
|
Sprite *spr = (scumm_stricmp(S._file + 2, "MUCHA") == 0) ? new Fly(this, NULL)
|
2011-07-16 08:33:20 +00:00
|
|
|
: new Sprite(this, NULL);
|
2011-07-25 14:04:45 +00:00
|
|
|
assert(spr != NULL);
|
2011-07-16 08:33:20 +00:00
|
|
|
*spr = S;
|
|
|
|
_vga->_spareQ->append(spr);
|
|
|
|
}
|
|
|
|
|
2011-08-19 14:04:10 +00:00
|
|
|
for (int i = 0; i < kPocketNX; i++) {
|
2011-07-16 08:33:20 +00:00
|
|
|
register int r = _pocref[i];
|
|
|
|
_pocket[i] = (r < 0) ? NULL : _vga->_spareQ->locate(r);
|
|
|
|
}
|
|
|
|
}
|
2011-07-09 23:44:46 +00:00
|
|
|
}
|
2011-07-16 08:33:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool CGEEngine::readSavegameHeader(Common::InSaveFile *in, SavegameHeader &header) {
|
|
|
|
header.thumbnail = NULL;
|
|
|
|
|
|
|
|
// Get the savegame version
|
|
|
|
header.version = in->readByte();
|
2011-08-02 19:47:56 +00:00
|
|
|
if (header.version > kSavegameVersion)
|
2011-07-16 08:33:20 +00:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Read in the string
|
|
|
|
header.saveName.clear();
|
|
|
|
char ch;
|
2011-08-27 21:54:18 +00:00
|
|
|
while ((ch = (char)in->readByte()) != '\0')
|
|
|
|
header.saveName += ch;
|
2011-07-16 08:33:20 +00:00
|
|
|
|
|
|
|
// Get the thumbnail
|
2011-08-22 18:17:49 +00:00
|
|
|
header.thumbnail = Graphics::loadThumbnail(*in);
|
|
|
|
if (!header.thumbnail) {
|
2011-07-16 08:33:20 +00:00
|
|
|
delete header.thumbnail;
|
|
|
|
header.thumbnail = NULL;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read in save date/time
|
|
|
|
header.saveYear = in->readSint16LE();
|
|
|
|
header.saveMonth = in->readSint16LE();
|
|
|
|
header.saveDay = in->readSint16LE();
|
|
|
|
header.saveHour = in->readSint16LE();
|
|
|
|
header.saveMinutes = in->readSint16LE();
|
|
|
|
|
|
|
|
return true;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-07 06:11:29 +00:00
|
|
|
void CGEEngine::heroCover(int cvr) {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::heroCover(%d)", cvr);
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail->addCom(kSnCover, 1, cvr, NULL);
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-30 22:52:35 +00:00
|
|
|
void CGEEngine::trouble(int seq, int text) {
|
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::trouble(%d, %d)", seq, text);
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
_hero->park();
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail->addCom(kSnWait, -1, -1, _hero);
|
|
|
|
_snail->addCom(kSnSeq, -1, seq, _hero);
|
|
|
|
_snail->addCom(kSnSound, -1, 2, _hero);
|
|
|
|
_snail->addCom(kSnWait, -1, -1, _hero);
|
2011-07-30 22:52:35 +00:00
|
|
|
_snail->addCom(kSnSay, 1, text, _hero);
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-07 06:11:29 +00:00
|
|
|
void CGEEngine::offUse() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::offUse()");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
trouble(kSeqOffUse, kOffUse + newRandom(_offUseCount));
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-07 06:11:29 +00:00
|
|
|
void CGEEngine::tooFar() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::tooFar()");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-07-22 09:54:46 +00:00
|
|
|
trouble(kSeqTooFar, kTooFar);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-07 06:11:29 +00:00
|
|
|
void CGEEngine::loadHeroXY() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::loadHeroXY()");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-09-11 20:13:00 +00:00
|
|
|
EncryptedStream cf("CGE.HXY");
|
2011-08-06 05:29:49 +00:00
|
|
|
uint16 x, y;
|
|
|
|
|
2011-07-02 16:20:41 +00:00
|
|
|
memset(_heroXY, 0, sizeof(_heroXY));
|
2011-09-11 20:13:00 +00:00
|
|
|
if (!cf.err()) {
|
2011-09-14 06:15:30 +00:00
|
|
|
for (int i = 0; i < kSceneMax; ++i) {
|
2011-08-06 05:29:49 +00:00
|
|
|
cf.read((byte *)&x, 2);
|
|
|
|
cf.read((byte *)&y, 2);
|
|
|
|
|
2011-09-06 21:14:49 +00:00
|
|
|
_heroXY[i].x = (int16)FROM_LE_16(x);
|
|
|
|
_heroXY[i].y = (int16)FROM_LE_16(y);
|
2011-08-06 05:29:49 +00:00
|
|
|
}
|
|
|
|
}
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-05 21:13:12 +00:00
|
|
|
void CGEEngine::loadMapping() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::loadMapping()");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
if (_now <= kSceneMax) {
|
2011-09-11 20:13:00 +00:00
|
|
|
EncryptedStream cf("CGE.TAB");
|
|
|
|
if (!cf.err()) {
|
2011-08-19 10:36:43 +00:00
|
|
|
// Move to the data for the given room
|
|
|
|
cf.seek((_now - 1) * kMapArrSize);
|
|
|
|
|
|
|
|
// Read in the data
|
|
|
|
for (int z = 0; z < kMapZCnt; ++z) {
|
|
|
|
cf.read(&Cluster::_map[z][0], kMapXCnt);
|
|
|
|
}
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-20 12:27:36 +00:00
|
|
|
Square::Square(CGEEngine *vm) : Sprite(vm, NULL), _vm(vm) {
|
2011-08-19 10:36:43 +00:00
|
|
|
_flags._kill = true;
|
|
|
|
_flags._bDel = false;
|
2011-07-09 23:51:18 +00:00
|
|
|
|
2011-07-30 22:52:35 +00:00
|
|
|
BitmapPtr *MB = new BitmapPtr[2];
|
2011-08-19 17:48:49 +00:00
|
|
|
MB[0] = new Bitmap("BRICK");
|
2011-07-09 23:51:18 +00:00
|
|
|
MB[1] = NULL;
|
|
|
|
setShapeList(MB);
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-20 12:27:36 +00:00
|
|
|
void Square::touch(uint16 mask, int x, int y) {
|
2011-07-01 23:02:14 +00:00
|
|
|
Sprite::touch(mask, x, y);
|
2011-08-02 19:47:56 +00:00
|
|
|
if (mask & kMouseLeftUp) {
|
2011-07-01 06:37:40 +00:00
|
|
|
XZ(_x + x, _y + y).cell() = 0;
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnKill, -1, 0, this);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::setMapBrick(int x, int z) {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::setMapBrick(%d, %d)", x, z);
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-07-20 12:27:36 +00:00
|
|
|
Square *s = new Square(this);
|
2011-06-13 09:57:24 +00:00
|
|
|
if (s) {
|
2011-09-06 23:02:05 +00:00
|
|
|
char n[6];
|
2011-07-30 22:52:35 +00:00
|
|
|
s->gotoxy(x * kMapGridX, kMapTop + z * kMapGridZ);
|
2011-09-06 23:02:05 +00:00
|
|
|
sprintf(n, "%02d:%02d", x, z);
|
2011-07-01 06:37:40 +00:00
|
|
|
Cluster::_map[z][x] = 1;
|
2011-07-01 23:02:14 +00:00
|
|
|
s->setName(n);
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->insert(s, _vga->_showQ->first());
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-07 06:11:29 +00:00
|
|
|
void CGEEngine::keyClick() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::keyClick()");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnSound, -1, 5, NULL);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::resetQSwitch() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::resetQSwitch()");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnSeq, 123, 0, NULL);
|
2011-07-07 06:11:29 +00:00
|
|
|
keyClick();
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::quit() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::quit()");
|
2011-07-18 16:05:57 +00:00
|
|
|
|
2011-07-28 13:35:12 +00:00
|
|
|
static Choice QuitMenu[] = {
|
2011-07-01 06:37:40 +00:00
|
|
|
{ NULL, &CGEEngine::startCountDown },
|
|
|
|
{ NULL, &CGEEngine::resetQSwitch },
|
2011-06-26 23:03:47 +00:00
|
|
|
{ NULL, &CGEEngine::dummy }
|
2011-06-13 09:57:24 +00:00
|
|
|
};
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-19 10:36:43 +00:00
|
|
|
if (_snail->idle() && !_hero->_flags._hide) {
|
2011-07-03 14:22:26 +00:00
|
|
|
if (Vmenu::_addr) {
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnKill, -1, 0, Vmenu::_addr);
|
2011-07-01 06:37:40 +00:00
|
|
|
resetQSwitch();
|
2011-06-13 09:57:24 +00:00
|
|
|
} else {
|
2011-07-22 09:54:46 +00:00
|
|
|
QuitMenu[0]._text = _text->getText(kQuit);
|
|
|
|
QuitMenu[1]._text = _text->getText(kNoQuit);
|
|
|
|
(new Vmenu(this, QuitMenu, -1, -1))->setName(_text->getText(kQuitTitle));
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnSeq, 123, 1, NULL);
|
2011-07-07 06:11:29 +00:00
|
|
|
keyClick();
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-12 22:28:17 +00:00
|
|
|
void CGEEngine::miniStep(int stp) {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::miniStep(%d)", stp);
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-08-19 22:40:44 +00:00
|
|
|
if (stp < 0) {
|
2011-09-14 06:15:30 +00:00
|
|
|
_miniScene->_flags._hide = true;
|
2011-08-19 22:40:44 +00:00
|
|
|
} else {
|
2011-07-03 09:28:22 +00:00
|
|
|
*_miniShp[0] = *_miniShpList[stp];
|
2011-09-14 06:15:30 +00:00
|
|
|
_miniScene->_flags._hide = false;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-18 21:09:57 +00:00
|
|
|
void CGEEngine::postMiniStep(int step) {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(6, kCGEDebugEngine, "CGEEngine::postMiniStep(%d)", step);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
if (_miniScene && step != _recentStep)
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom2(kSnExec, -1, _recentStep = step, kMiniStep);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-18 21:14:22 +00:00
|
|
|
void CGEEngine::showBak(int ref) {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::showBack(%d)", ref);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
Sprite *spr = _vga->_spareQ->locate(ref);
|
2011-08-19 14:04:10 +00:00
|
|
|
if (!spr)
|
|
|
|
return;
|
|
|
|
|
2011-08-27 17:09:13 +00:00
|
|
|
Bitmap::_pal = _vga->_sysPal;
|
2011-08-19 14:04:10 +00:00
|
|
|
spr->expand();
|
|
|
|
Bitmap::_pal = NULL;
|
|
|
|
spr->show(2);
|
|
|
|
_vga->copyPage(1, 2);
|
|
|
|
_sys->setPal();
|
|
|
|
spr->contract();
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
void CGEEngine::sceneUp() {
|
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::sceneUp()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-08-19 14:04:10 +00:00
|
|
|
const int BakRef = 1000 * _now;
|
2011-07-02 16:20:41 +00:00
|
|
|
if (_music)
|
2011-08-12 11:33:45 +00:00
|
|
|
_midiPlayer.loadMidi(_now);
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-07-18 21:14:22 +00:00
|
|
|
showBak(BakRef);
|
2011-07-03 09:28:22 +00:00
|
|
|
loadMapping();
|
2011-07-03 14:22:26 +00:00
|
|
|
Sprite *spr = _vga->_spareQ->first();
|
2011-06-13 09:57:24 +00:00
|
|
|
while (spr) {
|
2011-06-29 14:13:17 +00:00
|
|
|
Sprite *n = spr->_next;
|
2011-09-14 06:15:30 +00:00
|
|
|
if (spr->_scene == _now || spr->_scene == 0)
|
2011-06-28 22:35:21 +00:00
|
|
|
if (spr->_ref != BakRef) {
|
2011-08-19 10:36:43 +00:00
|
|
|
if (spr->_flags._back)
|
2011-07-01 23:02:14 +00:00
|
|
|
spr->backShow();
|
2011-06-13 09:57:24 +00:00
|
|
|
else
|
2011-07-05 21:13:12 +00:00
|
|
|
expandSprite(spr);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
spr = n;
|
|
|
|
}
|
2011-07-24 21:42:03 +00:00
|
|
|
|
2011-07-29 08:02:32 +00:00
|
|
|
_sound->stop();
|
|
|
|
_fx->clear();
|
|
|
|
_fx->preload(0);
|
|
|
|
_fx->preload(BakRef);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
if (_hero) {
|
2011-09-06 21:14:49 +00:00
|
|
|
_hero->gotoxy(_heroXY[_now - 1].x, _heroXY[_now - 1].y);
|
2011-06-13 09:57:24 +00:00
|
|
|
// following 2 lines trims Hero's Z position!
|
2011-07-03 14:22:26 +00:00
|
|
|
_hero->tick();
|
|
|
|
_hero->_time = 1;
|
2011-08-19 10:36:43 +00:00
|
|
|
_hero->_flags._hide = false;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-02 16:20:41 +00:00
|
|
|
if (!_dark)
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->sunset();
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->copyPage(0, 1);
|
2011-07-02 16:20:41 +00:00
|
|
|
selectPocket(-1);
|
2011-07-03 14:22:26 +00:00
|
|
|
if (_hero)
|
|
|
|
_vga->_showQ->insert(_vga->_showQ->remove(_hero));
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-06-28 22:35:21 +00:00
|
|
|
if (_shadow) {
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->remove(_shadow);
|
2011-09-16 05:55:50 +00:00
|
|
|
_shadow->makeXlat(_vga->glass(_vga->_sysPal, 204, 204, 204));
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->insert(_shadow, _hero);
|
|
|
|
_shadow->_z = _hero->_z;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-07-13 06:44:58 +00:00
|
|
|
feedSnail(_vga->_showQ->locate(BakRef + 999), kTake);
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->show();
|
|
|
|
_vga->copyPage(1, 0);
|
|
|
|
_vga->show();
|
2011-08-27 17:09:13 +00:00
|
|
|
_vga->sunrise(_vga->_sysPal);
|
2011-07-02 16:20:41 +00:00
|
|
|
_dark = false;
|
2011-07-04 06:15:56 +00:00
|
|
|
if (!_startupMode)
|
2011-07-08 06:21:35 +00:00
|
|
|
_mouse->on();
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
void CGEEngine::sceneDown() {
|
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::sceneDown()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-08-19 10:36:43 +00:00
|
|
|
if (_horzLine && !_horzLine->_flags._hide)
|
2011-07-01 06:37:40 +00:00
|
|
|
switchMapping();
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-19 14:04:10 +00:00
|
|
|
for (Sprite *spr = _vga->_showQ->first(); spr;) {
|
2011-06-29 14:13:17 +00:00
|
|
|
Sprite *n = spr->_next;
|
2011-09-14 06:15:30 +00:00
|
|
|
if (spr->_ref >= 1000 /*&& spr->_scene*/) {
|
2011-06-28 22:35:21 +00:00
|
|
|
if (spr->_ref % 1000 == 999)
|
2011-07-13 06:44:58 +00:00
|
|
|
feedSnail(spr, kTake);
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_spareQ->append(_vga->_showQ->remove(spr));
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-18 06:54:22 +00:00
|
|
|
spr = n;
|
|
|
|
}
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
void CGEEngine::xScene() {
|
|
|
|
debugC(6, kCGEDebugEngine, "CGEEngine::xScene()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
sceneDown();
|
|
|
|
sceneUp();
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::qGame() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::qGame()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
sceneDown();
|
2011-07-02 16:20:41 +00:00
|
|
|
_oldLev = _lev;
|
2011-07-09 23:44:46 +00:00
|
|
|
|
|
|
|
// Write out the user's progress
|
2011-08-27 16:01:06 +00:00
|
|
|
saveGame(0, Common::String("Automatic Savegame"));
|
2011-07-09 23:44:46 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->sunset();
|
2011-07-03 09:28:22 +00:00
|
|
|
_finis = true;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
void CGEEngine::switchScene(int newScene) {
|
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::switchScene(%d)", newScene);
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
if (newScene == _now)
|
2011-08-19 14:04:10 +00:00
|
|
|
return;
|
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
if (newScene < 0) {
|
2011-08-19 14:04:10 +00:00
|
|
|
_snail->addCom(kSnLabel, -1, 0, NULL); // wait for repaint
|
2011-09-14 06:15:30 +00:00
|
|
|
_snail->addCom2(kSnExec, -1, 0, kQGame); // switch scene
|
2011-08-19 14:04:10 +00:00
|
|
|
} else {
|
2011-09-14 06:15:30 +00:00
|
|
|
_now = newScene;
|
2011-08-19 14:04:10 +00:00
|
|
|
_mouse->off();
|
|
|
|
if (_hero) {
|
|
|
|
_hero->park();
|
|
|
|
_hero->step(0);
|
2011-08-29 20:51:45 +00:00
|
|
|
_vga->_spareQ->_show = 0;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-09-14 06:15:30 +00:00
|
|
|
_sceneLight->gotoxy(kSceneX + ((_now - 1) % kSceneNx) * kSceneDx + kSceneSX,
|
|
|
|
kSceneY + ((_now - 1) / kSceneNx) * kSceneDy + kSceneSY);
|
2011-08-19 14:04:10 +00:00
|
|
|
killText();
|
|
|
|
if (!_startupMode)
|
|
|
|
keyClick();
|
|
|
|
_snail->addCom(kSnLabel, -1, 0, NULL); // wait for repaint
|
2011-09-14 06:15:30 +00:00
|
|
|
_snail->addCom2(kSnExec, 0, 0, kXScene); // switch scene
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-04 06:15:56 +00:00
|
|
|
System::System(CGEEngine *vm) : Sprite(vm, NULL), _vm(vm) {
|
2011-07-20 23:56:40 +00:00
|
|
|
_funDel = kHeroFun0;
|
2011-07-04 06:15:56 +00:00
|
|
|
setPal();
|
|
|
|
tick();
|
2011-06-20 21:40:22 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-18 21:09:57 +00:00
|
|
|
void System::setPal() {
|
2011-09-05 22:43:40 +00:00
|
|
|
Dac *p = _vga->_sysPal + 256 - ARRAYSIZE(g_stdPal);
|
|
|
|
for (uint i = 0; i < ARRAYSIZE(g_stdPal); i++) {
|
|
|
|
p[i]._r = g_stdPal[i]._r >> 2;
|
|
|
|
p[i]._g = g_stdPal[i]._g >> 2;
|
|
|
|
p[i]._b = g_stdPal[i]._b >> 2;
|
2011-07-18 21:09:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void System::funTouch() {
|
2011-08-02 19:47:56 +00:00
|
|
|
uint16 n = (_vm->_flag[0]) ? kHeroFun1 : kHeroFun0; // PAIN flag
|
2011-07-18 21:09:57 +00:00
|
|
|
if (_talk == NULL || n > _funDel)
|
|
|
|
_funDel = n;
|
|
|
|
}
|
|
|
|
|
2011-07-04 06:15:56 +00:00
|
|
|
void System::touch(uint16 mask, int x, int y) {
|
|
|
|
funTouch();
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
if (mask & kEventKeyb) {
|
2011-07-07 06:11:29 +00:00
|
|
|
_vm->keyClick();
|
2011-07-03 09:28:22 +00:00
|
|
|
killText();
|
2011-07-04 06:15:56 +00:00
|
|
|
if (_vm->_startupMode == 1) {
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail->addCom(kSnClear, -1, 0, NULL);
|
2011-06-13 09:57:24 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
switch (x) {
|
|
|
|
case 'X':
|
2011-07-31 17:56:14 +00:00
|
|
|
if (_keyboard->_key[kKeyAlt])
|
2011-09-04 09:23:01 +00:00
|
|
|
_vm->quit();
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
|
|
|
case '0':
|
|
|
|
case '1':
|
|
|
|
case '2':
|
|
|
|
case '3':
|
|
|
|
case '4':
|
2011-07-31 17:56:14 +00:00
|
|
|
if (_keyboard->_key[kKeyAlt]) {
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail->addCom(kSnLevel, -1, x - '0', NULL);
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
|
|
|
}
|
2011-09-04 09:23:01 +00:00
|
|
|
break;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
} else {
|
2011-07-04 06:15:56 +00:00
|
|
|
if (_vm->_startupMode)
|
2011-06-13 09:57:24 +00:00
|
|
|
return;
|
2011-09-14 06:15:30 +00:00
|
|
|
int selectedScene = 0;
|
2011-07-03 09:28:22 +00:00
|
|
|
_infoLine->update(NULL);
|
2011-07-20 23:56:40 +00:00
|
|
|
if (y >= kWorldHeight ) {
|
2011-09-14 06:15:30 +00:00
|
|
|
if (x < kButtonX) { // select scene?
|
|
|
|
if (y >= kSceneY && y < kSceneY + kSceneNy * kSceneDy &&
|
|
|
|
x >= kSceneX && x < kSceneX + kSceneNx * kSceneDx && !_vm->_game) {
|
|
|
|
selectedScene = ((y - kSceneY) / kSceneDy) * kSceneNx + (x - kSceneX) / kSceneDx + 1;
|
|
|
|
if (selectedScene > _vm->_maxScene)
|
|
|
|
selectedScene = 0;
|
2011-06-13 09:57:24 +00:00
|
|
|
} else {
|
2011-09-14 06:15:30 +00:00
|
|
|
selectedScene = 0;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-08-02 19:47:56 +00:00
|
|
|
} else if (mask & kMouseLeftUp) {
|
2011-07-20 23:56:40 +00:00
|
|
|
if (y >= kPocketY && y < kPocketY + kPocketNY * kPocketDY &&
|
|
|
|
x >= kPocketX && x < kPocketX + kPocketNX * kPocketDX) {
|
|
|
|
int n = ((y - kPocketY) / kPocketDY) * kPocketNX + (x - kPocketX) / kPocketDX;
|
2011-07-04 06:15:56 +00:00
|
|
|
_vm->selectPocket(n);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
_vm->postMiniStep(selectedScene - 1);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
if (mask & kMouseLeftUp) {
|
2011-09-14 06:15:30 +00:00
|
|
|
if (selectedScene && _snail->idle() && _hero->_tracePtr < 0)
|
|
|
|
_vm->switchScene(selectedScene);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-19 10:36:43 +00:00
|
|
|
if (_horzLine && !_horzLine->_flags._hide) {
|
2011-07-30 22:52:35 +00:00
|
|
|
if (y >= kMapTop && y < kMapTop + kMapHig) {
|
2011-09-05 21:50:30 +00:00
|
|
|
Cluster tmpCluster = XZ(x, y);
|
|
|
|
int16 x1 = tmpCluster._pt.x;
|
|
|
|
int16 z1 = tmpCluster._pt.y;
|
2011-07-01 06:37:40 +00:00
|
|
|
Cluster::_map[z1][x1] = 1;
|
|
|
|
_vm->setMapBrick(x1, z1);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-07-18 21:09:57 +00:00
|
|
|
} else {
|
2011-07-03 14:22:26 +00:00
|
|
|
if (!_talk && _snail->idle() && _hero
|
2011-07-30 22:52:35 +00:00
|
|
|
&& y >= kMapTop && y < kMapTop + kMapHig && !_vm->_game) {
|
2011-07-03 14:22:26 +00:00
|
|
|
_hero->findWay(XZ(x, y));
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-04 06:15:56 +00:00
|
|
|
void System::tick() {
|
|
|
|
if (!_vm->_startupMode)
|
|
|
|
if (--_funDel == 0) {
|
2011-07-03 09:28:22 +00:00
|
|
|
killText();
|
2011-07-02 16:20:41 +00:00
|
|
|
if (_snail->idle()) {
|
2011-08-02 19:47:56 +00:00
|
|
|
if (_vm->_flag[0]) // Pain flag
|
2011-07-07 06:11:29 +00:00
|
|
|
_vm->heroCover(9);
|
2011-07-25 17:09:12 +00:00
|
|
|
else { // CHECKME: Before, was: if (Startup::_core >= CORE_MID) {
|
2011-09-15 05:58:31 +00:00
|
|
|
int n = _vm->newRandom(100);
|
2011-06-13 09:57:24 +00:00
|
|
|
if (n > 96)
|
2011-07-20 23:56:40 +00:00
|
|
|
_vm->heroCover(6 + (_hero->_x + _hero->_w / 2 < kScrWidth / 2));
|
2011-08-19 23:32:20 +00:00
|
|
|
else if (n > 90)
|
|
|
|
_vm->heroCover(5);
|
|
|
|
else if (n > 60)
|
|
|
|
_vm->heroCover(4);
|
|
|
|
else
|
|
|
|
_vm->heroCover(3);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
}
|
2011-07-04 06:15:56 +00:00
|
|
|
funTouch();
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-07-20 23:56:40 +00:00
|
|
|
_time = kSystemRate;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-07 06:11:29 +00:00
|
|
|
void CGEEngine::switchColorMode() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::switchColorMode()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnSeq, 121, _vga->_mono = !_vga->_mono, NULL);
|
2011-07-07 06:11:29 +00:00
|
|
|
keyClick();
|
2011-08-27 17:09:13 +00:00
|
|
|
_vga->setColors(_vga->_sysPal, 64);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-04 06:15:56 +00:00
|
|
|
void CGEEngine::switchMusic() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::switchMusic()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-09-04 09:23:01 +00:00
|
|
|
_snail_->addCom(kSnSeq, 122, (_music = !_music), NULL);
|
|
|
|
keyClick();
|
|
|
|
|
2011-07-02 16:20:41 +00:00
|
|
|
if (_music)
|
2011-08-12 11:33:45 +00:00
|
|
|
_midiPlayer.loadMidi(_now);
|
2011-06-13 09:57:24 +00:00
|
|
|
else
|
2011-08-12 11:33:45 +00:00
|
|
|
_midiPlayer.killMidi();
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::startCountDown() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::startCountDown()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
switchScene(-1);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::switchMapping() {
|
2011-08-13 06:44:48 +00:00
|
|
|
assert(_horzLine);
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::switchMapping()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-08-19 10:36:43 +00:00
|
|
|
if (_horzLine && _horzLine->_flags._hide) {
|
2011-08-19 14:04:10 +00:00
|
|
|
for (int i = 0; i < kMapZCnt; i++) {
|
|
|
|
for (int j = 0; j < kMapXCnt; j++) {
|
2011-07-01 06:37:40 +00:00
|
|
|
if (Cluster::_map[i][j])
|
|
|
|
setMapBrick(j, i);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2011-08-19 14:04:10 +00:00
|
|
|
for (Sprite *s = _vga->_showQ->first(); s; s = s->_next)
|
2011-07-30 22:52:35 +00:00
|
|
|
if (s->_w == kMapGridX && s->_h == kMapGridZ)
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnKill, -1, 0, s);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-08-19 10:36:43 +00:00
|
|
|
_horzLine->_flags._hide = !_horzLine->_flags._hide;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-07 06:11:29 +00:00
|
|
|
void CGEEngine::killSprite() {
|
2011-07-20 12:22:56 +00:00
|
|
|
debugC(1, kCGEDebugEngine, "CGEEngine::killSprite()");
|
2011-07-18 21:09:57 +00:00
|
|
|
|
2011-08-19 10:36:43 +00:00
|
|
|
_sprite->_flags._kill = true;
|
|
|
|
_sprite->_flags._bDel = true;
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnKill, -1, 0, _sprite);
|
2011-06-28 22:35:21 +00:00
|
|
|
_sprite = NULL;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::optionTouch(int opt, uint16 mask) {
|
2011-06-13 09:57:24 +00:00
|
|
|
switch (opt) {
|
2011-08-19 14:04:10 +00:00
|
|
|
case 1:
|
2011-08-02 19:47:56 +00:00
|
|
|
if (mask & kMouseLeftUp)
|
2011-07-07 06:11:29 +00:00
|
|
|
switchColorMode();
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
case 2:
|
2011-08-21 07:51:49 +00:00
|
|
|
if (mask & kMouseLeftUp)
|
2011-07-04 06:15:56 +00:00
|
|
|
switchMusic();
|
2011-08-21 07:51:49 +00:00
|
|
|
else if (mask & kMouseRightUp)
|
|
|
|
warning("TODO: Use ScummVM sound dialog");
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
case 3:
|
2011-08-02 19:47:56 +00:00
|
|
|
if (mask & kMouseLeftUp)
|
2011-07-01 06:37:40 +00:00
|
|
|
quit();
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
#pragma argsused
|
2011-07-01 23:02:14 +00:00
|
|
|
void Sprite::touch(uint16 mask, int x, int y) {
|
2011-07-04 06:15:56 +00:00
|
|
|
_sys->funTouch();
|
2011-08-19 14:04:10 +00:00
|
|
|
|
|
|
|
if ((mask & kEventAttn) != 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
_infoLine->update(name());
|
|
|
|
|
|
|
|
if (mask & (kMouseRightDown | kMouseLeftDown))
|
|
|
|
_sprite = this;
|
|
|
|
|
|
|
|
if (_ref / 10 == 12) {
|
|
|
|
_vm->optionTouch(_ref % 10, mask);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_flags._syst)
|
|
|
|
return; // cannot access system sprites
|
|
|
|
|
|
|
|
if (_vm->_game)
|
|
|
|
if (mask & kMouseLeftUp) {
|
|
|
|
mask &= ~kMouseLeftUp;
|
|
|
|
mask |= kMouseRightUp;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
2011-08-19 14:04:10 +00:00
|
|
|
|
|
|
|
if ((mask & kMouseRightUp) && _snail->idle()) {
|
|
|
|
Sprite *ps = (_pocLight->_seqPtr) ? _pocket[_vm->_pocPtr] : NULL;
|
|
|
|
if (ps) {
|
|
|
|
if (_flags._kept || _hero->distance(this) < kDistMax) {
|
|
|
|
if (works(ps)) {
|
|
|
|
_vm->feedSnail(ps, kTake);
|
2011-06-13 11:07:45 +00:00
|
|
|
} else
|
2011-08-19 14:04:10 +00:00
|
|
|
_vm->offUse();
|
|
|
|
_vm->selectPocket(-1);
|
|
|
|
} else
|
|
|
|
_vm->tooFar();
|
|
|
|
} else {
|
|
|
|
if (_flags._kept) {
|
|
|
|
mask |= kMouseLeftUp;
|
2011-06-13 09:57:24 +00:00
|
|
|
} else {
|
2011-08-19 14:04:10 +00:00
|
|
|
if (_hero->distance(this) < kDistMax) {
|
|
|
|
if (_flags._port) {
|
2011-08-21 09:15:28 +00:00
|
|
|
if (_vm->findPocket(NULL) < 0) {
|
2011-08-19 14:04:10 +00:00
|
|
|
_vm->pocFul();
|
2011-08-21 09:15:28 +00:00
|
|
|
} else {
|
2011-08-19 14:04:10 +00:00
|
|
|
_snail->addCom(kSnReach, -1, -1, this);
|
|
|
|
_snail->addCom(kSnKeep, -1, -1, this);
|
|
|
|
_flags._port = false;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-08-19 14:04:10 +00:00
|
|
|
} else {
|
2011-08-21 09:15:28 +00:00
|
|
|
if (_takePtr != kNoPtr) {
|
2011-08-19 14:04:10 +00:00
|
|
|
if (snList(kTake)[_takePtr]._com == kSnNext)
|
|
|
|
_vm->offUse();
|
|
|
|
else
|
|
|
|
_vm->feedSnail(this, kTake);
|
2011-08-21 09:15:28 +00:00
|
|
|
} else {
|
2011-08-19 14:04:10 +00:00
|
|
|
_vm->offUse();
|
2011-08-21 09:15:28 +00:00
|
|
|
}
|
2011-08-19 14:04:10 +00:00
|
|
|
}
|
2011-08-21 09:15:28 +00:00
|
|
|
} else {
|
2011-08-19 14:04:10 +00:00
|
|
|
_vm->tooFar();
|
2011-08-21 09:15:28 +00:00
|
|
|
}
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
2011-08-19 14:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ((mask & kMouseLeftUp) && _snail->idle()) {
|
|
|
|
if (_flags._kept) {
|
|
|
|
for (int n = 0; n < kPocketNX; n++) {
|
|
|
|
if (_pocket[n] == this) {
|
|
|
|
_vm->selectPocket(n);
|
|
|
|
break;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-08-19 14:04:10 +00:00
|
|
|
}
|
2011-08-21 09:15:28 +00:00
|
|
|
} else {
|
2011-08-19 14:04:10 +00:00
|
|
|
_snail->addCom(kSnWalk, -1, -1, this); // Hero->FindWay(this);
|
2011-08-21 09:15:28 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
void CGEEngine::loadSprite(const char *fname, int ref, int scene, int col = 0, int row = 0, int pos = 0) {
|
2011-06-13 09:57:24 +00:00
|
|
|
static const char *Comd[] = { "Name", "Type", "Phase", "East",
|
|
|
|
"Left", "Right", "Top", "Bottom",
|
|
|
|
"Seq", "Near", "Take",
|
|
|
|
"Portable", "Transparent",
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
static const char *Type[] = { "DEAD", "AUTO", "WALK", "NEWTON", "LISSAJOUS",
|
|
|
|
"FLY", NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
int shpcnt = 0;
|
|
|
|
int type = 0; // DEAD
|
|
|
|
bool east = false;
|
|
|
|
bool port = false;
|
|
|
|
bool tran = false;
|
|
|
|
int i, lcnt = 0;
|
|
|
|
|
2011-09-11 20:13:00 +00:00
|
|
|
char tmpStr[kLineMax + 1];
|
|
|
|
Common::String line;
|
|
|
|
mergeExt(tmpStr, fname, kSprExt);
|
2011-08-19 14:04:10 +00:00
|
|
|
|
2011-09-13 22:10:59 +00:00
|
|
|
if (_resman->exist(tmpStr)) { // sprite description file exist
|
2011-09-11 20:13:00 +00:00
|
|
|
EncryptedStream sprf(tmpStr);
|
|
|
|
if (sprf.err())
|
|
|
|
error("Bad SPR [%s]", tmpStr);
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-08-19 14:04:10 +00:00
|
|
|
uint16 len;
|
2011-09-11 20:13:00 +00:00
|
|
|
for (line = sprf.readLine(); !sprf.eos(); line = sprf.readLine()) {
|
|
|
|
len = line.size();
|
2011-07-25 14:04:45 +00:00
|
|
|
lcnt++;
|
2011-09-11 20:13:00 +00:00
|
|
|
strcpy(tmpStr, line.c_str());
|
|
|
|
if (len == 0 || *tmpStr == '.')
|
2011-06-13 09:57:24 +00:00
|
|
|
continue;
|
|
|
|
|
2011-09-11 20:13:00 +00:00
|
|
|
if ((i = takeEnum(Comd, strtok(tmpStr, " =\t"))) < 0)
|
2011-07-02 18:25:39 +00:00
|
|
|
error("Bad line %d [%s]", lcnt, fname);
|
2011-06-13 09:57:24 +00:00
|
|
|
|
|
|
|
|
|
|
|
switch (i) {
|
|
|
|
case 0 : // Name - will be taken in Expand routine
|
|
|
|
break;
|
|
|
|
case 1 : // Type
|
2011-07-01 23:02:14 +00:00
|
|
|
if ((type = takeEnum(Type, strtok(NULL, " \t,;/"))) < 0)
|
2011-07-02 18:25:39 +00:00
|
|
|
error("Bad line %d [%s]", lcnt, fname);
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
|
|
|
case 2 : // Phase
|
2011-07-25 14:04:45 +00:00
|
|
|
shpcnt++;
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
|
|
|
case 3 : // East
|
|
|
|
east = (atoi(strtok(NULL, " \t,;/")) != 0);
|
|
|
|
break;
|
|
|
|
case 11 : // Portable
|
|
|
|
port = (atoi(strtok(NULL, " \t,;/")) != 0);
|
|
|
|
break;
|
|
|
|
case 12 : // Transparent
|
|
|
|
tran = (atoi(strtok(NULL, " \t,;/")) != 0);
|
|
|
|
break;
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
2011-06-13 09:57:24 +00:00
|
|
|
if (! shpcnt)
|
|
|
|
error("No shapes [%s]", fname);
|
2011-09-11 20:13:00 +00:00
|
|
|
} else {
|
|
|
|
// no sprite description: mono-shaped sprite with only .BMP file
|
2011-06-13 09:57:24 +00:00
|
|
|
++shpcnt;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
// make sprite of choosen type
|
|
|
|
switch (type) {
|
2011-08-19 14:04:10 +00:00
|
|
|
case 1:
|
|
|
|
// AUTO
|
2011-06-28 22:35:21 +00:00
|
|
|
_sprite = new Sprite(this, NULL);
|
|
|
|
if (_sprite) {
|
2011-07-01 23:02:14 +00:00
|
|
|
_sprite->gotoxy(col, row);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
case 2:
|
|
|
|
{ // WALK
|
2011-07-24 21:42:03 +00:00
|
|
|
Walk *w = new Walk(this, NULL);
|
2011-06-13 09:57:24 +00:00
|
|
|
if (w && ref == 1) {
|
2011-07-01 23:02:14 +00:00
|
|
|
w->gotoxy(col, row);
|
2011-07-03 14:22:26 +00:00
|
|
|
if (_hero)
|
2011-06-13 09:57:24 +00:00
|
|
|
error("2nd HERO [%s]", fname);
|
2011-07-03 14:22:26 +00:00
|
|
|
_hero = w;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-28 22:35:21 +00:00
|
|
|
_sprite = w;
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
}
|
2011-09-11 20:13:00 +00:00
|
|
|
case 3: // NEWTON
|
|
|
|
case 4: // LISSAJOUS
|
2011-06-13 09:57:24 +00:00
|
|
|
error("Bad type [%s]", fname);
|
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
case 5:
|
|
|
|
{ // FLY
|
2011-07-01 06:37:40 +00:00
|
|
|
Fly *f = new Fly(this, NULL);
|
2011-06-28 22:35:21 +00:00
|
|
|
_sprite = f;
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
}
|
|
|
|
default:
|
|
|
|
// DEAD
|
2011-06-28 22:35:21 +00:00
|
|
|
_sprite = new Sprite(this, NULL);
|
|
|
|
if (_sprite)
|
2011-07-01 23:02:14 +00:00
|
|
|
_sprite->gotoxy(col, row);
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
2011-08-19 14:04:10 +00:00
|
|
|
|
2011-06-28 22:35:21 +00:00
|
|
|
if (_sprite) {
|
|
|
|
_sprite->_ref = ref;
|
2011-09-14 06:15:30 +00:00
|
|
|
_sprite->_scene = scene;
|
2011-06-29 14:13:17 +00:00
|
|
|
_sprite->_z = pos;
|
2011-08-19 10:36:43 +00:00
|
|
|
_sprite->_flags._east = east;
|
|
|
|
_sprite->_flags._port = port;
|
|
|
|
_sprite->_flags._tran = tran;
|
|
|
|
_sprite->_flags._kill = true;
|
|
|
|
_sprite->_flags._bDel = true;
|
2011-06-29 11:17:07 +00:00
|
|
|
|
|
|
|
// Extract the filename, without the extension
|
2011-07-01 23:02:14 +00:00
|
|
|
strcpy(_sprite->_file, fname);
|
|
|
|
char *p = strchr(_sprite->_file, '.');
|
2011-06-29 11:17:07 +00:00
|
|
|
if (p)
|
|
|
|
*p = '\0';
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-06-29 14:13:17 +00:00
|
|
|
_sprite->_shpCnt = shpcnt;
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_spareQ->append(_sprite);
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::loadScript(const char *fname) {
|
2011-09-11 20:13:00 +00:00
|
|
|
EncryptedStream scrf(fname);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-11 20:13:00 +00:00
|
|
|
if (scrf.err())
|
2011-06-13 09:57:24 +00:00
|
|
|
return;
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-19 14:04:10 +00:00
|
|
|
bool ok = true;
|
|
|
|
int lcnt = 0;
|
|
|
|
|
2011-09-11 20:13:00 +00:00
|
|
|
char tmpStr[kLineMax+1];
|
|
|
|
Common::String line;
|
|
|
|
|
|
|
|
for (line = scrf.readLine(); !scrf.eos(); line = scrf.readLine()) {
|
2011-06-13 09:57:24 +00:00
|
|
|
char *p;
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
lcnt++;
|
2011-09-11 20:13:00 +00:00
|
|
|
strcpy(tmpStr, line.c_str());
|
|
|
|
if ((line.size() == 0) || (*tmpStr == '.'))
|
2011-06-13 09:57:24 +00:00
|
|
|
continue;
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
ok = false; // not OK if break
|
2011-08-19 14:04:10 +00:00
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
// sprite ident number
|
2011-09-11 20:13:00 +00:00
|
|
|
if ((p = strtok(tmpStr, " \t\n")) == NULL)
|
2011-06-09 06:20:53 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
int SpI = atoi(p);
|
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
// sprite file name
|
2011-08-19 14:04:10 +00:00
|
|
|
char *SpN;
|
2011-06-13 11:07:45 +00:00
|
|
|
if ((SpN = strtok(NULL, " ,;/\t\n")) == NULL)
|
2011-06-09 06:20:53 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
// sprite scene
|
2011-06-13 11:07:45 +00:00
|
|
|
if ((p = strtok(NULL, " ,;/\t\n")) == NULL)
|
2011-06-09 06:20:53 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
int SpA = atoi(p);
|
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
// sprite column
|
2011-06-13 11:07:45 +00:00
|
|
|
if ((p = strtok(NULL, " ,;/\t\n")) == NULL)
|
2011-06-09 06:20:53 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
int SpX = atoi(p);
|
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
// sprite row
|
2011-06-13 11:07:45 +00:00
|
|
|
if ((p = strtok(NULL, " ,;/\t\n")) == NULL)
|
2011-06-09 06:20:53 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
int SpY = atoi(p);
|
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
// sprite Z pos
|
2011-06-13 11:07:45 +00:00
|
|
|
if ((p = strtok(NULL, " ,;/\t\n")) == NULL)
|
2011-06-09 06:20:53 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
int SpZ = atoi(p);
|
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
// sprite life
|
2011-06-13 11:07:45 +00:00
|
|
|
if ((p = strtok(NULL, " ,;/\t\n")) == NULL)
|
2011-06-13 09:57:24 +00:00
|
|
|
break;
|
2011-08-19 14:04:10 +00:00
|
|
|
bool BkG = atoi(p) == 0;
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-06-13 09:57:24 +00:00
|
|
|
ok = true; // no break: OK
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-06-28 22:35:21 +00:00
|
|
|
_sprite = NULL;
|
2011-07-01 06:37:40 +00:00
|
|
|
loadSprite(SpN, SpI, SpA, SpX, SpY, SpZ);
|
2011-06-28 22:35:21 +00:00
|
|
|
if (_sprite && BkG)
|
2011-08-19 10:36:43 +00:00
|
|
|
_sprite->_flags._back = true;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-08-19 14:04:10 +00:00
|
|
|
|
|
|
|
if (!ok)
|
2011-07-02 18:25:39 +00:00
|
|
|
error("Bad INI line %d [%s]", lcnt, fname);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-16 04:45:28 +00:00
|
|
|
Sprite *CGEEngine::locate(int ref) {
|
|
|
|
Sprite *spr = _vga->_showQ->locate(ref);
|
|
|
|
return (spr) ? spr : _vga->_spareQ->locate(ref);
|
|
|
|
}
|
|
|
|
|
|
|
|
Sprite *CGEEngine::spriteAt(int x, int y) {
|
|
|
|
Sprite *spr = NULL, * tail = _vga->_showQ->last();
|
|
|
|
if (tail) {
|
|
|
|
for (spr = tail->_prev; spr; spr = spr->_prev) {
|
|
|
|
if (! spr->_flags._hide && ! spr->_flags._tran) {
|
|
|
|
if (spr->shp()->solidAt(x - spr->_x, y - spr->_y))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return spr;
|
|
|
|
}
|
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::mainLoop() {
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->show();
|
2011-07-02 16:20:41 +00:00
|
|
|
_snail_->runCom();
|
|
|
|
_snail->runCom();
|
2011-06-29 11:17:07 +00:00
|
|
|
|
2011-07-16 12:28:49 +00:00
|
|
|
// Handle a delay between game frames
|
|
|
|
handleFrame();
|
|
|
|
|
|
|
|
// Handle any pending events
|
|
|
|
_eventManager->poll();
|
|
|
|
}
|
|
|
|
|
|
|
|
void CGEEngine::handleFrame() {
|
2011-07-02 08:38:25 +00:00
|
|
|
// Game frame delay
|
|
|
|
uint32 millis = g_system->getMillis();
|
2011-08-02 19:47:56 +00:00
|
|
|
while (!_eventManager->_quitFlag && (millis < (_lastFrame + kGameFrameDelay))) {
|
2011-07-02 08:38:25 +00:00
|
|
|
// Handle any pending events
|
|
|
|
_eventManager->poll();
|
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
if (millis >= (_lastTick + kGameTickDelay)) {
|
2011-07-16 12:28:49 +00:00
|
|
|
// Dispatch the tick to any active objects
|
|
|
|
tick();
|
|
|
|
_lastTick = millis;
|
|
|
|
}
|
|
|
|
|
2011-07-02 08:38:25 +00:00
|
|
|
// Slight delay
|
2011-08-10 08:38:06 +00:00
|
|
|
g_system->delayMillis(5);
|
2011-07-02 08:38:25 +00:00
|
|
|
millis = g_system->getMillis();
|
|
|
|
}
|
|
|
|
_lastFrame = millis;
|
2011-07-03 10:20:01 +00:00
|
|
|
|
2011-08-02 19:47:56 +00:00
|
|
|
if (millis >= (_lastTick + kGameTickDelay)) {
|
2011-07-16 12:28:49 +00:00
|
|
|
// Dispatch the tick to any active objects
|
|
|
|
tick();
|
|
|
|
_lastTick = millis;
|
|
|
|
}
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 10:20:01 +00:00
|
|
|
void CGEEngine::tick() {
|
2011-07-03 14:22:26 +00:00
|
|
|
for (Sprite *spr = _vga->_showQ->first(); spr; spr = spr->_next) {
|
2011-07-03 10:20:01 +00:00
|
|
|
if (spr->_time) {
|
2011-08-19 10:36:43 +00:00
|
|
|
if (!spr->_flags._hide) {
|
2011-07-03 10:20:01 +00:00
|
|
|
if (--spr->_time == 0)
|
|
|
|
spr->tick();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::loadUser() {
|
2011-06-13 09:57:24 +00:00
|
|
|
// set scene
|
2011-07-29 08:02:32 +00:00
|
|
|
if (_mode == 0) {
|
2011-07-16 08:33:20 +00:00
|
|
|
// user .SVG file found - load it from slot 0
|
|
|
|
loadGame(0, NULL);
|
2011-07-29 08:02:32 +00:00
|
|
|
} else if (_mode == 1) {
|
2011-08-19 14:04:10 +00:00
|
|
|
// Load either initial game state savegame or launcher specified savegame
|
|
|
|
loadGame(_startGameSlot, NULL);
|
2011-07-29 08:02:32 +00:00
|
|
|
} else {
|
2011-08-19 14:04:10 +00:00
|
|
|
error("Creating setup savegames not supported");
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
2011-09-07 20:37:03 +00:00
|
|
|
loadScript("CGE.IN0");
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::runGame() {
|
2011-07-02 08:38:25 +00:00
|
|
|
if (_eventManager->_quitFlag)
|
|
|
|
return;
|
|
|
|
|
2011-07-03 09:28:22 +00:00
|
|
|
loadHeroXY();
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
_sceneLight->_flags._tran = true;
|
|
|
|
_vga->_showQ->append(_sceneLight);
|
|
|
|
_sceneLight->_flags._hide = true;
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-12 22:28:17 +00:00
|
|
|
const Seq pocSeq[] = {
|
|
|
|
{ 0, 0, 0, 0, 20 },
|
2011-06-13 09:57:24 +00:00
|
|
|
{ 1, 2, 0, 0, 4 },
|
|
|
|
{ 2, 3, 0, 0, 4 },
|
|
|
|
{ 3, 4, 0, 0, 16 },
|
|
|
|
{ 2, 5, 0, 0, 4 },
|
|
|
|
{ 1, 6, 0, 0, 4 },
|
|
|
|
{ 0, 1, 0, 0, 16 },
|
|
|
|
};
|
2011-07-12 11:16:23 +00:00
|
|
|
Seq *seq = (Seq *)malloc(7 * sizeof(Seq));
|
|
|
|
Common::copy(pocSeq, pocSeq + 7, seq);
|
|
|
|
_pocLight->setSeq(seq);
|
|
|
|
|
2011-08-19 10:36:43 +00:00
|
|
|
_pocLight->_flags._tran = true;
|
2011-06-29 14:13:17 +00:00
|
|
|
_pocLight->_time = 1;
|
|
|
|
_pocLight->_z = 120;
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->append(_pocLight);
|
2011-07-02 16:20:41 +00:00
|
|
|
selectPocket(-1);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-10 11:07:57 +00:00
|
|
|
_vga->_showQ->append(_mouse);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
|
|
|
// ___________
|
2011-07-01 06:37:40 +00:00
|
|
|
loadUser();
|
2011-06-09 06:20:53 +00:00
|
|
|
// ~~~~~~~~~~~
|
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
if ((_sprite = _vga->_spareQ->locate(121)) != NULL)
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnSeq, -1, _vga->_mono, _sprite);
|
2011-07-03 14:22:26 +00:00
|
|
|
if ((_sprite = _vga->_spareQ->locate(122)) != NULL)
|
2011-07-02 16:20:41 +00:00
|
|
|
_sprite->step(_music);
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail_->addCom(kSnSeq, -1, _music, _sprite);
|
2011-07-02 16:20:41 +00:00
|
|
|
if (!_music)
|
2011-08-12 11:33:45 +00:00
|
|
|
_midiPlayer.killMidi();
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-09-13 22:10:59 +00:00
|
|
|
if (_resman->exist("MINI.SPR")) {
|
2011-07-30 22:52:35 +00:00
|
|
|
_miniShp = new BitmapPtr[2];
|
2011-07-16 05:17:18 +00:00
|
|
|
_miniShp[0] = _miniShp[1] = NULL;
|
|
|
|
|
2011-08-06 11:03:24 +00:00
|
|
|
loadSprite("MINI", -1, 0, kMiniX, kMiniY);
|
2011-09-14 06:15:30 +00:00
|
|
|
expandSprite(_miniScene = _sprite); // NULL is ok
|
|
|
|
if (_miniScene) {
|
|
|
|
_miniScene->_flags._kill = false;
|
|
|
|
_miniScene->_flags._hide = true;
|
|
|
|
_miniShp[0] = new Bitmap(*_miniScene->shp());
|
|
|
|
_miniShpList = _miniScene->setShapeList(_miniShp);
|
2011-08-06 11:03:24 +00:00
|
|
|
postMiniStep(-1);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
if (_hero) {
|
2011-07-05 21:13:12 +00:00
|
|
|
expandSprite(_hero);
|
2011-09-06 21:14:49 +00:00
|
|
|
_hero->gotoxy(_heroXY[_now - 1].x, _heroXY[_now - 1].y);
|
2011-09-13 22:10:59 +00:00
|
|
|
if (_resman->exist("00SHADOW.SPR")) {
|
2011-07-03 14:22:26 +00:00
|
|
|
loadSprite("00SHADOW", -1, 0, _hero->_x + 14, _hero->_y + 51);
|
2011-07-12 11:53:07 +00:00
|
|
|
delete _shadow;
|
2011-06-28 22:35:21 +00:00
|
|
|
if ((_shadow = _sprite) != NULL) {
|
|
|
|
_shadow->_ref = 2;
|
2011-08-19 10:36:43 +00:00
|
|
|
_shadow->_flags._tran = true;
|
|
|
|
_shadow->_flags._kill = false;
|
|
|
|
_hero->_flags._shad = true;
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->insert(_vga->_spareQ->remove(_shadow), _hero);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-20 23:56:40 +00:00
|
|
|
_infoLine->gotoxy(kInfoX, kInfoY);
|
2011-08-19 10:36:43 +00:00
|
|
|
_infoLine->_flags._tran = true;
|
2011-07-03 09:28:22 +00:00
|
|
|
_infoLine->update(NULL);
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->insert(_infoLine);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-03 09:28:22 +00:00
|
|
|
_debugLine->_z = 126;
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->insert(_debugLine);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-13 06:44:48 +00:00
|
|
|
if (_horzLine) {
|
|
|
|
_horzLine->_y = kMapTop - (kMapTop > 0);
|
|
|
|
_horzLine->_z = 126;
|
|
|
|
_vga->_showQ->insert(_horzLine);
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-20 23:56:40 +00:00
|
|
|
_mouse->_busy = _vga->_spareQ->locate(kBusyRef);
|
2011-07-08 06:21:35 +00:00
|
|
|
if (_mouse->_busy)
|
|
|
|
expandSprite(_mouse->_busy);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-04 06:15:56 +00:00
|
|
|
_startupMode = 0;
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-09-14 06:15:30 +00:00
|
|
|
_snail->addCom(kSnLevel, -1, _oldLev, &_sceneLight);
|
|
|
|
_sceneLight->gotoxy(kSceneX + ((_now - 1) % kSceneNx) * kSceneDx + kSceneSX,
|
|
|
|
kSceneY + ((_now - 1) / kSceneNx) * kSceneDy + kSceneSY);
|
|
|
|
sceneUp();
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
_keyboard->setClient(_sys);
|
2011-06-13 09:57:24 +00:00
|
|
|
// main loop
|
2011-07-03 09:28:22 +00:00
|
|
|
while (!_finis && !_eventManager->_quitFlag) {
|
2011-08-27 22:48:53 +00:00
|
|
|
if (_flag[3])
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail->addCom2(kSnExec, -1, 0, kQGame);
|
2011-07-01 06:37:40 +00:00
|
|
|
mainLoop();
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-10 09:02:13 +00:00
|
|
|
// If finishing game due to closing ScummVM window, explicitly save the game
|
2011-08-10 10:41:39 +00:00
|
|
|
if (!_finis && canSaveGameStateCurrently())
|
2011-08-10 09:02:13 +00:00
|
|
|
qGame();
|
|
|
|
|
2011-07-02 06:46:31 +00:00
|
|
|
_keyboard->setClient(NULL);
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail->addCom(kSnClear, -1, 0, NULL);
|
|
|
|
_snail_->addCom(kSnClear, -1, 0, NULL);
|
2011-07-08 06:21:35 +00:00
|
|
|
_mouse->off();
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->clear();
|
|
|
|
_vga->_spareQ->clear();
|
|
|
|
_hero = NULL;
|
2011-06-28 22:35:21 +00:00
|
|
|
_shadow = NULL;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
void CGEEngine::movie(const char *ext) {
|
2011-09-07 20:37:03 +00:00
|
|
|
assert(ext);
|
|
|
|
|
2011-07-02 08:38:25 +00:00
|
|
|
if (_eventManager->_quitFlag)
|
|
|
|
return;
|
|
|
|
|
2011-09-07 20:37:03 +00:00
|
|
|
char fn[12];
|
|
|
|
sprintf(fn, "CGE.%s", (*ext == '.') ? ext +1 : ext);
|
|
|
|
|
2011-09-13 22:10:59 +00:00
|
|
|
if (_resman->exist(fn)) {
|
2011-07-01 06:37:40 +00:00
|
|
|
loadScript(fn);
|
2011-07-05 21:13:12 +00:00
|
|
|
expandSprite(_vga->_spareQ->locate(999));
|
2011-07-13 06:44:58 +00:00
|
|
|
feedSnail(_vga->_showQ->locate(999), kTake);
|
2011-07-12 12:44:04 +00:00
|
|
|
_vga->_showQ->append(_mouse);
|
2011-07-03 14:22:26 +00:00
|
|
|
_keyboard->setClient(_sys);
|
2011-07-02 16:20:41 +00:00
|
|
|
while (!_snail->idle() && !_eventManager->_quitFlag)
|
2011-07-01 06:37:40 +00:00
|
|
|
mainLoop();
|
2011-06-22 06:11:18 +00:00
|
|
|
|
2011-07-02 06:46:31 +00:00
|
|
|
_keyboard->setClient(NULL);
|
2011-07-23 12:31:39 +00:00
|
|
|
_snail->addCom(kSnClear, -1, 0, NULL);
|
|
|
|
_snail_->addCom(kSnClear, -1, 0, NULL);
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->clear();
|
|
|
|
_vga->_spareQ->clear();
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-01 06:37:40 +00:00
|
|
|
bool CGEEngine::showTitle(const char *name) {
|
2011-07-02 08:38:25 +00:00
|
|
|
if (_eventManager->_quitFlag)
|
|
|
|
return false;
|
|
|
|
|
2011-08-27 17:09:13 +00:00
|
|
|
Bitmap::_pal = _vga->_sysPal;
|
2011-07-30 22:52:35 +00:00
|
|
|
BitmapPtr *LB = new BitmapPtr[2];
|
2011-08-19 17:48:49 +00:00
|
|
|
LB[0] = new Bitmap(name);
|
2011-07-10 04:51:22 +00:00
|
|
|
LB[1] = NULL;
|
2011-06-30 06:30:23 +00:00
|
|
|
Bitmap::_pal = NULL;
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-06-28 22:35:21 +00:00
|
|
|
Sprite D(this, LB);
|
2011-08-19 10:36:43 +00:00
|
|
|
D._flags._kill = true;
|
|
|
|
D._flags._bDel = true;
|
2011-07-01 23:02:14 +00:00
|
|
|
D.center();
|
|
|
|
D.show(2);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-29 08:02:32 +00:00
|
|
|
if (_mode == 2) {
|
2011-08-02 19:47:56 +00:00
|
|
|
inf(kSavegame0Name);
|
2011-07-03 09:28:22 +00:00
|
|
|
_talk->show(2);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->sunset();
|
|
|
|
_vga->copyPage(1, 2);
|
|
|
|
_vga->copyPage(0, 1);
|
2011-07-02 16:20:41 +00:00
|
|
|
selectPocket(-1);
|
2011-08-27 17:09:13 +00:00
|
|
|
_vga->sunrise(_vga->_sysPal);
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-07-29 08:02:32 +00:00
|
|
|
if (_mode < 2 && !_soundOk) {
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->copyPage(1, 2);
|
|
|
|
_vga->copyPage(0, 1);
|
|
|
|
_vga->_showQ->append(_mouse);
|
2011-07-08 06:21:35 +00:00
|
|
|
_mouse->on();
|
2011-07-18 19:47:57 +00:00
|
|
|
for (; !_snail->idle() || Vmenu::_addr;) {
|
2011-07-01 06:37:40 +00:00
|
|
|
mainLoop();
|
2011-07-02 08:38:25 +00:00
|
|
|
if (_eventManager->_quitFlag)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-07-08 06:21:35 +00:00
|
|
|
_mouse->off();
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->_showQ->clear();
|
|
|
|
_vga->copyPage(0, 2);
|
2011-07-29 08:02:32 +00:00
|
|
|
_soundOk = 2;
|
2011-07-02 16:20:41 +00:00
|
|
|
if (_music)
|
2011-08-12 11:33:45 +00:00
|
|
|
_midiPlayer.loadMidi(0);
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-29 08:02:32 +00:00
|
|
|
if (_mode < 2) {
|
2011-08-29 20:51:45 +00:00
|
|
|
// At this point the game originally set the protection variables
|
|
|
|
// used by the copy protection check
|
2011-09-07 20:37:03 +00:00
|
|
|
movie(kPaylistExt); // paylist
|
2011-08-29 20:51:45 +00:00
|
|
|
_vga->copyPage(1, 2);
|
|
|
|
_vga->copyPage(0, 1);
|
|
|
|
_vga->_showQ->append(_mouse);
|
|
|
|
// In the original game, the user had to enter his name
|
|
|
|
// As it was only used to name savegames, it has been removed
|
|
|
|
_vga->_showQ->clear();
|
|
|
|
_vga->copyPage(0, 2);
|
2011-06-26 23:03:47 +00:00
|
|
|
|
2011-08-27 12:05:04 +00:00
|
|
|
if (_mode == 0) {
|
|
|
|
// The auto-load of savegame #0 is currently disabled
|
|
|
|
#if 0
|
2011-07-16 08:33:20 +00:00
|
|
|
if (savegameExists(0)) {
|
|
|
|
// Load the savegame
|
|
|
|
loadGame(0, NULL, true); // only system vars
|
2011-08-27 17:09:13 +00:00
|
|
|
_vga->setColors(_vga->_sysPal, 64);
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->update();
|
2011-07-05 21:13:12 +00:00
|
|
|
if (_flag[3]) { //flag FINIS
|
2011-07-29 08:02:32 +00:00
|
|
|
_mode++;
|
2011-07-05 21:13:12 +00:00
|
|
|
_flag[3] = false;
|
2011-06-13 09:57:24 +00:00
|
|
|
}
|
2011-06-13 11:07:45 +00:00
|
|
|
} else
|
2011-08-27 12:05:04 +00:00
|
|
|
#endif
|
2011-07-29 08:02:32 +00:00
|
|
|
_mode++;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-29 08:02:32 +00:00
|
|
|
if (_mode < 2)
|
2011-09-07 20:37:03 +00:00
|
|
|
movie(kWinkExt);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-03 14:22:26 +00:00
|
|
|
_vga->copyPage(0, 2);
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-08-27 12:05:04 +00:00
|
|
|
return true;
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
|
|
|
|
2011-07-05 21:13:12 +00:00
|
|
|
void CGEEngine::cge_main() {
|
2011-07-02 16:20:41 +00:00
|
|
|
memset(_barriers, 0xFF, sizeof(_barriers));
|
2011-06-09 06:20:53 +00:00
|
|
|
|
2011-07-08 06:21:35 +00:00
|
|
|
if (!_mouse->_exist)
|
2011-08-02 19:47:56 +00:00
|
|
|
error("%s", _text->getText(kTextNoMouse));
|
2011-06-28 22:35:21 +00:00
|
|
|
|
2011-09-13 22:10:59 +00:00
|
|
|
if (!_resman->exist(kSavegame0Name))
|
2011-07-29 08:02:32 +00:00
|
|
|
_mode = 2;
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-08-19 10:36:43 +00:00
|
|
|
_debugLine->_flags._hide = true;
|
2011-08-13 06:44:48 +00:00
|
|
|
if (_horzLine)
|
2011-08-19 10:36:43 +00:00
|
|
|
_horzLine->_flags._hide = true;
|
2011-06-13 09:57:24 +00:00
|
|
|
|
2011-07-29 08:02:32 +00:00
|
|
|
if (_music && _soundOk)
|
2011-08-12 11:33:45 +00:00
|
|
|
_midiPlayer.loadMidi(0);
|
2011-07-02 08:38:25 +00:00
|
|
|
|
2011-07-16 11:12:19 +00:00
|
|
|
if (_startGameSlot != -1) {
|
|
|
|
// Starting up a savegame from the launcher
|
2011-07-29 08:02:32 +00:00
|
|
|
_mode++;
|
2011-07-01 06:37:40 +00:00
|
|
|
runGame();
|
2011-07-16 11:12:19 +00:00
|
|
|
|
2011-07-04 06:15:56 +00:00
|
|
|
_startupMode = 2;
|
2011-07-05 21:13:12 +00:00
|
|
|
if (_flag[3]) // Flag FINIS
|
2011-09-07 20:37:03 +00:00
|
|
|
movie(kEndgExt);
|
2011-07-16 11:12:19 +00:00
|
|
|
} else {
|
2011-07-29 08:02:32 +00:00
|
|
|
if (_mode < 2)
|
2011-07-20 23:56:40 +00:00
|
|
|
movie(kLgoExt);
|
2011-07-16 11:12:19 +00:00
|
|
|
|
|
|
|
if (showTitle("WELCOME")) {
|
2011-08-29 20:51:45 +00:00
|
|
|
if (_mode == 1)
|
2011-09-07 20:37:03 +00:00
|
|
|
movie(kIntroExt);
|
2011-07-16 11:12:19 +00:00
|
|
|
runGame();
|
|
|
|
_startupMode = 2;
|
|
|
|
if (_flag[3]) // Flag FINIS
|
2011-09-07 20:37:03 +00:00
|
|
|
movie(kEndgExt);
|
2011-07-16 11:12:19 +00:00
|
|
|
} else
|
|
|
|
_vga->sunset();
|
|
|
|
}
|
2011-06-09 06:20:53 +00:00
|
|
|
}
|
2011-06-10 20:57:09 +00:00
|
|
|
|
|
|
|
} // End of namespace CGE
|