[Scummvm-cvs-logs] scummvm master -> fbc2c6d08ac96c92e2424118dc9b0548628287e5
Strangerke
Strangerke at scummvm.org
Wed Jun 13 17:44:37 CEST 2012
This automated email contains information about 1 new commit which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
fbc2c6d08a HUGO: More renaming
Commit: fbc2c6d08ac96c92e2424118dc9b0548628287e5
https://github.com/scummvm/scummvm/commit/fbc2c6d08ac96c92e2424118dc9b0548628287e5
Author: Strangerke (strangerke at scummvm.org)
Date: 2012-06-13T08:44:09-07:00
Commit Message:
HUGO: More renaming
Changed paths:
engines/hugo/dialogs.cpp
engines/hugo/file.cpp
engines/hugo/file.h
engines/hugo/hugo.cpp
engines/hugo/hugo.h
engines/hugo/mouse.cpp
engines/hugo/parser.cpp
engines/hugo/schedule.cpp
engines/hugo/schedule.h
engines/hugo/sound.cpp
diff --git a/engines/hugo/dialogs.cpp b/engines/hugo/dialogs.cpp
index 0efd47a..0f07d52 100644
--- a/engines/hugo/dialogs.cpp
+++ b/engines/hugo/dialogs.cpp
@@ -109,12 +109,12 @@ void TopMenu::reflowLayout() {
// Set the graphics to the 'on' buttons, except for the variable ones
_whatButton->setGfx(_arrayBmp[4 * kMenuWhat + scale - 1]);
- _musicButton->setGfx(_arrayBmp[4 * kMenuMusic + scale - 1 + ((_vm->_config.musicFl) ? 0 : 2)]);
- _soundFXButton->setGfx(_arrayBmp[4 * kMenuSoundFX + scale - 1 + ((_vm->_config.soundFl) ? 0 : 2)]);
+ _musicButton->setGfx(_arrayBmp[4 * kMenuMusic + scale - 1 + ((_vm->_config._musicFl) ? 0 : 2)]);
+ _soundFXButton->setGfx(_arrayBmp[4 * kMenuSoundFX + scale - 1 + ((_vm->_config._soundFl) ? 0 : 2)]);
_saveButton->setGfx(_arrayBmp[4 * kMenuSave + scale - 1]);
_loadButton->setGfx(_arrayBmp[4 * kMenuLoad + scale - 1]);
_recallButton->setGfx(_arrayBmp[4 * kMenuRecall + scale - 1]);
- _turboButton->setGfx(_arrayBmp[4 * kMenuTurbo + scale - 1 + ((_vm->_config.turboFl) ? 0 : 2)]);
+ _turboButton->setGfx(_arrayBmp[4 * kMenuTurbo + scale - 1 + ((_vm->_config._turboFl) ? 0 : 2)]);
_lookButton->setGfx(_arrayBmp[4 * kMenuLook + scale - 1]);
_inventButton->setGfx(_arrayBmp[4 * kMenuInventory + scale - 1]);
}
@@ -176,7 +176,7 @@ void TopMenu::handleCommand(GUI::CommandSender *sender, uint32 command, uint32 d
break;
case kCmdMusic:
_vm->_sound->toggleMusic();
- _musicButton->setGfx(_arrayBmp[4 * kMenuMusic + (g_system->getOverlayWidth() > 320 ? 2 : 1) - 1 + ((_vm->_config.musicFl) ? 0 : 2)]);
+ _musicButton->setGfx(_arrayBmp[4 * kMenuMusic + (g_system->getOverlayWidth() > 320 ? 2 : 1) - 1 + ((_vm->_config._musicFl) ? 0 : 2)]);
_musicButton->draw();
g_gui.theme()->updateScreen();
g_system->updateScreen();
diff --git a/engines/hugo/file.cpp b/engines/hugo/file.cpp
index a3fc5df..219e29a 100644
--- a/engines/hugo/file.cpp
+++ b/engines/hugo/file.cpp
@@ -54,7 +54,7 @@ static const int s_bootCypherLen = sizeof(s_bootCypher) - 1;
FileManager::FileManager(HugoEngine *vm) : _vm(vm) {
_hasReadHeader = false;
- firstUIFFl = true;
+ _firstUIFFl = true;
}
FileManager::~FileManager() {
@@ -624,28 +624,28 @@ void FileManager::readBootFile() {
* This file contains, between others, the bitmaps of the fonts used in the application
* UIF means User interface database (Windows Only)
*/
-uif_hdr_t *FileManager::getUIFHeader(const uif_t id) {
- debugC(1, kDebugFile, "getUIFHeader(%d)", id);
+uif_hdr_t *FileManager::get_UIFHeader(const uif_t id) {
+ debugC(1, kDebugFile, "get_UIFHeader(%d)", id);
// Initialize offset lookup if not read yet
- if (firstUIFFl) {
- firstUIFFl = false;
+ if (_firstUIFFl) {
+ _firstUIFFl = false;
// Open unbuffered to do far read
Common::File ip; // Image data file
if (!ip.open(getUifFilename()))
error("File not found: %s", getUifFilename());
- if (ip.size() < (int32)sizeof(UIFHeader))
+ if (ip.size() < (int32)sizeof(_UIFHeader))
error("Wrong UIF file format");
for (int i = 0; i < kMaxUifs; ++i) {
- UIFHeader[i]._size = ip.readUint16LE();
- UIFHeader[i]._offset = ip.readUint32LE();
+ _UIFHeader[i]._size = ip.readUint16LE();
+ _UIFHeader[i]._offset = ip.readUint32LE();
}
ip.close();
}
- return &UIFHeader[id];
+ return &_UIFHeader[id];
}
/**
@@ -660,8 +660,8 @@ void FileManager::readUIFItem(const int16 id, byte *buf) {
error("File not found: %s", getUifFilename());
// Seek to data
- uif_hdr_t *UIFHeaderPtr = getUIFHeader((uif_t)id);
- ip.seek(UIFHeaderPtr->_offset, SEEK_SET);
+ uif_hdr_t *_UIFHeaderPtr = get_UIFHeader((uif_t)id);
+ ip.seek(_UIFHeaderPtr->_offset, SEEK_SET);
// We support pcx images and straight data
seq_t *dummySeq; // Dummy seq_t for image data
@@ -671,7 +671,7 @@ void FileManager::readUIFItem(const int16 id, byte *buf) {
free(dummySeq);
break;
default: // Read file data into supplied array
- if (ip.read(buf, UIFHeaderPtr->_size) != UIFHeaderPtr->_size)
+ if (ip.read(buf, _UIFHeaderPtr->_size) != _UIFHeaderPtr->_size)
error("Wrong UIF file format");
break;
}
diff --git a/engines/hugo/file.h b/engines/hugo/file.h
index 817bf49..e7c467a 100644
--- a/engines/hugo/file.h
+++ b/engines/hugo/file.h
@@ -105,8 +105,8 @@ protected:
byte _fill2[60];
}; // Header of a PCC file
- bool firstUIFFl;
- uif_hdr_t UIFHeader[kMaxUifs]; // Lookup for uif fonts/images
+ bool _firstUIFFl;
+ uif_hdr_t _UIFHeader[kMaxUifs]; // Lookup for uif fonts/images
Common::File _stringArchive; // Handle for string file
Common::File _sceneryArchive1; // Handle for scenery file
@@ -122,7 +122,7 @@ protected:
private:
byte *convertPCC(byte *p, const uint16 y, const uint16 bpl, image_pt dataPtr) const;
- uif_hdr_t *getUIFHeader(const uif_t id);
+ uif_hdr_t *get_UIFHeader(const uif_t id);
//Strangerke : Not used?
void printBootText();
diff --git a/engines/hugo/hugo.cpp b/engines/hugo/hugo.cpp
index 450f4ff..7462da0 100644
--- a/engines/hugo/hugo.cpp
+++ b/engines/hugo/hugo.cpp
@@ -562,10 +562,10 @@ void HugoEngine::initStatus() {
void HugoEngine::initConfig() {
debugC(1, kDebugEngine, "initConfig()");
- _config.musicFl = true; // Music state initially on
- _config.soundFl = true; // Sound state initially on
- _config.turboFl = false; // Turbo state initially off
- initPlaylist(_config.playlist); // Initialize default tune playlist
+ _config._musicFl = true; // Music state initially on
+ _config._soundFl = true; // Sound state initially on
+ _config._turboFl = false; // Turbo state initially off
+ initPlaylist(_config._playlist); // Initialize default tune playlist
_file->readBootFile(); // Read startup structure
}
@@ -577,7 +577,7 @@ void HugoEngine::resetConfig() {
// Find first tune and play it
for (int16 i = 0; i < kMaxTunes; i++) {
- if (_config.playlist[i]) {
+ if (_config._playlist[i]) {
_sound->playMusic(i);
break;
}
@@ -694,7 +694,7 @@ bool HugoEngine::canSaveGameStateCurrently() {
}
int8 HugoEngine::getTPS() const {
- return ((_config.turboFl) ? kTurboTps : _normalTPS);
+ return ((_config._turboFl) ? kTurboTps : _normalTPS);
}
void HugoEngine::syncSoundSettings() {
diff --git a/engines/hugo/hugo.h b/engines/hugo/hugo.h
index 3ad6fce..68b771f 100644
--- a/engines/hugo/hugo.h
+++ b/engines/hugo/hugo.h
@@ -83,10 +83,10 @@ static const int kHeroMinWidth = 16; // Minimum width of hero
typedef char command_t[kMaxLineSize + 8]; // Command line (+spare for prompt,cursor)
struct config_t { // User's config (saved)
- bool musicFl; // State of Music button/menu item
- bool soundFl; // State of Sound button/menu item
- bool turboFl; // State of Turbo button/menu item
- bool playlist[kMaxTunes]; // Tune playlist
+ bool _musicFl; // State of Music button/menu item
+ bool _soundFl; // State of Sound button/menu item
+ bool _turboFl; // State of Turbo button/menu item
+ bool _playlist[kMaxTunes]; // Tune playlist
};
typedef byte icondib_t[kXPix * kInvDy]; // Icon bar dib
@@ -185,32 +185,16 @@ struct status_t { // Game status (not saved)
uint32 _tick; // Current time in ticks
vstate_t _viewState; // View state machine
int16 _song; // Current song
-
-// Strangerke - Suppress as related to playback
-// bool playbackFl; // Game is in playback mode
-// bool recordFl; // Game is in record mode
-// Strangerke - Not used ?
-// bool helpFl; // Calling WinHelp (don't disable music)
-// bool mmtimeFl; // Multimedia timer supported
-// bool demoFl; // Game is in demo mode
-// bool textBoxFl; // Game is (halted) in text box
-// int16 screenWidth; // Desktop screen width
-// int16 saveSlot; // Current slot to save/restore game
-// int16 cx, cy; // Cursor position (dib coords)
-// uint32 saveTick; // Time of last save in ticks
-//
-// typedef char fpath_t[kMaxPath]; // File path
-// fpath_t path; // Alternate path for saved files
};
/**
* Structure to define an EXIT or other collision-activated hotspot
*/
struct hotspot_t {
- int screenIndex; // Screen in which hotspot appears
- int x1, y1, x2, y2; // Bounding box of hotspot
- uint16 actIndex; // Actions to carry out if a 'hit'
- int16 viewx, viewy, direction; // Used in auto-route mode
+ int _screenIndex; // Screen in which hotspot appears
+ int _x1, _y1, _x2, _y2; // Bounding box of hotspot
+ uint16 _actIndex; // Actions to carry out if a 'hit'
+ int16 _viewx, _viewy, _direction; // Used in auto-route mode
};
class FileManager;
diff --git a/engines/hugo/mouse.cpp b/engines/hugo/mouse.cpp
index 323f362..864934a 100644
--- a/engines/hugo/mouse.cpp
+++ b/engines/hugo/mouse.cpp
@@ -98,11 +98,11 @@ int MouseHandler::getMouseY() const {
}
int16 MouseHandler::getDirection(const int16 hotspotId) const {
- return _hotspots[hotspotId].direction;
+ return _hotspots[hotspotId]._direction;
}
int16 MouseHandler::getHotspotActIndex(const int16 hotspotId) const {
- return _hotspots[hotspotId].actIndex;
+ return _hotspots[hotspotId]._actIndex;
}
/**
@@ -137,9 +137,9 @@ void MouseHandler::cursorText(const char *buffer, const int16 cx, const int16 cy
int16 MouseHandler::findExit(const int16 cx, const int16 cy, byte screenId) {
debugC(2, kDebugMouse, "findExit(%d, %d, %d)", cx, cy, screenId);
- for (int i = 0; _hotspots[i].screenIndex >= 0; i++) {
- if (_hotspots[i].screenIndex == screenId) {
- if (cx >= _hotspots[i].x1 && cx <= _hotspots[i].x2 && cy >= _hotspots[i].y1 && cy <= _hotspots[i].y2)
+ for (int i = 0; _hotspots[i]._screenIndex >= 0; i++) {
+ if (_hotspots[i]._screenIndex == screenId) {
+ if (cx >= _hotspots[i]._x1 && cx <= _hotspots[i]._x2 && cy >= _hotspots[i]._y1 && cy <= _hotspots[i]._y2)
return i;
}
}
@@ -224,19 +224,19 @@ void MouseHandler::processLeftClick(const int16 objId, const int16 cx, const int
break;
case kExitHotspot: // Walk to exit hotspot
i = findExit(cx, cy, *_vm->_screen_p);
- x = _hotspots[i].viewx;
- y = _hotspots[i].viewy;
+ x = _hotspots[i]._viewx;
+ y = _hotspots[i]._viewy;
if (x >= 0) { // Hotspot refers to an exit
// Special case of immediate exit
if (_jumpExitFl) {
// Get rid of iconbar if necessary
if (_vm->_inventory->getInventoryState() != kInventoryOff)
_vm->_inventory->setInventoryState(kInventoryUp);
- _vm->_scheduler->insertActionList(_hotspots[i].actIndex);
+ _vm->_scheduler->insertActionList(_hotspots[i]._actIndex);
} else { // Set up route to exit spot
- if (_hotspots[i].direction == Common::KEYCODE_RIGHT)
+ if (_hotspots[i]._direction == Common::KEYCODE_RIGHT)
x -= kHeroMaxWidth;
- else if (_hotspots[i].direction == Common::KEYCODE_LEFT)
+ else if (_hotspots[i]._direction == Common::KEYCODE_LEFT)
x += kHeroMaxWidth;
if (!_vm->_route->startRoute(kRouteExit, i, x, y))
Utils::notifyBox(_vm->_text->getTextMouse(kMsNoWayText)); // Can't get there
@@ -328,7 +328,7 @@ void MouseHandler::mouseHandler() {
// Process cursor over an exit hotspot
if (objId == -1) {
int i = findExit(cx, cy, *_vm->_screen_p);
- if (i != -1 && _hotspots[i].viewx >= 0) {
+ if (i != -1 && _hotspots[i]._viewx >= 0) {
objId = kExitHotspot;
cursorText(_vm->_text->getTextMouse(kMsExit), cx, cy, U_FONT8, _TBRIGHTWHITE);
}
@@ -344,15 +344,15 @@ void MouseHandler::mouseHandler() {
}
void MouseHandler::readHotspot(Common::ReadStream &in, hotspot_t &hotspot) {
- hotspot.screenIndex = in.readSint16BE();
- hotspot.x1 = in.readSint16BE();
- hotspot.y1 = in.readSint16BE();
- hotspot.x2 = in.readSint16BE();
- hotspot.y2 = in.readSint16BE();
- hotspot.actIndex = in.readUint16BE();
- hotspot.viewx = in.readSint16BE();
- hotspot.viewy = in.readSint16BE();
- hotspot.direction = in.readSint16BE();
+ hotspot._screenIndex = in.readSint16BE();
+ hotspot._x1 = in.readSint16BE();
+ hotspot._y1 = in.readSint16BE();
+ hotspot._x2 = in.readSint16BE();
+ hotspot._y2 = in.readSint16BE();
+ hotspot._actIndex = in.readUint16BE();
+ hotspot._viewx = in.readSint16BE();
+ hotspot._viewy = in.readSint16BE();
+ hotspot._direction = in.readSint16BE();
}
/**
@@ -376,10 +376,10 @@ void MouseHandler::loadHotspots(Common::ReadStream &in) {
* Display hotspot boundaries for the current screen
*/
void MouseHandler::drawHotspots() const {
- for (int i = 0; _hotspots[i].screenIndex >= 0; i++) {
+ for (int i = 0; _hotspots[i]._screenIndex >= 0; i++) {
hotspot_t *hotspot = &_hotspots[i];
- if (hotspot->screenIndex == _vm->_hero->_screenIndex)
- _vm->_screen->drawRectangle(false, hotspot->x1, hotspot->y1, hotspot->x2, hotspot->y2, _TLIGHTRED);
+ if (hotspot->_screenIndex == _vm->_hero->_screenIndex)
+ _vm->_screen->drawRectangle(false, hotspot->_x1, hotspot->_y1, hotspot->_x2, hotspot->_y2, _TLIGHTRED);
}
}
} // End of namespace Hugo
diff --git a/engines/hugo/parser.cpp b/engines/hugo/parser.cpp
index b4255e6..3b0eb1d 100644
--- a/engines/hugo/parser.cpp
+++ b/engines/hugo/parser.cpp
@@ -198,7 +198,7 @@ void Parser::freeParser() {
}
void Parser::switchTurbo() {
- _vm->_config.turboFl = !_vm->_config.turboFl;
+ _vm->_config._turboFl = !_vm->_config._turboFl;
}
/**
@@ -256,7 +256,7 @@ void Parser::charHandler() {
}
sprintf(_vm->_statusLine, ">%s%c", _cmdLine, _cmdLineCursor);
- sprintf(_vm->_scoreLine, "F1-Help %s Score: %d of %d Sound %s", (_vm->_config.turboFl) ? "T" : " ", _vm->getScore(), _vm->getMaxScore(), (_vm->_config.soundFl) ? "On" : "Off");
+ sprintf(_vm->_scoreLine, "F1-Help %s Score: %d of %d Sound %s", (_vm->_config._turboFl) ? "T" : " ", _vm->getScore(), _vm->getMaxScore(), (_vm->_config._soundFl) ? "On" : "Off");
// See if "look" button pressed
if (gameStatus._lookFl) {
diff --git a/engines/hugo/schedule.cpp b/engines/hugo/schedule.cpp
index 18e4144..0e57b08 100644
--- a/engines/hugo/schedule.cpp
+++ b/engines/hugo/schedule.cpp
@@ -68,13 +68,13 @@ void Scheduler::initEventQueue() {
// Chain next_p from first to last
for (int i = kMaxEvents; --i;)
- _events[i - 1].nextEvent = &_events[i];
- _events[kMaxEvents - 1].nextEvent = 0;
+ _events[i - 1]._nextEvent = &_events[i];
+ _events[kMaxEvents - 1]._nextEvent = 0;
// Chain prev_p from last to first
for (int i = 1; i < kMaxEvents; i++)
- _events[i].prevEvent = &_events[i - 1];
- _events[0].prevEvent = 0;
+ _events[i]._prevEvent = &_events[i - 1];
+ _events[0]._prevEvent = 0;
_headEvent = _tailEvent = 0; // Event list is empty
_freeEvent = _events; // Free list is full
@@ -89,8 +89,8 @@ event_t *Scheduler::getQueue() {
if (!_freeEvent) // Error: no more events available
error("An error has occurred: %s", "getQueue");
event_t *resEvent = _freeEvent;
- _freeEvent = _freeEvent->nextEvent;
- resEvent->nextEvent = 0;
+ _freeEvent = _freeEvent->_nextEvent;
+ resEvent->_nextEvent = 0;
return resEvent;
}
@@ -101,7 +101,7 @@ void Scheduler::insertActionList(const uint16 actIndex) {
debugC(1, kDebugSchedule, "insertActionList(%d)", actIndex);
if (_actListArr[actIndex]) {
- for (int i = 0; _actListArr[actIndex][i].a0.actType != ANULL; i++)
+ for (int i = 0; _actListArr[actIndex][i]._a0._actType != ANULL; i++)
insertAction(&_actListArr[actIndex][i]);
}
}
@@ -147,9 +147,9 @@ uint32 Scheduler::getDosTicks(const bool updateFl) {
void Scheduler::processBonus(const int bonusIndex) {
debugC(1, kDebugSchedule, "processBonus(%d)", bonusIndex);
- if (!_points[bonusIndex].scoredFl) {
- _vm->adjustScore(_points[bonusIndex].score);
- _points[bonusIndex].scoredFl = true;
+ if (!_points[bonusIndex]._scoredFl) {
+ _vm->adjustScore(_points[bonusIndex]._score);
+ _points[bonusIndex]._scoredFl = true;
}
}
@@ -178,8 +178,8 @@ void Scheduler::newScreen(const int screenIndex) {
event_t *curEvent = _headEvent; // The earliest event
event_t *wrkEvent; // Event ptr
while (curEvent) { // While mature events found
- wrkEvent = curEvent->nextEvent; // Save p (becomes undefined after Del)
- if (curEvent->localActionFl)
+ wrkEvent = curEvent->_nextEvent; // Save p (becomes undefined after Del)
+ if (curEvent->_localActionFl)
delQueue(curEvent); // Return event to free list
curEvent = wrkEvent;
}
@@ -261,8 +261,8 @@ void Scheduler::loadPoints(Common::SeekableReadStream &in) {
_numBonuses = numElem;
_points = (point_t *)malloc(sizeof(point_t) * _numBonuses);
for (int i = 0; i < _numBonuses; i++) {
- _points[i].score = in.readByte();
- _points[i].scoredFl = false;
+ _points[i]._score = in.readByte();
+ _points[i]._scoredFl = false;
}
} else {
in.skip(numElem);
@@ -273,277 +273,277 @@ void Scheduler::loadPoints(Common::SeekableReadStream &in) {
void Scheduler::readAct(Common::ReadStream &in, act &curAct) {
uint16 numSubAct;
- curAct.a0.actType = (action_t) in.readByte();
- switch (curAct.a0.actType) {
+ curAct._a0._actType = (action_t) in.readByte();
+ switch (curAct._a0._actType) {
case ANULL: // -1
break;
case ASCHEDULE: // 0
- curAct.a0.timer = in.readSint16BE();
- curAct.a0.actIndex = in.readUint16BE();
+ curAct._a0._timer = in.readSint16BE();
+ curAct._a0._actIndex = in.readUint16BE();
break;
case START_OBJ: // 1
- curAct.a1.timer = in.readSint16BE();
- curAct.a1.objIndex = in.readSint16BE();
- curAct.a1.cycleNumb = in.readSint16BE();
- curAct.a1.cycle = (cycle_t) in.readByte();
+ curAct._a1._timer = in.readSint16BE();
+ curAct._a1._objIndex = in.readSint16BE();
+ curAct._a1._cycleNumb = in.readSint16BE();
+ curAct._a1._cycle = (cycle_t) in.readByte();
break;
case INIT_OBJXY: // 2
- curAct.a2.timer = in.readSint16BE();
- curAct.a2.objIndex = in.readSint16BE();
- curAct.a2.x = in.readSint16BE();
- curAct.a2.y = in.readSint16BE();
+ curAct._a2._timer = in.readSint16BE();
+ curAct._a2._objIndex = in.readSint16BE();
+ curAct._a2._x = in.readSint16BE();
+ curAct._a2._y = in.readSint16BE();
break;
case PROMPT: // 3
- curAct.a3.timer = in.readSint16BE();
- curAct.a3.promptIndex = in.readSint16BE();
+ curAct._a3._timer = in.readSint16BE();
+ curAct._a3._promptIndex = in.readSint16BE();
numSubAct = in.readUint16BE();
- curAct.a3.responsePtr = (int *)malloc(sizeof(int) * numSubAct);
+ curAct._a3._responsePtr = (int *)malloc(sizeof(int) * numSubAct);
for (int k = 0; k < numSubAct; k++)
- curAct.a3.responsePtr[k] = in.readSint16BE();
- curAct.a3.actPassIndex = in.readUint16BE();
- curAct.a3.actFailIndex = in.readUint16BE();
- curAct.a3.encodedFl = (in.readByte() == 1) ? true : false;
+ curAct._a3._responsePtr[k] = in.readSint16BE();
+ curAct._a3._actPassIndex = in.readUint16BE();
+ curAct._a3._actFailIndex = in.readUint16BE();
+ curAct._a3._encodedFl = (in.readByte() == 1) ? true : false;
break;
case BKGD_COLOR: // 4
- curAct.a4.timer = in.readSint16BE();
- curAct.a4.newBackgroundColor = in.readUint32BE();
+ curAct._a4._timer = in.readSint16BE();
+ curAct._a4._newBackgroundColor = in.readUint32BE();
break;
case INIT_OBJVXY: // 5
- curAct.a5.timer = in.readSint16BE();
- curAct.a5.objIndex = in.readSint16BE();
- curAct.a5.vx = in.readSint16BE();
- curAct.a5.vy = in.readSint16BE();
+ curAct._a5._timer = in.readSint16BE();
+ curAct._a5._objIndex = in.readSint16BE();
+ curAct._a5._vx = in.readSint16BE();
+ curAct._a5._vy = in.readSint16BE();
break;
case INIT_CARRY: // 6
- curAct.a6.timer = in.readSint16BE();
- curAct.a6.objIndex = in.readSint16BE();
- curAct.a6.carriedFl = (in.readByte() == 1) ? true : false;
+ curAct._a6._timer = in.readSint16BE();
+ curAct._a6._objIndex = in.readSint16BE();
+ curAct._a6._carriedFl = (in.readByte() == 1) ? true : false;
break;
case INIT_HF_COORD: // 7
- curAct.a7.timer = in.readSint16BE();
- curAct.a7.objIndex = in.readSint16BE();
+ curAct._a7._timer = in.readSint16BE();
+ curAct._a7._objIndex = in.readSint16BE();
break;
case NEW_SCREEN: // 8
- curAct.a8.timer = in.readSint16BE();
- curAct.a8.screenIndex = in.readSint16BE();
+ curAct._a8._timer = in.readSint16BE();
+ curAct._a8._screenIndex = in.readSint16BE();
break;
case INIT_OBJSTATE: // 9
- curAct.a9.timer = in.readSint16BE();
- curAct.a9.objIndex = in.readSint16BE();
- curAct.a9.newState = in.readByte();
+ curAct._a9._timer = in.readSint16BE();
+ curAct._a9._objIndex = in.readSint16BE();
+ curAct._a9._newState = in.readByte();
break;
case INIT_PATH: // 10
- curAct.a10.timer = in.readSint16BE();
- curAct.a10.objIndex = in.readSint16BE();
- curAct.a10.newPathType = in.readSint16BE();
- curAct.a10.vxPath = in.readByte();
- curAct.a10.vyPath = in.readByte();
+ curAct._a10._timer = in.readSint16BE();
+ curAct._a10._objIndex = in.readSint16BE();
+ curAct._a10._newPathType = in.readSint16BE();
+ curAct._a10._vxPath = in.readByte();
+ curAct._a10._vyPath = in.readByte();
break;
case COND_R: // 11
- curAct.a11.timer = in.readSint16BE();
- curAct.a11.objIndex = in.readSint16BE();
- curAct.a11.stateReq = in.readByte();
- curAct.a11.actPassIndex = in.readUint16BE();
- curAct.a11.actFailIndex = in.readUint16BE();
+ curAct._a11._timer = in.readSint16BE();
+ curAct._a11._objIndex = in.readSint16BE();
+ curAct._a11._stateReq = in.readByte();
+ curAct._a11._actPassIndex = in.readUint16BE();
+ curAct._a11._actFailIndex = in.readUint16BE();
break;
case TEXT: // 12
- curAct.a12.timer = in.readSint16BE();
- curAct.a12.stringIndex = in.readSint16BE();
+ curAct._a12._timer = in.readSint16BE();
+ curAct._a12._stringIndex = in.readSint16BE();
break;
case SWAP_IMAGES: // 13
- curAct.a13.timer = in.readSint16BE();
- curAct.a13.objIndex1 = in.readSint16BE();
- curAct.a13.objIndex2 = in.readSint16BE();
+ curAct._a13._timer = in.readSint16BE();
+ curAct._a13._objIndex1 = in.readSint16BE();
+ curAct._a13._objIndex2 = in.readSint16BE();
break;
case COND_SCR: // 14
- curAct.a14.timer = in.readSint16BE();
- curAct.a14.objIndex = in.readSint16BE();
- curAct.a14.screenReq = in.readSint16BE();
- curAct.a14.actPassIndex = in.readUint16BE();
- curAct.a14.actFailIndex = in.readUint16BE();
+ curAct._a14._timer = in.readSint16BE();
+ curAct._a14._objIndex = in.readSint16BE();
+ curAct._a14._screenReq = in.readSint16BE();
+ curAct._a14._actPassIndex = in.readUint16BE();
+ curAct._a14._actFailIndex = in.readUint16BE();
break;
case AUTOPILOT: // 15
- curAct.a15.timer = in.readSint16BE();
- curAct.a15.objIndex1 = in.readSint16BE();
- curAct.a15.objIndex2 = in.readSint16BE();
- curAct.a15.dx = in.readByte();
- curAct.a15.dy = in.readByte();
+ curAct._a15._timer = in.readSint16BE();
+ curAct._a15._objIndex1 = in.readSint16BE();
+ curAct._a15._objIndex2 = in.readSint16BE();
+ curAct._a15._dx = in.readByte();
+ curAct._a15._dy = in.readByte();
break;
case INIT_OBJ_SEQ: // 16
- curAct.a16.timer = in.readSint16BE();
- curAct.a16.objIndex = in.readSint16BE();
- curAct.a16.seqIndex = in.readSint16BE();
+ curAct._a16._timer = in.readSint16BE();
+ curAct._a16._objIndex = in.readSint16BE();
+ curAct._a16._seqIndex = in.readSint16BE();
break;
case SET_STATE_BITS: // 17
- curAct.a17.timer = in.readSint16BE();
- curAct.a17.objIndex = in.readSint16BE();
- curAct.a17.stateMask = in.readSint16BE();
+ curAct._a17._timer = in.readSint16BE();
+ curAct._a17._objIndex = in.readSint16BE();
+ curAct._a17._stateMask = in.readSint16BE();
break;
case CLEAR_STATE_BITS: // 18
- curAct.a18.timer = in.readSint16BE();
- curAct.a18.objIndex = in.readSint16BE();
- curAct.a18.stateMask = in.readSint16BE();
+ curAct._a18._timer = in.readSint16BE();
+ curAct._a18._objIndex = in.readSint16BE();
+ curAct._a18._stateMask = in.readSint16BE();
break;
case TEST_STATE_BITS: // 19
- curAct.a19.timer = in.readSint16BE();
- curAct.a19.objIndex = in.readSint16BE();
- curAct.a19.stateMask = in.readSint16BE();
- curAct.a19.actPassIndex = in.readUint16BE();
- curAct.a19.actFailIndex = in.readUint16BE();
+ curAct._a19._timer = in.readSint16BE();
+ curAct._a19._objIndex = in.readSint16BE();
+ curAct._a19._stateMask = in.readSint16BE();
+ curAct._a19._actPassIndex = in.readUint16BE();
+ curAct._a19._actFailIndex = in.readUint16BE();
break;
case DEL_EVENTS: // 20
- curAct.a20.timer = in.readSint16BE();
- curAct.a20.actTypeDel = (action_t) in.readByte();
+ curAct._a20._timer = in.readSint16BE();
+ curAct._a20._actTypeDel = (action_t) in.readByte();
break;
case GAMEOVER: // 21
- curAct.a21.timer = in.readSint16BE();
+ curAct._a21._timer = in.readSint16BE();
break;
case INIT_HH_COORD: // 22
- curAct.a22.timer = in.readSint16BE();
- curAct.a22.objIndex = in.readSint16BE();
+ curAct._a22._timer = in.readSint16BE();
+ curAct._a22._objIndex = in.readSint16BE();
break;
case EXIT: // 23
- curAct.a23.timer = in.readSint16BE();
+ curAct._a23._timer = in.readSint16BE();
break;
case BONUS: // 24
- curAct.a24.timer = in.readSint16BE();
- curAct.a24.pointIndex = in.readSint16BE();
+ curAct._a24._timer = in.readSint16BE();
+ curAct._a24._pointIndex = in.readSint16BE();
break;
case COND_BOX: // 25
- curAct.a25.timer = in.readSint16BE();
- curAct.a25.objIndex = in.readSint16BE();
- curAct.a25.x1 = in.readSint16BE();
- curAct.a25.y1 = in.readSint16BE();
- curAct.a25.x2 = in.readSint16BE();
- curAct.a25.y2 = in.readSint16BE();
- curAct.a25.actPassIndex = in.readUint16BE();
- curAct.a25.actFailIndex = in.readUint16BE();
+ curAct._a25._timer = in.readSint16BE();
+ curAct._a25._objIndex = in.readSint16BE();
+ curAct._a25._x1 = in.readSint16BE();
+ curAct._a25._y1 = in.readSint16BE();
+ curAct._a25._x2 = in.readSint16BE();
+ curAct._a25._y2 = in.readSint16BE();
+ curAct._a25._actPassIndex = in.readUint16BE();
+ curAct._a25._actFailIndex = in.readUint16BE();
break;
case SOUND: // 26
- curAct.a26.timer = in.readSint16BE();
- curAct.a26.soundIndex = in.readSint16BE();
+ curAct._a26._timer = in.readSint16BE();
+ curAct._a26._soundIndex = in.readSint16BE();
break;
case ADD_SCORE: // 27
- curAct.a27.timer = in.readSint16BE();
- curAct.a27.objIndex = in.readSint16BE();
+ curAct._a27._timer = in.readSint16BE();
+ curAct._a27._objIndex = in.readSint16BE();
break;
case SUB_SCORE: // 28
- curAct.a28.timer = in.readSint16BE();
- curAct.a28.objIndex = in.readSint16BE();
+ curAct._a28._timer = in.readSint16BE();
+ curAct._a28._objIndex = in.readSint16BE();
break;
case COND_CARRY: // 29
- curAct.a29.timer = in.readSint16BE();
- curAct.a29.objIndex = in.readSint16BE();
- curAct.a29.actPassIndex = in.readUint16BE();
- curAct.a29.actFailIndex = in.readUint16BE();
+ curAct._a29._timer = in.readSint16BE();
+ curAct._a29._objIndex = in.readSint16BE();
+ curAct._a29._actPassIndex = in.readUint16BE();
+ curAct._a29._actFailIndex = in.readUint16BE();
break;
case INIT_MAZE: // 30
- curAct.a30.timer = in.readSint16BE();
- curAct.a30.mazeSize = in.readByte();
- curAct.a30.x1 = in.readSint16BE();
- curAct.a30.y1 = in.readSint16BE();
- curAct.a30.x2 = in.readSint16BE();
- curAct.a30.y2 = in.readSint16BE();
- curAct.a30.x3 = in.readSint16BE();
- curAct.a30.x4 = in.readSint16BE();
- curAct.a30.firstScreenIndex = in.readByte();
+ curAct._a30._timer = in.readSint16BE();
+ curAct._a30._mazeSize = in.readByte();
+ curAct._a30._x1 = in.readSint16BE();
+ curAct._a30._y1 = in.readSint16BE();
+ curAct._a30._x2 = in.readSint16BE();
+ curAct._a30._y2 = in.readSint16BE();
+ curAct._a30._x3 = in.readSint16BE();
+ curAct._a30._x4 = in.readSint16BE();
+ curAct._a30._firstScreenIndex = in.readByte();
break;
case EXIT_MAZE: // 31
- curAct.a31.timer = in.readSint16BE();
+ curAct._a31._timer = in.readSint16BE();
break;
case INIT_PRIORITY: // 32
- curAct.a32.timer = in.readSint16BE();
- curAct.a32.objIndex = in.readSint16BE();
- curAct.a32.priority = in.readByte();
+ curAct._a32._timer = in.readSint16BE();
+ curAct._a32._objIndex = in.readSint16BE();
+ curAct._a32._priority = in.readByte();
break;
case INIT_SCREEN: // 33
- curAct.a33.timer = in.readSint16BE();
- curAct.a33.objIndex = in.readSint16BE();
- curAct.a33.screenIndex = in.readSint16BE();
+ curAct._a33._timer = in.readSint16BE();
+ curAct._a33._objIndex = in.readSint16BE();
+ curAct._a33._screenIndex = in.readSint16BE();
break;
case AGSCHEDULE: // 34
- curAct.a34.timer = in.readSint16BE();
- curAct.a34.actIndex = in.readUint16BE();
+ curAct._a34._timer = in.readSint16BE();
+ curAct._a34._actIndex = in.readUint16BE();
break;
case REMAPPAL: // 35
- curAct.a35.timer = in.readSint16BE();
- curAct.a35.oldColorIndex = in.readSint16BE();
- curAct.a35.newColorIndex = in.readSint16BE();
+ curAct._a35._timer = in.readSint16BE();
+ curAct._a35._oldColorIndex = in.readSint16BE();
+ curAct._a35._newColorIndex = in.readSint16BE();
break;
case COND_NOUN: // 36
- curAct.a36.timer = in.readSint16BE();
- curAct.a36.nounIndex = in.readUint16BE();
- curAct.a36.actPassIndex = in.readUint16BE();
- curAct.a36.actFailIndex = in.readUint16BE();
+ curAct._a36._timer = in.readSint16BE();
+ curAct._a36._nounIndex = in.readUint16BE();
+ curAct._a36._actPassIndex = in.readUint16BE();
+ curAct._a36._actFailIndex = in.readUint16BE();
break;
case SCREEN_STATE: // 37
- curAct.a37.timer = in.readSint16BE();
- curAct.a37.screenIndex = in.readSint16BE();
- curAct.a37.newState = in.readByte();
+ curAct._a37._timer = in.readSint16BE();
+ curAct._a37._screenIndex = in.readSint16BE();
+ curAct._a37._newState = in.readByte();
break;
case INIT_LIPS: // 38
- curAct.a38.timer = in.readSint16BE();
- curAct.a38.lipsObjIndex = in.readSint16BE();
- curAct.a38.objIndex = in.readSint16BE();
- curAct.a38.dxLips = in.readByte();
- curAct.a38.dyLips = in.readByte();
+ curAct._a38._timer = in.readSint16BE();
+ curAct._a38._lipsObjIndex = in.readSint16BE();
+ curAct._a38._objIndex = in.readSint16BE();
+ curAct._a38._dxLips = in.readByte();
+ curAct._a38._dyLips = in.readByte();
break;
case INIT_STORY_MODE: // 39
- curAct.a39.timer = in.readSint16BE();
- curAct.a39.storyModeFl = (in.readByte() == 1);
+ curAct._a39._timer = in.readSint16BE();
+ curAct._a39._storyModeFl = (in.readByte() == 1);
break;
case WARN: // 40
- curAct.a40.timer = in.readSint16BE();
- curAct.a40.stringIndex = in.readSint16BE();
+ curAct._a40._timer = in.readSint16BE();
+ curAct._a40._stringIndex = in.readSint16BE();
break;
case COND_BONUS: // 41
- curAct.a41.timer = in.readSint16BE();
- curAct.a41.BonusIndex = in.readSint16BE();
- curAct.a41.actPassIndex = in.readUint16BE();
- curAct.a41.actFailIndex = in.readUint16BE();
+ curAct._a41._timer = in.readSint16BE();
+ curAct._a41._bonusIndex = in.readSint16BE();
+ curAct._a41._actPassIndex = in.readUint16BE();
+ curAct._a41._actFailIndex = in.readUint16BE();
break;
case TEXT_TAKE: // 42
- curAct.a42.timer = in.readSint16BE();
- curAct.a42.objIndex = in.readSint16BE();
+ curAct._a42._timer = in.readSint16BE();
+ curAct._a42._objIndex = in.readSint16BE();
break;
case YESNO: // 43
- curAct.a43.timer = in.readSint16BE();
- curAct.a43.promptIndex = in.readSint16BE();
- curAct.a43.actYesIndex = in.readUint16BE();
- curAct.a43.actNoIndex = in.readUint16BE();
+ curAct._a43._timer = in.readSint16BE();
+ curAct._a43._promptIndex = in.readSint16BE();
+ curAct._a43._actYesIndex = in.readUint16BE();
+ curAct._a43._actNoIndex = in.readUint16BE();
break;
case STOP_ROUTE: // 44
- curAct.a44.timer = in.readSint16BE();
+ curAct._a44._timer = in.readSint16BE();
break;
case COND_ROUTE: // 45
- curAct.a45.timer = in.readSint16BE();
- curAct.a45.routeIndex = in.readSint16BE();
- curAct.a45.actPassIndex = in.readUint16BE();
- curAct.a45.actFailIndex = in.readUint16BE();
+ curAct._a45._timer = in.readSint16BE();
+ curAct._a45._routeIndex = in.readSint16BE();
+ curAct._a45._actPassIndex = in.readUint16BE();
+ curAct._a45._actFailIndex = in.readUint16BE();
break;
case INIT_JUMPEXIT: // 46
- curAct.a46.timer = in.readSint16BE();
- curAct.a46.jumpExitFl = (in.readByte() == 1);
+ curAct._a46._timer = in.readSint16BE();
+ curAct._a46._jumpExitFl = (in.readByte() == 1);
break;
case INIT_VIEW: // 47
- curAct.a47.timer = in.readSint16BE();
- curAct.a47.objIndex = in.readSint16BE();
- curAct.a47.viewx = in.readSint16BE();
- curAct.a47.viewy = in.readSint16BE();
- curAct.a47.direction = in.readSint16BE();
+ curAct._a47._timer = in.readSint16BE();
+ curAct._a47._objIndex = in.readSint16BE();
+ curAct._a47._viewx = in.readSint16BE();
+ curAct._a47._viewy = in.readSint16BE();
+ curAct._a47._direction = in.readSint16BE();
break;
case INIT_OBJ_FRAME: // 48
- curAct.a48.timer = in.readSint16BE();
- curAct.a48.objIndex = in.readSint16BE();
- curAct.a48.seqIndex = in.readSint16BE();
- curAct.a48.frameIndex = in.readSint16BE();
+ curAct._a48._timer = in.readSint16BE();
+ curAct._a48._objIndex = in.readSint16BE();
+ curAct._a48._seqIndex = in.readSint16BE();
+ curAct._a48._frameIndex = in.readSint16BE();
break;
case OLD_SONG: //49
- curAct.a49.timer = in.readSint16BE();
- curAct.a49.songIndex = in.readUint16BE();
+ curAct._a49._timer = in.readSint16BE();
+ curAct._a49._songIndex = in.readUint16BE();
break;
default:
- error("Engine - Unknown action type encountered: %d", curAct.a0.actType);
+ error("Engine - Unknown action type encountered: %d", curAct._a0._actType);
}
}
@@ -572,13 +572,13 @@ void Scheduler::loadActListArr(Common::ReadStream &in) {
readAct(in, _actListArr[i][j]);
} else {
readAct(in, tmpAct);
- if (tmpAct.a0.actType == PROMPT)
- free(tmpAct.a3.responsePtr);
+ if (tmpAct._a0._actType == PROMPT)
+ free(tmpAct._a3._responsePtr);
}
}
if (varnt == _vm->_gameVariant)
- _actListArr[i][numSubElem].a0.actType = ANULL;
+ _actListArr[i][numSubElem]._a0._actType = ANULL;
}
}
}
@@ -626,9 +626,9 @@ void Scheduler::freeScheduler() {
if (_actListArr) {
for (int i = 0; i < _actListArrSize; i++) {
- for (int j = 0; _actListArr[i][j].a0.actType != ANULL; j++) {
- if (_actListArr[i][j].a0.actType == PROMPT)
- free(_actListArr[i][j].a3.responsePtr);
+ for (int j = 0; _actListArr[i][j]._a0._actType != ANULL; j++) {
+ if (_actListArr[i][j]._a0._actType == PROMPT)
+ free(_actListArr[i][j]._a3._responsePtr);
}
free(_actListArr[i]);
}
@@ -658,30 +658,30 @@ void Scheduler::processMaze(const int x1, const int x2, const int y1, const int
if (x1 < _vm->_maze._x1) {
// Exit west
- _actListArr[_alNewscrIndex][3].a8.screenIndex = *_vm->_screen_p - 1;
- _actListArr[_alNewscrIndex][0].a2.x = _vm->_maze._x2 - kShiftSize - (x2 - x1);
- _actListArr[_alNewscrIndex][0].a2.y = _vm->_hero->_y;
+ _actListArr[_alNewscrIndex][3]._a8._screenIndex = *_vm->_screen_p - 1;
+ _actListArr[_alNewscrIndex][0]._a2._x = _vm->_maze._x2 - kShiftSize - (x2 - x1);
+ _actListArr[_alNewscrIndex][0]._a2._y = _vm->_hero->_y;
_vm->_route->resetRoute();
insertActionList(_alNewscrIndex);
} else if (x2 > _vm->_maze._x2) {
// Exit east
- _actListArr[_alNewscrIndex][3].a8.screenIndex = *_vm->_screen_p + 1;
- _actListArr[_alNewscrIndex][0].a2.x = _vm->_maze._x1 + kShiftSize;
- _actListArr[_alNewscrIndex][0].a2.y = _vm->_hero->_y;
+ _actListArr[_alNewscrIndex][3]._a8._screenIndex = *_vm->_screen_p + 1;
+ _actListArr[_alNewscrIndex][0]._a2._x = _vm->_maze._x1 + kShiftSize;
+ _actListArr[_alNewscrIndex][0]._a2._y = _vm->_hero->_y;
_vm->_route->resetRoute();
insertActionList(_alNewscrIndex);
} else if (y1 < _vm->_maze._y1 - kShiftSize) {
// Exit north
- _actListArr[_alNewscrIndex][3].a8.screenIndex = *_vm->_screen_p - _vm->_maze._size;
- _actListArr[_alNewscrIndex][0].a2.x = _vm->_maze._x3;
- _actListArr[_alNewscrIndex][0].a2.y = _vm->_maze._y2 - kShiftSize - (y2 - y1);
+ _actListArr[_alNewscrIndex][3]._a8._screenIndex = *_vm->_screen_p - _vm->_maze._size;
+ _actListArr[_alNewscrIndex][0]._a2._x = _vm->_maze._x3;
+ _actListArr[_alNewscrIndex][0]._a2._y = _vm->_maze._y2 - kShiftSize - (y2 - y1);
_vm->_route->resetRoute();
insertActionList(_alNewscrIndex);
} else if (y2 > _vm->_maze._y2 - kShiftSize / 2) {
// Exit south
- _actListArr[_alNewscrIndex][3].a8.screenIndex = *_vm->_screen_p + _vm->_maze._size;
- _actListArr[_alNewscrIndex][0].a2.x = _vm->_maze._x4;
- _actListArr[_alNewscrIndex][0].a2.y = _vm->_maze._y1 + kShiftSize;
+ _actListArr[_alNewscrIndex][3]._a8._screenIndex = *_vm->_screen_p + _vm->_maze._size;
+ _actListArr[_alNewscrIndex][0]._a2._x = _vm->_maze._x4;
+ _actListArr[_alNewscrIndex][0]._a2._y = _vm->_maze._y1 + kShiftSize;
_vm->_route->resetRoute();
insertActionList(_alNewscrIndex);
}
@@ -712,13 +712,13 @@ void Scheduler::saveEvents(Common::WriteStream *f) {
// fix up action pointer (to do better)
int16 index, subElem;
- findAction(wrkEvent->action, &index, &subElem);
+ findAction(wrkEvent->_action, &index, &subElem);
f->writeSint16BE(index);
f->writeSint16BE(subElem);
- f->writeByte((wrkEvent->localActionFl) ? 1 : 0);
- f->writeUint32BE(wrkEvent->time);
- f->writeSint16BE((wrkEvent->prevEvent == 0) ? -1 : (wrkEvent->prevEvent - _events));
- f->writeSint16BE((wrkEvent->nextEvent == 0) ? -1 : (wrkEvent->nextEvent - _events));
+ f->writeByte((wrkEvent->_localActionFl) ? 1 : 0);
+ f->writeUint32BE(wrkEvent->_time);
+ f->writeSint16BE((wrkEvent->_prevEvent == 0) ? -1 : (wrkEvent->_prevEvent - _events));
+ f->writeSint16BE((wrkEvent->_nextEvent == 0) ? -1 : (wrkEvent->_nextEvent - _events));
}
}
@@ -738,7 +738,7 @@ void Scheduler::restoreActions(Common::ReadStream *f) {
int16 Scheduler::calcMaxPoints() const {
int16 tmpScore = 0;
for (int i = 0; i < _numBonuses; i++)
- tmpScore += _points[i].score;
+ tmpScore += _points[i]._score;
return tmpScore;
}
@@ -752,282 +752,282 @@ void Scheduler::saveActions(Common::WriteStream *f) const {
for (int i = 0; i < _actListArrSize; i++) {
// write all the sub elems data
- for (nbrSubElem = 1; _actListArr[i][nbrSubElem - 1].a0.actType != ANULL; nbrSubElem++)
+ for (nbrSubElem = 1; _actListArr[i][nbrSubElem - 1]._a0._actType != ANULL; nbrSubElem++)
;
f->writeUint16BE(nbrSubElem);
for (int j = 0; j < nbrSubElem; j++) {
- subElemType = _actListArr[i][j].a0.actType;
+ subElemType = _actListArr[i][j]._a0._actType;
f->writeByte(subElemType);
switch (subElemType) {
case ANULL: // -1
break;
case ASCHEDULE: // 0
- f->writeSint16BE(_actListArr[i][j].a0.timer);
- f->writeUint16BE(_actListArr[i][j].a0.actIndex);
+ f->writeSint16BE(_actListArr[i][j]._a0._timer);
+ f->writeUint16BE(_actListArr[i][j]._a0._actIndex);
break;
case START_OBJ: // 1
- f->writeSint16BE(_actListArr[i][j].a1.timer);
- f->writeSint16BE(_actListArr[i][j].a1.objIndex);
- f->writeSint16BE(_actListArr[i][j].a1.cycleNumb);
- f->writeByte(_actListArr[i][j].a1.cycle);
+ f->writeSint16BE(_actListArr[i][j]._a1._timer);
+ f->writeSint16BE(_actListArr[i][j]._a1._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a1._cycleNumb);
+ f->writeByte(_actListArr[i][j]._a1._cycle);
break;
case INIT_OBJXY: // 2
- f->writeSint16BE(_actListArr[i][j].a2.timer);
- f->writeSint16BE(_actListArr[i][j].a2.objIndex);
- f->writeSint16BE(_actListArr[i][j].a2.x);
- f->writeSint16BE(_actListArr[i][j].a2.y);
+ f->writeSint16BE(_actListArr[i][j]._a2._timer);
+ f->writeSint16BE(_actListArr[i][j]._a2._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a2._x);
+ f->writeSint16BE(_actListArr[i][j]._a2._y);
break;
case PROMPT: // 3
- f->writeSint16BE(_actListArr[i][j].a3.timer);
- f->writeSint16BE(_actListArr[i][j].a3.promptIndex);
- for (nbrCpt = 0; _actListArr[i][j].a3.responsePtr[nbrCpt] != -1; nbrCpt++)
+ f->writeSint16BE(_actListArr[i][j]._a3._timer);
+ f->writeSint16BE(_actListArr[i][j]._a3._promptIndex);
+ for (nbrCpt = 0; _actListArr[i][j]._a3._responsePtr[nbrCpt] != -1; nbrCpt++)
;
nbrCpt++;
f->writeUint16BE(nbrCpt);
for (int k = 0; k < nbrCpt; k++)
- f->writeSint16BE(_actListArr[i][j].a3.responsePtr[k]);
- f->writeUint16BE(_actListArr[i][j].a3.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a3.actFailIndex);
- f->writeByte((_actListArr[i][j].a3.encodedFl) ? 1 : 0);
+ f->writeSint16BE(_actListArr[i][j]._a3._responsePtr[k]);
+ f->writeUint16BE(_actListArr[i][j]._a3._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a3._actFailIndex);
+ f->writeByte((_actListArr[i][j]._a3._encodedFl) ? 1 : 0);
break;
case BKGD_COLOR: // 4
- f->writeSint16BE(_actListArr[i][j].a4.timer);
- f->writeUint32BE(_actListArr[i][j].a4.newBackgroundColor);
+ f->writeSint16BE(_actListArr[i][j]._a4._timer);
+ f->writeUint32BE(_actListArr[i][j]._a4._newBackgroundColor);
break;
case INIT_OBJVXY: // 5
- f->writeSint16BE(_actListArr[i][j].a5.timer);
- f->writeSint16BE(_actListArr[i][j].a5.objIndex);
- f->writeSint16BE(_actListArr[i][j].a5.vx);
- f->writeSint16BE(_actListArr[i][j].a5.vy);
+ f->writeSint16BE(_actListArr[i][j]._a5._timer);
+ f->writeSint16BE(_actListArr[i][j]._a5._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a5._vx);
+ f->writeSint16BE(_actListArr[i][j]._a5._vy);
break;
case INIT_CARRY: // 6
- f->writeSint16BE(_actListArr[i][j].a6.timer);
- f->writeSint16BE(_actListArr[i][j].a6.objIndex);
- f->writeByte((_actListArr[i][j].a6.carriedFl) ? 1 : 0);
+ f->writeSint16BE(_actListArr[i][j]._a6._timer);
+ f->writeSint16BE(_actListArr[i][j]._a6._objIndex);
+ f->writeByte((_actListArr[i][j]._a6._carriedFl) ? 1 : 0);
break;
case INIT_HF_COORD: // 7
- f->writeSint16BE(_actListArr[i][j].a7.timer);
- f->writeSint16BE(_actListArr[i][j].a7.objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a7._timer);
+ f->writeSint16BE(_actListArr[i][j]._a7._objIndex);
break;
case NEW_SCREEN: // 8
- f->writeSint16BE(_actListArr[i][j].a8.timer);
- f->writeSint16BE(_actListArr[i][j].a8.screenIndex);
+ f->writeSint16BE(_actListArr[i][j]._a8._timer);
+ f->writeSint16BE(_actListArr[i][j]._a8._screenIndex);
break;
case INIT_OBJSTATE: // 9
- f->writeSint16BE(_actListArr[i][j].a9.timer);
- f->writeSint16BE(_actListArr[i][j].a9.objIndex);
- f->writeByte(_actListArr[i][j].a9.newState);
+ f->writeSint16BE(_actListArr[i][j]._a9._timer);
+ f->writeSint16BE(_actListArr[i][j]._a9._objIndex);
+ f->writeByte(_actListArr[i][j]._a9._newState);
break;
case INIT_PATH: // 10
- f->writeSint16BE(_actListArr[i][j].a10.timer);
- f->writeSint16BE(_actListArr[i][j].a10.objIndex);
- f->writeSint16BE(_actListArr[i][j].a10.newPathType);
- f->writeByte(_actListArr[i][j].a10.vxPath);
- f->writeByte(_actListArr[i][j].a10.vyPath);
+ f->writeSint16BE(_actListArr[i][j]._a10._timer);
+ f->writeSint16BE(_actListArr[i][j]._a10._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a10._newPathType);
+ f->writeByte(_actListArr[i][j]._a10._vxPath);
+ f->writeByte(_actListArr[i][j]._a10._vyPath);
break;
case COND_R: // 11
- f->writeSint16BE(_actListArr[i][j].a11.timer);
- f->writeSint16BE(_actListArr[i][j].a11.objIndex);
- f->writeByte(_actListArr[i][j].a11.stateReq);
- f->writeUint16BE(_actListArr[i][j].a11.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a11.actFailIndex);
+ f->writeSint16BE(_actListArr[i][j]._a11._timer);
+ f->writeSint16BE(_actListArr[i][j]._a11._objIndex);
+ f->writeByte(_actListArr[i][j]._a11._stateReq);
+ f->writeUint16BE(_actListArr[i][j]._a11._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a11._actFailIndex);
break;
case TEXT: // 12
- f->writeSint16BE(_actListArr[i][j].a12.timer);
- f->writeSint16BE(_actListArr[i][j].a12.stringIndex);
+ f->writeSint16BE(_actListArr[i][j]._a12._timer);
+ f->writeSint16BE(_actListArr[i][j]._a12._stringIndex);
break;
case SWAP_IMAGES: // 13
- f->writeSint16BE(_actListArr[i][j].a13.timer);
- f->writeSint16BE(_actListArr[i][j].a13.objIndex1);
- f->writeSint16BE(_actListArr[i][j].a13.objIndex2);
+ f->writeSint16BE(_actListArr[i][j]._a13._timer);
+ f->writeSint16BE(_actListArr[i][j]._a13._objIndex1);
+ f->writeSint16BE(_actListArr[i][j]._a13._objIndex2);
break;
case COND_SCR: // 14
- f->writeSint16BE(_actListArr[i][j].a14.timer);
- f->writeSint16BE(_actListArr[i][j].a14.objIndex);
- f->writeSint16BE(_actListArr[i][j].a14.screenReq);
- f->writeUint16BE(_actListArr[i][j].a14.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a14.actFailIndex);
+ f->writeSint16BE(_actListArr[i][j]._a14._timer);
+ f->writeSint16BE(_actListArr[i][j]._a14._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a14._screenReq);
+ f->writeUint16BE(_actListArr[i][j]._a14._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a14._actFailIndex);
break;
case AUTOPILOT: // 15
- f->writeSint16BE(_actListArr[i][j].a15.timer);
- f->writeSint16BE(_actListArr[i][j].a15.objIndex1);
- f->writeSint16BE(_actListArr[i][j].a15.objIndex2);
- f->writeByte(_actListArr[i][j].a15.dx);
- f->writeByte(_actListArr[i][j].a15.dy);
+ f->writeSint16BE(_actListArr[i][j]._a15._timer);
+ f->writeSint16BE(_actListArr[i][j]._a15._objIndex1);
+ f->writeSint16BE(_actListArr[i][j]._a15._objIndex2);
+ f->writeByte(_actListArr[i][j]._a15._dx);
+ f->writeByte(_actListArr[i][j]._a15._dy);
break;
case INIT_OBJ_SEQ: // 16
- f->writeSint16BE(_actListArr[i][j].a16.timer);
- f->writeSint16BE(_actListArr[i][j].a16.objIndex);
- f->writeSint16BE(_actListArr[i][j].a16.seqIndex);
+ f->writeSint16BE(_actListArr[i][j]._a16._timer);
+ f->writeSint16BE(_actListArr[i][j]._a16._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a16._seqIndex);
break;
case SET_STATE_BITS: // 17
- f->writeSint16BE(_actListArr[i][j].a17.timer);
- f->writeSint16BE(_actListArr[i][j].a17.objIndex);
- f->writeSint16BE(_actListArr[i][j].a17.stateMask);
+ f->writeSint16BE(_actListArr[i][j]._a17._timer);
+ f->writeSint16BE(_actListArr[i][j]._a17._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a17._stateMask);
break;
case CLEAR_STATE_BITS: // 18
- f->writeSint16BE(_actListArr[i][j].a18.timer);
- f->writeSint16BE(_actListArr[i][j].a18.objIndex);
- f->writeSint16BE(_actListArr[i][j].a18.stateMask);
+ f->writeSint16BE(_actListArr[i][j]._a18._timer);
+ f->writeSint16BE(_actListArr[i][j]._a18._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a18._stateMask);
break;
case TEST_STATE_BITS: // 19
- f->writeSint16BE(_actListArr[i][j].a19.timer);
- f->writeSint16BE(_actListArr[i][j].a19.objIndex);
- f->writeSint16BE(_actListArr[i][j].a19.stateMask);
- f->writeUint16BE(_actListArr[i][j].a19.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a19.actFailIndex);
+ f->writeSint16BE(_actListArr[i][j]._a19._timer);
+ f->writeSint16BE(_actListArr[i][j]._a19._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a19._stateMask);
+ f->writeUint16BE(_actListArr[i][j]._a19._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a19._actFailIndex);
break;
case DEL_EVENTS: // 20
- f->writeSint16BE(_actListArr[i][j].a20.timer);
- f->writeByte(_actListArr[i][j].a20.actTypeDel);
+ f->writeSint16BE(_actListArr[i][j]._a20._timer);
+ f->writeByte(_actListArr[i][j]._a20._actTypeDel);
break;
case GAMEOVER: // 21
- f->writeSint16BE(_actListArr[i][j].a21.timer);
+ f->writeSint16BE(_actListArr[i][j]._a21._timer);
break;
case INIT_HH_COORD: // 22
- f->writeSint16BE(_actListArr[i][j].a22.timer);
- f->writeSint16BE(_actListArr[i][j].a22.objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a22._timer);
+ f->writeSint16BE(_actListArr[i][j]._a22._objIndex);
break;
case EXIT: // 23
- f->writeSint16BE(_actListArr[i][j].a23.timer);
+ f->writeSint16BE(_actListArr[i][j]._a23._timer);
break;
case BONUS: // 24
- f->writeSint16BE(_actListArr[i][j].a24.timer);
- f->writeSint16BE(_actListArr[i][j].a24.pointIndex);
+ f->writeSint16BE(_actListArr[i][j]._a24._timer);
+ f->writeSint16BE(_actListArr[i][j]._a24._pointIndex);
break;
case COND_BOX: // 25
- f->writeSint16BE(_actListArr[i][j].a25.timer);
- f->writeSint16BE(_actListArr[i][j].a25.objIndex);
- f->writeSint16BE(_actListArr[i][j].a25.x1);
- f->writeSint16BE(_actListArr[i][j].a25.y1);
- f->writeSint16BE(_actListArr[i][j].a25.x2);
- f->writeSint16BE(_actListArr[i][j].a25.y2);
- f->writeUint16BE(_actListArr[i][j].a25.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a25.actFailIndex);
+ f->writeSint16BE(_actListArr[i][j]._a25._timer);
+ f->writeSint16BE(_actListArr[i][j]._a25._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a25._x1);
+ f->writeSint16BE(_actListArr[i][j]._a25._y1);
+ f->writeSint16BE(_actListArr[i][j]._a25._x2);
+ f->writeSint16BE(_actListArr[i][j]._a25._y2);
+ f->writeUint16BE(_actListArr[i][j]._a25._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a25._actFailIndex);
break;
case SOUND: // 26
- f->writeSint16BE(_actListArr[i][j].a26.timer);
- f->writeSint16BE(_actListArr[i][j].a26.soundIndex);
+ f->writeSint16BE(_actListArr[i][j]._a26._timer);
+ f->writeSint16BE(_actListArr[i][j]._a26._soundIndex);
break;
case ADD_SCORE: // 27
- f->writeSint16BE(_actListArr[i][j].a27.timer);
- f->writeSint16BE(_actListArr[i][j].a27.objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a27._timer);
+ f->writeSint16BE(_actListArr[i][j]._a27._objIndex);
break;
case SUB_SCORE: // 28
- f->writeSint16BE(_actListArr[i][j].a28.timer);
- f->writeSint16BE(_actListArr[i][j].a28.objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a28._timer);
+ f->writeSint16BE(_actListArr[i][j]._a28._objIndex);
break;
case COND_CARRY: // 29
- f->writeSint16BE(_actListArr[i][j].a29.timer);
- f->writeSint16BE(_actListArr[i][j].a29.objIndex);
- f->writeUint16BE(_actListArr[i][j].a29.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a29.actFailIndex);
+ f->writeSint16BE(_actListArr[i][j]._a29._timer);
+ f->writeSint16BE(_actListArr[i][j]._a29._objIndex);
+ f->writeUint16BE(_actListArr[i][j]._a29._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a29._actFailIndex);
break;
case INIT_MAZE: // 30
- f->writeSint16BE(_actListArr[i][j].a30.timer);
- f->writeByte(_actListArr[i][j].a30.mazeSize);
- f->writeSint16BE(_actListArr[i][j].a30.x1);
- f->writeSint16BE(_actListArr[i][j].a30.y1);
- f->writeSint16BE(_actListArr[i][j].a30.x2);
- f->writeSint16BE(_actListArr[i][j].a30.y2);
- f->writeSint16BE(_actListArr[i][j].a30.x3);
- f->writeSint16BE(_actListArr[i][j].a30.x4);
- f->writeByte(_actListArr[i][j].a30.firstScreenIndex);
+ f->writeSint16BE(_actListArr[i][j]._a30._timer);
+ f->writeByte(_actListArr[i][j]._a30._mazeSize);
+ f->writeSint16BE(_actListArr[i][j]._a30._x1);
+ f->writeSint16BE(_actListArr[i][j]._a30._y1);
+ f->writeSint16BE(_actListArr[i][j]._a30._x2);
+ f->writeSint16BE(_actListArr[i][j]._a30._y2);
+ f->writeSint16BE(_actListArr[i][j]._a30._x3);
+ f->writeSint16BE(_actListArr[i][j]._a30._x4);
+ f->writeByte(_actListArr[i][j]._a30._firstScreenIndex);
break;
case EXIT_MAZE: // 31
- f->writeSint16BE(_actListArr[i][j].a31.timer);
+ f->writeSint16BE(_actListArr[i][j]._a31._timer);
break;
case INIT_PRIORITY: // 32
- f->writeSint16BE(_actListArr[i][j].a32.timer);
- f->writeSint16BE(_actListArr[i][j].a32.objIndex);
- f->writeByte(_actListArr[i][j].a32.priority);
+ f->writeSint16BE(_actListArr[i][j]._a32._timer);
+ f->writeSint16BE(_actListArr[i][j]._a32._objIndex);
+ f->writeByte(_actListArr[i][j]._a32._priority);
break;
case INIT_SCREEN: // 33
- f->writeSint16BE(_actListArr[i][j].a33.timer);
- f->writeSint16BE(_actListArr[i][j].a33.objIndex);
- f->writeSint16BE(_actListArr[i][j].a33.screenIndex);
+ f->writeSint16BE(_actListArr[i][j]._a33._timer);
+ f->writeSint16BE(_actListArr[i][j]._a33._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a33._screenIndex);
break;
case AGSCHEDULE: // 34
- f->writeSint16BE(_actListArr[i][j].a34.timer);
- f->writeUint16BE(_actListArr[i][j].a34.actIndex);
+ f->writeSint16BE(_actListArr[i][j]._a34._timer);
+ f->writeUint16BE(_actListArr[i][j]._a34._actIndex);
break;
case REMAPPAL: // 35
- f->writeSint16BE(_actListArr[i][j].a35.timer);
- f->writeSint16BE(_actListArr[i][j].a35.oldColorIndex);
- f->writeSint16BE(_actListArr[i][j].a35.newColorIndex);
+ f->writeSint16BE(_actListArr[i][j]._a35._timer);
+ f->writeSint16BE(_actListArr[i][j]._a35._oldColorIndex);
+ f->writeSint16BE(_actListArr[i][j]._a35._newColorIndex);
break;
case COND_NOUN: // 36
- f->writeSint16BE(_actListArr[i][j].a36.timer);
- f->writeUint16BE(_actListArr[i][j].a36.nounIndex);
- f->writeUint16BE(_actListArr[i][j].a36.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a36.actFailIndex);
+ f->writeSint16BE(_actListArr[i][j]._a36._timer);
+ f->writeUint16BE(_actListArr[i][j]._a36._nounIndex);
+ f->writeUint16BE(_actListArr[i][j]._a36._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a36._actFailIndex);
break;
case SCREEN_STATE: // 37
- f->writeSint16BE(_actListArr[i][j].a37.timer);
- f->writeSint16BE(_actListArr[i][j].a37.screenIndex);
- f->writeByte(_actListArr[i][j].a37.newState);
+ f->writeSint16BE(_actListArr[i][j]._a37._timer);
+ f->writeSint16BE(_actListArr[i][j]._a37._screenIndex);
+ f->writeByte(_actListArr[i][j]._a37._newState);
break;
case INIT_LIPS: // 38
- f->writeSint16BE(_actListArr[i][j].a38.timer);
- f->writeSint16BE(_actListArr[i][j].a38.lipsObjIndex);
- f->writeSint16BE(_actListArr[i][j].a38.objIndex);
- f->writeByte(_actListArr[i][j].a38.dxLips);
- f->writeByte(_actListArr[i][j].a38.dyLips);
+ f->writeSint16BE(_actListArr[i][j]._a38._timer);
+ f->writeSint16BE(_actListArr[i][j]._a38._lipsObjIndex);
+ f->writeSint16BE(_actListArr[i][j]._a38._objIndex);
+ f->writeByte(_actListArr[i][j]._a38._dxLips);
+ f->writeByte(_actListArr[i][j]._a38._dyLips);
break;
case INIT_STORY_MODE: // 39
- f->writeSint16BE(_actListArr[i][j].a39.timer);
- f->writeByte((_actListArr[i][j].a39.storyModeFl) ? 1 : 0);
+ f->writeSint16BE(_actListArr[i][j]._a39._timer);
+ f->writeByte((_actListArr[i][j]._a39._storyModeFl) ? 1 : 0);
break;
case WARN: // 40
- f->writeSint16BE(_actListArr[i][j].a40.timer);
- f->writeSint16BE(_actListArr[i][j].a40.stringIndex);
+ f->writeSint16BE(_actListArr[i][j]._a40._timer);
+ f->writeSint16BE(_actListArr[i][j]._a40._stringIndex);
break;
case COND_BONUS: // 41
- f->writeSint16BE(_actListArr[i][j].a41.timer);
- f->writeSint16BE(_actListArr[i][j].a41.BonusIndex);
- f->writeUint16BE(_actListArr[i][j].a41.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a41.actFailIndex);
+ f->writeSint16BE(_actListArr[i][j]._a41._timer);
+ f->writeSint16BE(_actListArr[i][j]._a41._bonusIndex);
+ f->writeUint16BE(_actListArr[i][j]._a41._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a41._actFailIndex);
break;
case TEXT_TAKE: // 42
- f->writeSint16BE(_actListArr[i][j].a42.timer);
- f->writeSint16BE(_actListArr[i][j].a42.objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a42._timer);
+ f->writeSint16BE(_actListArr[i][j]._a42._objIndex);
break;
case YESNO: // 43
- f->writeSint16BE(_actListArr[i][j].a43.timer);
- f->writeSint16BE(_actListArr[i][j].a43.promptIndex);
- f->writeUint16BE(_actListArr[i][j].a43.actYesIndex);
- f->writeUint16BE(_actListArr[i][j].a43.actNoIndex);
+ f->writeSint16BE(_actListArr[i][j]._a43._timer);
+ f->writeSint16BE(_actListArr[i][j]._a43._promptIndex);
+ f->writeUint16BE(_actListArr[i][j]._a43._actYesIndex);
+ f->writeUint16BE(_actListArr[i][j]._a43._actNoIndex);
break;
case STOP_ROUTE: // 44
- f->writeSint16BE(_actListArr[i][j].a44.timer);
+ f->writeSint16BE(_actListArr[i][j]._a44._timer);
break;
case COND_ROUTE: // 45
- f->writeSint16BE(_actListArr[i][j].a45.timer);
- f->writeSint16BE(_actListArr[i][j].a45.routeIndex);
- f->writeUint16BE(_actListArr[i][j].a45.actPassIndex);
- f->writeUint16BE(_actListArr[i][j].a45.actFailIndex);
+ f->writeSint16BE(_actListArr[i][j]._a45._timer);
+ f->writeSint16BE(_actListArr[i][j]._a45._routeIndex);
+ f->writeUint16BE(_actListArr[i][j]._a45._actPassIndex);
+ f->writeUint16BE(_actListArr[i][j]._a45._actFailIndex);
break;
case INIT_JUMPEXIT: // 46
- f->writeSint16BE(_actListArr[i][j].a46.timer);
- f->writeByte((_actListArr[i][j].a46.jumpExitFl) ? 1 : 0);
+ f->writeSint16BE(_actListArr[i][j]._a46._timer);
+ f->writeByte((_actListArr[i][j]._a46._jumpExitFl) ? 1 : 0);
break;
case INIT_VIEW: // 47
- f->writeSint16BE(_actListArr[i][j].a47.timer);
- f->writeSint16BE(_actListArr[i][j].a47.objIndex);
- f->writeSint16BE(_actListArr[i][j].a47.viewx);
- f->writeSint16BE(_actListArr[i][j].a47.viewy);
- f->writeSint16BE(_actListArr[i][j].a47.direction);
+ f->writeSint16BE(_actListArr[i][j]._a47._timer);
+ f->writeSint16BE(_actListArr[i][j]._a47._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a47._viewx);
+ f->writeSint16BE(_actListArr[i][j]._a47._viewy);
+ f->writeSint16BE(_actListArr[i][j]._a47._direction);
break;
case INIT_OBJ_FRAME: // 48
- f->writeSint16BE(_actListArr[i][j].a48.timer);
- f->writeSint16BE(_actListArr[i][j].a48.objIndex);
- f->writeSint16BE(_actListArr[i][j].a48.seqIndex);
- f->writeSint16BE(_actListArr[i][j].a48.frameIndex);
+ f->writeSint16BE(_actListArr[i][j]._a48._timer);
+ f->writeSint16BE(_actListArr[i][j]._a48._objIndex);
+ f->writeSint16BE(_actListArr[i][j]._a48._seqIndex);
+ f->writeSint16BE(_actListArr[i][j]._a48._frameIndex);
break;
case OLD_SONG: // 49, Added by Strangerke for DOS versions
- f->writeSint16BE(_actListArr[i][j].a49.timer);
- f->writeUint16BE(_actListArr[i][j].a49.songIndex);
+ f->writeSint16BE(_actListArr[i][j]._a49._timer);
+ f->writeUint16BE(_actListArr[i][j]._a49._songIndex);
break;
default:
error("Unknown action %d", subElemType);
@@ -1057,7 +1057,7 @@ void Scheduler::findAction(const act* action, int16* index, int16* subElem) {
return;
}
j++;
- } while (_actListArr[i][j-1].a0.actType != ANULL);
+ } while (_actListArr[i][j-1]._a0._actType != ANULL);
}
// action not found ??
assert(0);
@@ -1102,18 +1102,18 @@ void Scheduler::restoreEvents(Common::ReadStream *f) {
// fix up action pointer (to do better)
if ((index == -1) && (subElem == -1))
- _events[i].action = 0;
+ _events[i]._action = 0;
else
- _events[i].action = (act *)&_actListArr[index][subElem];
+ _events[i]._action = (act *)&_actListArr[index][subElem];
- _events[i].localActionFl = (f->readByte() == 1) ? true : false;
- _events[i].time = f->readUint32BE();
+ _events[i]._localActionFl = (f->readByte() == 1) ? true : false;
+ _events[i]._time = f->readUint32BE();
int16 prevIndex = f->readSint16BE();
int16 nextIndex = f->readSint16BE();
- _events[i].prevEvent = (prevIndex == -1) ? (event_t *)0 : &_events[prevIndex];
- _events[i].nextEvent = (nextIndex == -1) ? (event_t *)0 : &_events[nextIndex];
+ _events[i]._prevEvent = (prevIndex == -1) ? (event_t *)0 : &_events[prevIndex];
+ _events[i]._nextEvent = (nextIndex == -1) ? (event_t *)0 : &_events[nextIndex];
}
_freeEvent = (freeIndex == -1) ? 0 : &_events[freeIndex];
_headEvent = (headIndex == -1) ? 0 : &_events[headIndex];
@@ -1123,8 +1123,8 @@ void Scheduler::restoreEvents(Common::ReadStream *f) {
uint32 curTime = getTicks();
event_t *wrkEvent = _headEvent; // The earliest event
while (wrkEvent) { // While mature events found
- wrkEvent->time = wrkEvent->time - saveTime + curTime;
- wrkEvent = wrkEvent->nextEvent;
+ wrkEvent->_time = wrkEvent->_time - saveTime + curTime;
+ wrkEvent = wrkEvent->_nextEvent;
}
}
@@ -1133,52 +1133,52 @@ void Scheduler::restoreEvents(Common::ReadStream *f) {
* The queue goes from head (earliest) to tail (latest) timewise
*/
void Scheduler::insertAction(act *action) {
- debugC(1, kDebugSchedule, "insertAction() - Action type A%d", action->a0.actType);
+ debugC(1, kDebugSchedule, "insertAction() - Action type A%d", action->_a0._actType);
// First, get and initialize the event structure
event_t *curEvent = getQueue();
- curEvent->action = action;
- switch (action->a0.actType) { // Assign whether local or global
+ curEvent->_action = action;
+ switch (action->_a0._actType) { // Assign whether local or global
case AGSCHEDULE:
- curEvent->localActionFl = false; // Lasts over a new screen
+ curEvent->_localActionFl = false; // Lasts over a new screen
break;
// Workaround: When dying, switch to storyMode in order to block the keyboard.
case GAMEOVER:
_vm->getGameStatus()._storyModeFl = true;
// No break on purpose
default:
- curEvent->localActionFl = true; // Rest are for current screen only
+ curEvent->_localActionFl = true; // Rest are for current screen only
break;
}
- curEvent->time = action->a0.timer + getTicks(); // Convert rel to abs time
+ curEvent->_time = action->_a0._timer + getTicks(); // Convert rel to abs time
// Now find the place to insert the event
if (!_tailEvent) { // Empty queue
_tailEvent = _headEvent = curEvent;
- curEvent->nextEvent = curEvent->prevEvent = 0;
+ curEvent->_nextEvent = curEvent->_prevEvent = 0;
} else {
event_t *wrkEvent = _tailEvent; // Search from latest time back
bool found = false;
while (wrkEvent && !found) {
- if (wrkEvent->time <= curEvent->time) { // Found if new event later
+ if (wrkEvent->_time <= curEvent->_time) { // Found if new event later
found = true;
if (wrkEvent == _tailEvent) // New latest in list
_tailEvent = curEvent;
else
- wrkEvent->nextEvent->prevEvent = curEvent;
- curEvent->nextEvent = wrkEvent->nextEvent;
- wrkEvent->nextEvent = curEvent;
- curEvent->prevEvent = wrkEvent;
+ wrkEvent->_nextEvent->_prevEvent = curEvent;
+ curEvent->_nextEvent = wrkEvent->_nextEvent;
+ wrkEvent->_nextEvent = curEvent;
+ curEvent->_prevEvent = wrkEvent;
}
- wrkEvent = wrkEvent->prevEvent;
+ wrkEvent = wrkEvent->_prevEvent;
}
if (!found) { // Must be earliest in list
- _headEvent->prevEvent = curEvent; // So insert as new head
- curEvent->nextEvent = _headEvent;
- curEvent->prevEvent = 0;
+ _headEvent->_prevEvent = curEvent; // So insert as new head
+ curEvent->_nextEvent = _headEvent;
+ curEvent->_prevEvent = 0;
_headEvent = curEvent;
}
}
@@ -1190,94 +1190,94 @@ void Scheduler::insertAction(act *action) {
* to the next action in the list, except special case of NEW_SCREEN
*/
event_t *Scheduler::doAction(event_t *curEvent) {
- debugC(1, kDebugSchedule, "doAction - Event action type : %d", curEvent->action->a0.actType);
+ debugC(1, kDebugSchedule, "doAction - Event action type : %d", curEvent->_action->_a0._actType);
status_t &gameStatus = _vm->getGameStatus();
- act *action = curEvent->action;
+ act *action = curEvent->_action;
object_t *obj1;
int dx, dy;
event_t *wrkEvent; // Save ev_p->next_p for return
- switch (action->a0.actType) {
+ switch (action->_a0._actType) {
case ANULL: // Big NOP from DEL_EVENTS
break;
case ASCHEDULE: // act0: Schedule an action list
- insertActionList(action->a0.actIndex);
+ insertActionList(action->_a0._actIndex);
break;
case START_OBJ: // act1: Start an object cycling
- _vm->_object->_objects[action->a1.objIndex]._cycleNumb = action->a1.cycleNumb;
- _vm->_object->_objects[action->a1.objIndex]._cycling = action->a1.cycle;
+ _vm->_object->_objects[action->_a1._objIndex]._cycleNumb = action->_a1._cycleNumb;
+ _vm->_object->_objects[action->_a1._objIndex]._cycling = action->_a1._cycle;
break;
case INIT_OBJXY: // act2: Initialize an object
- _vm->_object->_objects[action->a2.objIndex]._x = action->a2.x; // Coordinates
- _vm->_object->_objects[action->a2.objIndex]._y = action->a2.y;
+ _vm->_object->_objects[action->_a2._objIndex]._x = action->_a2._x; // Coordinates
+ _vm->_object->_objects[action->_a2._objIndex]._y = action->_a2._y;
break;
case PROMPT: // act3: Prompt user for key phrase
promptAction(action);
break;
case BKGD_COLOR: // act4: Set new background color
- _vm->_screen->setBackgroundColor(action->a4.newBackgroundColor);
+ _vm->_screen->setBackgroundColor(action->_a4._newBackgroundColor);
break;
case INIT_OBJVXY: // act5: Initialize an object velocity
- _vm->_object->setVelocity(action->a5.objIndex, action->a5.vx, action->a5.vy);
+ _vm->_object->setVelocity(action->_a5._objIndex, action->_a5._vx, action->_a5._vy);
break;
case INIT_CARRY: // act6: Initialize an object
- _vm->_object->setCarry(action->a6.objIndex, action->a6.carriedFl); // carried status
+ _vm->_object->setCarry(action->_a6._objIndex, action->_a6._carriedFl); // carried status
break;
case INIT_HF_COORD: // act7: Initialize an object to hero's "feet" coords
- _vm->_object->_objects[action->a7.objIndex]._x = _vm->_hero->_x - 1;
- _vm->_object->_objects[action->a7.objIndex]._y = _vm->_hero->_y + _vm->_hero->_currImagePtr->_y2 - 1;
- _vm->_object->_objects[action->a7.objIndex]._screenIndex = *_vm->_screen_p; // Don't forget screen!
+ _vm->_object->_objects[action->_a7._objIndex]._x = _vm->_hero->_x - 1;
+ _vm->_object->_objects[action->_a7._objIndex]._y = _vm->_hero->_y + _vm->_hero->_currImagePtr->_y2 - 1;
+ _vm->_object->_objects[action->_a7._objIndex]._screenIndex = *_vm->_screen_p; // Don't forget screen!
break;
case NEW_SCREEN: // act8: Start new screen
- newScreen(action->a8.screenIndex);
+ newScreen(action->_a8._screenIndex);
break;
case INIT_OBJSTATE: // act9: Initialize an object state
- _vm->_object->_objects[action->a9.objIndex]._state = action->a9.newState;
+ _vm->_object->_objects[action->_a9._objIndex]._state = action->_a9._newState;
break;
case INIT_PATH: // act10: Initialize an object path and velocity
- _vm->_object->setPath(action->a10.objIndex, (path_t) action->a10.newPathType, action->a10.vxPath, action->a10.vyPath);
+ _vm->_object->setPath(action->_a10._objIndex, (path_t) action->_a10._newPathType, action->_a10._vxPath, action->_a10._vyPath);
break;
case COND_R: // act11: action lists conditional on object state
- if (_vm->_object->_objects[action->a11.objIndex]._state == action->a11.stateReq)
- insertActionList(action->a11.actPassIndex);
+ if (_vm->_object->_objects[action->_a11._objIndex]._state == action->_a11._stateReq)
+ insertActionList(action->_a11._actPassIndex);
else
- insertActionList(action->a11.actFailIndex);
+ insertActionList(action->_a11._actFailIndex);
break;
case TEXT: // act12: Text box (CF WARN)
- Utils::notifyBox(_vm->_file->fetchString(action->a12.stringIndex)); // Fetch string from file
+ Utils::notifyBox(_vm->_file->fetchString(action->_a12._stringIndex)); // Fetch string from file
break;
case SWAP_IMAGES: // act13: Swap 2 object images
- _vm->_object->swapImages(action->a13.objIndex1, action->a13.objIndex2);
+ _vm->_object->swapImages(action->_a13._objIndex1, action->_a13._objIndex2);
break;
case COND_SCR: // act14: Conditional on current screen
- if (_vm->_object->_objects[action->a14.objIndex]._screenIndex == action->a14.screenReq)
- insertActionList(action->a14.actPassIndex);
+ if (_vm->_object->_objects[action->_a14._objIndex]._screenIndex == action->_a14._screenReq)
+ insertActionList(action->_a14._actPassIndex);
else
- insertActionList(action->a14.actFailIndex);
+ insertActionList(action->_a14._actFailIndex);
break;
case AUTOPILOT: // act15: Home in on a (stationary) object
- _vm->_object->homeIn(action->a15.objIndex1, action->a15.objIndex2, action->a15.dx, action->a15.dy);
+ _vm->_object->homeIn(action->_a15._objIndex1, action->_a15._objIndex2, action->_a15._dx, action->_a15._dy);
break;
case INIT_OBJ_SEQ: // act16: Set sequence number to use
// Note: Don't set a sequence at time 0 of a new screen, it causes
// problems clearing the boundary bits of the object! t>0 is safe
- _vm->_object->_objects[action->a16.objIndex]._currImagePtr = _vm->_object->_objects[action->a16.objIndex]._seqList[action->a16.seqIndex]._seqPtr;
+ _vm->_object->_objects[action->_a16._objIndex]._currImagePtr = _vm->_object->_objects[action->_a16._objIndex]._seqList[action->_a16._seqIndex]._seqPtr;
break;
case SET_STATE_BITS: // act17: OR mask with curr obj state
- _vm->_object->_objects[action->a17.objIndex]._state |= action->a17.stateMask;
+ _vm->_object->_objects[action->_a17._objIndex]._state |= action->_a17._stateMask;
break;
case CLEAR_STATE_BITS: // act18: AND ~mask with curr obj state
- _vm->_object->_objects[action->a18.objIndex]._state &= ~action->a18.stateMask;
+ _vm->_object->_objects[action->_a18._objIndex]._state &= ~action->_a18._stateMask;
break;
case TEST_STATE_BITS: // act19: If all bits set, do apass else afail
- if ((_vm->_object->_objects[action->a19.objIndex]._state & action->a19.stateMask) == action->a19.stateMask)
- insertActionList(action->a19.actPassIndex);
+ if ((_vm->_object->_objects[action->_a19._objIndex]._state & action->_a19._stateMask) == action->_a19._stateMask)
+ insertActionList(action->_a19._actPassIndex);
else
- insertActionList(action->a19.actFailIndex);
+ insertActionList(action->_a19._actFailIndex);
break;
case DEL_EVENTS: // act20: Remove all events of this action type
- delEventType(action->a20.actTypeDel);
+ delEventType(action->_a20._actTypeDel);
break;
case GAMEOVER: // act21: Game over!
// NOTE: Must wait at least 1 tick before issuing this action if
@@ -1285,148 +1285,148 @@ event_t *Scheduler::doAction(event_t *curEvent) {
gameStatus._gameOverFl = true;
break;
case INIT_HH_COORD: // act22: Initialize an object to hero's actual coords
- _vm->_object->_objects[action->a22.objIndex]._x = _vm->_hero->_x;
- _vm->_object->_objects[action->a22.objIndex]._y = _vm->_hero->_y;
- _vm->_object->_objects[action->a22.objIndex]._screenIndex = *_vm->_screen_p;// Don't forget screen!
+ _vm->_object->_objects[action->_a22._objIndex]._x = _vm->_hero->_x;
+ _vm->_object->_objects[action->_a22._objIndex]._y = _vm->_hero->_y;
+ _vm->_object->_objects[action->_a22._objIndex]._screenIndex = *_vm->_screen_p;// Don't forget screen!
break;
case EXIT: // act23: Exit game back to DOS
_vm->endGame();
break;
case BONUS: // act24: Get bonus score for action
- processBonus(action->a24.pointIndex);
+ processBonus(action->_a24._pointIndex);
break;
case COND_BOX: // act25: Conditional on bounding box
- obj1 = &_vm->_object->_objects[action->a25.objIndex];
+ obj1 = &_vm->_object->_objects[action->_a25._objIndex];
dx = obj1->_x + obj1->_currImagePtr->_x1;
dy = obj1->_y + obj1->_currImagePtr->_y2;
- if ((dx >= action->a25.x1) && (dx <= action->a25.x2) &&
- (dy >= action->a25.y1) && (dy <= action->a25.y2))
- insertActionList(action->a25.actPassIndex);
+ if ((dx >= action->_a25._x1) && (dx <= action->_a25._x2) &&
+ (dy >= action->_a25._y1) && (dy <= action->_a25._y2))
+ insertActionList(action->_a25._actPassIndex);
else
- insertActionList(action->a25.actFailIndex);
+ insertActionList(action->_a25._actFailIndex);
break;
case SOUND: // act26: Play a sound (or tune)
- if (action->a26.soundIndex < _vm->_tunesNbr)
- _vm->_sound->playMusic(action->a26.soundIndex);
+ if (action->_a26._soundIndex < _vm->_tunesNbr)
+ _vm->_sound->playMusic(action->_a26._soundIndex);
else
- _vm->_sound->playSound(action->a26.soundIndex, kSoundPriorityMedium);
+ _vm->_sound->playSound(action->_a26._soundIndex, kSoundPriorityMedium);
break;
case ADD_SCORE: // act27: Add object's value to score
- _vm->adjustScore(_vm->_object->_objects[action->a27.objIndex]._objValue);
+ _vm->adjustScore(_vm->_object->_objects[action->_a27._objIndex]._objValue);
break;
case SUB_SCORE: // act28: Subtract object's value from score
- _vm->adjustScore(-_vm->_object->_objects[action->a28.objIndex]._objValue);
+ _vm->adjustScore(-_vm->_object->_objects[action->_a28._objIndex]._objValue);
break;
case COND_CARRY: // act29: Conditional on object being carried
- if (_vm->_object->isCarried(action->a29.objIndex))
- insertActionList(action->a29.actPassIndex);
+ if (_vm->_object->isCarried(action->_a29._objIndex))
+ insertActionList(action->_a29._actPassIndex);
else
- insertActionList(action->a29.actFailIndex);
+ insertActionList(action->_a29._actFailIndex);
break;
case INIT_MAZE: // act30: Enable and init maze structure
_vm->_maze._enabledFl = true;
- _vm->_maze._size = action->a30.mazeSize;
- _vm->_maze._x1 = action->a30.x1;
- _vm->_maze._y1 = action->a30.y1;
- _vm->_maze._x2 = action->a30.x2;
- _vm->_maze._y2 = action->a30.y2;
- _vm->_maze._x3 = action->a30.x3;
- _vm->_maze._x4 = action->a30.x4;
- _vm->_maze._firstScreenIndex = action->a30.firstScreenIndex;
+ _vm->_maze._size = action->_a30._mazeSize;
+ _vm->_maze._x1 = action->_a30._x1;
+ _vm->_maze._y1 = action->_a30._y1;
+ _vm->_maze._x2 = action->_a30._x2;
+ _vm->_maze._y2 = action->_a30._y2;
+ _vm->_maze._x3 = action->_a30._x3;
+ _vm->_maze._x4 = action->_a30._x4;
+ _vm->_maze._firstScreenIndex = action->_a30._firstScreenIndex;
break;
case EXIT_MAZE: // act31: Disable maze mode
_vm->_maze._enabledFl = false;
break;
case INIT_PRIORITY:
- _vm->_object->_objects[action->a32.objIndex]._priority = action->a32.priority;
+ _vm->_object->_objects[action->_a32._objIndex]._priority = action->_a32._priority;
break;
case INIT_SCREEN:
- _vm->_object->_objects[action->a33.objIndex]._screenIndex = action->a33.screenIndex;
+ _vm->_object->_objects[action->_a33._objIndex]._screenIndex = action->_a33._screenIndex;
break;
case AGSCHEDULE: // act34: Schedule a (global) action list
- insertActionList(action->a34.actIndex);
+ insertActionList(action->_a34._actIndex);
break;
case REMAPPAL: // act35: Remap a palette color
- _vm->_screen->remapPal(action->a35.oldColorIndex, action->a35.newColorIndex);
+ _vm->_screen->remapPal(action->_a35._oldColorIndex, action->_a35._newColorIndex);
break;
case COND_NOUN: // act36: Conditional on noun mentioned
- if (_vm->_parser->isWordPresent(_vm->_text->getNounArray(action->a36.nounIndex)))
- insertActionList(action->a36.actPassIndex);
+ if (_vm->_parser->isWordPresent(_vm->_text->getNounArray(action->_a36._nounIndex)))
+ insertActionList(action->_a36._actPassIndex);
else
- insertActionList(action->a36.actFailIndex);
+ insertActionList(action->_a36._actFailIndex);
break;
case SCREEN_STATE: // act37: Set new screen state
- _vm->_screenStates[action->a37.screenIndex] = action->a37.newState;
+ _vm->_screenStates[action->_a37._screenIndex] = action->_a37._newState;
break;
case INIT_LIPS: // act38: Position lips on object
- _vm->_object->_objects[action->a38.lipsObjIndex]._x = _vm->_object->_objects[action->a38.objIndex]._x + action->a38.dxLips;
- _vm->_object->_objects[action->a38.lipsObjIndex]._y = _vm->_object->_objects[action->a38.objIndex]._y + action->a38.dyLips;
- _vm->_object->_objects[action->a38.lipsObjIndex]._screenIndex = *_vm->_screen_p; // Don't forget screen!
- _vm->_object->_objects[action->a38.lipsObjIndex]._cycling = kCycleForward;
+ _vm->_object->_objects[action->_a38._lipsObjIndex]._x = _vm->_object->_objects[action->_a38._objIndex]._x + action->_a38._dxLips;
+ _vm->_object->_objects[action->_a38._lipsObjIndex]._y = _vm->_object->_objects[action->_a38._objIndex]._y + action->_a38._dyLips;
+ _vm->_object->_objects[action->_a38._lipsObjIndex]._screenIndex = *_vm->_screen_p; // Don't forget screen!
+ _vm->_object->_objects[action->_a38._lipsObjIndex]._cycling = kCycleForward;
break;
case INIT_STORY_MODE: // act39: Init story_mode flag
// This is similar to the QUIET path mode, except that it is
// independant of it and it additionally disables the ">" prompt
- gameStatus._storyModeFl = action->a39.storyModeFl;
+ gameStatus._storyModeFl = action->_a39._storyModeFl;
break;
case WARN: // act40: Text box (CF TEXT)
- Utils::notifyBox(_vm->_file->fetchString(action->a40.stringIndex));
+ Utils::notifyBox(_vm->_file->fetchString(action->_a40._stringIndex));
break;
case COND_BONUS: // act41: Perform action if got bonus
- if (_points[action->a41.BonusIndex].scoredFl)
- insertActionList(action->a41.actPassIndex);
+ if (_points[action->_a41._bonusIndex]._scoredFl)
+ insertActionList(action->_a41._actPassIndex);
else
- insertActionList(action->a41.actFailIndex);
+ insertActionList(action->_a41._actFailIndex);
break;
case TEXT_TAKE: // act42: Text box with "take" message
- Utils::notifyBox(Common::String::format(TAKE_TEXT, _vm->_text->getNoun(_vm->_object->_objects[action->a42.objIndex]._nounIndex, TAKE_NAME)));
+ Utils::notifyBox(Common::String::format(TAKE_TEXT, _vm->_text->getNoun(_vm->_object->_objects[action->_a42._objIndex]._nounIndex, TAKE_NAME)));
break;
case YESNO: // act43: Prompt user for Yes or No
- if (Utils::yesNoBox(_vm->_file->fetchString(action->a43.promptIndex)))
- insertActionList(action->a43.actYesIndex);
+ if (Utils::yesNoBox(_vm->_file->fetchString(action->_a43._promptIndex)))
+ insertActionList(action->_a43._actYesIndex);
else
- insertActionList(action->a43.actNoIndex);
+ insertActionList(action->_a43._actNoIndex);
break;
case STOP_ROUTE: // act44: Stop any route in progress
_vm->_route->resetRoute();
break;
case COND_ROUTE: // act45: Conditional on route in progress
- if (_vm->_route->getRouteIndex() >= action->a45.routeIndex)
- insertActionList(action->a45.actPassIndex);
+ if (_vm->_route->getRouteIndex() >= action->_a45._routeIndex)
+ insertActionList(action->_a45._actPassIndex);
else
- insertActionList(action->a45.actFailIndex);
+ insertActionList(action->_a45._actFailIndex);
break;
case INIT_JUMPEXIT: // act46: Init status.jumpexit flag
// This is to allow left click on exit to get there immediately
// For example the plane crash in Hugo2 where hero is invisible
// Couldn't use INVISIBLE flag since conflicts with boat in Hugo1
- _vm->_mouse->setJumpExitFl(action->a46.jumpExitFl);
+ _vm->_mouse->setJumpExitFl(action->_a46._jumpExitFl);
break;
- case INIT_VIEW: // act47: Init object.viewx, viewy, dir
- _vm->_object->_objects[action->a47.objIndex]._viewx = action->a47.viewx;
- _vm->_object->_objects[action->a47.objIndex]._viewy = action->a47.viewy;
- _vm->_object->_objects[action->a47.objIndex]._direction = action->a47.direction;
+ case INIT_VIEW: // act47: Init object._viewx, viewy, dir
+ _vm->_object->_objects[action->_a47._objIndex]._viewx = action->_a47._viewx;
+ _vm->_object->_objects[action->_a47._objIndex]._viewy = action->_a47._viewy;
+ _vm->_object->_objects[action->_a47._objIndex]._direction = action->_a47._direction;
break;
case INIT_OBJ_FRAME: // act48: Set seq,frame number to use
// Note: Don't set a sequence at time 0 of a new screen, it causes
// problems clearing the boundary bits of the object! t>0 is safe
- _vm->_object->_objects[action->a48.objIndex]._currImagePtr = _vm->_object->_objects[action->a48.objIndex]._seqList[action->a48.seqIndex]._seqPtr;
- for (dx = 0; dx < action->a48.frameIndex; dx++)
- _vm->_object->_objects[action->a48.objIndex]._currImagePtr = _vm->_object->_objects[action->a48.objIndex]._currImagePtr->_nextSeqPtr;
+ _vm->_object->_objects[action->_a48._objIndex]._currImagePtr = _vm->_object->_objects[action->_a48._objIndex]._seqList[action->_a48._seqIndex]._seqPtr;
+ for (dx = 0; dx < action->_a48._frameIndex; dx++)
+ _vm->_object->_objects[action->_a48._objIndex]._currImagePtr = _vm->_object->_objects[action->_a48._objIndex]._currImagePtr->_nextSeqPtr;
break;
case OLD_SONG:
// Replaces ACT26 for DOS games.
- _vm->_sound->_DOSSongPtr = _vm->_text->getTextData(action->a49.songIndex);
+ _vm->_sound->_DOSSongPtr = _vm->_text->getTextData(action->_a49._songIndex);
break;
default:
error("An error has occurred: %s", "doAction");
break;
}
- if (action->a0.actType == NEW_SCREEN) { // New_screen() deletes entire list
+ if (action->_a0._actType == NEW_SCREEN) { // New_screen() deletes entire list
return 0; // next_p = 0 since list now empty
} else {
- wrkEvent = curEvent->nextEvent;
+ wrkEvent = curEvent->_nextEvent;
delQueue(curEvent); // Return event to free list
return wrkEvent; // Return next event ptr
}
@@ -1445,37 +1445,37 @@ void Scheduler::delQueue(event_t *curEvent) {
debugC(4, kDebugSchedule, "delQueue()");
if (curEvent == _headEvent) { // If p was the head ptr
- _headEvent = curEvent->nextEvent; // then make new head_p
+ _headEvent = curEvent->_nextEvent; // then make new head_p
} else { // Unlink p
- curEvent->prevEvent->nextEvent = curEvent->nextEvent;
- if (curEvent->nextEvent)
- curEvent->nextEvent->prevEvent = curEvent->prevEvent;
+ curEvent->_prevEvent->_nextEvent = curEvent->_nextEvent;
+ if (curEvent->_nextEvent)
+ curEvent->_nextEvent->_prevEvent = curEvent->_prevEvent;
else
- _tailEvent = curEvent->prevEvent;
+ _tailEvent = curEvent->_prevEvent;
}
if (_headEvent)
- _headEvent->prevEvent = 0; // Mark end of list
+ _headEvent->_prevEvent = 0; // Mark end of list
else
_tailEvent = 0; // Empty queue
- curEvent->nextEvent = _freeEvent; // Return p to free list
+ curEvent->_nextEvent = _freeEvent; // Return p to free list
if (_freeEvent) // Special case, if free list was empty
- _freeEvent->prevEvent = curEvent;
+ _freeEvent->_prevEvent = curEvent;
_freeEvent = curEvent;
}
/**
* Delete all the active events of a given type
*/
-void Scheduler::delEventType(const action_t actTypeDel) {
+void Scheduler::delEventType(const action_t _actTypeDel) {
// Note: actions are not deleted here, simply turned into NOPs!
event_t *wrkEvent = _headEvent; // The earliest event
event_t *saveEvent;
while (wrkEvent) { // While events found in list
- saveEvent = wrkEvent->nextEvent;
- if (wrkEvent->action->a20.actType == actTypeDel)
+ saveEvent = wrkEvent->_nextEvent;
+ if (wrkEvent->_action->_a20._actType == _actTypeDel)
delQueue(wrkEvent);
wrkEvent = saveEvent;
}
@@ -1486,8 +1486,8 @@ void Scheduler::delEventType(const action_t actTypeDel) {
*/
void Scheduler::savePoints(Common::WriteStream *out) const {
for (int i = 0; i < _numBonuses; i++) {
- out->writeByte(_points[i].score);
- out->writeByte((_points[i].scoredFl) ? 1 : 0);
+ out->writeByte(_points[i]._score);
+ out->writeByte((_points[i]._scoredFl) ? 1 : 0);
}
}
@@ -1497,8 +1497,8 @@ void Scheduler::savePoints(Common::WriteStream *out) const {
void Scheduler::restorePoints(Common::ReadStream *in) {
// Restore points table
for (int i = 0; i < _numBonuses; i++) {
- _points[i].score = in->readByte();
- _points[i].scoredFl = (in->readByte() == 1);
+ _points[i]._score = in->readByte();
+ _points[i]._scoredFl = (in->readByte() == 1);
}
}
@@ -1527,27 +1527,27 @@ void Scheduler_v1d::runScheduler() {
uint32 ticker = getTicks(); // The time now, in ticks
event_t *curEvent = _headEvent; // The earliest event
- while (curEvent && (curEvent->time <= ticker)) // While mature events found
+ while (curEvent && (curEvent->_time <= ticker)) // While mature events found
curEvent = doAction(curEvent); // Perform the action (returns next_p)
}
void Scheduler_v1d::promptAction(act *action) {
Common::String response;
- response = Utils::promptBox(_vm->_file->fetchString(action->a3.promptIndex));
+ response = Utils::promptBox(_vm->_file->fetchString(action->_a3._promptIndex));
response.toLowercase();
char resp[256];
Common::strlcpy(resp, response.c_str(), 256);
- if (action->a3.encodedFl)
+ if (action->_a3._encodedFl)
decodeString(resp);
- if (strstr(resp, _vm->_file->fetchString(action->a3.responsePtr[0])))
- insertActionList(action->a3.actPassIndex);
+ if (strstr(resp, _vm->_file->fetchString(action->_a3._responsePtr[0])))
+ insertActionList(action->_a3._actPassIndex);
else
- insertActionList(action->a3.actFailIndex);
+ insertActionList(action->_a3._actFailIndex);
}
/**
@@ -1577,24 +1577,24 @@ const char *Scheduler_v2d::getCypher() const {
void Scheduler_v2d::promptAction(act *action) {
Common::String response;
- response = Utils::promptBox(_vm->_file->fetchString(action->a3.promptIndex));
+ response = Utils::promptBox(_vm->_file->fetchString(action->_a3._promptIndex));
response.toLowercase();
- debug(1, "doAction(act3), expecting answer %s", _vm->_file->fetchString(action->a3.responsePtr[0]));
+ debug(1, "doAction(act3), expecting answer %s", _vm->_file->fetchString(action->_a3._responsePtr[0]));
bool found = false;
const char *tmpStr; // General purpose string ptr
- for (int dx = 0; !found && (action->a3.responsePtr[dx] != -1); dx++) {
- tmpStr = _vm->_file->fetchString(action->a3.responsePtr[dx]);
+ for (int dx = 0; !found && (action->_a3._responsePtr[dx] != -1); dx++) {
+ tmpStr = _vm->_file->fetchString(action->_a3._responsePtr[dx]);
if (response.contains(tmpStr))
found = true;
}
if (found)
- insertActionList(action->a3.actPassIndex);
+ insertActionList(action->_a3._actPassIndex);
else
- insertActionList(action->a3.actFailIndex);
+ insertActionList(action->_a3._actFailIndex);
}
/**
@@ -1641,9 +1641,9 @@ void Scheduler_v1w::runScheduler() {
uint32 ticker = getTicks(); // The time now, in ticks
event_t *curEvent = _headEvent; // The earliest event
- while (curEvent && (curEvent->time <= ticker)) // While mature events found
+ while (curEvent && (curEvent->_time <= ticker)) // While mature events found
curEvent = doAction(curEvent); // Perform the action (returns next_p)
- _vm->getGameStatus()._tick++; // Accessed elsewhere via getTicks()
+ _vm->getGameStatus()._tick++; // Accessed elsewhere via getTicks()
}
} // End of namespace Hugo
diff --git a/engines/hugo/schedule.h b/engines/hugo/schedule.h
index 60d51f0..74a65a5 100644
--- a/engines/hugo/schedule.h
+++ b/engines/hugo/schedule.h
@@ -93,424 +93,425 @@ enum action_t { // Parameters:
};
struct act0 { // Type 0 - Schedule
- action_t actType; // The type of action
- int timer; // Time to set off the action
- uint16 actIndex; // Ptr to an action list
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ uint16 _actIndex; // Ptr to an action list
};
struct act1 { // Type 1 - Start an object
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int cycleNumb; // Number of times to cycle
- cycle_t cycle; // Direction to start cycling
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _cycleNumb; // Number of times to cycle
+ cycle_t _cycle; // Direction to start cycling
};
struct act2 { // Type 2 - Initialize an object coords
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int x, y; // Coordinates
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _x, _y; // Coordinates
};
struct act3 { // Type 3 - Prompt user for text
- action_t actType; // The type of action
- int timer; // Time to set off the action
- uint16 promptIndex; // Index of prompt string
- int *responsePtr; // Array of indexes to valid response string(s) (terminate list with -1)
- uint16 actPassIndex; // Ptr to action list if success
- uint16 actFailIndex; // Ptr to action list if failure
- bool encodedFl; // (HUGO 1 DOS ONLY) Whether response is encoded or not
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ uint16 _promptIndex; // Index of prompt string
+ int *_responsePtr; // Array of indexes to valid response string(s) (terminate list with -1)
+ uint16 _actPassIndex; // Ptr to action list if success
+ uint16 _actFailIndex; // Ptr to action list if failure
+ bool _encodedFl; // (HUGO 1 DOS ONLY) Whether response is encoded or not
};
struct act4 { // Type 4 - Set new background color
- action_t actType; // The type of action
- int timer; // Time to set off the action
- long newBackgroundColor; // New color
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ long _newBackgroundColor; // New color
};
struct act5 { // Type 5 - Initialize an object velocity
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int vx, vy; // velocity
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _vx, _vy; // velocity
};
struct act6 { // Type 6 - Initialize an object carrying
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- bool carriedFl; // carrying
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ bool _carriedFl; // carrying
};
struct act7 { // Type 7 - Initialize an object to hero's coords
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
};
struct act8 { // Type 8 - switch to new screen
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int screenIndex; // The new screen number
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _screenIndex; // The new screen number
};
struct act9 { // Type 9 - Initialize an object state
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- byte newState; // New state
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ byte _newState; // New state
};
struct act10 { // Type 10 - Initialize an object path type
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int newPathType; // New path type
- int8 vxPath, vyPath; // Max delta velocities e.g. for CHASE
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _newPathType; // New path type
+ int8 _vxPath, _vyPath; // Max delta velocities e.g. for CHASE
};
struct act11 { // Type 11 - Conditional on object's state
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- byte stateReq; // Required state
- uint16 actPassIndex; // Ptr to action list if success
- uint16 actFailIndex; // Ptr to action list if failure
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ byte _stateReq; // Required state
+ uint16 _actPassIndex; // Ptr to action list if success
+ uint16 _actFailIndex; // Ptr to action list if failure
};
struct act12 { // Type 12 - Simple text box
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int stringIndex; // Index (enum) of string in strings.dat
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _stringIndex; // Index (enum) of string in strings.dat
};
struct act13 { // Type 13 - Swap first object image with second
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex1; // Index of first object
- int objIndex2; // 2nd
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex1; // Index of first object
+ int _objIndex2; // 2nd
};
struct act14 { // Type 14 - Conditional on current screen
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The required object
- int screenReq; // The required screen number
- uint16 actPassIndex; // Ptr to action list if success
- uint16 actFailIndex; // Ptr to action list if failure
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The required object
+ int _screenReq; // The required screen number
+ uint16 _actPassIndex; // Ptr to action list if success
+ uint16 _actFailIndex; // Ptr to action list if failure
};
struct act15 { // Type 15 - Home in on an object
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex1; // The object number homing in
- int objIndex2; // The object number to home in on
- int8 dx, dy; // Max delta velocities
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex1; // The object number homing in
+ int _objIndex2; // The object number to home in on
+ int8 _dx, _dy; // Max delta velocities
};
+
// Note: Don't set a sequence at time 0 of a new screen, it causes
// problems clearing the boundary bits of the object! timer > 0 is safe
struct act16 { // Type 16 - Set curr_seq_p to seq
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int seqIndex; // The index of seq array to set to
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _seqIndex; // The index of seq array to set to
};
struct act17 { // Type 17 - SET obj individual state bits
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int stateMask; // The mask to OR with current obj state
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _stateMask; // The mask to OR with current obj state
};
struct act18 { // Type 18 - CLEAR obj individual state bits
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int stateMask; // The mask to ~AND with current obj state
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _stateMask; // The mask to ~AND with current obj state
};
struct act19 { // Type 19 - TEST obj individual state bits
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int stateMask; // The mask to AND with current obj state
- uint16 actPassIndex; // Ptr to action list (all bits set)
- uint16 actFailIndex; // Ptr to action list (not all set)
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _stateMask; // The mask to AND with current obj state
+ uint16 _actPassIndex; // Ptr to action list (all bits set)
+ uint16 _actFailIndex; // Ptr to action list (not all set)
};
struct act20 { // Type 20 - Remove all events with this type of action
- action_t actType; // The type of action
- int timer; // Time to set off the action
- action_t actTypeDel; // The action type to remove
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ action_t _actTypeDel; // The action type to remove
};
struct act21 { // Type 21 - Gameover. Disable hero & commands
- action_t actType; // The type of action
- int timer; // Time to set off the action
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
};
struct act22 { // Type 22 - Initialize an object to hero's coords
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
};
struct act23 { // Type 23 - Exit game back to DOS
- action_t actType; // The type of action
- int timer; // Time to set off the action
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
};
struct act24 { // Type 24 - Get bonus score
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int pointIndex; // Index into points array
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _pointIndex; // Index into points array
};
struct act25 { // Type 25 - Conditional on bounding box
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The required object number
- int x1, y1, x2, y2; // The bounding box
- uint16 actPassIndex; // Ptr to action list if success
- uint16 actFailIndex; // Ptr to action list if failure
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The required object number
+ int _x1, _y1, _x2, _y2; // The bounding box
+ uint16 _actPassIndex; // Ptr to action list if success
+ uint16 _actFailIndex; // Ptr to action list if failure
};
struct act26 { // Type 26 - Play a sound
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int16 soundIndex; // Sound index in data file
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int16 _soundIndex; // Sound index in data file
};
struct act27 { // Type 27 - Add object's value to score
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // object number
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // object number
};
struct act28 { // Type 28 - Subtract object's value from score
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // object number
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // object number
};
struct act29 { // Type 29 - Conditional on object carried
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The required object number
- uint16 actPassIndex; // Ptr to action list if success
- uint16 actFailIndex; // Ptr to action list if failure
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The required object number
+ uint16 _actPassIndex; // Ptr to action list if success
+ uint16 _actFailIndex; // Ptr to action list if failure
};
struct act30 { // Type 30 - Start special maze processing
- action_t actType; // The type of action
- int timer; // Time to set off the action
- byte mazeSize; // Size of (square) maze
- int x1, y1, x2, y2; // Bounding box of maze
- int x3, x4; // Extra x points for perspective correction
- byte firstScreenIndex; // First (top left) screen of maze
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ byte _mazeSize; // Size of (square) maze
+ int _x1, _y1, _x2, _y2; // Bounding box of maze
+ int _x3, _x4; // Extra x points for perspective correction
+ byte _firstScreenIndex; // First (top left) screen of maze
};
struct act31 { // Type 31 - Exit special maze processing
- action_t actType; // The type of action
- int timer; // Time to set off the action
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
};
struct act32 { // Type 32 - Init fbg field of object
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- byte priority; // Value of foreground/background field
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ byte _priority; // Value of foreground/background field
};
struct act33 { // Type 33 - Init screen field of object
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int screenIndex; // Screen number
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _screenIndex; // Screen number
};
struct act34 { // Type 34 - Global Schedule
- action_t actType; // The type of action
- int timer; // Time to set off the action
- uint16 actIndex; // Ptr to an action list
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ uint16 _actIndex; // Ptr to an action list
};
struct act35 { // Type 35 - Remappe palette
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int16 oldColorIndex; // Old color index, 0..15
- int16 newColorIndex; // New color index, 0..15
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int16 _oldColorIndex; // Old color index, 0..15
+ int16 _newColorIndex; // New color index, 0..15
};
struct act36 { // Type 36 - Conditional on noun mentioned
- action_t actType; // The type of action
- int timer; // Time to set off the action
- uint16 nounIndex; // The required noun (list)
- uint16 actPassIndex; // Ptr to action list if success
- uint16 actFailIndex; // Ptr to action list if failure
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ uint16 _nounIndex; // The required noun (list)
+ uint16 _actPassIndex; // Ptr to action list if success
+ uint16 _actFailIndex; // Ptr to action list if failure
};
struct act37 { // Type 37 - Set new screen state
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int screenIndex; // The screen number
- byte newState; // The new state
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _screenIndex; // The screen number
+ byte _newState; // The new state
};
struct act38 { // Type 38 - Position lips
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int lipsObjIndex; // The LIPS object
- int objIndex; // The object to speak
- byte dxLips; // Relative offset of x
- byte dyLips; // Relative offset of y
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _lipsObjIndex; // The LIPS object
+ int _objIndex; // The object to speak
+ byte _dxLips; // Relative offset of x
+ byte _dyLips; // Relative offset of y
};
struct act39 { // Type 39 - Init story mode
- action_t actType; // The type of action
- int timer; // Time to set off the action
- bool storyModeFl; // New state of story_mode flag
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ bool _storyModeFl; // New state of story_mode flag
};
struct act40 { // Type 40 - Unsolicited text box
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int stringIndex; // Index (enum) of string in strings.dat
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _stringIndex; // Index (enum) of string in strings.dat
};
struct act41 { // Type 41 - Conditional on bonus scored
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int BonusIndex; // Index into bonus list
- uint16 actPassIndex; // Index of the action list if scored for the first time
- uint16 actFailIndex; // Index of the action list if already scored
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _bonusIndex; // Index into bonus list
+ uint16 _actPassIndex; // Index of the action list if scored for the first time
+ uint16 _actFailIndex; // Index of the action list if already scored
};
struct act42 { // Type 42 - Text box with "take" string
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object taken
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object taken
};
struct act43 { // Type 43 - Prompt user for Yes or No
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int promptIndex; // index of prompt string
- uint16 actYesIndex; // Ptr to action list if YES
- uint16 actNoIndex; // Ptr to action list if NO
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _promptIndex; // index of prompt string
+ uint16 _actYesIndex; // Ptr to action list if YES
+ uint16 _actNoIndex; // Ptr to action list if NO
};
struct act44 { // Type 44 - Stop any route in progress
- action_t actType; // The type of action
- int timer; // Time to set off the action
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
};
struct act45 { // Type 45 - Conditional on route in progress
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int routeIndex; // Must be >= current status.rindex
- uint16 actPassIndex; // Ptr to action list if en-route
- uint16 actFailIndex; // Ptr to action list if not
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _routeIndex; // Must be >= current status.rindex
+ uint16 _actPassIndex; // Ptr to action list if en-route
+ uint16 _actFailIndex; // Ptr to action list if not
};
struct act46 { // Type 46 - Init status.jumpexit
- action_t actType; // The type of action
- int timer; // Time to set off the action
- bool jumpExitFl; // New state of jumpexit flag
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ bool _jumpExitFl; // New state of jumpexit flag
};
struct act47 { // Type 47 - Init viewx,viewy,dir
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object
- int16 viewx; // object.viewx
- int16 viewy; // object.viewy
- int16 direction; // object.dir
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object
+ int16 _viewx; // object.viewx
+ int16 _viewy; // object.viewy
+ int16 _direction; // object.dir
};
struct act48 { // Type 48 - Set curr_seq_p to frame n
- action_t actType; // The type of action
- int timer; // Time to set off the action
- int objIndex; // The object number
- int seqIndex; // The index of seq array to set to
- int frameIndex; // The index of frame to set to
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ int _objIndex; // The object number
+ int _seqIndex; // The index of seq array to set to
+ int _frameIndex; // The index of frame to set to
};
-struct act49 { // Added by Strangerke - Type 79 - Play a song (DOS way)
- action_t actType; // The type of action
- int timer; // Time to set off the action
- uint16 songIndex; // Song index in string array
+struct act49 { // Added by Strangerke - Type 49 - Play a song (DOS way)
+ action_t _actType; // The type of action
+ int _timer; // Time to set off the action
+ uint16 _songIndex; // Song index in string array
};
union act {
- act0 a0;
- act1 a1;
- act2 a2;
- act3 a3;
- act4 a4;
- act5 a5;
- act6 a6;
- act7 a7;
- act8 a8;
- act9 a9;
- act10 a10;
- act11 a11;
- act12 a12;
- act13 a13;
- act14 a14;
- act15 a15;
- act16 a16;
- act17 a17;
- act18 a18;
- act19 a19;
- act20 a20;
- act21 a21;
- act22 a22;
- act23 a23;
- act24 a24;
- act25 a25;
- act26 a26;
- act27 a27;
- act28 a28;
- act29 a29;
- act30 a30;
- act31 a31;
- act32 a32;
- act33 a33;
- act34 a34;
- act35 a35;
- act36 a36;
- act37 a37;
- act38 a38;
- act39 a39;
- act40 a40;
- act41 a41;
- act42 a42;
- act43 a43;
- act44 a44;
- act45 a45;
- act46 a46;
- act47 a47;
- act48 a48;
- act49 a49;
+ act0 _a0;
+ act1 _a1;
+ act2 _a2;
+ act3 _a3;
+ act4 _a4;
+ act5 _a5;
+ act6 _a6;
+ act7 _a7;
+ act8 _a8;
+ act9 _a9;
+ act10 _a10;
+ act11 _a11;
+ act12 _a12;
+ act13 _a13;
+ act14 _a14;
+ act15 _a15;
+ act16 _a16;
+ act17 _a17;
+ act18 _a18;
+ act19 _a19;
+ act20 _a20;
+ act21 _a21;
+ act22 _a22;
+ act23 _a23;
+ act24 _a24;
+ act25 _a25;
+ act26 _a26;
+ act27 _a27;
+ act28 _a28;
+ act29 _a29;
+ act30 _a30;
+ act31 _a31;
+ act32 _a32;
+ act33 _a33;
+ act34 _a34;
+ act35 _a35;
+ act36 _a36;
+ act37 _a37;
+ act38 _a38;
+ act39 _a39;
+ act40 _a40;
+ act41 _a41;
+ act42 _a42;
+ act43 _a43;
+ act44 _a44;
+ act45 _a45;
+ act46 _a46;
+ act47 _a47;
+ act48 _a48;
+ act49 _a49;
};
struct event_t {
- act *action; // Ptr to action to perform
- bool localActionFl; // true if action is only for this screen
- uint32 time; // (absolute) time to perform action
- struct event_t *prevEvent; // Chain to previous event
- struct event_t *nextEvent; // Chain to next event
+ act *_action; // Ptr to action to perform
+ bool _localActionFl; // true if action is only for this screen
+ uint32 _time; // (absolute) time to perform action
+ struct event_t *_prevEvent; // Chain to previous event
+ struct event_t *_nextEvent; // Chain to next event
};
/**
* Following are points for achieving certain actions.
*/
struct point_t {
- byte score; // The value of the point
- bool scoredFl; // Whether scored yet
+ byte _score; // The value of the point
+ bool _scoredFl; // Whether scored yet
};
class Scheduler {
diff --git a/engines/hugo/sound.cpp b/engines/hugo/sound.cpp
index eed4164..463a19a 100644
--- a/engines/hugo/sound.cpp
+++ b/engines/hugo/sound.cpp
@@ -162,16 +162,16 @@ void SoundHandler::stopMusic() {
* Turn music on and off
*/
void SoundHandler::toggleMusic() {
- _vm->_config.musicFl = !_vm->_config.musicFl;
+ _vm->_config._musicFl = !_vm->_config._musicFl;
- _midiPlayer->pause(!_vm->_config.musicFl);
+ _midiPlayer->pause(!_vm->_config._musicFl);
}
/**
* Turn digitized sound on and off
*/
void SoundHandler::toggleSound() {
- _vm->_config.soundFl = !_vm->_config.soundFl;
+ _vm->_config._soundFl = !_vm->_config._soundFl;
}
void SoundHandler::playMIDI(sound_pt seq_p, uint16 size) {
@@ -185,7 +185,7 @@ void SoundHandler::playMusic(int16 tune) {
sound_pt seqPtr; // Sequence data from file
uint16 size; // Size of sequence data
- if (_vm->_config.musicFl) {
+ if (_vm->_config._musicFl) {
_vm->getGameStatus()._song = tune;
seqPtr = _vm->_file->getSound(tune, &size);
playMIDI(seqPtr, size);
@@ -203,7 +203,7 @@ void SoundHandler::playSound(int16 sound, const byte priority) {
uint16 size; // Size of data
// Sound disabled
- if (!_vm->_config.soundFl || !_vm->_mixer->isReady())
+ if (!_vm->_config._soundFl || !_vm->_mixer->isReady())
return;
syncVolume();
@@ -270,7 +270,7 @@ void SoundHandler::pcspkr_player() {
static const uint16 pcspkrFlats[8] = {1435, 1279, 2342, 2150, 1916, 1755, 1611}; // The flats, Ab to Bb
// Does the user not want any sound?
- if (!_vm->_config.soundFl || !_vm->_mixer->isReady())
+ if (!_vm->_config._soundFl || !_vm->_mixer->isReady())
return;
// Is there no song?
More information about the Scummvm-git-logs
mailing list