[Scummvm-cvs-logs] scummvm master -> c2e9f38d79a577e54c5baefbcf9601c00e145e98
sev-
sev at scummvm.org
Fri Feb 21 20:15:31 CET 2014
This automated email contains information about 28 new commits which have been
pushed to the 'scummvm' repo located at https://github.com/scummvm/scummvm .
Summary:
5f4fc9a1dd BBVS: Initial commit
11a5807110 BBVS: Remove obsolete code in BbAnt minigame
ef55f5b774 BBVS: Replace minigame flags parameter
24fd658795 BBVS: Add loading/saving of minigame hiscores
bb1dc9136b BBVS: Remove some debug output
8fcfe61003 BBVS: Add delayMillis to update loops to save some cpu time
c31762d0c4 BBVS: Add easter egg videos handling
7c8b7467c2 BBVS: Fix mainmenu after intro videos
4d2a42eec7 BBVS: Disable gamemodule debug output
ea519818e2 BBVS: Wrap some long lines
542197a891 BBVS: Very small cleanup
cf51529cfd Merge remote-tracking branch 'origin/master' into bbvs
46593461d2 BBVS: Fix detection
d0690dfbb1 BBVS: Remove debug output code from GameModule methods
5c93ecb130 BBVS: Set the best video mode when playing a video instead of a hardcoded one
3471c0c24d BBVS: Fix compilation in MSVC10 as suggested by dreammaster
62e7b4bbba BBVS: Fix GCC warning (signed/unsigned comparison)
86b5192d1b BBVS: Use spaces instead of tabs for formatting
9263bb9eb3 BBVS: Fix formatting (use tab instead of spaces)
3847654bcd BBVS: Fix include guard and include guard name comments for endifs
82bb55aa89 BBVS: Remove obsolete debug comments
6078bf7eba BBVS: Remove rectIntersection and use Rect::findIntersectingRect instead
2f22673945 BBVS: Remove unneccessary makeLoopingAudioStream in playSpeech and use the audiostream directly
f0acfd4645 BBVS: Use int16 instead of int in Rect struct
882cf2f5ba BBVS: Fix const char string arrays
3aba8da16b BBVS: Remove Point type and use BBPoint instead in BBAnt minigame
608485729b BBVS: Make kAnimationsTbl and kObjKindAnimTables const in BBAnt minigame
c2e9f38d79 Merge pull request #435 from johndoe123/bbvs
Commit: 5f4fc9a1dd5668ab9fa9706a8e86b2ec3ac808d1
https://github.com/scummvm/scummvm/commit/5f4fc9a1dd5668ab9fa9706a8e86b2ec3ac808d1
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-29T04:27:47-08:00
Commit Message:
BBVS: Initial commit
Changed paths:
A engines/bbvs/bbvs.cpp
A engines/bbvs/bbvs.h
A engines/bbvs/configure.engine
A engines/bbvs/detection.cpp
A engines/bbvs/dialogs.cpp
A engines/bbvs/dialogs.h
A engines/bbvs/gamemodule.cpp
A engines/bbvs/gamemodule.h
A engines/bbvs/graphics.cpp
A engines/bbvs/graphics.h
A engines/bbvs/minigames/bbairguitar.cpp
A engines/bbvs/minigames/bbairguitar.h
A engines/bbvs/minigames/bbairguitar_anims.cpp
A engines/bbvs/minigames/bbant.cpp
A engines/bbvs/minigames/bbant.h
A engines/bbvs/minigames/bbant_anims.cpp
A engines/bbvs/minigames/bbloogie.cpp
A engines/bbvs/minigames/bbloogie.h
A engines/bbvs/minigames/bbloogie_anims.cpp
A engines/bbvs/minigames/bbtennis.cpp
A engines/bbvs/minigames/bbtennis.h
A engines/bbvs/minigames/bbtennis_anims.cpp
A engines/bbvs/minigames/minigame.cpp
A engines/bbvs/minigames/minigame.h
A engines/bbvs/module.mk
A engines/bbvs/saveload.cpp
A engines/bbvs/sound.cpp
A engines/bbvs/sound.h
A engines/bbvs/spritemodule.cpp
A engines/bbvs/spritemodule.h
A engines/bbvs/videoplayer.cpp
engines/configure.engines
engines/engines.mk
engines/plugins_table.h
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
new file mode 100644
index 0000000..2b0a4a5
--- /dev/null
+++ b/engines/bbvs/bbvs.cpp
@@ -0,0 +1,2196 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/bbvs.h"
+#include "bbvs/dialogs.h"
+#include "bbvs/gamemodule.h"
+#include "bbvs/graphics.h"
+#include "bbvs/sound.h"
+#include "bbvs/spritemodule.h"
+#include "bbvs/minigames/bbairguitar.h"
+#include "bbvs/minigames/bbant.h"
+#include "bbvs/minigames/bbloogie.h"
+#include "bbvs/minigames/bbtennis.h"
+#include "bbvs/minigames/minigame.h"
+
+#include "audio/audiostream.h"
+#include "common/config-manager.h"
+#include "common/debug-channels.h"
+#include "common/error.h"
+#include "common/fs.h"
+#include "common/timer.h"
+#include "engines/util.h"
+#include "graphics/cursorman.h"
+#include "graphics/font.h"
+#include "graphics/fontman.h"
+#include "graphics/palette.h"
+#include "graphics/surface.h"
+
+namespace Bbvs {
+
+static const BBPoint kInventorySlotPositions[] = {
+ { 66, 191}, { 94, 217}, {192, 217}, {159, 213}, {228, 49},
+ {137, 49}, {168, 165}, {101, 55}, {177, 46}, {165, 165},
+ {202, 74}, {141, 53}, {164, 164}, {165, 78}, {167, 71},
+ {142, 188}, {171, 100}, {250, 216}, {200, 72}, {200, 72},
+ {101, 82}, { 67, 93}, {133, 87}, {123, 220}, {199, 129},
+ {188, 192}, {102, 82}, {188, 192}, { 99, 170}, { 68, 126},
+ {159, 130}, {102, 116}, {207, 157}, {130, 141}, {236, 100},
+ {102, 197}, {141, 186}, {200, 102}, {221, 220}, {222, 188},
+ {135, 93}, {134, 145}, { 96, 224}, {128, 224}, {160, 224},
+ {192, 224}, {224, 224}, {240, 224}, {256, 224}, { 0, 0}
+};
+
+static const BBRect kVerbRects[6] = {
+ {-32, -2, 19, 27}, {-33, -33, 19, 27}, { 12, -2, 19, 27},
+ { 13, -33, 19, 27}, {-10, 8, 19, 27}, {-11, -49, 19, 27}
+};
+
+static const int8 kWalkTurnTbl[] = {
+ 7, 9, 4, 8, 6, 10, 5, 11
+};
+
+static const int8 kWalkAnimTbl[32] = {
+ 3, 0, 0, 0, 2, 1, 1, 1,
+ 15, 12, 14, 13, 0, 0, 0, 0,
+ 7, 9, 4, 8, 6, 10, 5, 11,
+ 3, 0, 2, 1, 15, 12, 14, 13
+};
+
+static const int8 kTurnInfo[8][8] = {
+ { 0, 1, 1, 1, 1, -1, -1, -1},
+ {-1, 0, 1, 1, 1, 1, -1, -1},
+ {-1, -1, 0, 1, 1, 1, 1, -1},
+ {-1, -1, -1, 0, 1, 1, 1, 1},
+ { 1, -1, -1, -1, 0, 1, 1, 1},
+ { 1, 1, -1, -1, -1, 0, 1, 1},
+ { 1, 1, 1, -1, -1, -1, 0, 1},
+ { 1, 1, 1, 1, -1, -1, -1, 0}
+};
+
+static const byte kTurnTbl[] = {
+ 2, 6, 4, 0, 2, 6, 4, 0,
+ 3, 1, 5, 7, 0, 0, 0, 0
+};
+
+static const int kAfterVideoSceneNum[] = {
+// 0, 43, 23, 12, 4, 44, 2,
+// 16, 4, 4, 4, 44, 12, 44
+ 0, 43, 23, 12, 4, 44, 2,
+ 16, 4, 4, 4, 44, 12, 32
+};
+
+const int kMainMenu = 44;
+
+bool WalkArea::contains(const Common::Point &pt) const {
+ return Common::Rect(x, y, x + width, y + height).contains(pt);
+}
+
+BbvsEngine::BbvsEngine(OSystem *syst, const ADGameDescription *gd) :
+ Engine(syst), _gameDescription(gd) {
+
+ _random = new Common::RandomSource("bbvs");
+
+ Engine::syncSoundSettings();
+
+}
+
+BbvsEngine::~BbvsEngine() {
+
+ delete _random;
+
+}
+
+void BbvsEngine::newGame() {
+ _currInventoryItem = -1;
+ _newSceneNum = 32;
+}
+
+void BbvsEngine::continueGameFromQuickSave() {
+ _bootSaveSlot = 0;
+}
+
+void BbvsEngine::setNewSceneNum(int newSceneNum) {
+ _newSceneNum = newSceneNum;
+}
+
+Common::Error BbvsEngine::run() {
+
+ _isSaveAllowed = false;
+ _hasSnapshot = false;
+
+ initGraphics(320, 240, false);
+
+ _screen = new Screen(_system);
+ _gameModule = new GameModule();
+ _spriteModule = new SpriteModule();
+ _sound = new SoundMan();
+
+ allocSnapshot();
+
+ _gameTicks = 0;
+ _playVideoNumber = 0;
+ _bootSaveSlot = -1;
+
+ memset(_inventoryItemStatus, 0, sizeof(_inventoryItemStatus));
+ memset(_gameVars, 0, sizeof(_gameVars));
+ memset(_sceneVisited, 0, sizeof(_sceneVisited));
+
+ _mouseX = 160;
+ _mouseY = 120;
+ _mouseButtons = 0;
+
+ _currVerbNum = kVerbLook;
+ _currInventoryItem = -1;
+ _currTalkObjectIndex = -1;
+ _currSceneNum = 0;
+ //_newSceneNum = 31;
+
+ //_newSceneNum = 23; // Class room
+ _newSceneNum = kMainMenu; // Main menu (TODO Buttons etc.)
+ //_newSceneNum = 25;// Tank and crash
+ //_newSceneNum = 7;
+ //_newSceneNum = 12;
+
+ if (ConfMan.hasKey("save_slot"))
+ _bootSaveSlot = ConfMan.getInt("save_slot");
+
+ while (!shouldQuit()) {
+ updateEvents();
+ if (_currSceneNum < kMainMenu || _newSceneNum > 0 || _bootSaveSlot >= 0)
+ updateGame();
+ else if (_currSceneNum == kMainMenu)
+ runMainMenu();
+ if (_playVideoNumber > 0) {
+ playVideo(_playVideoNumber);
+ _playVideoNumber = 0;
+ }
+ }
+
+ writeContinueSavegame();
+
+ freeSnapshot();
+
+ delete _sound;
+ delete _spriteModule;
+ delete _gameModule;
+ delete _screen;
+
+ debug(0, "run() done");
+
+ return Common::kNoError;
+}
+
+bool BbvsEngine::hasFeature(EngineFeature f) const {
+ return
+ (f == kSupportsRTL) ||
+ (f == kSupportsLoadingDuringRuntime) ||
+ (f == kSupportsSavingDuringRuntime);
+}
+
+void BbvsEngine::updateEvents() {
+ Common::Event event;
+
+ while (_eventMan->pollEvent(event)) {
+ switch (event.type) {
+ case Common::EVENT_KEYDOWN:
+ _keyCode = event.kbd.keycode;
+ break;
+ case Common::EVENT_KEYUP:
+ _keyCode = Common::KEYCODE_INVALID;
+ break;
+ case Common::EVENT_MOUSEMOVE:
+ _mouseX = event.mouse.x;
+ _mouseY = event.mouse.y;
+ break;
+ case Common::EVENT_LBUTTONDOWN:
+ _mouseButtons |= kLeftButtonClicked;
+ _mouseButtons |= kLeftButtonDown;
+ break;
+ case Common::EVENT_LBUTTONUP:
+ _mouseButtons &= ~kLeftButtonDown;
+ break;
+ case Common::EVENT_RBUTTONDOWN:
+ _mouseButtons |= kRightButtonClicked;
+ _mouseButtons |= kRightButtonDown;
+ break;
+ case Common::EVENT_RBUTTONUP:
+ _mouseButtons &= ~kRightButtonDown;
+ break;
+ case Common::EVENT_QUIT:
+ quitGame();
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+int BbvsEngine::getRandom(int max) {
+ return max == 0 ? 0 : _random->getRandomNumber(max - 1);
+}
+
+void BbvsEngine::drawDebugInfo() {
+#if 0
+ Graphics::Surface *s = _screen->_surface;
+ const Graphics::Font *font = FontMan.getFontByUsage(Graphics::FontManager::kConsoleFont);
+ for (int i = 0; i < _walkAreasCount; ++i) {
+ WalkArea *walkArea = &_walkAreas[i];
+ Common::Rect r(walkArea->x, walkArea->y, walkArea->x + walkArea->width, walkArea->y + walkArea->height);
+ s->frameRect(r, 255);
+ Common::String text = Common::String::format("%d", i);
+ font->drawString(s, text, r.left + 1, r.top + 1, 100, 11);
+ }
+#endif
+}
+
+void BbvsEngine::drawScreen() {
+ drawDebugInfo();
+ _screen->copyToScreen();
+}
+
+void BbvsEngine::updateGame() {
+ int currTicks, inputTicks;
+
+ if (_gameTicks > 0) {
+ currTicks = _system->getMillis();
+ inputTicks = (currTicks - _gameTicks) / 17;
+ _gameTicks = currTicks - (currTicks - _gameTicks) % 17;
+ } else {
+ inputTicks = 1;
+ _gameTicks = _system->getMillis();
+ }
+
+ if (inputTicks > 20) {
+ inputTicks = 20;
+ _gameTicks = _system->getMillis();
+ }
+
+ if (inputTicks == 0)
+ return;
+
+ if (_mouseX >= 320 || _mouseY >= 240) {
+ _mouseY = -1;
+ _mouseX = -1;
+ }
+
+ bool done;
+
+ do {
+ done = !update(_mouseX, _mouseY, _mouseButtons, _keyCode);
+ _mouseButtons &= ~kLeftButtonClicked;
+ _mouseButtons &= ~kRightButtonClicked;
+ _keyCode = Common::KEYCODE_INVALID;
+ } while (--inputTicks && _playVideoNumber == 0 && _gameTicks > 0 && !done);
+
+ if (!done && _playVideoNumber == 0 && _gameTicks > 0) {
+ DrawList drawList;
+ buildDrawList(drawList);
+ _screen->drawDrawList(drawList, _spriteModule);
+ drawScreen();
+ }
+
+}
+
+bool BbvsEngine::evalCondition(Conditions &conditions) {
+ bool result = true;
+ for (int i = 0; i < 8 && result; ++i) {
+ const Condition &condition = conditions.conditions[i];
+ switch (condition.cond) {
+ case kCondSceneObjectVerb:
+ result = _activeItemType == KITSceneObject && condition.value1 == _currVerbNum && condition.value2 == _activeItemIndex;
+ break;
+ case kCondBgObjectVerb:
+ result = _activeItemType == kITBgObject && condition.value1 == _currVerbNum && condition.value2 == _activeItemIndex;
+ break;
+ case kCondSceneObjectInventory:
+ result = _activeItemType == KITSceneObject && _currVerbNum == kVerbInvItem && condition.value1 == _currInventoryItem && condition.value2 == _activeItemIndex;
+ break;
+ case kCondBgObjectInventory:
+ result = _activeItemType == kITBgObject && _currVerbNum == kVerbInvItem && condition.value1 == _currInventoryItem && condition.value2 == _activeItemIndex;
+ break;
+ case kCondHasInventoryItem:
+ result = _inventoryItemStatus[condition.value1] != 0;
+ break;
+ case kCondHasNotInventoryItem:
+ result = _inventoryItemStatus[condition.value1] == 0;
+ break;
+ case kCondIsGameVar:
+ result = _gameVars[condition.value2] != 0;
+ break;
+ case kCondIsNotGameVar:
+ result = _gameVars[condition.value2] == 0;
+ break;
+ case kCondIsPrevSceneNum:
+ result = condition.value2 == _prevSceneNum;
+ break;
+ case kCondIsCurrTalkObject:
+ result = condition.value2 == _currTalkObjectIndex;
+ break;
+ case kCondIsDialogItem:
+ result = _activeItemType == kITDialog && condition.value1 == _activeItemIndex;
+ break;
+ case kCondIsCameraNum:
+ result = condition.value1 == _currCameraNum;
+ break;
+ case kCondIsNotPrevSceneNum:
+ result = condition.value2 != _prevSceneNum;
+ break;
+ case kCondIsButtheadAtBgObject:
+ result = _buttheadObject && _gameModule->getBgObject(condition.value2)->rect.contains(_buttheadObject->x >> 16, _buttheadObject->y >> 16);
+ break;
+ case kCondIsNotSceneVisited:
+ result = _sceneVisited[_currSceneNum] == 0;
+ break;
+ case kCondIsSceneVisited:
+ result = _sceneVisited[_currSceneNum] != 0;
+ break;
+ case kCondUnused:
+ case kCondDialogItem0:
+ case kCondIsCameraNumTransition:
+ result = false;
+ break;
+ }
+ }
+ return result;
+}
+
+bool BbvsEngine::evalCameraCondition(Conditions &conditions, int value) {
+ bool result = true;
+ for (int i = 0; i < 8 && result; ++i) {
+ const Condition &condition = conditions.conditions[i];
+ switch (condition.cond) {
+ case kCondHasInventoryItem:
+ result = _inventoryItemStatus[condition.value1] != 0;
+ break;
+ case kCondHasNotInventoryItem:
+ result = _inventoryItemStatus[condition.value1] == 0;
+ break;
+ case kCondIsGameVar:
+ result = _gameVars[condition.value2] != 0;
+ break;
+ case kCondIsNotGameVar:
+ result = _gameVars[condition.value2] == 0;
+ break;
+ case kCondIsPrevSceneNum:
+ result = condition.value2 == _prevSceneNum;
+ break;
+ case kCondIsNotPrevSceneNum:
+ result = condition.value2 != _prevSceneNum;
+ break;
+ case kCondIsNotSceneVisited:
+ result = _sceneVisited[_currSceneNum] == 0;
+ break;
+ case kCondIsSceneVisited:
+ result = _sceneVisited[_currSceneNum] != 0;
+ break;
+ case kCondIsCameraNumTransition:
+ result = condition.value1 == _currCameraNum && condition.value2 == value;
+ break;
+ case kCondUnused:
+ case kCondSceneObjectVerb:
+ case kCondBgObjectVerb:
+ case kCondSceneObjectInventory:
+ case kCondBgObjectInventory:
+ case kCondIsCurrTalkObject:
+ case kCondIsDialogItem:
+ case kCondIsCameraNum:
+ case kCondDialogItem0:
+ case kCondIsButtheadAtBgObject:
+ result = false;
+ break;
+ default:
+ break;
+ }
+ }
+ return result;
+}
+
+int BbvsEngine::evalDialogCondition(Conditions &conditions) {
+ int result = -1;
+ bool success = false;
+ for (int i = 0; i < 8; ++i) {
+ const Condition &condition = conditions.conditions[i];
+ switch (condition.cond) {
+ case kCondSceneObjectVerb:
+ success = _activeItemType == KITSceneObject && condition.value1 == _currVerbNum && condition.value2 == _activeItemIndex;
+ break;
+ case kCondBgObjectVerb:
+ success = _activeItemType == kITBgObject && condition.value1 == _currVerbNum && condition.value2 == _activeItemIndex;
+ break;
+ case kCondSceneObjectInventory:
+ success = _activeItemType == KITSceneObject && _currVerbNum == kVerbInvItem && condition.value1 == _currInventoryItem && condition.value2 == _activeItemIndex;
+ break;
+ case kCondBgObjectInventory:
+ success = _activeItemType == kITBgObject && _currVerbNum == kVerbInvItem && condition.value1 == _currInventoryItem && condition.value2 == _activeItemIndex;
+ break;
+ case kCondHasInventoryItem:
+ success = _inventoryItemStatus[condition.value1] != 0;
+ break;
+ case kCondHasNotInventoryItem:
+ success = _inventoryItemStatus[condition.value1] == 0;
+ break;
+ case kCondIsGameVar:
+ success = _gameVars[condition.value2] != 0;
+ break;
+ case kCondIsNotGameVar:
+ success = _gameVars[condition.value2] == 0;
+ break;
+ case kCondIsPrevSceneNum:
+ success = condition.value2 == _prevSceneNum;
+ break;
+ case kCondIsCurrTalkObject:
+ success = condition.value2 == _currTalkObjectIndex;
+ break;
+ case kCondIsDialogItem:
+ result = condition.value1;
+ break;
+ case kCondIsCameraNum:
+ success = condition.value1 == _currCameraNum;
+ break;
+ case kCondIsNotPrevSceneNum:
+ success = condition.value2 != _prevSceneNum;
+ break;
+ case kCondIsButtheadAtBgObject:
+ success = _buttheadObject && _gameModule->getBgObject(condition.value2)->rect.contains(_buttheadObject->x >> 16, _buttheadObject->y >> 16);
+ break;
+ case kCondIsNotSceneVisited:
+ success = _sceneVisited[_currSceneNum] == 0;
+ break;
+ case kCondIsSceneVisited:
+ success = _sceneVisited[_currSceneNum] != 0;
+ break;
+ case kCondDialogItem0:
+ return 0;
+ case kCondUnused:
+ case kCondIsCameraNumTransition:
+ success = false;
+ break;
+ }
+ if (!success)
+ return -1;
+ }
+ return result;
+}
+
+void BbvsEngine::evalActionResults(ActionResults &results) {
+ for (int i = 0; i < 8; ++i) {
+ const ActionResult &result = results.actionResults[i];
+ switch (result.kind) {
+ case kActResAddInventoryItem:
+ _inventoryItemStatus[result.value1] = 1;
+ _currVerbNum = kVerbInvItem;
+ _currInventoryItem = result.value1;
+ break;
+ case kActResRemoveInventoryItem:
+ _inventoryItemStatus[result.value1] = 0;
+ if (result.value1 == _currInventoryItem)
+ _currInventoryItem = -1;
+ if (_currVerbNum == kVerbInvItem)
+ _currVerbNum = kVerbLook;
+ break;
+ case kActResSetGameVar:
+ _gameVars[result.value2] = 1;
+ break;
+ case kActResUnsetGameVar:
+ _gameVars[result.value2] = 0;
+ break;
+ case kActResStartDialog:
+ _gameState = kGSDialog;
+ break;
+ case kActResChangeScene:
+ _newSceneNum = result.value2;
+ break;
+ }
+ }
+}
+
+void BbvsEngine::updateBackgroundSounds() {
+ for (int i = 0; i < _gameModule->getSceneSoundsCount(); ++i) {
+ SceneSound *sceneSound = _gameModule->getSceneSound(i);
+ bool isActive = evalCondition(sceneSound->conditions);
+ debug(5, "bgSound(%d) isActive: %d; soundNum: %d", i, isActive, sceneSound->soundNum);
+ if (isActive && !_backgroundSoundsActive[i]) {
+ playSound(sceneSound->soundNum, true);
+ _backgroundSoundsActive[i] = 1;
+ } else if (!isActive && _backgroundSoundsActive[i]) {
+ stopSound(sceneSound->soundNum);
+ _backgroundSoundsActive[i] = 0;
+ }
+ }
+}
+
+void BbvsEngine::loadScene(int sceneNum) {
+ debug("BbvsEngine::loadScene() sceneNum: %d", sceneNum);
+
+ Common::String sprFilename = Common::String::format("vnm/vspr%04d.vnm", sceneNum);
+ Common::String gamFilename = Common::String::format("vnm/game%04d.vnm", sceneNum);
+
+ _screen->clear();
+
+ _spriteModule->load(sprFilename.c_str());
+ _gameModule->load(gamFilename.c_str());
+
+ Palette palette = _spriteModule->getPalette();
+ _screen->setPalette(palette);
+
+ // Preload sounds
+ for (uint i = 0; i < _gameModule->getPreloadSoundsCount(); ++i) {
+ Common::String filename = Common::String::format("snd/snd%05d.aif", _gameModule->getPreloadSound(i));
+ _sound->loadSound(filename);
+ }
+
+ if (sceneNum >= kMainMenu) {
+ DrawList drawList;
+ drawList.add(_gameModule->getBgSpriteIndex(0), 0, 0, 0);
+ _screen->drawDrawList(drawList, _spriteModule);
+ drawScreen();
+ }
+
+}
+
+void BbvsEngine::initScene(bool sounds) {
+
+ stopSpeech();
+ stopSounds();
+ _sound->unloadSounds();
+
+ _gameState = kGSScene;
+ _prevSceneNum = _currSceneNum;
+ _sceneVisited[_currSceneNum] = 1;
+ _mouseCursorSpriteIndex = 0;
+ _verbPos.x = -1;
+ _verbPos.y = -1;
+ _activeItemType = kITEmpty;
+ _activeItemIndex = 0;
+ _cameraPos.x = 0;
+ _cameraPos.y = 0;
+ _newCameraPos.x = 0;
+ _newCameraPos.y = 0;
+ _inventoryButtonIndex = -1;
+ _currTalkObjectIndex = -1;
+ _currCameraNum = 0;
+ _walkMousePos.x = -1;
+ _walkMousePos.y = -1;
+ _currAction = 0;
+ _currActionCommandIndex = -1;
+ _currActionCommandTimeStamp = 0;
+ _dialogSlotCount = 0;
+ _buttheadObject = 0;
+ _beavisObject = 0;
+
+ memset(_backgroundSoundsActive, 0, sizeof(_backgroundSoundsActive));
+
+ memset(_sceneObjects, 0, sizeof(_sceneObjects));
+ for (int i = 0; i < kSceneObjectsCount; ++i) {
+ _sceneObjects[i].walkDestPt.x = -1;
+ _sceneObjects[i].walkDestPt.y = -1;
+ }
+
+ memset(_dialogItemStatus, 0, sizeof(_dialogItemStatus));
+
+ _sceneObjectActions.clear();
+
+ loadScene(_newSceneNum);
+ _currSceneNum = _newSceneNum;
+ _newSceneNum = 0;
+
+ for (int i = 0; i < _gameModule->getSceneObjectDefsCount(); ++i)
+ _sceneObjects[i].sceneObjectDef = _gameModule->getSceneObjectDef(i);
+
+ for (int i = 0; i < _gameModule->getSceneObjectInitsCount(); ++i) {
+ SceneObjectInit *soInit = _gameModule->getSceneObjectInit(i);
+ if (evalCondition(soInit->conditions)) {
+ SceneObject *sceneObject = &_sceneObjects[soInit->sceneObjectIndex];
+ sceneObject->anim = _gameModule->getAnimation(soInit->animIndex);
+ sceneObject->animIndex = soInit->animIndex;
+ sceneObject->frameIndex = sceneObject->anim->frameCount - 1;
+ sceneObject->frameTicks = 1;
+ sceneObject->x = soInit->x << 16;
+ sceneObject->y = soInit->y << 16;
+ }
+ }
+
+ if (_gameModule->getButtheadObjectIndex() >= 0) {
+ _buttheadObject = &_sceneObjects[_gameModule->getButtheadObjectIndex()];
+ // Search for the Beavis object
+ for (int i = 0; i < _gameModule->getSceneObjectDefsCount(); ++i)
+ if (!strcmp(_sceneObjects[i].sceneObjectDef->name, "Beavis")) {
+ _beavisObject = &_sceneObjects[i];
+ break;
+ }
+ }
+
+ updateSceneObjectsTurnValue();
+
+ updateWalkableRects();
+
+ _currCameraNum = 0;
+ if (_buttheadObject) {
+ int minDistance = 0xFFFFFF;
+ for (int cameraNum = 0; cameraNum < 4; ++cameraNum) {
+ CameraInit *cameraInit = _gameModule->getCameraInit(cameraNum);
+ int curDistance = ABS(cameraInit->cameraPos.x - (int)(_buttheadObject->x >> 16) + 160);
+ if (curDistance < minDistance) {
+ minDistance = curDistance;
+ _currCameraNum = cameraNum;
+ }
+ }
+ }
+
+ _cameraPos = _gameModule->getCameraInit(_currCameraNum)->cameraPos;
+ _newCameraPos = _cameraPos;
+
+ _walkAreaActions.clear();
+ for (int i = 0; i < _gameModule->getActionsCount(); ++i) {
+ Action *action = _gameModule->getAction(i);
+ for (int j = 0; j < 8; ++j)
+ if (action->conditions.conditions[j].cond == kCondIsButtheadAtBgObject)
+ _walkAreaActions.push_back(action);
+ }
+
+ _mouseCursorSpriteIndex = 0;
+
+ _activeItemIndex = 0;
+ _activeItemType = kITEmpty;
+
+ for (int i = 0; i < _gameModule->getActionsCount(); ++i) {
+ Action *action = _gameModule->getAction(i);
+ if (evalCondition(action->conditions)) {
+ _gameState = kGSWait;
+ _currAction = action;
+ for (uint j = 0; j < action->actionCommands.size(); ++j) {
+ ActionCommand *actionCommand = &action->actionCommands[j];
+ if (actionCommand->cmd == kActionCmdSetCameraPos) {
+ _currCameraNum = actionCommand->param;
+ _cameraPos = _gameModule->getCameraInit(_currCameraNum)->cameraPos;
+ _newCameraPos = _cameraPos;
+ break;
+ }
+ }
+ break;
+ }
+ }
+
+ if (sounds)
+ updateBackgroundSounds();
+
+}
+
+bool BbvsEngine::changeScene() {
+
+ writeContinueSavegame();
+
+ if (_newSceneNum >= 27 && _newSceneNum <= 30) {
+ // Run minigames
+ stopSpeech();
+ stopSounds();
+ _sceneVisited[_currSceneNum] = 1;
+ if (runMinigame(_newSceneNum - 27)) {
+ SWAP(_currSceneNum, _newSceneNum);
+ }
+ } else if (_newSceneNum >= 31 && _newSceneNum <= 43) {
+ // Play video
+ stopSpeech();
+ stopSounds();
+ _sceneVisited[_currSceneNum] = 1;
+ _playVideoNumber = _newSceneNum - 30;
+ _currSceneNum = _newSceneNum;
+ _newSceneNum = kAfterVideoSceneNum[_playVideoNumber];
+ } else if (_newSceneNum >= 100 && _currSceneNum == 45) {
+ // Play secret video
+ stopSounds();
+ _playVideoNumber = _newSceneNum;
+ _currSceneNum = 49;
+ _newSceneNum = 45;
+ } else {
+ // Normal scene
+ initScene(true);
+ }
+
+ return true;
+
+}
+
+bool BbvsEngine::update(int mouseX, int mouseY, uint mouseButtons, Common::KeyCode keyCode) {
+
+ if (_bootSaveSlot >= 0) {
+ loadGameState(_bootSaveSlot);
+ _gameTicks = 0;
+ _bootSaveSlot = -1;
+ return false;
+ }
+
+ if (_newSceneNum != 0) {
+ _gameTicks = 0;
+ return changeScene();
+ }
+
+ _mousePos.x = mouseX + _cameraPos.x;
+ _mousePos.y = mouseY + _cameraPos.y;
+
+ switch (_gameState) {
+
+ case kGSScene:
+ _isSaveAllowed = true;
+ saveSnapshot();
+ if (mouseButtons & kRightButtonDown) {
+ _verbPos = _mousePos;
+ if (_mousePos.x - _cameraPos.x < 33)
+ _verbPos.x = _cameraPos.x + 33;
+ if (_verbPos.x - _cameraPos.x > 287)
+ _verbPos.x = _cameraPos.x + 287;
+ if (_verbPos.y - _cameraPos.y < 51)
+ _verbPos.y = _cameraPos.y + 51;
+ if (_verbPos.y - _cameraPos.y > 208)
+ _verbPos.y = _cameraPos.y + 208;
+ _gameState = kGSVerbs;
+ } else {
+ switch (keyCode) {
+ case Common::KEYCODE_SPACE:
+ case Common::KEYCODE_i:
+ _inventoryButtonIndex = -1;
+ _gameState = kGSInventory;
+ return true;
+ case Common::KEYCODE_l:
+ _currVerbNum = kVerbLook;
+ break;
+ case Common::KEYCODE_t:
+ _currVerbNum = kVerbTalk;
+ break;
+ case Common::KEYCODE_u:
+ _currVerbNum = kVerbUse;
+ break;
+ case Common::KEYCODE_w:
+ _currVerbNum = kVerbWalk;
+ break;
+ default:
+ break;
+ }
+ updateScene(mouseButtons & kLeftButtonClicked);
+ updateCommon();
+ }
+ break;
+
+ case kGSInventory:
+ _isSaveAllowed = true;
+ saveSnapshot();
+ if (mouseButtons & kRightButtonClicked)
+ _currVerbNum = kVerbUse;
+ switch (keyCode) {
+ case Common::KEYCODE_SPACE:
+ case Common::KEYCODE_i:
+ _gameState = kGSScene;
+ stopSpeech();
+ return true;
+ case Common::KEYCODE_l:
+ _currVerbNum = kVerbLook;
+ break;
+ case Common::KEYCODE_u:
+ _currVerbNum = kVerbUse;
+ break;
+ default:
+ break;
+ }
+ updateInventory(mouseButtons & kLeftButtonClicked);
+ break;
+
+ case kGSVerbs:
+ _isSaveAllowed = false;
+ updateVerbs();
+ if (!(mouseButtons & kRightButtonDown)) {
+ if (_currVerbNum == kVerbShowInv) {
+ _inventoryButtonIndex = -1;
+ _gameState = kGSInventory;
+ } else {
+ _gameState = kGSScene;
+ }
+ }
+ break;
+
+ case kGSWait:
+ case kGSWaitDialog:
+ _isSaveAllowed = false;
+ _activeItemType = kITEmpty;
+ _activeItemIndex = 0;
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(9);
+ if (keyCode == Common::KEYCODE_ESCAPE)
+ skipCurrAction();
+ else
+ updateCommon();
+ break;
+
+ case kGSDialog:
+ _isSaveAllowed = true;
+ saveSnapshot();
+ updateDialog(mouseButtons & kLeftButtonClicked);
+ updateCommon();
+ break;
+
+ }
+
+ return true;
+}
+
+void BbvsEngine::buildDrawList(DrawList &drawList) {
+
+ if (_gameState == kGSInventory) {
+
+ // Inventory background
+ drawList.add(_gameModule->getGuiSpriteIndex(15), 0, 0, 0);
+
+ // Inventory button
+ if (_inventoryButtonIndex == 0)
+ drawList.add(_gameModule->getGuiSpriteIndex(18 + 0), 97, 13, 1);
+ else if (_inventoryButtonIndex == 1)
+ drawList.add(_gameModule->getGuiSpriteIndex(18 + 1), 135, 15, 1);
+ else if (_inventoryButtonIndex == 2)
+ drawList.add(_gameModule->getGuiSpriteIndex(18 + 2), 202, 13, 1);
+
+ // Inventory items
+ int currItem = -1;
+ if (_currVerbNum == kVerbInvItem)
+ currItem = _currInventoryItem;
+ for (int i = 0; i < 50; ++i)
+ if (_inventoryItemStatus[i] && currItem != i)
+ drawList.add(_gameModule->getInventoryItemSpriteIndex(i * 2), kInventorySlotPositions[i].x, kInventorySlotPositions[i].y, 1);
+
+ } else {
+
+ // Scene objects
+ for (int i = 0; i < _gameModule->getSceneObjectDefsCount(); ++i) {
+ SceneObject *sceneObject = &_sceneObjects[i];
+ Animation *anim = sceneObject->anim;
+ if (anim) {
+ drawList.add(anim->frameSpriteIndices[sceneObject->frameIndex],
+ (sceneObject->x >> 16) - _cameraPos.x, (sceneObject->y >> 16) - _cameraPos.y,
+ sceneObject->y >> 16);
+ }
+ }
+
+ // Background objects
+ for (int i = 0; i < _gameModule->getBgSpritesCount(); ++i)
+ drawList.add(_gameModule->getBgSpriteIndex(i), -_cameraPos.x, -_cameraPos.y, _gameModule->getBgSpritePriority(i));
+
+ if (_gameState == kGSVerbs) {
+ // Verbs icon background
+ for (int i = 0; i < 6; ++i) {
+ if (i != 4) {
+ int index = (i == _activeItemIndex) ? 17 : 16;
+ drawList.add(_gameModule->getGuiSpriteIndex(index), _verbPos.x + kVerbRects[i].x - _cameraPos.x,
+ _verbPos.y + kVerbRects[i].y - _cameraPos.y, 499);
+ }
+ }
+ // Verbs background
+ drawList.add(_gameModule->getGuiSpriteIndex(13), _verbPos.x - _cameraPos.x,
+ _verbPos.y - _cameraPos.y, 500);
+ // Selected inventory item
+ if (_currInventoryItem >= 0) {
+ drawList.add(_gameModule->getInventoryItemSpriteIndex(2 * _currInventoryItem), _verbPos.x - _cameraPos.x,
+ _verbPos.y - _cameraPos.y + 27, 500);
+ }
+ }
+
+ if (_gameState == kGSDialog) {
+ // Dialog background
+ drawList.add(_gameModule->getGuiSpriteIndex(14), 0, 0, 500);
+ // Dialog icons
+ int iconX = 16;
+ for (int i = 0; i < 50; ++i)
+ if (_dialogItemStatus[i]) {
+ drawList.add(_gameModule->getDialogItemSpriteIndex(i), iconX, 36, 501);
+ iconX += 32;
+ }
+ }
+
+ }
+
+ // Mouse cursor
+ if (_mouseCursorSpriteIndex > 0 && _mousePos.x >= 0)
+ drawList.add(_mouseCursorSpriteIndex, _mousePos.x - _cameraPos.x, _mousePos.y - _cameraPos.y, 1000);
+
+}
+
+void BbvsEngine::updateVerbs() {
+
+ _activeItemIndex = 99;
+
+ if (_mousePos.x < 0) {
+ _mouseCursorSpriteIndex = 0;
+ return;
+ }
+
+ for (int i = 0; i < 6; ++i) {
+ const BBRect &verbRect = kVerbRects[i];
+ const int16 x = _verbPos.x + verbRect.x;
+ const int16 y = _verbPos.y + verbRect.y;
+ if (Common::Rect(x, y, x + verbRect.width, y + verbRect.height).contains(_mousePos)) {
+ if (i != kVerbInvItem || _currInventoryItem >= 0) {
+ _currVerbNum = i;
+ _activeItemIndex = i;
+ }
+ break;
+ }
+ }
+
+ switch (_currVerbNum) {
+ case kVerbLook:
+ case kVerbUse:
+ case kVerbTalk:
+ case kVerbWalk:
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(2 * _currVerbNum);
+ break;
+ case kVerbInvItem:
+ _mouseCursorSpriteIndex = _gameModule->getInventoryItemSpriteIndex(2 * _currInventoryItem);
+ break;
+ case kVerbShowInv:
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(8);
+ break;
+ }
+
+}
+
+void BbvsEngine::updateDialog(bool clicked) {
+
+ if (_mousePos.x < 0) {
+ _mouseCursorSpriteIndex = 0;
+ _activeItemType = 0;
+ return;
+ }
+
+ if (_mousePos.y > 32) {
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(10);
+ _activeItemIndex = 0;
+ _activeItemType = kITEmpty;
+ if (clicked)
+ _gameState = kGSScene;
+ return;
+ }
+
+ int slotX = (_mousePos.x - _cameraPos.x) / 32;
+
+ if (slotX >= _dialogSlotCount) {
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(4);
+ _activeItemType = kITEmpty;
+ _activeItemIndex = 0;
+ return;
+ }
+
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(5);
+ _activeItemType = kITDialog;
+
+ // Find the selected dialog item index
+ for (int i = 0; i < 50 && slotX >= 0; ++i) {
+ if (_dialogItemStatus[i]) {
+ --slotX;
+ _activeItemIndex = i;
+ }
+ }
+
+ // Select the dialog item action if it was clicked
+ if (clicked) {
+ for (int i = 0; i < _gameModule->getActionsCount(); ++i) {
+ Action *action = _gameModule->getAction(i);
+ if (evalCondition(action->conditions)) {
+ _mouseCursorSpriteIndex = 0;
+ _gameState = kGSWaitDialog;
+ _currAction = action;
+ break;
+ }
+ }
+ }
+
+}
+
+void BbvsEngine::updateInventory(bool clicked) {
+
+ Common::Rect kInvButtonRects[3] = {
+ Common::Rect(97, 13, 97 + 20, 13 + 26),
+ Common::Rect(135, 15, 135 + 46, 15 + 25),
+ Common::Rect(202, 13, 202 + 20, 13 + 26)};
+
+ if (_mousePos.x < 0) {
+ _mouseCursorSpriteIndex = 0;
+ _activeItemType = 0;
+ return;
+ }
+
+ if (_currVerbNum != kVerbLook && _currVerbNum != kVerbUse && _currVerbNum != kVerbInvItem)
+ _currVerbNum = kVerbUse;
+
+ const int16 mx = _mousePos.x - _cameraPos.x;
+ const int16 my = _mousePos.y - _cameraPos.y;
+
+ // Check inventory exit left/right edge of screen
+ if (mx < 40 || mx > 280) {
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(10);
+ _activeItemIndex = 0;
+ _activeItemType = kITEmpty;
+ if (clicked) {
+ _gameState = kGSScene;
+ stopSpeech();
+ }
+ return;
+ }
+
+ // Check hovered/clicked inventory button
+ _inventoryButtonIndex = -1;
+ if (kInvButtonRects[0].contains(mx, my)) {
+ _inventoryButtonIndex = 0;
+ if (clicked)
+ _currVerbNum = kVerbLook;
+ } else if (kInvButtonRects[2].contains(mx, my)) {
+ _inventoryButtonIndex = 2;
+ if (clicked)
+ _currVerbNum = kVerbUse;
+ } else if (kInvButtonRects[1].contains(mx, my)) {
+ _inventoryButtonIndex = 1;
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(10);
+ _activeItemIndex = 0;
+ _activeItemType = kITEmpty;
+ if (clicked) {
+ _gameState = kGSScene;
+ stopSpeech();
+ }
+ return;
+ }
+
+ // Find hovered/clicked inventory item
+
+ int currItem = -1;
+
+ if (_currVerbNum == kVerbInvItem)
+ currItem = _currInventoryItem;
+
+ _activeItemType = kITEmpty;
+
+ for (int i = 0; i < 50; ++i) {
+ if (_inventoryItemStatus[i] && i != currItem) {
+ InventoryItemInfo *info = _gameModule->getInventoryItemInfo(i);
+ const int16 sx = kInventorySlotPositions[i].x + info->xOffs;
+ const int16 sy = kInventorySlotPositions[i].y + info->yOffs;
+ if (Common::Rect(sx, sy, sx + info->width, sy + info->height).contains(mx, my)) {
+ _activeItemType = kITInvItem;
+ _activeItemIndex = i;
+ break;
+ }
+ }
+ }
+
+ // Update mouse cursor and select inventory item if clicked
+
+ if (_activeItemType == kITInvItem) {
+ if (clicked) {
+ if (_currVerbNum == kVerbLook) {
+ stopSpeech();
+ playSpeech(_activeItemIndex + 10000);
+ } else if (_currVerbNum == kVerbUse) {
+ _currInventoryItem = _activeItemIndex;
+ _currVerbNum = kVerbInvItem;
+ _mouseCursorSpriteIndex = _gameModule->getInventoryItemSpriteIndex(2 * _activeItemIndex);
+ } else if (_currVerbNum == kVerbInvItem) {
+ if ((_currInventoryItem == 22 && _activeItemIndex == 39) ||
+ (_currInventoryItem == 39 && _activeItemIndex == 22)) {
+ _inventoryItemStatus[22] = 0;
+ _inventoryItemStatus[39] = 0;
+ _inventoryItemStatus[40] = 1;
+ _currVerbNum = kVerbInvItem;
+ _currInventoryItem = 40;
+ _mouseCursorSpriteIndex = _gameModule->getInventoryItemSpriteIndex(40);
+ }
+ if ((_currInventoryItem == 25 && _activeItemIndex == 26) ||
+ (_currInventoryItem == 26 && _activeItemIndex == 25)) {
+ _inventoryItemStatus[26] = 0;
+ _inventoryItemStatus[25] = 0;
+ _inventoryItemStatus[27] = 1;
+ _currVerbNum = kVerbInvItem;
+ _currInventoryItem = 27;
+ _mouseCursorSpriteIndex = _gameModule->getInventoryItemSpriteIndex(27);
+ }
+ }
+ } else {
+ if (_currVerbNum == kVerbLook)
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(1);
+ else if (_currVerbNum == kVerbUse)
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(3);
+ else if (_currVerbNum == kVerbInvItem)
+ _mouseCursorSpriteIndex = _gameModule->getInventoryItemSpriteIndex(2 * _currInventoryItem + 1);
+ }
+ } else {
+ if (_currVerbNum >= kVerbInvItem)
+ _mouseCursorSpriteIndex = _gameModule->getInventoryItemSpriteIndex(2 * _currInventoryItem);
+ else
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(2 * _currVerbNum);
+ }
+
+}
+
+void BbvsEngine::updateScene(bool clicked) {
+
+ if (_mousePos.x < 0) {
+ _mouseCursorSpriteIndex = 0;
+ _activeItemType = kITNone;
+ return;
+ }
+
+ int lastPriority = 0;
+
+ _activeItemType = kITEmpty;
+
+ for (int i = 0; i < _gameModule->getSceneObjectDefsCount(); ++i) {
+ SceneObject *sceneObject = &_sceneObjects[i];
+ if (sceneObject->anim) {
+ Common::Rect frameRect = sceneObject->anim->frameRects1[sceneObject->frameIndex];
+ const int objY = sceneObject->y >> 16;
+ frameRect.translate(sceneObject->x >> 16, objY);
+ if (lastPriority <= objY && frameRect.width() > 0 && frameRect.contains(_mousePos)) {
+ lastPriority = objY;
+ _activeItemIndex = i;
+ _activeItemType = KITSceneObject;
+ }
+ }
+ }
+
+ for (int i = 0; i < _gameModule->getBgObjectsCount(); ++i) {
+ BgObject *bgObject = _gameModule->getBgObject(i);
+ if (lastPriority <= bgObject->rect.bottom && bgObject->rect.contains(_mousePos)) {
+ lastPriority = bgObject->rect.bottom;
+ _activeItemIndex = i;
+ _activeItemType = kITBgObject;
+ }
+ }
+
+ if (_currVerbNum >= kVerbInvItem)
+ _mouseCursorSpriteIndex = _gameModule->getInventoryItemSpriteIndex(2 * _currInventoryItem);
+ else
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(2 * _currVerbNum);
+
+ bool checkMore = true;
+
+ if (_activeItemType == KITSceneObject || _activeItemType == kITBgObject) {
+ for (int i = 0; i < _gameModule->getActionsCount(); ++i) {
+ Action *action = _gameModule->getAction(i);
+ if (evalCondition(action->conditions)) {
+ checkMore = false;
+ if (clicked) {
+ _mouseCursorSpriteIndex = 0;
+ _gameState = kGSWait;
+ _currAction = action;
+ if (_currVerbNum == kVerbTalk)
+ _currTalkObjectIndex = _activeItemIndex;
+ if (_buttheadObject) {
+ _buttheadObject->walkDestPt.x = -1;
+ _buttheadObject->walkCount = 0;
+ }
+ } else {
+ if (_currVerbNum >= kVerbInvItem)
+ _mouseCursorSpriteIndex = _gameModule->getInventoryItemSpriteIndex(2 * _currInventoryItem + 1);
+ else
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(2 * _currVerbNum + 1);
+ }
+ break;
+ }
+ }
+ }
+
+ // Test scroll arrow left
+ if (checkMore && _buttheadObject && _buttheadObject->anim && _mousePos.x - _cameraPos.x < 16 && _currCameraNum > 0) {
+ --_currCameraNum;
+ for (int i = 0; i < _gameModule->getActionsCount(); ++i) {
+ Action *action = _gameModule->getAction(i);
+ if (evalCameraCondition(action->conditions, _currCameraNum + 1)) {
+ checkMore = false;
+ if (clicked) {
+ _mouseCursorSpriteIndex = 0;
+ _gameState = kGSWait;
+ _currAction = action;
+ _buttheadObject->walkDestPt.x = -1;
+ _buttheadObject->walkCount = 0;
+ } else {
+ _activeItemType = kITScroll;
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(12);
+ }
+ break;
+ }
+ }
+ ++_currCameraNum;
+ }
+
+ // Test scroll arrow right
+ if (checkMore && _buttheadObject && _buttheadObject->anim && _mousePos.x - _cameraPos.x >= 304 && _currCameraNum < 4) {
+ ++_currCameraNum;
+ for (int i = 0; i < _gameModule->getActionsCount(); ++i) {
+ Action *action = _gameModule->getAction(i);
+ if (evalCameraCondition(action->conditions, _currCameraNum - 1)) {
+ checkMore = false;
+ if (clicked) {
+ _mouseCursorSpriteIndex = 0;
+ _gameState = kGSWait;
+ _currAction = action;
+ _buttheadObject->walkDestPt.x = -1;
+ _buttheadObject->walkCount = 0;
+ } else {
+ _activeItemType = kITScroll;
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(11);
+ }
+ break;
+ }
+ }
+ --_currCameraNum;
+ }
+
+ if (checkMore && _buttheadObject && _buttheadObject->anim) {
+ _walkMousePos = _mousePos;
+
+ while (1) {
+ int foundIndex = -1;
+
+ for (int i = 0; i < _walkableRectsCount; ++i)
+ if (_walkableRects[i].contains(_walkMousePos)) {
+ foundIndex = i;
+ break;
+ }
+
+ if (foundIndex >= 0) {
+ if (_walkMousePos.y != _mousePos.y)
+ _walkMousePos.y = _walkableRects[foundIndex].top;
+ break;
+ } else {
+ _walkMousePos.y += 4;
+ if (_walkMousePos.y >= 240)
+ break;
+ }
+
+ }
+
+ if (_beavisObject->anim) {
+ Common::Rect frameRect = _beavisObject->anim->frameRects2[_beavisObject->frameIndex];
+ frameRect.translate(_beavisObject->x >> 16, (_beavisObject->y >> 16) + 1);
+ if (!frameRect.isEmpty() && frameRect.contains(_walkMousePos))
+ _walkMousePos.y = frameRect.bottom;
+ }
+
+ if (_walkMousePos.y < 240 && canButtheadWalkToDest(_walkMousePos)) {
+ if (clicked) {
+ _buttheadObject->walkDestPt = _walkMousePos;
+ _buttheadObject->walkCount = 0;
+ }
+ for (int i = 0; i < _gameModule->getSceneExitsCount(); ++i) {
+ SceneExit *sceneExit = _gameModule->getSceneExit(i);
+ if (sceneExit->rect.contains(_walkMousePos.x, _walkMousePos.y)) {
+ _activeItemIndex = i;
+ _activeItemType = kITSceneExit;
+ _mouseCursorSpriteIndex = _gameModule->getGuiSpriteIndex(10);
+ }
+ }
+ } else {
+ _walkMousePos.x = -1;
+ _walkMousePos.y = -1;
+ }
+
+ }
+
+}
+
+bool BbvsEngine::performActionCommand(ActionCommand *actionCommand) {
+ debug(5, "BbvsEngine::performActionCommand() cmd: %d", actionCommand->cmd);
+
+ switch (actionCommand->cmd) {
+
+ case kActionCmdStop:
+ stopSpeech();
+ return false;
+
+ case kActionCmdWalkObject:
+ {
+ SceneObject *sceneObject = &_sceneObjects[actionCommand->sceneObjectIndex];
+ debug(5, "[%s] walks from (%d, %d) to (%d, %d)", sceneObject->sceneObjectDef->name,
+ sceneObject->x >> 16, sceneObject->y >> 16, actionCommand->walkDest.x, actionCommand->walkDest.y);
+ walkObject(sceneObject, actionCommand->walkDest, actionCommand->param);
+ }
+ return true;
+
+ case kActionCmdMoveObject:
+ {
+ SceneObject *sceneObject = &_sceneObjects[actionCommand->sceneObjectIndex];
+ sceneObject->x = actionCommand->walkDest.x << 16;
+ sceneObject->y = actionCommand->walkDest.y << 16;
+ sceneObject->xIncr = 0;
+ sceneObject->yIncr = 0;
+ sceneObject->walkCount = 0;
+ }
+ return true;
+
+ case kActionCmdAnimObject:
+ {
+ SceneObject *sceneObject = &_sceneObjects[actionCommand->sceneObjectIndex];
+ if (actionCommand->param == 0) {
+ sceneObject->anim = 0;
+ sceneObject->animIndex = 0;
+ sceneObject->frameTicks = 0;
+ sceneObject->frameIndex = 0;
+ } else if (actionCommand->timeStamp != 0 || sceneObject->anim != _gameModule->getAnimation(actionCommand->param)) {
+ sceneObject->animIndex = actionCommand->param;
+ sceneObject->anim = _gameModule->getAnimation(actionCommand->param);
+ sceneObject->frameIndex = sceneObject->anim->frameCount - 1;
+ sceneObject->frameTicks = 1;
+ }
+ }
+ return true;
+
+ case kActionCmdSetCameraPos:
+ _currCameraNum = actionCommand->param;
+ _newCameraPos = _gameModule->getCameraInit(_currCameraNum)->cameraPos;
+ updateBackgroundSounds();
+ return true;
+
+ case kActionCmdPlaySpeech:
+ playSpeech(actionCommand->param);
+ return true;
+
+ case kActionCmdPlaySound:
+ playSound(actionCommand->param);
+ return true;
+
+ case kActionCmdStartBackgroundSound:
+ {
+ const uint soundIndex = _gameModule->getSceneSoundIndex(actionCommand->param);
+ if (!_backgroundSoundsActive[soundIndex]) {
+ _backgroundSoundsActive[soundIndex] = 1;
+ playSound(actionCommand->param, true);
+ }
+ }
+ return true;
+
+ case kActionCmdStopBackgroundSound:
+ {
+ const uint soundIndex = _gameModule->getSceneSoundIndex(actionCommand->param);
+ _backgroundSoundsActive[soundIndex] = 0;
+ stopSound(actionCommand->param);
+ }
+ return true;
+
+ default:
+ return true;
+
+ }
+
+}
+
+bool BbvsEngine::processCurrAction() {
+ bool actionsFinished = false;
+
+ if (_sceneObjectActions.size() == 0) {
+
+ for (uint i = 0; i < _currAction->actionCommands.size(); ++i) {
+ ActionCommand *actionCommand = &_currAction->actionCommands[i];
+ if (actionCommand->timeStamp != 0)
+ break;
+
+ if (actionCommand->cmd == kActionCmdMoveObject || actionCommand->cmd == kActionCmdAnimObject) {
+ SceneObjectAction *sceneObjectAction = 0;
+ // See if there's already an entry for the SceneObject
+ for (uint j = 0; j < _sceneObjectActions.size(); ++j)
+ if (_sceneObjectActions[j].sceneObjectIndex == actionCommand->sceneObjectIndex) {
+ sceneObjectAction = &_sceneObjectActions[j];
+ break;
+ }
+ // If not, add one
+ if (!sceneObjectAction) {
+ SceneObjectAction newSceneObjectAction;
+ newSceneObjectAction.sceneObjectIndex = actionCommand->sceneObjectIndex;
+ _sceneObjectActions.push_back(newSceneObjectAction);
+ sceneObjectAction = &_sceneObjectActions.back();
+ }
+ if (actionCommand->cmd == kActionCmdMoveObject) {
+ sceneObjectAction->walkDest = actionCommand->walkDest;
+ } else {
+ sceneObjectAction->animationIndex = actionCommand->param;
+ }
+ }
+
+ if (actionCommand->cmd == kActionCmdSetCameraPos) {
+ _currCameraNum = actionCommand->param;
+ _newCameraPos = _gameModule->getCameraInit(actionCommand->param)->cameraPos;
+ }
+
+ }
+
+ // Delete entries for SceneObjects without anim
+ for (uint i = 0; i < _sceneObjectActions.size();) {
+ if (!_sceneObjects[_sceneObjectActions[i].sceneObjectIndex].anim)
+ _sceneObjectActions.remove_at(i);
+ else
+ ++i;
+ }
+
+ // Prepare affected scene objects
+ for (uint i = 0; i < _sceneObjectActions.size(); ++i) {
+ _sceneObjects[_sceneObjectActions[i].sceneObjectIndex].walkCount = 0;
+ _sceneObjects[_sceneObjectActions[i].sceneObjectIndex].turnCount = 0;
+ }
+
+ }
+
+ actionsFinished = true;
+
+ // Update SceneObject actions (walk and turn)
+ for (uint i = 0; i < _sceneObjectActions.size(); ++i) {
+ SceneObjectAction *soAction = &_sceneObjectActions[i];
+ SceneObject *sceneObject = &_sceneObjects[soAction->sceneObjectIndex];
+ if (sceneObject->walkDestPt.x != -1) {
+ debug(5, "waiting for walk to finish");
+ actionsFinished = false;
+ } else if ((sceneObject->x >> 16) != soAction->walkDest.x || (sceneObject->y >> 16) != soAction->walkDest.y) {
+ debug(5, "starting to walk");
+ sceneObject->walkDestPt = soAction->walkDest;
+ actionsFinished = false;
+ } else if (sceneObject->walkCount == 0 && sceneObject->turnCount == 0) {
+ debug(5, "not walking");
+ for (int turnCount = 0; turnCount < 8; ++turnCount)
+ if (sceneObject->sceneObjectDef->animIndices[kWalkTurnTbl[turnCount]] == soAction->animationIndex && sceneObject->turnValue != turnCount) {
+ sceneObject->turnCount = turnCount | 0x80;
+ break;
+ }
+ }
+ if (sceneObject->turnCount)
+ actionsFinished = false;
+ }
+
+ if (actionsFinished)
+ _sceneObjectActions.clear();
+
+ return actionsFinished;
+}
+
+void BbvsEngine::skipCurrAction() {
+ ActionCommands &actionCommands = _currAction->actionCommands;
+ while (_currAction && _newSceneNum == 0)
+ updateCommon();
+ for (uint i = 0; i < actionCommands.size(); ++i)
+ if (actionCommands[i].cmd == kActionCmdPlaySound)
+ stopSound(actionCommands[i].param);
+ _system->delayMillis(250);
+ _gameTicks = 0;
+}
+
+void BbvsEngine::updateCommon() {
+
+ if (_currAction) {
+
+ bool doActionCommands = true;
+
+ if (_currActionCommandTimeStamp == 0) {
+ doActionCommands = processCurrAction();
+ _currActionCommandIndex = 0;
+ }
+
+ if (doActionCommands) {
+
+ ActionCommand *actionCommand = &_currAction->actionCommands[_currActionCommandIndex];
+
+ while (actionCommand->timeStamp == _currActionCommandTimeStamp &&
+ _currActionCommandIndex < (int)_currAction->actionCommands.size()) {
+ if (!performActionCommand(actionCommand)) {
+ _gameState = kGSScene;
+ evalActionResults(_currAction->results);
+ if (_gameState == kGSDialog)
+ updateDialogConditions();
+ _currAction = 0;
+ _currActionCommandTimeStamp = 0;
+ _currActionCommandIndex = -1;
+ updateSceneObjectsTurnValue();
+ updateWalkableRects();
+ break;
+ }
+ actionCommand = &_currAction->actionCommands[++_currActionCommandIndex];
+ }
+
+ if (_currAction) {
+ ++_currActionCommandTimeStamp;
+ } else {
+ _activeItemIndex = 0;
+ _mouseCursorSpriteIndex = 0;
+ _activeItemType = kITEmpty;
+ for (int i = 0; i < _gameModule->getActionsCount(); ++i) {
+ Action *action = _gameModule->getAction(i);
+ if (evalCondition(action->conditions)) {
+ _gameState = kGSWait;
+ _currAction = action;
+ }
+ }
+ }
+
+ }
+
+ }
+
+ for (int i = 0; i < _gameModule->getSceneObjectDefsCount(); ++i) {
+ SceneObject *sceneObject = &_sceneObjects[i];
+
+ if (sceneObject->walkDestPt.x != -1) {
+ if (sceneObject->walkCount == 0) {
+ debug(5, "[%s] needs to walk", sceneObject->sceneObjectDef->name);
+ startWalkObject(sceneObject);
+ if (sceneObject->walkCount == 0) {
+ debug(5, "no walk possible");
+ sceneObject->walkDestPt.x = -1;
+ sceneObject->walkDestPt.y = -1;
+ sceneObject->xIncr = 0;
+ sceneObject->yIncr = 0;
+ }
+ }
+ updateWalkObject(sceneObject);
+ }
+
+ if (sceneObject->walkCount > 0 && sceneObject->turnCount == 0) {
+ debug(5, "walk step, xIncr: %d, yIncr: %d", sceneObject->xIncr, sceneObject->yIncr);
+ sceneObject->x += sceneObject->xIncr;
+ sceneObject->y += sceneObject->yIncr;
+ --sceneObject->walkCount;
+ } else if (sceneObject->turnCount != 0) {
+ debug(5, "need turn, turnCount: %d", sceneObject->turnCount);
+ turnObject(sceneObject);
+ }
+
+ if (sceneObject == _buttheadObject && sceneObject->walkDestPt.x != -1) {
+ for (uint j = 0; j < _walkAreaActions.size(); ++j) {
+ if (_walkAreaActions[j] != _currAction && evalCondition(_walkAreaActions[j]->conditions)) {
+ _sceneObjectActions.clear();
+ _gameState = kGSWait;
+ _currAction = _walkAreaActions[j];
+ _currActionCommandTimeStamp = 0;
+ _currActionCommandIndex = -1;
+ for (int k = 0; k < _gameModule->getSceneObjectDefsCount(); ++k) {
+ SceneObject *sceneObject2 = &_sceneObjects[k];
+ sceneObject2->walkDestPt.x = -1;
+ sceneObject2->walkDestPt.y = -1;
+ sceneObject2->walkCount = 0;
+ }
+ break;
+ }
+ }
+ }
+
+ if (sceneObject->anim && --sceneObject->frameTicks == 0) {
+ if (++sceneObject->frameIndex >= sceneObject->anim->frameCount)
+ sceneObject->frameIndex = 0;
+ sceneObject->frameTicks = sceneObject->anim->frameTicks[sceneObject->frameIndex];
+ }
+
+ }
+
+ if (!_currAction && _buttheadObject) {
+ int16 buttheadX = _buttheadObject->x >> 16;
+ int16 buttheadY = _buttheadObject->y >> 16;
+ CameraInit *cameraInit = _gameModule->getCameraInit(_currCameraNum);
+ for (int i = 0; i < 8; ++i) {
+ if (cameraInit->rects[i].contains(buttheadX, buttheadY)) {
+ int newCameraNum = cameraInit->cameraLinks[i];
+ if (_currCameraNum != newCameraNum) {
+ int prevCameraNum = _currCameraNum;
+ _currCameraNum = newCameraNum;
+ _newCameraPos = _gameModule->getCameraInit(newCameraNum)->cameraPos;
+ for (int j = 0; j < _gameModule->getActionsCount(); ++j) {
+ Action *action = _gameModule->getAction(j);
+ if (evalCameraCondition(action->conditions, prevCameraNum)) {
+ _gameState = kGSWait;
+ _currAction = action;
+ _mouseCursorSpriteIndex = 0;
+ _buttheadObject->walkDestPt.x = -1;
+ _buttheadObject->walkCount = 0;
+ break;
+ }
+ }
+ updateBackgroundSounds();
+ }
+ }
+ }
+ }
+
+ if (_cameraPos.x < _newCameraPos.x)
+ ++_cameraPos.x;
+ if (_cameraPos.x > _newCameraPos.x)
+ --_cameraPos.x;
+ if (_cameraPos.y < _newCameraPos.y)
+ ++_cameraPos.y;
+ if (_cameraPos.y > _newCameraPos.y)
+ --_cameraPos.y;
+
+ // Check if Butthead is inside a scene exit
+ if (_newSceneNum == 0 && !_currAction && _buttheadObject) {
+ int16 buttheadX = _buttheadObject->x >> 16;
+ int16 buttheadY = _buttheadObject->y >> 16;
+ for (int i = 0; i < _gameModule->getSceneExitsCount(); ++i) {
+ SceneExit *sceneExit = _gameModule->getSceneExit(i);
+ if (sceneExit->rect.contains(buttheadX, buttheadY)) {
+ _newSceneNum = sceneExit->newModuleNum;
+ break;
+ }
+ }
+ }
+
+}
+
+void BbvsEngine::startWalkObject(SceneObject *sceneObject) {
+ const int kMaxDistance = 0xFFFFFF;
+
+ if (_buttheadObject != sceneObject && _beavisObject != sceneObject)
+ return;
+
+ initWalkAreas(sceneObject);
+ _sourceWalkAreaPt.x = sceneObject->x >> 16;
+ _sourceWalkAreaPt.y = sceneObject->y >> 16;
+
+ _sourceWalkArea = getWalkAreaAtPos(_sourceWalkAreaPt);
+ if (!_sourceWalkArea)
+ return;
+
+ _destWalkAreaPt = sceneObject->walkDestPt;
+
+ _destWalkArea = getWalkAreaAtPos(_destWalkAreaPt);
+ if (!_destWalkArea)
+ return;
+
+ if (_sourceWalkArea != _destWalkArea) {
+ _currWalkDistance = kMaxDistance;
+ walkFindPath(_sourceWalkArea, 0);
+ _destWalkAreaPt = _currWalkDistance == kMaxDistance ? _sourceWalkAreaPt : _finalWalkPt;
+ }
+
+ walkObject(sceneObject, _destWalkAreaPt, sceneObject->sceneObjectDef->walkSpeed);
+
+}
+
+void BbvsEngine::updateWalkObject(SceneObject *sceneObject) {
+ int animIndex;
+
+ if (sceneObject->walkCount > 0 && (sceneObject->xIncr != 0 || sceneObject->yIncr != 0)) {
+ if (ABS(sceneObject->xIncr) <= ABS(sceneObject->yIncr))
+ sceneObject->turnValue = sceneObject->yIncr >= 0 ? 0 : 4;
+ else
+ sceneObject->turnValue = sceneObject->xIncr >= 0 ? 6 : 2;
+ animIndex = sceneObject->sceneObjectDef->animIndices[kWalkAnimTbl[sceneObject->turnValue]];
+ sceneObject->turnCount = 0;
+ sceneObject->turnTicks = 0;
+ } else {
+ animIndex = sceneObject->sceneObjectDef->animIndices[kWalkTurnTbl[sceneObject->turnValue]];
+ }
+
+ Animation *anim = 0;
+ if (animIndex > 0)
+ anim = _gameModule->getAnimation(animIndex);
+
+ if (sceneObject->anim != anim) {
+ if (anim) {
+ sceneObject->anim = anim;
+ sceneObject->animIndex = animIndex;
+ sceneObject->frameTicks = 1;
+ sceneObject->frameIndex = anim->frameCount - 1;
+ } else {
+ sceneObject->anim = 0;
+ sceneObject->animIndex = 0;
+ sceneObject->frameTicks = 0;
+ sceneObject->frameIndex = 0;
+ }
+ }
+
+}
+
+void BbvsEngine::walkObject(SceneObject *sceneObject, const Common::Point &destPt, int walkSpeed) {
+ int deltaX = destPt.x - (sceneObject->x >> 16);
+ int deltaY = destPt.y - (sceneObject->y >> 16);
+ float distance = sqrt(deltaX * deltaX + deltaY * deltaY);
+ // NOTE The original doesn't have this check but without it the whole pathfinding breaks
+ if (distance > 0.0) {
+ sceneObject->walkCount = distance / ((((float)ABS(deltaX) / distance) + 1.0) * ((float)walkSpeed / 120));
+ sceneObject->xIncr = ((float)deltaX / sceneObject->walkCount) * 65536.0;
+ sceneObject->yIncr = ((float)deltaY / sceneObject->walkCount) * 65536.0;
+ sceneObject->x = (sceneObject->x & 0xFFFF0000) | 0x8000;
+ sceneObject->y = (sceneObject->y & 0xFFFF0000) | 0x8000;
+ } else
+ sceneObject->walkCount = 0;
+}
+
+void BbvsEngine::turnObject(SceneObject *sceneObject) {
+ if (sceneObject->turnTicks > 0) {
+ --sceneObject->turnTicks;
+ } else {
+ int turnDir = kTurnInfo[sceneObject->turnValue][sceneObject->turnCount & 0x7F];
+ if (turnDir) {
+ sceneObject->turnValue = (sceneObject->turnValue + turnDir) & 7;
+ int turnAnimIndex = sceneObject->sceneObjectDef->animIndices[kWalkTurnTbl[sceneObject->turnValue]];
+ if (turnAnimIndex) {
+ Animation *anim = _gameModule->getAnimation(turnAnimIndex);
+ if (anim) {
+ sceneObject->anim = anim;
+ sceneObject->animIndex = turnAnimIndex;
+ sceneObject->turnTicks = 4;
+ sceneObject->frameTicks = 1;
+ sceneObject->frameIndex = anim->frameCount - 1;
+ }
+ }
+ } else {
+ sceneObject->turnCount = 0;
+ }
+ }
+}
+
+bool BbvsEngine::rectIntersection(const Common::Rect &rect1, const Common::Rect &rect2, Common::Rect &outRect) {
+ outRect.left = MAX(rect1.left, rect2.left);
+ outRect.top = MAX(rect1.top, rect2.top);
+ outRect.right = MIN(rect1.right, rect2.right);
+ outRect.bottom = MIN(rect1.bottom, rect2.bottom);
+ return !outRect.isEmpty();
+}
+
+int BbvsEngine::rectSubtract(const Common::Rect &rect1, const Common::Rect &rect2, Common::Rect *outRects) {
+ int count = 0;
+ Common::Rect workRect;
+ if (rectIntersection(rect1, rect2, workRect)) {
+ count = 0;
+ outRects[count] = Common::Rect(rect2.width(), workRect.top - rect2.top);
+ if (!outRects[count].isEmpty()) {
+ outRects[count].translate(rect2.left, rect2.top);
+ ++count;
+ }
+ outRects[count] = Common::Rect(workRect.left - rect2.left, workRect.height());
+ if (!outRects[count].isEmpty()) {
+ outRects[count].translate(rect2.left, workRect.top);
+ ++count;
+ }
+ outRects[count] = Common::Rect(rect2.right - workRect.right, workRect.height());
+ if (!outRects[count].isEmpty()) {
+ outRects[count].translate(workRect.right, workRect.top);
+ ++count;
+ }
+ outRects[count] = Common::Rect(rect2.width(), rect2.bottom - workRect.bottom);
+ if (!outRects[count].isEmpty()) {
+ outRects[count].translate(rect2.left, workRect.bottom);
+ ++count;
+ }
+ } else {
+ outRects[0] = rect2;
+ count = 1;
+ }
+ return count;
+}
+
+WalkInfo *BbvsEngine::addWalkInfo(int16 x, int16 y, int delta, int direction, int16 midPtX, int16 midPtY, int walkAreaIndex) {
+ WalkInfo *walkInfo = &_walkInfos[_walkInfosCount++];
+ walkInfo->walkAreaIndex = walkAreaIndex;
+ walkInfo->direction = direction;
+ walkInfo->x = x;
+ walkInfo->y = y;
+ walkInfo->delta = delta;
+ walkInfo->midPt.x = midPtX;
+ walkInfo->midPt.y = midPtY;
+ return walkInfo;
+}
+
+void BbvsEngine::initWalkAreas(SceneObject *sceneObject) {
+ int16 objX = sceneObject->x >> 16;
+ int16 objY = sceneObject->y >> 16;
+ Common::Rect rect;
+ bool doRect = false;
+ Common::Rect *workWalkableRects;
+
+ if (_buttheadObject == sceneObject && _beavisObject->anim) {
+ rect = _beavisObject->anim->frameRects2[_beavisObject->frameIndex];
+ rect.translate(_beavisObject->x >> 16, 1 + (_beavisObject->y >> 16));
+ doRect = !rect.isEmpty();
+ } else if (_buttheadObject->anim) {
+ rect = _buttheadObject->anim->frameRects2[_buttheadObject->frameIndex];
+ rect.translate(_buttheadObject->x >> 16, 1 + (_buttheadObject->y >> 16));
+ doRect = !rect.isEmpty();
+ }
+
+ workWalkableRects = _walkableRects;
+
+ _walkAreasCount = _walkableRectsCount;
+
+ if (doRect && !rect.contains(objX, objY)) {
+ _walkAreasCount = 0;
+ for (int i = 0; i < _walkableRectsCount; ++i)
+ _walkAreasCount += rectSubtract(rect, _walkableRects[i], &_tempWalkableRects1[_walkAreasCount]);
+ workWalkableRects = _tempWalkableRects1;
+ }
+
+ for (int i = 0; i < _walkAreasCount; ++i) {
+ _walkAreas[i].x = workWalkableRects[i].left;
+ _walkAreas[i].y = workWalkableRects[i].top;
+ _walkAreas[i].width = workWalkableRects[i].width();
+ _walkAreas[i].height = workWalkableRects[i].height();
+ _walkAreas[i].checked = false;
+ _walkAreas[i].linksCount = 0;
+ }
+
+ _walkInfosCount = 0;
+
+ // Find connections between the walkRects
+
+ for (int i = 0; i < _walkAreasCount; ++i) {
+ WalkArea *walkArea1 = &_walkAreas[i];
+ int xIter = walkArea1->x + walkArea1->width;
+ int yIter = walkArea1->y + walkArea1->height;
+
+ for (int j = 0; j < _walkAreasCount; ++j) {
+ WalkArea *walkArea2 = &_walkAreas[j];
+
+ if (i == j)
+ continue;
+
+ if (walkArea2->y == yIter) {
+ int wa1x = MAX(walkArea1->x, walkArea2->x);
+ int wa2x = MIN(walkArea2->x + walkArea2->width, xIter);
+ if (wa2x > wa1x) {
+ debug(5, "WalkArea %d connected to %d by Y", i, j);
+ WalkInfo *walkInfo1 = addWalkInfo(wa1x, yIter - 1, wa2x - wa1x, 0, wa1x + (wa2x - wa1x) / 2, yIter - 1, i);
+ WalkInfo *walkInfo2 = addWalkInfo(wa1x, yIter, wa2x - wa1x, 0, wa1x + (wa2x - wa1x) / 2, yIter, j);
+ walkArea1->linksD1[walkArea1->linksCount] = walkInfo1;
+ walkArea1->linksD2[walkArea1->linksCount] = walkInfo2;
+ walkArea1->links[walkArea1->linksCount++] = walkArea2;
+ walkArea2->linksD1[walkArea2->linksCount] = walkInfo2;
+ walkArea2->linksD2[walkArea2->linksCount] = walkInfo1;
+ walkArea2->links[walkArea2->linksCount++] = walkArea1;
+ }
+ }
+
+ if (walkArea2->x == xIter) {
+ int wa1y = MAX(walkArea1->y, walkArea2->y);
+ int wa2y = MIN(walkArea2->y + walkArea2->height, yIter);
+ if (wa2y > wa1y) {
+ debug(5, "WalkArea %d connected to %d by X", i, j);
+ WalkInfo *walkInfo1 = addWalkInfo(xIter - 1, wa1y, wa2y - wa1y, 1, xIter - 1, wa1y + (wa2y - wa1y) / 2, i);
+ WalkInfo *walkInfo2 = addWalkInfo(xIter, wa1y, wa2y - wa1y, 1, xIter, wa1y + (wa2y - wa1y) / 2, j);
+ walkArea1->linksD1[walkArea1->linksCount] = walkInfo1;
+ walkArea1->linksD2[walkArea1->linksCount] = walkInfo2;
+ walkArea1->links[walkArea1->linksCount++] = walkArea2;
+ walkArea2->linksD1[walkArea2->linksCount] = walkInfo2;
+ walkArea2->linksD2[walkArea2->linksCount] = walkInfo1;
+ walkArea2->links[walkArea2->linksCount++] = walkArea1;
+ }
+ }
+
+ }
+
+ }
+
+}
+
+WalkArea *BbvsEngine::getWalkAreaAtPos(const Common::Point &pt) {
+ for (int i = 0; i < _walkAreasCount; ++i) {
+ WalkArea *walkArea = &_walkAreas[i];
+ if (walkArea->contains(pt))
+ return walkArea;
+ }
+ return 0;
+}
+
+bool BbvsEngine::canButtheadWalkToDest(const Common::Point &destPt) {
+ Common::Point srcPt;
+
+ _walkReachedDestArea = false;
+ initWalkAreas(_buttheadObject);
+ srcPt.x = _buttheadObject->x >> 16;
+ srcPt.y = _buttheadObject->y >> 16;
+ _sourceWalkArea = getWalkAreaAtPos(srcPt);
+ if (_sourceWalkArea) {
+ _destWalkArea = getWalkAreaAtPos(destPt);
+ if (_destWalkArea)
+ canWalkToDest(_sourceWalkArea, 0);
+ }
+ return _walkReachedDestArea;
+}
+
+void BbvsEngine::canWalkToDest(WalkArea *walkArea, int infoCount) {
+
+ if (_destWalkArea == walkArea) {
+ _walkReachedDestArea = true;
+ return;
+ }
+
+ if (_gameModule->getFieldC() <= 320 || infoCount <= 20) {
+ walkArea->checked = true;
+ for (int linkIndex = 0; linkIndex < walkArea->linksCount; ++linkIndex) {
+ if (!walkArea->links[linkIndex]->checked) {
+ canWalkToDest(walkArea->links[linkIndex], infoCount + 2);
+ if (_walkReachedDestArea)
+ break;
+ }
+ }
+ walkArea->checked = false;
+ }
+
+}
+
+bool BbvsEngine::walkTestLineWalkable(const Common::Point &sourcePt, const Common::Point &destPt, WalkInfo *walkInfo) {
+ const float ptDeltaX = destPt.x - sourcePt.x;
+ const float ptDeltaY = destPt.y - sourcePt.y;
+ const float wDeltaX = walkInfo->x - sourcePt.x;
+ const float wDeltaY = walkInfo->y - sourcePt.y;
+ if (destPt.x == sourcePt.x)
+ return true;
+ if (walkInfo->direction) {
+ const float nDeltaY = wDeltaX * ptDeltaY / ptDeltaX + (float)sourcePt.y - (float)walkInfo->y;
+ return (nDeltaY >= 0.0) && (nDeltaY < (float)walkInfo->delta);
+ } else {
+ const float nDeltaX = wDeltaY / ptDeltaX * ptDeltaY + (float)sourcePt.x - (float)walkInfo->x;
+ return (nDeltaX >= 0.0) && (nDeltaX < (float)walkInfo->delta);
+ }
+ return false;
+}
+
+void BbvsEngine::walkFindPath(WalkArea *sourceWalkArea, int infoCount) {
+ if (_destWalkArea == sourceWalkArea) {
+ walkFoundPath(infoCount);
+ } else if (_gameModule->getFieldC() <= 320 || infoCount <= 20) {
+ sourceWalkArea->checked = true;
+ for (int linkIndex = 0; linkIndex < sourceWalkArea->linksCount; ++linkIndex) {
+ if (!sourceWalkArea->links[linkIndex]->checked) {
+ _walkInfoPtrs[infoCount + 0] = sourceWalkArea->linksD1[linkIndex];
+ _walkInfoPtrs[infoCount + 1] = sourceWalkArea->linksD2[linkIndex];
+ walkFindPath(sourceWalkArea->links[linkIndex], infoCount + 2);
+ }
+ }
+ sourceWalkArea->checked = false;
+ }
+}
+
+int BbvsEngine::calcDistance(const Common::Point &pt1, const Common::Point &pt2) {
+ return sqrt((pt1.x - pt2.x) * (pt1.x - pt2.x) + (pt1.y - pt2.y) * (pt1.y - pt2.y));
+}
+
+void BbvsEngine::walkFoundPath(int count) {
+ debug(5, "BbvsEngine::walkFoundPath(%d)", count);
+
+ Common::Point midPt = _sourceWalkAreaPt;
+ int totalMidPtDistance = 0;
+
+ if (count > 0) {
+ Common::Point lastMidPt;
+ int halfCount = (count + 1) >> 1;
+ for (int i = 0; i < halfCount; ++i) {
+ lastMidPt = midPt;
+ midPt = _walkInfoPtrs[i * 2]->midPt;
+ totalMidPtDistance += calcDistance(midPt, lastMidPt);
+ }
+ }
+
+ int distance = calcDistance(midPt, _destWalkAreaPt) + totalMidPtDistance;
+
+ debug(5, "BbvsEngine::walkFoundPath() distance: %d; _currWalkDistance: %d", distance, _currWalkDistance);
+
+ if (distance >= _currWalkDistance)
+ return;
+
+ debug(5, "BbvsEngine::walkFoundPath() distance smaller");
+
+ _currWalkDistance = distance;
+
+ Common::Point destPt = _destWalkAreaPt, newDestPt;
+
+ // TODO This needs some cleanup but seems to work
+
+ while (1) {
+
+ int index = 0;
+ if (count > 0) {
+ do {
+ if (!walkTestLineWalkable(_sourceWalkAreaPt, destPt, _walkInfoPtrs[index]))
+ break;
+ ++index;
+ } while (index < count);
+ }
+
+ if (index == count)
+ break;
+
+ WalkInfo *walkInfo = _walkInfoPtrs[--count];
+ destPt.x = walkInfo->x;
+ destPt.y = walkInfo->y;
+
+ if (walkInfo->direction) {
+ newDestPt.x = walkInfo->x;
+ newDestPt.y = walkInfo->y + walkInfo->delta - 1;
+ } else {
+ newDestPt.x = walkInfo->x + walkInfo->delta - 1;
+ newDestPt.y = walkInfo->y;
+ }
+
+ if ((newDestPt.x - _destWalkAreaPt.x) * (newDestPt.x - _destWalkAreaPt.x) +
+ (newDestPt.y - _destWalkAreaPt.y) * (newDestPt.y - _destWalkAreaPt.y) <
+ (destPt.x - _destWalkAreaPt.x) * (destPt.x - _destWalkAreaPt.x) +
+ (destPt.y - _destWalkAreaPt.y) * (destPt.y - _destWalkAreaPt.y))
+ destPt = newDestPt;
+
+ }
+
+ debug(5, "BbvsEngine::walkFoundPath() destPt: (%d, %d)", destPt.x, destPt.y);
+
+ _finalWalkPt = destPt;
+
+ debug(5, "BbvsEngine::walkFoundPath() OK");
+
+}
+
+void BbvsEngine::updateWalkableRects() {
+ // Go through all walkable rects and subtract all scene object rects
+ Common::Rect *rectsList1 = _tempWalkableRects1;
+ Common::Rect *rectsList2 = _gameModule->getWalkRects();
+ _walkableRectsCount = _gameModule->getWalkRectsCount();
+ for (int i = 0; i < _gameModule->getSceneObjectDefsCount(); ++i) {
+ SceneObject *sceneObject = &_sceneObjects[i];
+ Animation *anim = sceneObject->anim;
+ if (anim && _buttheadObject != sceneObject && _beavisObject != sceneObject) {
+ Common::Rect rect = sceneObject->anim->frameRects2[sceneObject->frameIndex];
+ rect.translate(sceneObject->x >> 16, sceneObject->y >> 16);
+ int count = _walkableRectsCount;
+ _walkableRectsCount = 0;
+ for (int j = 0; j < count; ++j)
+ _walkableRectsCount += rectSubtract(rect, rectsList2[j], &rectsList1[_walkableRectsCount]);
+ if (rectsList1 == _tempWalkableRects1) {
+ rectsList1 = _tempWalkableRects2;
+ rectsList2 = _tempWalkableRects1;
+ } else {
+ rectsList1 = _tempWalkableRects1;
+ rectsList2 = _tempWalkableRects2;
+ }
+ }
+ }
+ for (int i = 0; i < _walkableRectsCount; ++i)
+ _walkableRects[i] = rectsList2[i];
+}
+
+void BbvsEngine::updateSceneObjectsTurnValue() {
+ for (int i = 0; i < _gameModule->getSceneObjectDefsCount(); ++i) {
+ SceneObject *sceneObject = &_sceneObjects[i];
+ sceneObject->turnValue = 0;
+ for (int j = 0; j < 12; ++j) {
+ if (sceneObject->sceneObjectDef->animIndices[j] == sceneObject->animIndex) {
+ sceneObject->turnValue = kTurnTbl[j];
+ break;
+ }
+ }
+ }
+}
+
+void BbvsEngine::updateDialogConditions() {
+ _dialogSlotCount = 0;
+ memset(_dialogItemStatus, 0, sizeof(_dialogItemStatus));
+ for (int i = 0; i < _gameModule->getActionsCount(); ++i) {
+ Action *action = _gameModule->getAction(i);
+ int slotIndex = evalDialogCondition(action->conditions);
+ if (slotIndex >= 0) {
+ _dialogItemStatus[slotIndex] = 1;
+ ++_dialogSlotCount;
+ }
+ }
+}
+
+void BbvsEngine::playSpeech(int soundNum) {
+ debug(5, "playSpeech(%0d)", soundNum);
+ Common::String sndFilename = Common::String::format("snd/snd%05d.aif", soundNum);
+ Common::File *fd = new Common::File();
+ fd->open(sndFilename);
+ Audio::AudioStream *audioStream = Audio::makeLoopingAudioStream(Audio::makeAIFFStream(fd, DisposeAfterUse::YES), 1);
+ _mixer->playStream(Audio::Mixer::kSpeechSoundType, &_speechSoundHandle, audioStream);
+
+}
+
+void BbvsEngine::stopSpeech() {
+ _mixer->stopHandle(_speechSoundHandle);
+}
+
+void BbvsEngine::playSound(uint soundNum, bool loop) {
+ debug(5, "playSound(%0d)", soundNum);
+ for (uint i = 0; i < _gameModule->getPreloadSoundsCount(); ++i)
+ if (_gameModule->getPreloadSound(i) == soundNum) {
+ _sound->playSound(i, loop);
+ break;
+ }
+}
+
+void BbvsEngine::stopSound(uint soundNum) {
+ for (uint i = 0; i < _gameModule->getPreloadSoundsCount(); ++i)
+ if (_gameModule->getPreloadSound(i) == soundNum) {
+ _sound->stopSound(i);
+ break;
+ }
+}
+
+void BbvsEngine::stopSounds() {
+ _sound->stopAllSounds();
+}
+
+bool BbvsEngine::runMinigame(int minigameNum) {
+ debug("BbvsEngine::runMinigame() minigameNum: %d", minigameNum);
+
+ int callFlags = 0;
+
+ if (_currSceneNum != kMainMenu)
+ callFlags = 1;
+
+ _sound->unloadSounds();
+
+ Minigame *minigame = 0;
+
+ switch (minigameNum) {
+ case 0:
+ minigame = new MinigameBbloogie(this);
+ break;
+ case 1:
+ minigame = new MinigameBbTennis(this);
+ break;
+ case 2:
+ minigame = new MinigameBbAnt(this);
+ break;
+ case 3:
+ minigame = new MinigameBbAirGuitar(this);
+ break;
+ default:
+ error("Incorrect minigame number %d", minigameNum);
+ break;
+ }
+
+ int minigameResult = minigame->run(callFlags);
+
+ delete minigame;
+
+ // Check if the prinicpal was hit with a megaloogie in the loogie minigame
+ if (minigameNum == 0 && minigameResult == 1)
+ _gameVars[42] = 1;
+
+ //DEBUG Fake it :)
+ if (minigameNum == 0)
+ _gameVars[42] = 1;
+
+ return true;
+}
+
+void BbvsEngine::runMainMenu() {
+ MainMenu *mainMenu = new MainMenu(this);
+ mainMenu->runModal();
+ delete mainMenu;
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/bbvs.h b/engines/bbvs/bbvs.h
new file mode 100644
index 0000000..eaeb529
--- /dev/null
+++ b/engines/bbvs/bbvs.h
@@ -0,0 +1,412 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef BBVS_H
+#define BBVS_H
+
+#include "audio/mixer.h"
+#include "audio/decoders/aiff.h"
+#include "common/array.h"
+#include "common/events.h"
+#include "common/file.h"
+#include "common/memstream.h"
+#include "common/random.h"
+#include "common/str.h"
+#include "common/substream.h"
+#include "common/system.h"
+#include "common/winexe.h"
+#include "common/winexe_pe.h"
+#include "engines/engine.h"
+
+struct ADGameDescription;
+
+namespace Bbvs {
+
+class ActionCommands;
+struct Action;
+class GameModule;
+struct Condition;
+struct Conditions;
+struct ActionResult;
+struct ActionResults;
+struct ActionCommand;
+struct CameraInit;
+struct SceneObjectDef;
+struct SceneObjectInit;
+struct SceneExit;
+struct Animation;
+struct SceneSound;
+class DrawList;
+class SpriteModule;
+class Screen;
+class SoundMan;
+
+#define BBVS_SAVEGAME_VERSION 0
+
+enum {
+ kVerbLook = 0,
+ kVerbUse = 1,
+ kVerbTalk = 2,
+ kVerbWalk = 3,
+ kVerbInvItem = 4,
+ kVerbShowInv = 5
+};
+
+enum {
+ kITNone = 0,
+ kITEmpty = 1,
+ KITSceneObject = 2,
+ kITBgObject = 3,
+ kITDialog = 4,
+ kITScroll = 5,
+ kITSceneExit = 6,
+ kITInvItem = 7
+};
+
+enum {
+ kGSScene = 0,
+ kGSInventory = 1,
+ kGSVerbs = 2,
+ kGSWait = 3,
+ kGSDialog = 4,
+ kGSWaitDialog = 5
+};
+
+enum {
+ kActionCmdStop = 0,
+ kActionCmdWalkObject = 3,
+ kActionCmdMoveObject = 4,
+ kActionCmdAnimObject = 5,
+ kActionCmdSetCameraPos = 7,
+ kActionCmdPlaySpeech = 8,
+ kActionCmdPlaySound = 10,
+ kActionCmdStartBackgroundSound = 11,
+ kActionCmdStopBackgroundSound = 12
+};
+
+enum {
+ kCondUnused = 1,
+ kCondSceneObjectVerb = 2,
+ kCondBgObjectVerb = 3,
+ kCondSceneObjectInventory = 4,
+ kCondBgObjectInventory = 5,
+ kCondHasInventoryItem = 6,
+ kCondHasNotInventoryItem = 7,
+ kCondIsGameVar = 8,
+ kCondIsNotGameVar = 9,
+ kCondIsPrevSceneNum = 10,
+ kCondIsCurrTalkObject = 11,
+ kCondIsDialogItem = 12,
+ kCondIsCameraNum = 13,
+ kCondIsNotPrevSceneNum = 14,
+ kCondDialogItem0 = 15,
+ kCondIsButtheadAtBgObject = 16,
+ kCondIsNotSceneVisited = 17,
+ kCondIsSceneVisited = 18,
+ kCondIsCameraNumTransition = 19
+};
+
+enum {
+ kActResAddInventoryItem = 1,
+ kActResRemoveInventoryItem = 2,
+ kActResSetGameVar = 3,
+ kActResUnsetGameVar = 4,
+ kActResStartDialog = 5,
+ kActResChangeScene = 6
+};
+
+enum {
+ kLeftButtonClicked = 1,
+ kRightButtonClicked = 2,
+ kLeftButtonDown = 4,
+ kRightButtonDown = 8,
+ kAnyButtonClicked = kLeftButtonClicked | kRightButtonClicked,
+ kAnyButtonDown = kLeftButtonDown | kRightButtonDown
+};
+
+struct BBPoint {
+ int16 x, y;
+};
+
+struct BBRect {
+ int16 x, y, width, height;
+};
+
+struct BBPolygon {
+ const BBPoint *points;
+ int pointsCount;
+};
+
+struct Rect {
+ int left, top, right, bottom;
+};
+
+struct SceneObject {
+ uint32 x, y;
+ SceneObjectDef *sceneObjectDef;
+ Animation *anim;
+ int animIndex;
+ int frameIndex;
+ int frameTicks;
+ int walkCount;
+ int xIncr, yIncr;
+ int turnValue, turnCount, turnTicks;
+ Common::Point walkDestPt;
+ SceneObject() : sceneObjectDef(0), anim(0) {
+ }
+};
+
+struct SceneObjectAction {
+ int sceneObjectIndex;
+ int animationIndex;
+ Common::Point walkDest;
+};
+
+struct WalkInfo {
+ int16 x, y;
+ int delta;
+ int direction;
+ Common::Point midPt;
+ int walkAreaIndex;
+};
+
+struct WalkArea {
+ int16 x, y, width, height;
+ bool checked;
+ int linksCount;
+ WalkArea *links[16];
+ WalkInfo *linksD1[32];
+ WalkInfo *linksD2[32];
+ bool contains(const Common::Point &pt) const;
+};
+
+const int kSceneObjectsCount = 64;
+const int kSceneSoundsCount = 8;
+const int kInventoryItemStatusCount = 50;
+const int kDialogItemStatusCount = 50;
+const int kGameVarsCount = 2000;
+const int kSceneVisitedCount = 64;
+
+class BbvsEngine : public Engine {
+protected:
+ Common::Error run();
+ virtual bool hasFeature(EngineFeature f) const;
+public:
+ BbvsEngine(OSystem *syst, const ADGameDescription *gd);
+ ~BbvsEngine();
+ void newGame();
+ void continueGameFromQuickSave();
+ void setNewSceneNum(int newSceneNum);
+private:
+ const ADGameDescription *_gameDescription;
+ Graphics::PixelFormat _pixelFormat;
+public:
+ Common::RandomSource *_random;
+
+ GameModule *_gameModule;
+ SpriteModule *_spriteModule;
+ SoundMan *_sound;
+
+ Screen *_screen;
+
+ int _bootSaveSlot;
+
+ int _mouseX, _mouseY;
+ uint _mouseButtons;
+ Common::KeyCode _keyCode;
+
+ int _mouseCursorSpriteIndex;
+
+ int _gameState;
+ int _gameTicks;
+
+ Common::Point _mousePos;
+ Common::Point _verbPos;
+ Common::Point _walkMousePos;
+
+ int _activeItemType;
+ int _activeItemIndex;
+ int _currTalkObjectIndex;
+
+ Common::Point _cameraPos, _newCameraPos;
+
+ int _newSceneNum, _prevSceneNum, _currSceneNum;
+ int _playVideoNumber;
+
+ int _dialogSlotCount;
+ byte _dialogItemStatus[kDialogItemStatusCount];
+
+ byte _gameVars[kGameVarsCount];
+ byte _sceneVisited[kSceneVisitedCount];
+
+ int _currVerbNum;
+
+ int _currInventoryItem;
+ byte _inventoryItemStatus[kInventoryItemStatusCount];
+ int _inventoryButtonIndex;
+
+ Action *_currAction;
+ uint32 _currActionCommandTimeStamp;
+ int _currActionCommandIndex;
+
+ Common::Array<Action*> _walkAreaActions;
+
+ SceneObject _sceneObjects[kSceneObjectsCount];
+ Common::Array<SceneObjectAction> _sceneObjectActions;
+
+ SceneObject *_buttheadObject, *_beavisObject;
+ int _currCameraNum;
+
+ byte _backgroundSoundsActive[kSceneSoundsCount];
+ Audio::SoundHandle _speechSoundHandle;
+
+ int _walkAreasCount;
+ WalkArea _walkAreas[80];
+ int _walkInfosCount;
+ WalkInfo _walkInfos[256];
+ int _walkableRectsCount;
+ Common::Rect _walkableRects[256];
+ Common::Rect _tempWalkableRects1[256];
+ Common::Rect _tempWalkableRects2[256];
+ WalkInfo *_walkInfoPtrs[256];
+
+ WalkArea *_sourceWalkArea, *_destWalkArea;
+ Common::Point _sourceWalkAreaPt, _destWalkAreaPt, _finalWalkPt;
+ int _currWalkDistance;
+ bool _walkReachedDestArea;
+
+ bool _hasSnapshot;
+ uint32 _snapshotSize;
+ byte *_snapshot;
+ Common::SeekableMemoryWriteStream *_snapshotStream;
+
+ void updateEvents();
+ int getRandom(int max);
+
+ void drawDebugInfo();
+ void drawScreen();
+
+ void updateGame();
+
+ bool evalCondition(Conditions &conditions);
+ bool evalCameraCondition(Conditions &conditions, int value);
+ int evalDialogCondition(Conditions &conditions);
+ void evalActionResults(ActionResults &results);
+
+ void updateBackgroundSounds();
+
+ void loadScene(int sceneNum);
+ void initScene(bool sounds);
+ bool changeScene();
+ bool update(int mouseX, int mouseY, uint mouseButtons, Common::KeyCode keyCode);
+
+ void buildDrawList(DrawList &drawList);
+
+ void updateVerbs();
+ void updateDialog(bool clicked);
+ void updateInventory(bool clicked);
+ void updateScene(bool clicked);
+
+ bool performActionCommand(ActionCommand *actionCommand);
+ bool processCurrAction();
+ void skipCurrAction();
+
+ void updateCommon();
+
+ void updateWalkableRects();
+ void startWalkObject(SceneObject *sceneObject);
+ void updateWalkObject(SceneObject *sceneObject);
+ void walkObject(SceneObject *sceneObject, const Common::Point &destPt, int walkSpeed);
+ void turnObject(SceneObject *sceneObject);
+
+ bool rectIntersection(const Common::Rect &rect1, const Common::Rect &rect2, Common::Rect &outRect);
+ int rectSubtract(const Common::Rect &rect1, const Common::Rect &rect2, Common::Rect *outRects);
+
+ WalkInfo *addWalkInfo(int16 x, int16 y, int delta, int direction, int16 midPtX, int16 midPtY, int walkAreaIndex);
+ void initWalkAreas(SceneObject *sceneObject);
+ WalkArea *getWalkAreaAtPos(const Common::Point &pt);
+ bool canButtheadWalkToDest(const Common::Point &destPt);
+ void canWalkToDest(WalkArea *walkArea, int infoCount);
+ bool walkTestLineWalkable(const Common::Point &sourcePt, const Common::Point &destPt, WalkInfo *walkInfo);
+ void walkFindPath(WalkArea *sourceWalkArea, int infoCount);
+ int calcDistance(const Common::Point &pt1, const Common::Point &pt2);
+ void walkFoundPath(int count);
+
+ void updateSceneObjectsTurnValue();
+ void updateDialogConditions();
+
+ void playSpeech(int soundNum);
+ void stopSpeech();
+
+ void playSound(uint soundNum, bool loop = false);
+ void stopSound(uint soundNum);
+ void stopSounds();
+
+ bool runMinigame(int minigameNum);
+ void playVideo(int videoNum);
+
+ void runMainMenu();
+
+ // Savegame API
+
+ enum kReadSaveHeaderError {
+ kRSHENoError = 0,
+ kRSHEInvalidType = 1,
+ kRSHEInvalidVersion = 2,
+ kRSHEIoError = 3
+ };
+
+ struct SaveHeader {
+ Common::String description;
+ uint32 version;
+ byte gameID;
+ uint32 flags;
+ uint32 saveDate;
+ uint32 saveTime;
+ uint32 playTime;
+ Graphics::Surface *thumbnail;
+ };
+
+ bool _isSaveAllowed;
+
+ bool canLoadGameStateCurrently() { return _isSaveAllowed; }
+ bool canSaveGameStateCurrently() { return _isSaveAllowed; }
+ Common::Error loadGameState(int slot);
+ Common::Error saveGameState(int slot, const Common::String &description);
+ void savegame(const char *filename, const char *description);
+ void loadgame(const char *filename);
+ const char *getSavegameFilename(int num);
+ bool existsSavegame(int num);
+ static Common::String getSavegameFilename(const Common::String &target, int num);
+ static kReadSaveHeaderError readSaveHeader(Common::SeekableReadStream *in, bool loadThumbnail, SaveHeader &header);
+
+ void allocSnapshot();
+ void freeSnapshot();
+ void saveSnapshot();
+
+ void writeContinueSavegame();
+
+};
+
+} // End of namespace Bbvs
+
+#endif // BBVS_H
diff --git a/engines/bbvs/configure.engine b/engines/bbvs/configure.engine
new file mode 100644
index 0000000..c1dc1ef
--- /dev/null
+++ b/engines/bbvs/configure.engine
@@ -0,0 +1,3 @@
+# This file is included from the main "configure" script
+# add_engine [name] [desc] [build-by-default] [subengines] [base games] [deps]
+add_engine bbvs "Beavis and Butthead in Virtual Stupidity" no
diff --git a/engines/bbvs/detection.cpp b/engines/bbvs/detection.cpp
new file mode 100644
index 0000000..698380d
--- /dev/null
+++ b/engines/bbvs/detection.cpp
@@ -0,0 +1,161 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/bbvs.h"
+
+#include "common/config-manager.h"
+#include "engines/advancedDetector.h"
+#include "common/savefile.h"
+#include "common/system.h"
+#include "base/plugins.h"
+#include "graphics/thumbnail.h"
+
+static const PlainGameDescriptor bbvsGames[] = {
+ { "bbvs", "Bbvs" },
+ { 0, 0 }
+};
+
+namespace Bbvs {
+
+static const ADGameDescription gameDescriptions[] = {
+ {
+ "bbvs", "",
+ {
+ {"game0001.vnm", 0, "637e5411751c7065bc385dd73d224561", 64004},
+ AD_LISTEND
+ },
+ Common::EN_ANY, Common::kPlatformWindows, ADGF_NO_FLAGS, GUIO0()
+ },
+
+ AD_TABLE_END_MARKER
+};
+
+} // End of namespace Bbvs
+
+static const char * const directoryGlobs[] = {
+ "vnm",
+ 0
+};
+
+class BbvsMetaEngine : public AdvancedMetaEngine {
+public:
+ BbvsMetaEngine() : AdvancedMetaEngine(Bbvs::gameDescriptions, sizeof(ADGameDescription), bbvsGames) {
+ _singleid = "bbvs";
+ _maxScanDepth = 3;
+ _directoryGlobs = directoryGlobs;
+ }
+
+ virtual const char *getName() const {
+ return "MTV's Beavis and Butt-Head in Virtual Stupidity";
+ }
+
+ virtual const char *getOriginalCopyright() const {
+ return "(C) 1995 Viacom New Media";
+ }
+
+ virtual bool hasFeature(MetaEngineFeature f) const;
+ virtual bool createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const;
+ virtual int getMaximumSaveSlot() const;
+ virtual SaveStateList listSaves(const char *target) const;
+ SaveStateDescriptor querySaveMetaInfos(const char *target, int slot) const;
+ virtual void removeSaveState(const char *target, int slot) const;
+};
+
+bool BbvsMetaEngine::hasFeature(MetaEngineFeature f) const {
+ return
+ (f == kSupportsListSaves) ||
+ (f == kSupportsDeleteSave) ||
+ (f == kSupportsLoadingDuringStartup) ||
+ (f == kSavesSupportMetaInfo) ||
+ (f == kSavesSupportThumbnail) ||
+ (f == kSavesSupportCreationDate);
+}
+
+void BbvsMetaEngine::removeSaveState(const char *target, int slot) const {
+ Common::String fileName = Common::String::format("%s.%03d", target, slot);
+ g_system->getSavefileManager()->removeSavefile(fileName);
+}
+
+int BbvsMetaEngine::getMaximumSaveSlot() const {
+ return 999;
+}
+
+SaveStateList BbvsMetaEngine::listSaves(const char *target) const {
+ Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
+ Bbvs::BbvsEngine::SaveHeader header;
+ Common::String pattern = target;
+ pattern += ".???";
+ Common::StringArray filenames;
+ filenames = saveFileMan->listSavefiles(pattern.c_str());
+ Common::sort(filenames.begin(), filenames.end()); // Sort (hopefully ensuring we are sorted numerically..)
+ SaveStateList saveList;
+ for (Common::StringArray::const_iterator file = filenames.begin(); file != filenames.end(); file++) {
+ // Obtain the last 3 digits of the filename, since they correspond to the save slot
+ int slotNum = atoi(file->c_str() + file->size() - 3);
+ if (slotNum >= 0 && slotNum <= 999) {
+ Common::InSaveFile *in = saveFileMan->openForLoading(file->c_str());
+ if (in) {
+ if (Bbvs::BbvsEngine::readSaveHeader(in, false, header) == Bbvs::BbvsEngine::kRSHENoError) {
+ saveList.push_back(SaveStateDescriptor(slotNum, header.description));
+ }
+ delete in;
+ }
+ }
+ }
+ return saveList;
+}
+
+SaveStateDescriptor BbvsMetaEngine::querySaveMetaInfos(const char *target, int slot) const {
+ Common::String filename = Bbvs::BbvsEngine::getSavegameFilename(target, slot);
+ Common::InSaveFile *in = g_system->getSavefileManager()->openForLoading(filename.c_str());
+ if (in) {
+ Bbvs::BbvsEngine::SaveHeader header;
+ Bbvs::BbvsEngine::kReadSaveHeaderError error;
+ error = Bbvs::BbvsEngine::readSaveHeader(in, true, header);
+ delete in;
+ if (error == Bbvs::BbvsEngine::kRSHENoError) {
+ SaveStateDescriptor desc(slot, header.description);
+ // Slot 0 is used for the "Continue" save
+ desc.setDeletableFlag(slot != 0);
+ desc.setWriteProtectedFlag(slot == 0);
+ desc.setThumbnail(header.thumbnail);
+ desc.setSaveDate(header.saveDate & 0xFFFF, (header.saveDate >> 16) & 0xFF, (header.saveDate >> 24) & 0xFF);
+ desc.setSaveTime((header.saveTime >> 16) & 0xFF, (header.saveTime >> 8) & 0xFF);
+ desc.setPlayTime(header.playTime * 1000);
+ return desc;
+ }
+ }
+ return SaveStateDescriptor();
+}
+
+bool BbvsMetaEngine::createInstance(OSystem *syst, Engine **engine, const ADGameDescription *desc) const {
+ if (desc) {
+ *engine = new Bbvs::BbvsEngine(syst, desc);
+ }
+ return desc != 0;
+}
+
+#if PLUGIN_ENABLED_DYNAMIC(BBVS)
+ REGISTER_PLUGIN_DYNAMIC(BBVS, PLUGIN_TYPE_ENGINE, BbvsMetaEngine);
+#else
+ REGISTER_PLUGIN_STATIC(BBVS, PLUGIN_TYPE_ENGINE, BbvsMetaEngine);
+#endif
diff --git a/engines/bbvs/dialogs.cpp b/engines/bbvs/dialogs.cpp
new file mode 100644
index 0000000..5247a58
--- /dev/null
+++ b/engines/bbvs/dialogs.cpp
@@ -0,0 +1,182 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/dialogs.h"
+#include "common/events.h"
+#include "gui/gui-manager.h"
+#include "gui/ThemeEval.h"
+
+namespace Bbvs {
+
+struct MenuButton {
+ const char *label;
+ uint32 cmd;
+};
+
+static const MenuButton kMenuButtons[] = {
+ // Main menu
+ {"New Game", kCmdNewGame},
+ {"Continue", kCmdContinue},
+ {"Options", kCmdOptions},
+ {"Mini Games", kCmdMiniGames},
+ {"Quit", kCmdQuit},
+ // Options
+ {"Uninstall", kCmdUninstall},
+ {"Credits", kCmdCredits},
+ {"Opening", kCmdOpening},
+ {"Chicks 'n' Stuff", kCmdChicksNStuff},
+ {"Back ..", kCmdBack},
+ // Minigames
+ {"Hock-A-Loogie", kCmdHockALoogie},
+ {"Bug Justice", kCmdBugJustice},
+ {"Court Chaos", kCmdCourtChaos},
+ {"Air Guitar", kCmdAirGuitar},
+ {"Back ..", kCmdBack}
+};
+
+MainMenu::MainMenu(BbvsEngine *vm) : Dialog(0, 0, 1, 1), _vm(vm) {
+ init();
+}
+
+MainMenu::~MainMenu() {
+}
+
+void MainMenu::init() {
+ _buttons[0] = new GUI::ButtonWidget(this, 0, 0, 1, 1, "", 0, 0);
+ _buttons[1] = new GUI::ButtonWidget(this, 0, 0, 1, 1, "", 0, 0);
+ _buttons[2] = new GUI::ButtonWidget(this, 0, 0, 1, 1, "", 0, 0);
+ _buttons[3] = new GUI::ButtonWidget(this, 0, 0, 1, 1, "", 0, 0);
+ _buttons[4] = new GUI::ButtonWidget(this, 0, 0, 1, 1, "", 0, 0);
+ gotoMenuScreen(kMainMenuScr);
+}
+
+void MainMenu::reflowLayout() {
+ const int screenW = g_system->getOverlayWidth();
+ const int screenH = g_system->getOverlayHeight();
+
+ const int buttonWidth = screenW * 70 / 320;
+ const int buttonHeight = screenH * 14 / 240;
+ const int buttonPadding = screenW * 3 / 320;
+
+ _w = 2 * buttonWidth + buttonPadding;
+ _h = 3 * buttonHeight + 3 * buttonPadding;
+ _x = (screenW - _w) / 2;
+ _y = screenH - _h;
+
+ int x = 0, y = 0;
+
+ x = 0;
+ y = 0;
+ _buttons[0]->resize(x, y, buttonWidth, buttonHeight);
+ x += buttonWidth + buttonPadding;
+ _buttons[1]->resize(x, y, buttonWidth, buttonHeight);
+
+ x = 0;
+ y += buttonHeight + buttonPadding;
+ _buttons[2]->resize(x, y, buttonWidth, buttonHeight);
+ x += buttonWidth + buttonPadding;
+ _buttons[3]->resize(x, y, buttonWidth, buttonHeight);
+
+ x = (_w - buttonWidth) / 2; // Center the last button
+ y += buttonHeight + buttonPadding;
+ _buttons[4]->resize(x, y, buttonWidth, buttonHeight);
+
+ GUI::Dialog::reflowLayout();
+
+}
+
+void MainMenu::handleCommand(GUI::CommandSender *sender, uint32 command, uint32 data) {
+ switch (command) {
+ // Main menu
+ case kCmdNewGame:
+ close();
+ _vm->newGame();
+ break;
+ case kCmdContinue:
+ close();
+ _vm->continueGameFromQuickSave();
+ break;
+ case kCmdOptions:
+ gotoMenuScreen(kOptionsMenuScr);
+ break;
+ case kCmdMiniGames:
+ gotoMenuScreen(kMiniGamesMenuScr);
+ break;
+ case kCmdQuit:
+ close();
+ _vm->quitGame();
+ break;
+ // Options menu
+ case kCmdUninstall:
+ break;
+ case kCmdCredits:
+ gotoScene(45);
+ break;
+ case kCmdOpening:
+ gotoScene(43);
+ break;
+ case kCmdChicksNStuff:
+ gotoScene(41);
+ break;
+ // Minigames menu
+ case kCmdHockALoogie:
+ gotoScene(27);
+ break;
+ case kCmdBugJustice:
+ gotoScene(29);
+ break;
+ case kCmdCourtChaos:
+ gotoScene(28);
+ break;
+ case kCmdAirGuitar:
+ gotoScene(30);
+ break;
+ case kCmdBack:
+ gotoMenuScreen(kMainMenuScr);
+ break;
+ default:
+ Dialog::handleCommand(sender, command, data);
+ }
+}
+
+void MainMenu::gotoMenuScreen(int screen) {
+ for (int i = 0; i < 5; ++i) {
+ const MenuButton *btn = &kMenuButtons[screen * 5 + i];
+ _buttons[i]->setLabel(btn->label);
+ _buttons[i]->setCmd(btn->cmd);
+ _buttons[i]->setEnabled(btn->cmd != 0);
+ }
+ // Enable the "Continue" button if a savegame at slot 0 exists
+ if (screen == kMainMenuScr)
+ _buttons[1]->setEnabled(canContinue());
+}
+
+bool MainMenu::canContinue() {
+ return _vm->existsSavegame(0);
+}
+
+void MainMenu::gotoScene(int sceneNum) {
+ close();
+ _vm->setNewSceneNum(sceneNum);
+}
+
+} // End of namespace Hugo
diff --git a/engines/bbvs/dialogs.h b/engines/bbvs/dialogs.h
new file mode 100644
index 0000000..9ecc33a
--- /dev/null
+++ b/engines/bbvs/dialogs.h
@@ -0,0 +1,81 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef BBVS_DIALOGS_H
+#define BBVS_DIALOGS_H
+
+#include "bbvs/bbvs.h"
+#include "gui/dialog.h"
+#include "gui/widgets/edittext.h"
+
+namespace Bbvs {
+
+enum {
+ // Main menu
+ kCmdNewGame = 'NEWG',
+ kCmdContinue = 'CONT',
+ kCmdOptions = 'OPTN',
+ kCmdMiniGames = 'MINI',
+ kCmdQuit = 'QUIT',
+ // Options
+ kCmdUninstall = 0,
+ kCmdCredits = 'CRED',
+ kCmdOpening = 'OPEN',
+ kCmdChicksNStuff = 'CHIC',
+ // Minigames
+ kCmdHockALoogie = 'HOCK',
+ kCmdBugJustice = 'BUGJ',
+ kCmdCourtChaos = 'CORT',
+ kCmdAirGuitar = 'AIRG',
+ kCmdBack = 'BACK'
+};
+
+enum {
+ kMainMenuScr = 0,
+ kOptionsMenuScr = 1,
+ kMiniGamesMenuScr = 2
+};
+
+class MainMenu : public GUI::Dialog {
+public:
+ MainMenu(BbvsEngine *vm);
+ ~MainMenu();
+
+ void reflowLayout();
+ void handleCommand(GUI::CommandSender *sender, uint32 command, uint32 data);
+
+protected:
+ BbvsEngine *_vm;
+
+ void init();
+
+ GUI::ButtonWidget *_buttons[5];
+
+ void gotoMenuScreen(int index);
+ bool canContinue();
+ void gotoScene(int sceneNum);
+
+};
+
+}
+
+#endif // BBVS_DIALOGS_H
diff --git a/engines/bbvs/gamemodule.cpp b/engines/bbvs/gamemodule.cpp
new file mode 100644
index 0000000..abc5086
--- /dev/null
+++ b/engines/bbvs/gamemodule.cpp
@@ -0,0 +1,630 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/gamemodule.h"
+#include "engines/util.h"
+
+namespace Bbvs {
+
+#define DEBUG_DUMP
+
+GameModule::GameModule()
+ : _bgSpriteCount(0), _bgSpriteIndices(0), _bgSpritePriorities(0), _walkRectsCount(0),
+ _walkRects(0), _sceneExitsCount(0), _sceneExits(0), _bgObjectsCount(0), _bgObjects(0),
+ _animationsCount(0), _animations(0), _sceneObjectDefsCount(0), _sceneObjectDefs(0),
+ _sceneObjectInitsCount(0), _sceneObjectInits(0), _actionsCount(0), _actions(0),
+ _sceneSoundsCount(0), _sceneSounds(0), _preloadSoundsCount(0), _preloadSounds(0) {
+}
+
+GameModule::~GameModule() {
+ unload();
+}
+
+void GameModule::load(const char *filename) {
+ debug(0, "GameModule::load()");
+
+ unload();
+
+ Common::File fd;
+
+ if (!fd.open(filename))
+ error("GameModule::load() Could not open %s", filename);
+
+ loadBgSprites(fd);
+ loadCameraInits(fd);
+ loadWalkRects(fd);
+ loadSceneExits(fd);
+ loadBgObjects(fd);
+ loadAnimations(fd);
+ loadSceneObjectDefs(fd);
+ loadSceneObjectInits(fd);
+ loadActions(fd);
+ loadGuiSpriteIndices(fd);
+ loadInventoryItemSpriteIndices(fd);
+ loadInventoryItemInfos(fd);
+ loadDialogItemSpriteIndices(fd);
+ loadSceneSounds(fd);
+ loadPreloadSounds(fd);
+
+ fd.seek(0xC);
+ _fieldC = fd.readUint32LE();
+
+ fd.seek(0x1A8);
+ _buttheadObjectIndex = fd.readUint32LE();
+
+ fd.close();
+
+ debug(0, "GameModule::load() OK");
+}
+
+int GameModule::getFieldC() {
+ return _fieldC;
+}
+
+int GameModule::getButtheadObjectIndex() {
+ return _buttheadObjectIndex;
+}
+
+int GameModule::getGuiSpriteIndex(int index) {
+ assert(index < kGuiSpriteCount);
+ return _guiSpriteIndices[index];
+}
+
+int GameModule::getInventoryItemSpriteIndex(int index) {
+ assert(index < kInventoryItemSpriteCount);
+ return _inventoryItemSpriteIndices[index];
+}
+
+int GameModule::getDialogItemSpriteIndex(int index) {
+ assert(index < kDialogItemSpriteCount);
+ return _dialogItemSpriteIndices[index];
+}
+
+int GameModule::getActionsCount() {
+ return _actionsCount;
+}
+
+Action *GameModule::getAction(int index) {
+ assert(index < _actionsCount);
+ return &_actions[index];
+}
+
+InventoryItemInfo *GameModule::getInventoryItemInfo(int index) {
+ assert(index < kInventoryItemCount);
+ return &_inventoryItemInfos[index];
+}
+
+CameraInit *GameModule::getCameraInit(int cameraNum) {
+ assert(cameraNum < kCameraInitsCount);
+ return &_cameraInits[cameraNum];
+}
+
+int GameModule::getSceneExitsCount() {
+ return _sceneExitsCount;
+}
+
+SceneExit *GameModule::getSceneExit(int index) {
+ assert(index < _sceneExitsCount);
+ return &_sceneExits[index];
+}
+
+int GameModule::getWalkRectsCount() {
+ return _walkRectsCount;
+}
+
+Common::Rect *GameModule::getWalkRects() {
+ return _walkRects;
+}
+
+int GameModule::getSceneObjectDefsCount() {
+ return _sceneObjectDefsCount;
+}
+
+SceneObjectDef *GameModule::getSceneObjectDef(int index) {
+ assert(index < _sceneObjectDefsCount);
+ return &_sceneObjectDefs[index];
+}
+
+int GameModule::getSceneObjectInitsCount() {
+ return _sceneObjectInitsCount;
+}
+
+SceneObjectInit *GameModule::getSceneObjectInit(int index) {
+ assert(index < _sceneObjectInitsCount);
+ return &_sceneObjectInits[index];
+}
+
+int GameModule::getBgObjectsCount() {
+ return _bgObjectsCount;
+}
+
+BgObject *GameModule::getBgObject(int index) {
+ assert(index < _bgObjectsCount);
+ return &_bgObjects[index];
+}
+
+int GameModule::getBgSpritesCount() {
+ return _bgSpriteCount;
+}
+
+int GameModule::getBgSpriteIndex(int index) {
+ assert(index < _bgSpriteCount);
+ return _bgSpriteIndices[index];
+}
+
+int GameModule::getBgSpritePriority(int index) {
+ assert(index < _bgSpriteCount);
+ return _bgSpritePriorities[index];
+}
+
+int GameModule::getSceneSoundsCount() {
+ return _sceneSoundsCount;
+}
+
+SceneSound *GameModule::getSceneSound(int index) {
+ assert(index < _sceneSoundsCount);
+ return &_sceneSounds[index];
+}
+
+uint GameModule::getSceneSoundIndex(uint soundNum) {
+ for (int i = 0; i < getSceneSoundsCount(); ++i)
+ if (getSceneSound(i)->soundNum == soundNum)
+ return i;
+ return 0;
+}
+
+uint GameModule::getPreloadSoundsCount() {
+ return _preloadSoundsCount;
+}
+
+uint GameModule::getPreloadSound(uint index) {
+ assert(index < _preloadSoundsCount);
+ return _preloadSounds[index];
+}
+
+Animation *GameModule::getAnimation(int index) {
+ assert(index < _animationsCount);
+ return &_animations[index];
+}
+
+Common::Point GameModule::readPoint(Common::SeekableReadStream &s) {
+ Common::Point p;
+ p.x = s.readUint16LE();
+ p.y = s.readUint16LE();
+ return p;
+}
+
+Common::Rect GameModule::readRect(Common::SeekableReadStream &s) {
+ Common::Rect r;
+ r.left = s.readUint16LE();
+ r.top = s.readUint16LE();
+ r.setWidth(s.readUint16LE());
+ r.setHeight(s.readUint16LE());
+ return r;
+}
+
+Conditions GameModule::readConditions(Common::SeekableReadStream &s) {
+ Conditions c;
+ for (int i = 0; i < 8; ++i) {
+ c.conditions[i].cond = s.readByte();
+ c.conditions[i].value1 = s.readByte();
+ c.conditions[i].value2 = s.readUint16LE();
+ }
+ return c;
+}
+
+void GameModule::unload() {
+ delete[] _bgSpriteIndices;
+ delete[] _bgSpritePriorities;
+ delete[] _walkRects;
+ delete[] _sceneExits;
+ delete[] _bgObjects;
+ delete[] _animations;
+ delete[] _sceneObjectDefs;
+ delete[] _sceneObjectInits;
+ delete[] _actions;
+ delete[] _sceneSounds;
+ delete[] _preloadSounds;
+ _bgSpriteIndices = 0;
+ _bgSpritePriorities = 0;
+ _walkRects = 0;
+ _sceneExits = 0;
+ _bgObjects = 0;
+ _animations = 0;
+ _sceneObjectDefs = 0;
+ _sceneObjectInits = 0;
+ _actions = 0;
+ _sceneSounds = 0;
+ _preloadSounds = 0;
+}
+
+void GameModule::loadBgSprites(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadBgSprites()");
+
+ s.seek(0x14);
+ _bgSpriteCount = s.readUint32LE();
+ uint32 bgSpriteIndicesOffs = s.readUint32LE();
+ uint32 bgSpritePrioritiesOffs = s.readUint32LE();
+ _bgSpriteIndices = new int[_bgSpriteCount];
+ _bgSpritePriorities = new int16[_bgSpriteCount];
+ s.seek(bgSpriteIndicesOffs);
+ for (int i = 0; i < _bgSpriteCount; ++i)
+ _bgSpriteIndices[i] = s.readUint32LE();
+ s.seek(bgSpritePrioritiesOffs);
+ for (int i = 0; i < _bgSpriteCount; ++i)
+ _bgSpritePriorities[i] = s.readUint16LE();
+
+#ifdef DEBUG_DUMP
+ for (int i = 0; i < _bgSpriteCount; ++i) {
+ debug(0, "BgSprite(%d) %04X %d", i, _bgSpriteIndices[i], _bgSpritePriorities[i]);
+ }
+#endif
+
+}
+
+void GameModule::loadCameraInits(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadCameraInits()");
+
+ s.seek(0x20);
+ for (int i = 0; i < kCameraInitsCount; ++i) {
+ CameraInit &cameraInit = _cameraInits[i];
+ cameraInit.cameraPos = readPoint(s);
+ for (int j = 0; j < 8; ++j)
+ cameraInit.cameraLinks[j] = s.readByte();
+ for (int j = 0; j < 8; ++j)
+ cameraInit.rects[j] = readRect(s);
+ }
+
+#ifdef DEBUG_DUMP
+ for (int i = 0; i < 4; ++i) {
+ CameraInit &cameraInit = _cameraInits[i];
+ debug(0, "CameraInit(%d) (%d, %d)", i, cameraInit.cameraPos.x, cameraInit.cameraPos.y);
+ debugN(0, "CameraInit(%d) ", i);
+ for (int j = 0; j < 8; ++j)
+ debugN(0, "%d ", cameraInit.cameraLinks[j]);
+ debug(0, ".");
+ for (int j = 0; j < 8; ++j)
+ debug(0, "CameraInit(%d) (%d, %d, %d, %d)", i, cameraInit.rects[j].left,
+ cameraInit.rects[j].top, cameraInit.rects[j].right, cameraInit.rects[j].bottom);
+ }
+#endif
+
+}
+
+void GameModule::loadWalkRects(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadWalkRects()");
+
+ s.seek(0x150);
+ _walkRectsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _walkRects = new Common::Rect[_walkRectsCount];
+ s.seek(offs);
+ for (int i = 0; i < _walkRectsCount; ++i)
+ _walkRects[i] = readRect(s);
+
+#ifdef DEBUG_DUMP
+#endif
+
+}
+
+void GameModule::loadSceneExits(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadSceneExits()");
+
+ s.seek(0x158);
+ _sceneExitsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _sceneExits = new SceneExit[_sceneExitsCount];
+ s.seek(offs);
+ for (int i = 0; i < _sceneExitsCount; ++i) {
+ _sceneExits[i].rect = readRect(s);
+ _sceneExits[i].newModuleNum = s.readUint32LE();
+ }
+
+#ifdef DEBUG_DUMP
+ for (int i = 0; i < _sceneExitsCount; ++i) {
+ debug(0, "SceneExit(%d) (%d, %d, %d, %d) %d", i, _sceneExits[i].rect.left, _sceneExits[i].rect.top,
+ _sceneExits[i].rect.right, _sceneExits[i].rect.bottom, _sceneExits[i].newModuleNum);
+ }
+#endif
+
+}
+
+void GameModule::loadBgObjects(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadBgObjects()");
+
+ s.seek(0x160);
+ _bgObjectsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _bgObjects = new BgObject[_bgObjectsCount];
+ s.seek(offs);
+ for (int i = 0; i < _bgObjectsCount; ++i) {
+ s.read(_bgObjects[i].name, 20);
+ _bgObjects[i].rect = readRect(s);
+ }
+
+#ifdef DEBUG_DUMP
+ for (int i = 0; i < _bgObjectsCount; ++i) {
+ debug(0, "BgObject(%d) [%s] (%d, %d, %d, %d)", i, _bgObjects[i].name, _bgObjects[i].rect.left,
+ _bgObjects[i].rect.top, _bgObjects[i].rect.right, _bgObjects[i].rect.bottom);
+ }
+#endif
+
+}
+
+void GameModule::loadAnimations(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadAnimations()");
+
+ s.seek(0x168);
+ _animationsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _animations = new Animation[_animationsCount];
+ for (int i = 0; i < _animationsCount; ++i) {
+ Animation &anim = _animations[i];
+ s.seek(offs + i * 20);
+ anim.frameCount = s.readUint32LE();
+ uint32 frameSpriteIndicesOffs = s.readUint32LE();
+ uint32 frameTicksOffs = s.readUint32LE();
+ uint32 frameRects1Offs = s.readUint32LE();
+ uint32 frameRects2Offs = s.readUint32LE();
+ anim.frameSpriteIndices = new int[anim.frameCount];
+ s.seek(frameSpriteIndicesOffs);
+ for (int j = 0; j < anim.frameCount; ++j)
+ anim.frameSpriteIndices[j] = s.readUint32LE();
+ anim.frameTicks = new int16[anim.frameCount];
+ s.seek(frameTicksOffs);
+ for (int j = 0; j < anim.frameCount; ++j)
+ anim.frameTicks[j] = s.readUint16LE();
+ anim.frameRects1 = new Common::Rect[anim.frameCount];
+ s.seek(frameRects1Offs);
+ for (int j = 0; j < anim.frameCount; ++j)
+ anim.frameRects1[j] = readRect(s);
+ anim.frameRects2 = new Common::Rect[anim.frameCount];
+ s.seek(frameRects2Offs);
+ for (int j = 0; j < anim.frameCount; ++j)
+ anim.frameRects2[j] = readRect(s);
+ }
+
+#ifdef DEBUG_DUMP
+ for (int i = 0; i < _animationsCount; ++i) {
+ Animation &anim = _animations[i];
+ debug(0, "Animation(%d) frameCount: %d", i, anim.frameCount);
+ for (int j = 0; j < anim.frameCount; ++j) {
+ debug(0, "Frame %d: %04X %d (%d, %d, %d, %d) (%d, %d, %d, %d) ",
+ j, anim.frameSpriteIndices[j], anim.frameTicks[j],
+ anim.frameRects1[j].left, anim.frameRects1[j].top, anim.frameRects1[j].right,
+ anim.frameRects1[j].bottom, anim.frameRects2[j].left, anim.frameRects2[j].top,
+ anim.frameRects2[j].right, anim.frameRects2[j].bottom);
+ }
+ }
+#endif
+
+}
+
+void GameModule::loadSceneObjectDefs(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadSceneObjectDefs()");
+
+ s.seek(0x170);
+ _sceneObjectDefsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _sceneObjectDefs = new SceneObjectDef[_sceneObjectDefsCount];
+ s.seek(offs);
+ for (int i = 0; i < _sceneObjectDefsCount; ++i) {
+ s.read(_sceneObjectDefs[i].name, 20);
+ _sceneObjectDefs[i].walkSpeed = s.readUint32LE();
+ for (int j = 0; j < 16; ++j)
+ _sceneObjectDefs[i].animIndices[j] = s.readUint32LE();
+ }
+
+#ifdef DEBUG_DUMP
+ for (int i = 0; i < _sceneObjectDefsCount; ++i) {
+ debugN(0, "SceneObjectDef(%d) [%s] %d ", i, _sceneObjectDefs[i].name, _sceneObjectDefs[i].walkSpeed);
+ for (int j = 0; j < 16; ++j)
+ debugN(0, " %d", _sceneObjectDefs[i].animIndices[j]);
+ debug(0, ".");
+ }
+#endif
+
+}
+
+void GameModule::loadSceneObjectInits(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadSceneObjectInits()");
+
+ s.seek(0x178);
+ _sceneObjectInitsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _sceneObjectInits = new SceneObjectInit[_sceneObjectInitsCount];
+ s.seek(offs);
+ for (int i = 0; i < _sceneObjectInitsCount; ++i) {
+ _sceneObjectInits[i].conditions = readConditions(s);
+ _sceneObjectInits[i].sceneObjectIndex = s.readUint32LE();
+ _sceneObjectInits[i].animIndex = s.readUint32LE();
+ _sceneObjectInits[i].x = s.readUint16LE();
+ _sceneObjectInits[i].y = s.readUint16LE();
+ }
+
+#ifdef DEBUG_DUMP
+ for (int i = 0; i < _sceneObjectInitsCount; ++i) {
+ debug(0, "SceneObjectInit(%d) %d %d (%d, %d)", i, _sceneObjectInits[i].sceneObjectIndex,
+ _sceneObjectInits[i].animIndex, _sceneObjectInits[i].x, _sceneObjectInits[i].y);
+ for (int j = 0; j < 8; ++j)
+ debug(0, " condition(%d) %d %d %d", j, _sceneObjectInits[i].conditions.conditions[j].cond,
+ _sceneObjectInits[i].conditions.conditions[j].value1, _sceneObjectInits[i].conditions.conditions[j].value2);
+ }
+#endif
+
+}
+
+void GameModule::loadActions(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadActions()");
+
+ s.seek(0x180);
+ _actionsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _actions = new Action[_actionsCount];
+ for (int i = 0; i < _actionsCount; ++i) {
+ s.seek(offs + i * 72);
+ debug(0, "Action(%d) offs: %08X", i, offs + i * 72);
+ _actions[i].conditions = readConditions(s);
+ for (int j = 0; j < 8; ++j) {
+ _actions[i].results.actionResults[j].kind = s.readByte();
+ _actions[i].results.actionResults[j].value1 = s.readByte();
+ _actions[i].results.actionResults[j].value2 = s.readUint16LE();
+ }
+ const int actionListCount = s.readUint32LE();
+ const uint32 actionListOffs = s.readUint32LE();
+ s.seek(actionListOffs);
+ for (int j = 0; j < actionListCount; ++j) {
+ ActionCommand actionCommand;
+ actionCommand.cmd = s.readUint16LE();
+ actionCommand.sceneObjectIndex = s.readUint16LE();
+ actionCommand.timeStamp = s.readUint32LE();
+ actionCommand.walkDest = readPoint(s);
+ actionCommand.param = s.readUint32LE();
+ _actions[i].actionCommands.push_back(actionCommand);
+ }
+ }
+
+#ifdef DEBUG_DUMP
+ for (int i = 0; i < _actionsCount; ++i) {
+ debug(0, "Action(%d)", i);
+ for (int j = 0; j < 8; ++j)
+ debug(0, " condition(%d) %d %d %d", j, _actions[i].conditions.conditions[j].cond,
+ _actions[i].conditions.conditions[j].value1, _actions[i].conditions.conditions[j].value2);
+ for (int j = 0; j < 8; ++j)
+ debug(0, " result(%d) %d %d %d", j, _actions[i].results.actionResults[j].kind,
+ _actions[i].results.actionResults[j].value1, _actions[i].results.actionResults[j].value2);
+ for (uint j = 0; j < _actions[i].actionCommands.size(); ++j) {
+ ActionCommand &actionCommand = _actions[i].actionCommands[j];
+ debug(0, " entry(%d) cmd: %d sceneObjectIndex: %d timeStamp: %d walkDest: (%d, %d) param: %d", j, actionCommand.cmd, actionCommand.sceneObjectIndex,
+ actionCommand.timeStamp, actionCommand.walkDest.x, actionCommand.walkDest.y,
+ actionCommand.param);
+ }
+ }
+#endif
+
+}
+
+void GameModule::loadGuiSpriteIndices(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadGuiSpriteIndices()");
+
+ s.seek(0x188);
+ uint32 offs = s.readUint32LE();
+ s.seek(offs);
+ for (int i = 0; i < kGuiSpriteCount; ++i)
+ _guiSpriteIndices[i] = s.readUint32LE();
+
+#ifdef DEBUG_DUMP
+#endif
+
+}
+
+void GameModule::loadInventoryItemSpriteIndices(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadInventoryItemSpriteIndices()");
+
+ s.seek(0x18C);
+ uint32 offs = s.readUint32LE();
+ s.seek(offs);
+ for (int i = 0; i < kInventoryItemSpriteCount; ++i)
+ _inventoryItemSpriteIndices[i] = s.readUint32LE();
+
+#ifdef DEBUG_DUMP
+#endif
+
+}
+
+void GameModule::loadInventoryItemInfos(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadInventoryItemInfos()");
+
+ s.seek(0x190);
+ uint32 offs = s.readUint32LE();
+ s.seek(offs);
+ for (int i = 0; i < kInventoryItemCount; ++i) {
+ _inventoryItemInfos[i].xOffs = s.readUint16LE();
+ _inventoryItemInfos[i].yOffs = s.readUint16LE();
+ _inventoryItemInfos[i].width = s.readUint16LE();
+ _inventoryItemInfos[i].height = s.readUint16LE();
+ s.skip(8); // Unused
+ }
+
+#ifdef DEBUG_DUMP
+#endif
+
+}
+
+void GameModule::loadDialogItemSpriteIndices(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadDialogItemSpriteIndices()");
+
+ s.seek(0x194);
+ uint32 offs = s.readUint32LE();
+ s.seek(offs);
+ for (int i = 0; i < kDialogItemSpriteCount; ++i) {
+ _dialogItemSpriteIndices[i] = s.readUint32LE();
+ }
+
+#ifdef DEBUG_DUMP
+#endif
+
+}
+
+void GameModule::loadSceneSounds(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadSceneSounds()");
+
+ s.seek(0x1A0);
+ _sceneSoundsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _sceneSounds = new SceneSound[_sceneSoundsCount];
+ s.seek(offs);
+ for (int i = 0; i < _sceneSoundsCount; ++i) {
+ _sceneSounds[i].conditions = readConditions(s);
+ _sceneSounds[i].soundNum = s.readUint32LE();
+ }
+
+#ifdef DEBUG_DUMP
+ debug("_sceneSoundsCount: %d", _sceneSoundsCount);
+ for (int i = 0; i < _sceneSoundsCount; ++i) {
+ debug("sound(%d) soundNum: %d", i, _sceneSounds[i].soundNum);
+ }
+#endif
+
+}
+
+void GameModule::loadPreloadSounds(Common::SeekableReadStream &s) {
+ debug(0, "GameModule::loadPreloadSounds()");
+
+ s.seek(0x198);
+ _preloadSoundsCount = s.readUint32LE();
+ uint32 offs = s.readUint32LE();
+ _preloadSounds = new uint[_preloadSoundsCount];
+ s.seek(offs);
+ for (uint i = 0; i < _preloadSoundsCount; ++i)
+ _preloadSounds[i] = s.readUint32LE();
+
+#ifdef DEBUG_DUMP
+ debug("_preloadSoundsCount: %d", _preloadSoundsCount);
+ for (uint i = 0; i < _preloadSoundsCount; ++i) {
+ debug("preloadSound(%d) soundNum: %d", i, _preloadSounds[i]);
+ }
+#endif
+
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/gamemodule.h b/engines/bbvs/gamemodule.h
new file mode 100644
index 0000000..ffd2488
--- /dev/null
+++ b/engines/bbvs/gamemodule.h
@@ -0,0 +1,251 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef BBVS_GAMEMODULE_H
+#define BBVS_GAMEMODULE_H
+
+#include "common/array.h"
+#include "common/file.h"
+#include "common/memstream.h"
+#include "common/rect.h"
+#include "common/str.h"
+
+namespace Bbvs {
+
+const int kInventoryItemCount = 42;
+const int kInventoryItemSpriteCount = 2 * kInventoryItemCount;
+const int kDialogItemSpriteCount = 26;
+const int kGuiSpriteCount = 21;
+const int kCameraInitsCount = 4;
+
+struct Condition {
+ byte cond;
+ byte value1;
+ int16 value2;
+};
+
+struct Conditions {
+ Condition conditions[8];
+};
+
+struct ActionResult {
+ byte kind;
+ byte value1;
+ int16 value2;
+};
+
+struct ActionResults {
+ ActionResult actionResults[8];
+};
+
+struct ActionCommand {
+ uint16 cmd;
+ int16 sceneObjectIndex;
+ uint32 timeStamp;
+ Common::Point walkDest;
+ int32 param;
+};
+
+class ActionCommands : public Common::Array<ActionCommand> {
+};
+
+struct Action {
+ Conditions conditions;
+ ActionResults results;
+ ActionCommands actionCommands;
+};
+
+struct InventoryItemInfo {
+ int16 xOffs, yOffs;
+ int16 width, height;
+};
+
+struct CameraInit {
+ Common::Point cameraPos;
+ byte cameraLinks[8];
+ Common::Rect rects[8];
+};
+
+struct SceneObjectDef {
+ char name[20];
+ int animIndices[16];
+ int walkSpeed;
+};
+
+struct SceneObjectInit {
+ Conditions conditions;
+ int sceneObjectIndex;
+ int animIndex;
+ int x, y;
+};
+
+struct BgObject {
+ char name[20];
+ Common::Rect rect;
+};
+
+struct Animation {
+ int frameCount;
+ int *frameSpriteIndices;
+ int16 *frameTicks;
+ Common::Rect *frameRects1;
+ Common::Rect *frameRects2;
+ Animation()
+ : frameCount(0), frameSpriteIndices(0), frameTicks(0), frameRects1(0), frameRects2(0) {
+ }
+ ~Animation() {
+ delete[] frameSpriteIndices;
+ delete[] frameTicks;
+ delete[] frameRects1;
+ delete[] frameRects2;
+ }
+};
+
+struct SceneExit {
+ Common::Rect rect;
+ int newModuleNum;
+};
+
+struct SceneSound {
+ Conditions conditions;
+ uint soundNum;
+};
+
+class GameModule {
+public:
+ GameModule();
+ ~GameModule();
+
+ void load(const char *filename);
+
+ int getFieldC();
+ int getButtheadObjectIndex();
+
+ int getGuiSpriteIndex(int index);
+ int getInventoryItemSpriteIndex(int index);
+ int getDialogItemSpriteIndex(int index);
+
+ int getActionsCount();
+ Action *getAction(int index);
+
+ InventoryItemInfo *getInventoryItemInfo(int index);
+
+ CameraInit *getCameraInit(int cameraNum);
+
+ int getSceneExitsCount();
+ SceneExit *getSceneExit(int index);
+
+ int getWalkRectsCount();
+ Common::Rect *getWalkRects();
+
+ int getSceneObjectDefsCount();
+ SceneObjectDef *getSceneObjectDef(int index);
+
+ int getSceneObjectInitsCount();
+ SceneObjectInit *getSceneObjectInit(int index);
+
+ int getBgObjectsCount();
+ BgObject *getBgObject(int index);
+
+ int getBgSpritesCount();
+ int getBgSpriteIndex(int index);
+ int getBgSpritePriority(int index);
+
+ int getSceneSoundsCount();
+ SceneSound *getSceneSound(int index);
+ uint getSceneSoundIndex(uint soundNum);
+
+ uint getPreloadSoundsCount();
+ uint getPreloadSound(uint index);
+
+ Animation *getAnimation(int index);
+
+protected:
+
+ int _bgSpriteCount;
+ int *_bgSpriteIndices;
+ int16 *_bgSpritePriorities;
+
+ CameraInit _cameraInits[kCameraInitsCount];
+
+ int _walkRectsCount;
+ Common::Rect *_walkRects;
+
+ int _sceneExitsCount;
+ SceneExit *_sceneExits;
+
+ int _bgObjectsCount;
+ BgObject *_bgObjects;
+
+ int _animationsCount;
+ Animation *_animations;
+
+ int _sceneObjectDefsCount;
+ SceneObjectDef *_sceneObjectDefs;
+
+ int _sceneObjectInitsCount;
+ SceneObjectInit *_sceneObjectInits;
+
+ int _actionsCount;
+ Action *_actions;
+
+ int _sceneSoundsCount;
+ SceneSound *_sceneSounds;
+
+ uint _preloadSoundsCount;
+ uint *_preloadSounds;
+
+ int _guiSpriteIndices[kGuiSpriteCount];
+ int _inventoryItemSpriteIndices[kInventoryItemSpriteCount];
+ InventoryItemInfo _inventoryItemInfos[kInventoryItemCount];
+ int _dialogItemSpriteIndices[kDialogItemSpriteCount];
+
+ int _fieldC;
+ int _buttheadObjectIndex;
+
+ Common::Point readPoint(Common::SeekableReadStream &s);
+ Common::Rect readRect(Common::SeekableReadStream &s);
+ Conditions readConditions(Common::SeekableReadStream &s);
+
+ void unload();
+
+ void loadBgSprites(Common::SeekableReadStream &s);
+ void loadCameraInits(Common::SeekableReadStream &s);
+ void loadWalkRects(Common::SeekableReadStream &s);
+ void loadSceneExits(Common::SeekableReadStream &s);
+ void loadBgObjects(Common::SeekableReadStream &s);
+ void loadAnimations(Common::SeekableReadStream &s);
+ void loadSceneObjectDefs(Common::SeekableReadStream &s);
+ void loadSceneObjectInits(Common::SeekableReadStream &s);
+ void loadActions(Common::SeekableReadStream &s);
+ void loadGuiSpriteIndices(Common::SeekableReadStream &s);
+ void loadInventoryItemSpriteIndices(Common::SeekableReadStream &s);
+ void loadInventoryItemInfos(Common::SeekableReadStream &s);
+ void loadDialogItemSpriteIndices(Common::SeekableReadStream &s);
+ void loadSceneSounds(Common::SeekableReadStream &s);
+ void loadPreloadSounds(Common::SeekableReadStream &s);
+
+};
+
+} // End of namespace Bbvs
+
+#endif // BBVS_H
diff --git a/engines/bbvs/graphics.cpp b/engines/bbvs/graphics.cpp
new file mode 100644
index 0000000..810d910
--- /dev/null
+++ b/engines/bbvs/graphics.cpp
@@ -0,0 +1,141 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/graphics.h"
+
+namespace Bbvs {
+
+void DrawList::add(int index, int x, int y, int priority) {
+ debug(5, "DrawList::add() %d (%d, %d) %d", index, x, y, priority);
+ DrawListEntry drawListEntry;
+ drawListEntry.index = index;
+ drawListEntry.x = x;
+ drawListEntry.y = y;
+ drawListEntry.priority = priority;
+ // Insert the sprite at the correct position
+ uint insertIndex = 0;
+ while (insertIndex < size() && (*this)[insertIndex].priority <= priority)
+ ++insertIndex;
+ insert_at(insertIndex, drawListEntry);
+}
+
+Screen::Screen(OSystem *system) : _system(system) {
+ _surface = new Graphics::Surface();
+ _surface->create(320, 240, Graphics::PixelFormat::createFormatCLUT8());
+}
+
+Screen::~Screen() {
+ _surface->free();
+ delete _surface;
+}
+
+void Screen::setPalette(Palette &palette) {
+ byte pal[768];
+ memset(pal, 0, 768);
+ memcpy(&pal[palette.start * 3], palette.data, palette.count * 3);
+ _system->getPaletteManager()->setPalette(pal, 0, 256);
+}
+
+void Screen::copyToScreen() {
+ _system->copyRectToScreen((const byte*)_surface->getBasePtr(0, 0), _surface->pitch, 0, 0, 320, 240);
+ _system->updateScreen();
+}
+
+void Screen::clear() {
+ _surface->fillRect(Common::Rect(0, 0, 320, 240), 0);
+}
+
+void Screen::drawDrawList(DrawList &drawList, SpriteModule *spriteModule) {
+ for (uint i = 0; i < drawList.size(); ++i) {
+ debug(1, "index: %d; x: %d; y: %d; priority: %d", drawList[i].index, drawList[i].x, drawList[i].y, drawList[i].priority);
+ Sprite sprite = spriteModule->getSprite(drawList[i].index);
+ drawSprite(sprite, drawList[i].x, drawList[i].y);
+ }
+}
+
+void Screen::drawSprite(Sprite &sprite, int x, int y) {
+ debug(5, "Screen::drawSprite()");
+
+ int destX, destY, width, height, skipX = 0, skipY = 0;
+
+ destX = sprite.xOffs + x;
+ destY = sprite.yOffs + y;
+
+ if (destX >= _surface->w || destY >= _surface->h)
+ return;
+
+ height = sprite.height;
+ if (destY < 0) {
+ height += destY;
+ if (height <= 0)
+ return;
+ skipY = -destY;
+ destY = 0;
+ }
+ if (destY + height > _surface->h)
+ height = _surface->h - destY;
+
+ width = sprite.width;
+ if (destX < 0) {
+ width += destX;
+ if (width <= 0)
+ return;
+ skipX = -destX;
+ destX = 0;
+ }
+ if (destX + width >= _surface->w)
+ width = _surface->w - destX;
+
+ debug(0, "drawSprite() (%d, %d, %d, %d); skipX: %d; skipY: %d; %d", destX, destY, width, height, skipX, skipY, sprite.type);
+
+ if (sprite.type == 1) {
+ for (int yc = 0; yc < height; ++yc) {
+ byte *source = sprite.getRow(skipY + yc);
+ byte *dest = (byte*)_surface->getBasePtr(destX, destY + yc);
+ int currWidth = -skipX;
+ while (currWidth < width) {
+ int8 op = *source++;
+ if (op < 0) {
+ currWidth += (-op);
+ } else {
+ while (op >= 0 && currWidth < width) {
+ if (currWidth >= 0)
+ dest[currWidth] = *source;
+ ++source;
+ ++currWidth;
+ --op;
+ }
+ }
+ }
+ }
+ } else {
+ for (int yc = 0; yc < height; ++yc) {
+ byte *source = sprite.getRow(skipY + yc) + skipX;
+ byte *dest = (byte*)_surface->getBasePtr(destX, destY + yc);
+ memcpy(dest, source, width);
+ }
+ }
+
+ debug(5, "Screen::drawSprite() OK");
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/graphics.h b/engines/bbvs/graphics.h
new file mode 100644
index 0000000..277cf45
--- /dev/null
+++ b/engines/bbvs/graphics.h
@@ -0,0 +1,61 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef BBVS_GRAPHICS_H
+#define BBVS_GRAPHICS_H
+
+#include "bbvs/spritemodule.h"
+#include "common/array.h"
+#include "common/system.h"
+#include "graphics/palette.h"
+#include "graphics/surface.h"
+
+namespace Bbvs {
+
+struct DrawListEntry {
+ int index;
+ int x, y;
+ int priority;
+};
+
+class DrawList : public Common::Array<DrawListEntry> {
+public:
+ void add(int index, int x, int y, int priority);
+};
+
+class Screen {
+public:
+ Screen(OSystem *system);
+ ~Screen();
+ void setPalette(Palette &palette);
+ void copyToScreen();
+ void drawDrawList(DrawList &drawList, SpriteModule *spriteModule);
+ void drawSprite(Sprite &sprite, int x, int y);
+ void clear();
+//protected:
+ OSystem *_system;
+ Graphics::Surface *_surface;
+};
+
+} // End of namespace Bbvs
+
+#endif // BBVS_H
diff --git a/engines/bbvs/minigames/bbairguitar.cpp b/engines/bbvs/minigames/bbairguitar.cpp
new file mode 100644
index 0000000..f81bb49
--- /dev/null
+++ b/engines/bbvs/minigames/bbairguitar.cpp
@@ -0,0 +1,1198 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/minigames/bbairguitar.h"
+
+namespace Bbvs {
+
+static const char *kNoteSoundFilenames[] = {
+ "a.aif", "a#.aif", "b.aif", "c.aif", "c#.aif",
+ "d.aif", "d#.aif", "e.aif", "f.aif", "f#.aif",
+ "g.aif", "g#.aif", "a_oct.aif"
+};
+
+static const uint kNoteSoundFilenamesCount = ARRAYSIZE(kNoteSoundFilenames);
+
+static const char *kPatchDirectories[] = {
+ "rock", "burp", "fart"
+};
+
+static const uint kPatchDirectoriesCount = ARRAYSIZE(kPatchDirectories);
+
+static const BBPoint kPianoKeyArea1[] = {{29, 192}, {38, 192}, {38, 222}, {41, 222}, {41, 239}, {29, 239}};
+static const BBPoint kPianoKeyArea2[] = {{38, 192}, {43, 192}, {43, 222}, {38, 222}};
+static const BBPoint kPianoKeyArea3[] = {{43, 192}, {49, 192}, {49, 222}, {52, 222}, {52, 239}, {41, 239}, {41, 222}, {43, 222}};
+static const BBPoint kPianoKeyArea4[] = {{49, 192}, {54, 192}, {54, 222}, {49, 222}};
+static const BBPoint kPianoKeyArea5[] = {{54, 192}, {63, 192}, {63, 239}, {52, 239}, {52, 222}, {54, 222}};
+static const BBPoint kPianoKeyArea6[] = {{63, 192}, {71, 192}, {71, 222}, {74, 222}, {74, 239}, {63, 239}};
+static const BBPoint kPianoKeyArea7[] = {{71, 192}, {76, 192}, {76, 222}, {71, 222}};
+static const BBPoint kPianoKeyArea8[] = {{76, 192}, {82, 192}, {82, 222}, {85, 222}, {85, 239}, {74, 239}, {74, 222}, {76, 222}};
+static const BBPoint kPianoKeyArea9[] = {{82, 192}, {87, 192}, {87, 222}, {82, 222}};
+static const BBPoint kPianoKeyArea10[] = {{87, 192}, {94, 192}, {94, 222}, {96, 222}, {96, 239}, {85, 239}, {85, 222}, {87, 222}};
+static const BBPoint kPianoKeyArea11[] = {{94, 192}, {99, 192}, {99, 222}, {94, 222}};
+static const BBPoint kPianoKeyArea12[] = {{99, 192}, {107, 192}, {107, 239}, {96, 239}, {96, 222}, {99, 222}};
+static const BBPoint kPianoKeyArea13[] = {{107, 192}, {118, 192}, {118, 239}, {107, 239}};
+
+static const BBPolygon kPianoKeyAreas[] = {
+ {kPianoKeyArea1, ARRAYSIZE(kPianoKeyArea1)},
+ {kPianoKeyArea2, ARRAYSIZE(kPianoKeyArea2)},
+ {kPianoKeyArea3, ARRAYSIZE(kPianoKeyArea3)},
+ {kPianoKeyArea4, ARRAYSIZE(kPianoKeyArea4)},
+ {kPianoKeyArea5, ARRAYSIZE(kPianoKeyArea5)},
+ {kPianoKeyArea6, ARRAYSIZE(kPianoKeyArea6)},
+ {kPianoKeyArea7, ARRAYSIZE(kPianoKeyArea7)},
+ {kPianoKeyArea8, ARRAYSIZE(kPianoKeyArea8)},
+ {kPianoKeyArea9, ARRAYSIZE(kPianoKeyArea9)},
+ {kPianoKeyArea10, ARRAYSIZE(kPianoKeyArea10)},
+ {kPianoKeyArea11, ARRAYSIZE(kPianoKeyArea11)},
+ {kPianoKeyArea12, ARRAYSIZE(kPianoKeyArea12)},
+ {kPianoKeyArea13, ARRAYSIZE(kPianoKeyArea13)},
+};
+
+static const BBPoint kObjPoints[] = {
+ {161, 189}, {269, 189}, {161, 208}, {279, 208}, {172, 208},
+ {141, 224}, {257, 191}, {257, 199}, {148, 223}, {124, 224},
+ { 29, 192}, {182, 220}, {245, 220}, {269, 220}, {161, 220},
+ {203, 220}, {224, 220}, {123, 189}, {123, 199}, {123, 209},
+ {134, 224}, { 29, 185}, {124, 224}, {226, 127}, {226, 127},
+ {209, 141}, {244, 141}, {226, 127}, { 99, 107}, { 99, 107},
+ { 76, 137}, {118, 136}, { 99, 107}, {195, 104}, {100, 78}
+};
+
+static const MinigameBbAirGuitar::PianoKeyInfo kPianoKeyInfos[] = {
+ { 30, 192, 0},
+ { 38, 192, 5},
+ { 41, 192, 1},
+ { 49, 192, 5},
+ { 52, 192, 2},
+ { 63, 192, 3},
+ { 71, 192, 5},
+ { 74, 192, 1},
+ { 82, 192, 5},
+ { 85, 192, 1},
+ { 94, 192, 5},
+ { 96, 192, 2},
+ {107, 192, 4}
+};
+
+static const Rect kRect2 = {29, 189, 290, 239};
+static const Rect kPianoRect = {29, 192, 118, 239};
+
+static const Rect kPlayerButtonRects[] = {
+ {123, 189, 145, 199},
+ {123, 199, 145, 209},
+ {123, 209, 145, 220},
+ {148, 223, 156, 236},
+ {161, 189, 182, 205},
+ {161, 208, 171, 218},
+ {161, 220, 182, 231},
+ {182, 220, 203, 231},
+ {203, 220, 224, 231},
+ {224, 220, 245, 231},
+ {245, 220, 266, 231},
+ {269, 220, 290, 231},
+ {269, 189, 290, 205},
+ {279, 208, 290, 218}
+};
+
+static const BBPoint kPointsTbl1[] = {
+ {196, 191}, {202, 191}, {207, 191}, {212, 191}, {217, 191},
+ {223, 191}, {228, 191}, {233, 191}, {238, 191}, {244, 191},
+ {249, 191}
+};
+
+static const BBPoint kPointsTbl2[] = {
+ {196, 199}, {202, 199}, {207, 199}, {212, 199}, {217, 199},
+ {223, 199}, {228, 199}, {233, 199}, {238, 199}, {244, 199},
+ {249, 199}
+};
+
+static const struct { int frameIndex; byte flag; } kNoteFrameTbl[13] = {
+ {2, 0}, {2, 1}, {3, 0}, {3, 1}, {4, 0},
+ {5, 0}, {5, 1}, {6, 0}, {6, 1}, {0, 0},
+ {0, 1}, {1, 0}, {2, 0}
+};
+
+const int kTrackBarMinX = 172;
+const int kTrackBarMaxX = 272;
+
+bool MinigameBbAirGuitar::ptInRect(const Rect *r, int x, int y) {
+ return r && Common::Rect(r->left, r->top, r->right, r->bottom).contains(x, y);
+}
+
+bool MinigameBbAirGuitar::ptInPoly(const BBPolygon *poly, int x, int y) {
+ if (!poly)
+ return false;
+ const BBPoint *points = poly->points;
+ int pointsCount = poly->pointsCount;
+ bool result = false;
+ if (pointsCount > 0)
+ for (int i = 0, j = pointsCount - 1; i < pointsCount; j = i++)
+ if (((points[i].y > y) != (points[j].y > y)) &&
+ (x < (points[j].x - points[i].x) * (y - points[i].y) /
+ (points[j].y - points[i].y) + points[i].x))
+ result = !result;
+ return result;
+}
+
+void MinigameBbAirGuitar::buildDrawList(DrawList &drawList) {
+ switch (_gameState) {
+ case 0:
+ buildDrawList0(drawList);
+ break;
+ case 1:
+ buildDrawList1(drawList);
+ break;
+ }
+}
+
+void MinigameBbAirGuitar::buildDrawList0(DrawList &drawList) {
+
+ drawList.add(_objects[0].anim->frameIndices[0], _objects[0].x, _objects[0].y, 2000);
+
+ for (int i = 1; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind)
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, obj->y + 16);
+ }
+
+ if (_titleScreenSpriteIndex> 0)
+ drawList.add(_titleScreenSpriteIndex, 0, 0, 0);
+
+}
+
+void MinigameBbAirGuitar::buildDrawList1(DrawList &drawList) {
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind)
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, 255 - i);
+ }
+
+ if (_movingTrackBar) {
+ _trackBarX = _trackBarMouseX;
+ } else if (_totalTrackLength > 0) {
+ _trackBarX = 100 * _currTrackPos / _totalTrackLength + kTrackBarMinX;
+ } else {
+ _trackBarX = kTrackBarMinX;
+ }
+
+ if (_trackBarX > kTrackBarMaxX)
+ _trackBarX = kTrackBarMaxX;
+
+ _trackBarThumbRect.top = 208;
+ _trackBarThumbRect.bottom = 218;
+ _trackBarThumbRect.left = _trackBarX;
+ _trackBarThumbRect.right = _trackBarX + 6;
+
+ drawList.add(_objects[5].anim->frameIndices[0], _trackBarX, 208, 100);
+
+ if (_playerMode != 0) {
+ for (int i = 36; i < _vuMeterLeft2 + 36; ++i) {
+ int frameIndex = 0;
+ if (i >= 45)
+ frameIndex = 3;
+ else if (i >= 43)
+ frameIndex = 2;
+ else if (i >= 41)
+ frameIndex = 1;
+ drawList.add(_objects[i].anim->frameIndices[frameIndex], kPointsTbl1[i - 36].x, kPointsTbl1[i - 36].y, 254);
+ }
+ for (int i = 47; i < _vuMeterRight2 + 47; ++i) {
+ int frameIndex = 0;
+ if (i >= 56)
+ frameIndex = 3;
+ else if (i >= 54)
+ frameIndex = 2;
+ else if (i >= 52)
+ frameIndex = 1;
+ drawList.add(_objects[i].anim->frameIndices[frameIndex], kPointsTbl2[i - 47].x, kPointsTbl2[i - 47].y, 254);
+ }
+ }
+
+ if (_backgroundSpriteIndex > 0)
+ drawList.add(_backgroundSpriteIndex, 0, 0, 0);
+
+}
+
+void MinigameBbAirGuitar::drawSprites() {
+ DrawList drawList;
+ buildDrawList(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ _vm->_screen->copyToScreen();
+}
+
+void MinigameBbAirGuitar::initObjs() {
+ for (int i = 0; i < kMaxObjectsCount; ++i)
+ _objects[i].kind = 0;
+}
+
+MinigameBbAirGuitar::Obj *MinigameBbAirGuitar::getFreeObject() {
+ for (int i = 0; i < kMaxObjectsCount; ++i)
+ if (_objects[i].kind == 0)
+ return &_objects[i];
+ return 0;
+}
+
+void MinigameBbAirGuitar::initObjects() {
+ switch (_gameState) {
+ case 0:
+ initObjects0();
+ break;
+ case 1:
+ initObjects1();
+ break;
+ }
+}
+
+void MinigameBbAirGuitar::initObjects0() {
+ _objects[0].anim = getAnimation(0);
+ _objects[0].frameIndex = 0;
+ _objects[0].ticks = getAnimation(0)->frameTicks[0];
+ _objects[0].x = 160;
+ _objects[0].y = 120;
+ _objects[0].kind = 1;
+ _objects[1].anim = getAnimation(37);
+ _objects[1].frameIndex = 0;
+ _objects[1].ticks = getAnimation(37)->frameTicks[0];
+ _objects[1].x = 40;
+ _objects[1].y = 240;
+ _objects[1].kind = 2;
+ _objects[2].anim = getAnimation(36);
+ _objects[2].frameIndex = 0;
+ _objects[2].ticks = getAnimation(36)->frameTicks[0];
+ _objects[2].x = 280;
+ _objects[2].y = 240;
+ _objects[2].kind = 2;
+
+}
+
+void MinigameBbAirGuitar::initObjects1() {
+
+ for (int i = 0; i < 60; ++i)
+ _objects[i].kind = 0;
+
+ _objects[0].kind = 0;
+ _objects[0].kind = 1;
+ _objects[0].anim = getAnimation(0);
+ _objects[0].ticks = getAnimation(0)->frameTicks[0];
+ _objects[1].anim = getAnimation(1);
+ _objects[1].ticks = getAnimation(1)->frameTicks[0];
+ _objects[2].anim = getAnimation(2);
+ _objects[2].ticks = getAnimation(2)->frameTicks[0];
+ _objects[3].anim = getAnimation(3);
+ _objects[3].ticks = getAnimation(3)->frameTicks[0];
+ _objects[4].anim = getAnimation(4);
+ _objects[4].ticks = getAnimation(4)->frameTicks[0];
+ _objects[5].anim = getAnimation(5);
+ _objects[5].ticks = getAnimation(5)->frameTicks[0];
+ _objects[6].anim = getAnimation(6);
+ _objects[6].ticks = getAnimation(6)->frameTicks[0];
+ _objects[7].anim = getAnimation(8);
+ _objects[7].ticks = getAnimation(8)->frameTicks[0];
+ _objects[8].anim = getAnimation(9);
+ _objects[8].ticks = getAnimation(9)->frameTicks[0];
+ _objects[9].anim = getAnimation(10);
+ _objects[9].ticks = getAnimation(10)->frameTicks[0];
+ _objects[10].anim = getAnimation(11);
+ _objects[10].ticks = getAnimation(11)->frameTicks[0];
+ _objects[11].anim = getAnimation(12);
+ _objects[11].ticks = getAnimation(12)->frameTicks[0];
+ _objects[12].anim = getAnimation(13);
+ _objects[12].ticks = getAnimation(13)->frameTicks[0];
+ _objects[13].anim = getAnimation(14);
+ _objects[13].ticks = getAnimation(14)->frameTicks[0];
+ _objects[14].anim = getAnimation(15);
+ _objects[14].ticks = getAnimation(15)->frameTicks[0];
+ _objects[15].anim = getAnimation(16);
+ _objects[15].ticks = getAnimation(16)->frameTicks[0];
+ _objects[16].anim = getAnimation(17);
+ _objects[16].ticks = getAnimation(17)->frameTicks[0];
+ _objects[17].anim = getAnimation(18);
+ _objects[17].ticks = getAnimation(18)->frameTicks[0];
+ _objects[18].anim = getAnimation(19);
+ _objects[18].ticks = getAnimation(19)->frameTicks[0];
+ _objects[19].anim = getAnimation(20);
+ _objects[19].ticks = getAnimation(20)->frameTicks[0];
+ _objects[20].anim = getAnimation(21);
+ _objects[20].ticks = getAnimation(21)->frameTicks[0];
+ _objects[21].anim = getAnimation(11);
+ _objects[21].ticks = getAnimation(11)->frameTicks[0];
+ _objects[22].anim = getAnimation(22);
+ _objects[22].ticks = getAnimation(22)->frameTicks[0];
+ _objects[23].anim = getAnimation(23);
+ _objects[23].ticks = getAnimation(23)->frameTicks[0];
+ _objects[24].anim = getAnimation(24);
+ _objects[24].ticks = getAnimation(24)->frameTicks[0];
+ _objects[25].anim = getAnimation(25);
+ _objects[25].ticks = getAnimation(25)->frameTicks[0];
+ _objects[26].anim = getAnimation(26);
+ _objects[26].ticks = getAnimation(26)->frameTicks[0];
+ _objects[27].anim = getAnimation(27);
+ _objects[27].ticks = getAnimation(27)->frameTicks[0];
+ _objects[28].anim = getAnimation(28);
+ _objects[28].ticks = getAnimation(28)->frameTicks[0];
+ _objects[29].anim = getAnimation(29);
+ _objects[29].ticks = getAnimation(29)->frameTicks[0];
+ _objects[30].anim = getAnimation(30);
+ _objects[30].ticks = getAnimation(30)->frameTicks[0];
+ _objects[31].anim = getAnimation(31);
+ _objects[31].ticks = getAnimation(31)->frameTicks[0];
+ _objects[32].anim = getAnimation(32);
+ _objects[32].ticks = getAnimation(32)->frameTicks[0];
+ _objects[33].anim = getAnimation(33);
+ _objects[33].ticks = getAnimation(33)->frameTicks[0];
+ _objects[34].anim = getAnimation(34);
+ _objects[34].ticks = getAnimation(34)->frameTicks[0];
+ _objects[35].anim = getAnimation(35);
+ _objects[35].ticks = getAnimation(35)->frameTicks[0];
+
+ for (int i = 36; i <= 57; ++i) {
+ _objects[i].anim = getAnimation(7);
+ _objects[i].ticks = getAnimation(7)->frameTicks[0];
+ }
+
+ for (int i = 1; i <= 35; ++i) {
+ _objects[i].x = kObjPoints[i - 1].x;
+ _objects[i].y = kObjPoints[i - 1].y;
+ }
+
+ _objects[22].kind = 1;
+ _objects[6].kind = 1;
+ _objects[26].kind = 1;
+ _objects[26].frameIndex = 3;
+ _objects[27].kind = 1;
+ _objects[27].frameIndex = 3;
+ _objects[31].kind = 1;
+ _objects[31].frameIndex = 3;
+ _objects[32].kind = 1;
+ _objects[32].frameIndex = 3;
+ _objects[28].kind = 1;
+ _objects[33].kind = 1;
+ _objects[34].kind = 1;
+ _objects[35].kind = 1;
+
+ _track[0].noteNum = -1;
+ stop();
+ changePatch(0);
+
+}
+
+bool MinigameBbAirGuitar::updateStatus(int mouseX, int mouseY, uint mouseButtons) {
+ switch (_gameState) {
+ case 0:
+ return updateStatus0(mouseX, mouseY, mouseButtons);
+ case 1:
+ return updateStatus1(mouseX, mouseY, mouseButtons);
+ }
+ return false;
+}
+
+bool MinigameBbAirGuitar::updateStatus0(int mouseX, int mouseY, uint mouseButtons) {
+
+ if (mouseButtons & kAnyButtonDown) {
+ stopSound(1);
+ _rockTunePlaying = false;
+ _gameState = 1;
+ initObjects();
+ _gameTicks = 0;
+ } else {
+
+ if (!_rockTunePlaying) {
+ _rockTunePlaying = true;
+ playSound(1, true);
+ }
+
+ _objects[0].x = mouseX;
+ _objects[0].y = mouseY;
+
+ for (int i = 1; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind && --obj->ticks == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex >= obj->anim->frameCount)
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[obj->frameIndex];
+ }
+ }
+
+ }
+
+ return true;
+}
+
+bool MinigameBbAirGuitar::updateStatus1(int mouseX, int mouseY, uint mouseButtons) {
+
+ int currTicks = _vm->_system->getMillis();
+
+ if (_playerMode == 1 && _track[_trackIndex].ticks <= currTicks - _noteStartTime) {
+ noteOff(_track[_trackIndex].noteNum);
+ if (_trackIndex < _trackCount && _track[++_trackIndex].noteNum != -1)
+ noteOn(_track[_trackIndex].noteNum);
+ else
+ stop();
+ }
+
+ if (_vuMeterLeft1 - 2 <= _vuMeterLeft2) {
+ if (_vuMeterLeft1 + 1 >= _vuMeterLeft2) {
+ int incr = MIN(_vm->getRandom(4), 2) - 1;
+ if (incr < 0 && _vuMeterLeft2 == 0)
+ incr = -incr;
+ if (incr > 0 && _vuMeterLeft2 == 11)
+ incr = -incr;
+ _vuMeterLeft2 += incr;
+ } else {
+ --_vuMeterLeft2;
+ }
+ } else {
+ ++_vuMeterLeft2;
+ }
+
+ if (_vuMeterRight1 - 2 <= _vuMeterRight2) {
+ if (_vuMeterRight1 + 1 >= _vuMeterRight2) {
+ int incr = MIN(_vm->getRandom(4), 2) - 1;
+ if (incr < 0 && _vuMeterRight2 == 0)
+ incr = -incr;
+ if (incr > 0 && _vuMeterRight2 == 11)
+ incr = -incr;
+ _vuMeterRight2 += incr;
+ } else {
+ --_vuMeterRight2;
+ }
+ } else {
+ ++_vuMeterRight2;
+ }
+
+ if (_resetAnims && _vm->_system->getMillis() - _noteStartTime >= 1000)
+ resetObjs();
+
+ _objects[0].x = mouseX;
+ _objects[0].y = mouseY;
+
+ _trackBarMouseX = CLIP(mouseX, kTrackBarMinX, kTrackBarMaxX);
+
+ bool checkClick = false;
+
+ if (mouseButtons & kAnyButtonClicked) {
+ checkClick = true;
+ } else if (!(mouseButtons & kAnyButtonDown)) {
+ afterButtonReleased();
+ } else if (!_movingTrackBar && ((_currButtonNum >= 14 && ptInPoly(_currPianoKeyArea, mouseX, mouseY)) || ptInRect(_currPlayerButtonRect, mouseX, mouseY))) {
+ if (_currButtonNum == 5 && _trackIndex > 0) {
+ --_trackIndex;
+ calcTotalTicks2();
+ } else if (_currButtonNum == 13 && _trackIndex < _trackCount) {
+ ++_trackIndex;
+ calcTotalTicks2();
+ }
+ } else if (!_movingTrackBar)
+ checkClick = true;
+
+ if (checkClick) {
+
+ afterButtonReleased();
+ _objects[0].frameIndex = 1;
+
+ if (ptInRect(&kRect2, mouseX, mouseY)) {
+
+ if (_playerMode != 1 && ptInRect(&kPianoRect, mouseX, mouseY)) {
+ for (int i = 0; i <= 12; ++i) {
+ if (ptInPoly(&kPianoKeyAreas[i], mouseX, mouseY)) {
+ _currButtonNum = i + 14;
+ _currPianoKeyArea = &kPianoKeyAreas[i];
+ _objects[11].kind = 1;
+ _objects[11].x = kPianoKeyInfos[i].x;
+ _objects[11].y = kPianoKeyInfos[i].y;
+ _objects[11].frameIndex = kPianoKeyInfos[i].frameIndex;
+ noteOn(i);
+ break;
+ }
+ }
+ } else if (_playerMode != 1 && ptInRect(&_trackBarThumbRect, mouseX, mouseY)) {
+ _movingTrackBar = true;
+ } else {
+
+ int playerButtonNum = -1;
+ for (int i = 0; i < 14; ++i) {
+ if (ptInRect(&kPlayerButtonRects[i], mouseX, mouseY)) {
+ playerButtonNum = i;
+ break;
+ }
+ }
+
+ if (playerButtonNum >= 0) {
+ _currButtonNum = playerButtonNum;
+ _currPlayerButtonRect = &kPlayerButtonRects[playerButtonNum];
+
+ switch (playerButtonNum) {
+
+ case 0:
+ if (_playerMode == 0) {
+ changePatch(0);
+ _currFrameIndex = &_objects[18 + 0].frameIndex;
+ *_currFrameIndex = 0;
+ }
+ break;
+
+ case 1:
+ if (_playerMode == 0) {
+ changePatch(1);
+ _currFrameIndex = &_objects[18 + 1].frameIndex;
+ *_currFrameIndex = 0;
+ }
+ break;
+
+ case 2:
+ if (_playerMode == 0) {
+ changePatch(2);
+ _currFrameIndex = &_objects[18 + 2].frameIndex;
+ *_currFrameIndex = 0;
+ }
+ break;
+
+ case 3:
+ _btn3KindToggle = !_btn3KindToggle;
+ _objects[9].kind = _btn3KindToggle ? 0 : 1;
+ _objects[22].frameIndex = _btn3KindToggle ? 0 : 1;
+ break;
+
+ case 4:
+ if (_playerMode == 0) {
+ _objects[1].kind = 1;
+ _currFrameIndex = &_objects[1].frameIndex;
+ _objects[1].frameIndex = 0;
+ }
+ break;
+
+ case 5:
+ if (_playerMode == 0) {
+ if (_trackIndex > 0)
+ --_trackIndex;
+ _objects[3].kind = 1;
+ calcTotalTicks2();
+ }
+ break;
+
+ case 6:
+ stop();
+ _currFrameIndex = &_objects[15].frameIndex;
+ _objects[15].frameIndex = 0;
+ break;
+
+ case 7:
+ if (_playerMode == 0) {
+ play();
+ _currFrameIndex = &_objects[12].frameIndex;
+ _objects[12].frameIndex = 0;
+ }
+ break;
+
+ case 8:
+ if (_playerMode == 0) {
+ _trackIndex = 0;
+ _objects[16].kind = 1;
+ calcTotalTicks2();
+ }
+ break;
+
+ case 9:
+ if (_playerMode == 0) {
+ _trackIndex = _trackCount;
+ _objects[17].kind = 1;
+ calcTotalTicks2();
+ }
+ break;
+
+ case 10:
+ if (_playerMode == 0) {
+ record();
+ _currFrameIndex = &_objects[13].frameIndex;
+ _objects[13].frameIndex = 0;
+ }
+ break;
+
+ case 11:
+ if (_playerMode == 0) {
+ setPlayerMode3();
+ _currFrameIndex = &_objects[14].frameIndex;
+ _objects[14].frameIndex = 0;
+ }
+ break;
+
+ case 12:
+ if (_playerMode == 0) {
+ _objects[2].kind = 1;
+ _currFrameIndex = &_objects[2].frameIndex;
+ _objects[2].frameIndex = 0;
+ }
+ break;
+
+ case 13:
+ if (_playerMode == 0) {
+ if (_trackIndex < _trackCount)
+ ++_trackIndex;
+ _objects[4].kind = 1;
+ calcTotalTicks2();
+ }
+ break;
+
+ }
+ }
+ }
+ }
+ }
+
+ if (_playerMode != 0) {
+ _currTrackPos = currTicks + _actionStartTrackPos - _actionStartTime;
+ if (_currTrackPos > _actionTrackPos && _playerMode != 1) {
+ if (_currTrackPos >= 15000) {
+ _currTrackPos = 15000;
+ _actionTrackPos = 15000;
+ stop();
+ } else {
+ _actionTrackPos = currTicks + _actionStartTrackPos - _actionStartTime;
+ }
+ }
+ }
+
+ if (_buttonClickTicks + 1000 < currTicks)
+ _buttonClickTicks = currTicks;
+
+ int newKind = _buttonClickTicks + 500 < currTicks ? 1 : 0;
+
+ switch (_playerMode) {
+
+ case 1:
+ if (_currButtonNum == 7) {
+ _objects[12].kind = 1;
+ _objects[12].frameIndex = 0;
+ } else {
+ _objects[12].kind = newKind;
+ _objects[12].frameIndex = 1;
+ }
+ break;
+
+ case 2:
+ if (_currButtonNum == 10) {
+ _objects[13].kind = 1;
+ _objects[13].frameIndex = 0;
+ } else {
+ _objects[13].kind = newKind;
+ _objects[13].frameIndex = 1;
+ }
+ break;
+
+ case 3:
+ if (_currButtonNum == 11) {
+ _objects[14].kind = 1;
+ _objects[14].frameIndex = 0;
+ } else {
+ _objects[14].kind = newKind;
+ _objects[14].frameIndex = 1;
+ }
+ break;
+
+ }
+
+ updateObjs();
+
+ return true;
+}
+
+void MinigameBbAirGuitar::updateObjs() {
+ for (int i = 24; i <= 33; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind && --obj->ticks == 0) {
+ if (obj->frameIndex + 1 >= obj->anim->frameCount) {
+ obj->ticks = -1;
+ } else {
+ ++obj->frameIndex;
+ obj->ticks = obj->anim->frameTicks[obj->frameIndex];
+ }
+ }
+ }
+}
+
+int MinigameBbAirGuitar::run(uint flags) {
+
+ memset(_objects, 0, sizeof(_objects));
+
+ _currPatchNum = -1;
+ _btn3KindToggle = 0;
+ _currButtonNum = 27;
+ _actionStartTime = 0;
+ _currFrameIndex = 0;
+ _currPlayerButtonRect = 0;
+ _currPianoKeyArea = 0;
+ _trackCount = 0;
+ _trackIndex = 0;
+ _totalTrackLength = 0;
+ _actionTrackPos = 0;
+ _noteStartTime = 0;
+ _actionStartTrackPos = 0;
+ _trackBarX = kTrackBarMinX;
+ _currTrackPos = 0;
+ _currNoteNum = -2;
+ _resetAnims = false;
+ _vuMeterLeft2 = 0;
+ _vuMeterRight2 = 0;
+ _vuMeterLeft1 = 0;
+ _vuMeterRight1 = 0;
+ _rockTunePlaying = false;
+
+ _backgroundSpriteIndex = 97;
+ _titleScreenSpriteIndex = 98;
+
+ _fromMainGame = false;
+ if (flags & 1)
+ _fromMainGame = true;
+
+ _gameState = 0;
+ _gameTicks = 0;
+ _gameResult = 0;
+ _gameDone = false;
+ initObjects();
+
+ _spriteModule = new SpriteModule();
+ _spriteModule->load("bbairg/bbairg.000");
+
+ Palette palette = _spriteModule->getPalette();
+ _vm->_screen->setPalette(palette);
+
+ loadSounds();
+
+ while (!_vm->shouldQuit() &&!_gameDone) {
+ _vm->updateEvents();
+ update();
+ }
+
+ // Unload sounds
+ _vm->_sound->unloadSounds();
+
+ delete _spriteModule;
+
+ return _gameResult;
+}
+
+void MinigameBbAirGuitar::update() {
+
+ int currTicks, inputTicks;
+
+ if (_gameTicks > 0) {
+ currTicks = _vm->_system->getMillis();
+ inputTicks = 3 * (currTicks - _gameTicks) / 50;
+ _gameTicks = currTicks - (currTicks - _gameTicks - 50 * inputTicks / 3);
+ } else {
+ inputTicks = 1;
+ _gameTicks = _vm->_system->getMillis();
+ }
+
+ if (_vm->_keyCode == Common::KEYCODE_ESCAPE) {
+ _gameDone = true;
+ return;
+ }
+
+ if (inputTicks == 0)
+ return;
+
+ bool done;
+
+ do {
+ done = !updateStatus(_vm->_mouseX, _vm->_mouseY, _vm->_mouseButtons);
+ _vm->_mouseButtons &= ~kLeftButtonClicked;
+ _vm->_mouseButtons &= ~kRightButtonClicked;
+ _vm->_keyCode = Common::KEYCODE_INVALID;
+ } while (--inputTicks && _gameTicks > 0 && !done);
+
+ drawSprites();
+
+}
+
+void MinigameBbAirGuitar::play() {
+ if (_track[_trackIndex].noteNum != -1) {
+ _playerMode = 1;
+ _objects[7].kind = 1;
+ _objects[8].kind = 0;
+ _objects[15].kind = 0;
+ _actionStartTime = _vm->_system->getMillis();
+ _actionStartTrackPos = _currTrackPos;
+ noteOn(_track[_trackIndex].noteNum);
+ }
+}
+
+
+void MinigameBbAirGuitar::record() {
+ _playerMode = 2;
+ _objects[7].kind = 1;
+ _objects[8].kind = 0;
+ _objects[15].kind = 0;
+ _totalTrackLength = 15000;
+ _actionStartTime = _vm->_system->getMillis();
+ _actionStartTrackPos = _currTrackPos;
+ _noteStartTime = _vm->_system->getMillis();
+ _actionTrackPos = _currTrackPos;
+ _trackCount = _trackIndex;
+ _vuMeterRight1 = 0;
+ _vuMeterRight2 = 0;
+ _vuMeterLeft1 = 0;
+ _vuMeterLeft2 = 0;
+ _modified = true;
+ _track[_trackIndex].noteNum = -2;
+}
+
+void MinigameBbAirGuitar::setPlayerMode3() {
+ _playerMode = 3;
+ _objects[7].kind = 1;
+ _objects[8].kind = 0;
+ _objects[15].kind = 0;
+ _totalTrackLength = 15000;
+ _actionStartTime = _vm->_system->getMillis();
+ _actionStartTrackPos = _currTrackPos;
+ _noteStartTime = _vm->_system->getMillis();
+ _actionTrackPos = _currTrackPos;
+ _trackCount = _trackIndex;
+ _vuMeterRight1 = 0;
+ _vuMeterRight2 = 0;
+ _vuMeterLeft1 = 0;
+ _vuMeterLeft2 = 0;
+ _modified = true;
+ _track[_trackIndex].noteNum = -2;
+}
+
+void MinigameBbAirGuitar::stop() {
+ noteOff(_currNoteNum);
+ if (_playerMode == 2 || _playerMode == 3) {
+ _totalTrackLength = _actionTrackPos;
+ _track[_trackCount].noteNum = -1;
+ }
+ _playerMode = 0;
+ _objects[7].kind = 0;
+ _objects[8].kind = 1;
+ _objects[15].kind = 1;
+ _objects[15].frameIndex = 1;
+ _objects[12].kind = 0;
+ _objects[13].kind = 0;
+ _objects[14].kind = 0;
+ resetObjs();
+}
+
+void MinigameBbAirGuitar::changePatch(int patchNum) {
+
+ resetObjs();
+
+ if (patchNum == -1 || patchNum != _currPatchNum)
+ _currPatchNum = -1;
+
+ _objects[20].kind = 0;
+ _objects[19].kind = _objects[20].kind;
+ _objects[18].kind = _objects[19].kind;
+ _objects[patchNum + 18].kind = 1;
+ _objects[patchNum + 18].frameIndex = 1;
+ _objects[6].frameIndex = patchNum;
+ _currPatchNum = patchNum;
+}
+
+void MinigameBbAirGuitar::afterButtonReleased() {
+ if (_movingTrackBar) {
+ _movingTrackBar = false;
+ _currTrackPos = _totalTrackLength * (_trackBarX - kTrackBarMinX) / 100;
+ calcTotalTicks1();
+ } else {
+ switch (_currButtonNum) {
+ case 0:
+ case 1:
+ case 2:
+ *_currFrameIndex = 1;
+ break;
+ case 4:
+ *_currFrameIndex = 1;
+ // TODO PostMessageA(hWndParent, WM_COMMAND, 0x9C6Du, 0);
+ break;
+ case 5:
+ _objects[3].kind = 0;
+ break;
+ case 6:
+ *_currFrameIndex = 1;
+ break;
+ case 7:
+ *_currFrameIndex = 1;
+ break;
+ case 8:
+ _objects[16].kind = 0;
+ break;
+ case 9:
+ _objects[17].kind = 0;
+ break;
+ case 10:
+ *_currFrameIndex = 1;
+ break;
+ case 11:
+ *_currFrameIndex = 1;
+ break;
+ case 12:
+ *_currFrameIndex = 1;
+ // TODO PostMessageA(hWndParent, WM_COMMAND, 0x9C6Eu, 0);
+ break;
+ case 13:
+ _objects[4].kind = 0;
+ break;
+ case 14:
+ case 15:
+ case 16:
+ case 17:
+ case 18:
+ case 19:
+ case 20:
+ case 21:
+ case 22:
+ case 23:
+ case 24:
+ case 25:
+ case 26:
+ noteOff(_currButtonNum - 14);
+ break;
+ }
+ }
+
+ _objects->frameIndex = 0;
+ _currPlayerButtonRect = 0;
+ _currPianoKeyArea = 0;
+ _currButtonNum = 27;
+}
+
+void MinigameBbAirGuitar::calcTotalTicks2() {
+ _currTrackPos = 0;
+ for (int i = 0; i < _trackIndex; ++i)
+ _currTrackPos += _track[i].ticks;
+}
+
+void MinigameBbAirGuitar::calcTotalTicks1() {
+ int totalTicks = 0;
+ // TODO Try to clean this up
+ _trackIndex = 0;
+ if (_track[0].ticks <= _currTrackPos) {
+ do {
+ totalTicks += _track[_trackIndex].ticks;
+ if (_trackIndex >= _trackCount)
+ break;
+ ++_trackIndex;
+ } while (totalTicks + _track[_trackIndex].ticks <= _currTrackPos);
+ }
+ _currTrackPos = totalTicks;
+}
+
+void MinigameBbAirGuitar::noteOn(int noteNum) {
+
+ if (_currNoteNum != -2) {
+ if (noteNum == _currNoteNum)
+ return;
+ noteOff(_currNoteNum);
+ }
+
+ if (noteNum == -2) {
+ _vuMeterRight1 = 0;
+ _vuMeterRight2 = 0;
+ _vuMeterLeft1 = 0;
+ _vuMeterLeft2 = 0;
+ } else {
+ playNote(noteNum);
+ _vuMeterRight1 = 10;
+ _vuMeterRight2 = 10;
+ _vuMeterLeft1 = 10;
+ _vuMeterLeft2 = 10;
+ if (_btn3KindToggle) {
+ _objects[23].kind = 1;
+ _objects[23].frameIndex = noteNum;
+ } else {
+ _objects[10].kind = 1;
+ _objects[10].frameIndex = kNoteFrameTbl[noteNum].frameIndex;
+ if (kNoteFrameTbl[noteNum].flag) {
+ _objects[21].kind = 1;
+ _objects[21].frameIndex = 7;
+ }
+ }
+ }
+
+ _currNoteNum = noteNum;
+
+ if (_playerMode == 2 || _playerMode == 3) {
+ _ticksDelta = _vm->_system->getMillis() - _noteStartTime;
+ _track[_trackCount].ticks = _ticksDelta;
+ if (_trackCount < kMaxTracks)
+ ++_trackCount;
+ _track[_trackCount].noteNum = noteNum;
+ }
+
+ _noteStartTime = _vm->_system->getMillis();
+
+ if (noteNum != -2) {
+ _resetAnims = false;
+ if (_currPatchNum == 0) {
+ _objects[25].kind = 1;
+ _objects[28].kind = 0;
+ _objects[25].frameIndex = 0;
+ _objects[25].ticks = getAnimation(25)->frameTicks[0];
+ _objects[26].frameIndex = 0;
+ _objects[26].ticks = getAnimation(26)->frameTicks[0];
+ _objects[27].frameIndex = 0;
+ _objects[27].ticks = getAnimation(27)->frameTicks[0];
+ _objects[30].kind = 1;
+ _objects[33].kind = 0;
+ _objects[30].frameIndex = 0;
+ _objects[30].ticks = getAnimation(30)->frameTicks[0];
+ _objects[31].frameIndex = 0;
+ _objects[31].ticks = getAnimation(31)->frameTicks[0];
+ _objects[32].frameIndex = 0;
+ _objects[32].ticks = getAnimation(32)->frameTicks[0];
+ } else if (_currPatchNum == 1) {
+ _objects[29].kind = 1;
+ _objects[33].kind = 0;
+ _objects[29].frameIndex = 0;
+ _objects[29].ticks = getAnimation(29)->frameTicks[0];
+ _objects[31].frameIndex = 0;
+ _objects[31].ticks = getAnimation(31)->frameTicks[0];
+ _objects[32].frameIndex = 0;
+ _objects[32].ticks = getAnimation(32)->frameTicks[0];
+ } else if (_currPatchNum == 2) {
+ _objects[24].kind = 1;
+ _objects[28].kind = 0;
+ _objects[24].frameIndex = 0;
+ _objects[24].ticks = getAnimation(24)->frameTicks[0];
+ _objects[26].frameIndex = 0;
+ _objects[26].ticks = getAnimation(26)->frameTicks[0];
+ _objects[27].frameIndex = 0;
+ _objects[27].ticks = getAnimation(27)->frameTicks[0];
+ }
+ }
+
+}
+
+void MinigameBbAirGuitar::noteOff(int noteNum) {
+
+ if (_currNoteNum != noteNum)
+ return;
+
+ if (noteNum != -2)
+ stopNote(noteNum);
+
+ _objects[21].kind = 0;
+ _objects[23].kind = _objects[21].kind;
+ _objects[10].kind = _objects[23].kind;
+
+ _vuMeterRight1 = 0;
+ _vuMeterRight2 = 0;
+ _vuMeterLeft1 = 0;
+ _vuMeterLeft2 = 0;
+
+ _currNoteNum = -2;
+
+ _objects[11].kind = 0;
+
+ _ticksDelta = _vm->_system->getMillis() - _noteStartTime;
+
+ if (_playerMode == 2 || _playerMode == 3) {
+ if (_actionTrackPos + _ticksDelta > 15000)
+ _ticksDelta = 15000 - _actionTrackPos;
+ _track[_trackCount].ticks = _ticksDelta;
+ if (_trackCount < 2048)
+ ++_trackCount;
+ _track[_trackCount].noteNum = -2;
+ _noteStartTime = _vm->_system->getMillis();
+ }
+
+ if (noteNum != -2) {
+ if (_playerMode == 0) {
+ _resetAnims = true;
+ _noteStartTime = _vm->_system->getMillis();
+ }
+ if (_currPatchNum == 0) {
+ _objects[25].frameIndex = 3;
+ _objects[25].ticks = -1;
+ _objects[26].frameIndex = 3;
+ _objects[26].ticks = -1;
+ _objects[27].frameIndex = 3;
+ _objects[27].ticks = -1;
+ _objects[30].frameIndex = 3;
+ _objects[30].ticks = -1;
+ _objects[31].frameIndex = 3;
+ _objects[31].ticks = -1;
+ _objects[32].frameIndex = 3;
+ _objects[32].ticks = -1;
+ } else if (_currPatchNum == 1) {
+ _objects[29].frameIndex = 3;
+ _objects[29].ticks = -1;
+ _objects[31].frameIndex = 3;
+ _objects[31].ticks = -1;
+ _objects[32].frameIndex = 3;
+ _objects[32].ticks = -1;
+ } else if (_currPatchNum == 2) {
+ _objects[24].frameIndex = 2;
+ _objects[24].ticks = -1;
+ _objects[26].frameIndex = 3;
+ _objects[26].ticks = -1;
+ _objects[27].frameIndex = 3;
+ _objects[27].ticks = -1;
+ }
+ }
+
+}
+
+void MinigameBbAirGuitar::resetObjs() {
+ _resetAnims = false;
+ _objects[25].kind = 0;
+ _objects[24].kind = 0;
+ _objects[28].kind = 1;
+ _objects[26].frameIndex = 0;
+ _objects[26].ticks = -1;
+ _objects[27].frameIndex = 0;
+ _objects[27].ticks = -1;
+ _objects[30].kind = 0;
+ _objects[29].kind = 0;
+ _objects[33].kind = 1;
+ _objects[31].frameIndex = 0;
+ _objects[31].ticks = -1;
+ _objects[32].frameIndex = 0;
+ _objects[32].ticks = -1;
+}
+
+void MinigameBbAirGuitar::loadSounds() {
+ _vm->_sound->loadSound("bbairg/audio/rocktune.aif");
+ for (uint i = 0; i < kPatchDirectoriesCount; ++i) {
+ const char *patchDirectory = kPatchDirectories[i];
+ for (uint j = 0; j < kNoteSoundFilenamesCount; ++j) {
+ Common::String filename = Common::String::format("bbairg/audio/%s/%s", patchDirectory, kNoteSoundFilenames[j]);
+ _vm->_sound->loadSound(filename.c_str());
+ }
+ }
+}
+
+void MinigameBbAirGuitar::playNote(int noteNum) {
+ if (noteNum >= 0 && _currPatchNum >= 0)
+ playSound(2 + _currPatchNum * kNoteSoundFilenamesCount + noteNum);
+}
+
+void MinigameBbAirGuitar::stopNote(int noteNum) {
+ if (noteNum >= 0 && _currPatchNum >= 0)
+ stopSound(2 + _currPatchNum * kNoteSoundFilenamesCount + noteNum);
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/bbairguitar.h b/engines/bbvs/minigames/bbairguitar.h
new file mode 100644
index 0000000..70ba580
--- /dev/null
+++ b/engines/bbvs/minigames/bbairguitar.h
@@ -0,0 +1,148 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef BBVS_MINIGAMES_BBAIRGUITAR_H
+#define BBVS_MINIGAMES_BBAIRGUITAR_H
+
+#include "bbvs/minigames/minigame.h"
+
+namespace Bbvs {
+
+class MinigameBbAirGuitar : public Minigame {
+public:
+ MinigameBbAirGuitar(BbvsEngine *vm) : Minigame(vm) {};
+ int run(uint flags);
+public:
+
+ struct Obj {
+ int kind;
+ int x, y;
+ int xIncr, yIncr;
+ const ObjAnimation *anim;
+ int frameIndex;
+ int ticks;
+ int status;
+ int16 frameIndexAdd;
+ int16 unk2;
+ };
+
+ enum {
+ kMaxObjectsCount = 256,
+ kMaxTracks = 2049
+ };
+
+ struct PianoKeyInfo {
+ int x, y;
+ int frameIndex;
+ };
+
+ struct TrackEvt {
+ int8 noteNum;
+ int16 ticks;
+ };
+
+ Obj _objects[kMaxObjectsCount];
+
+ int _playerMode;
+
+ bool _modified;
+
+ TrackEvt _track[kMaxTracks];
+ int _trackIndex, _trackCount;
+
+ int _noteStartTime;
+
+ int _vuMeterLeft1, _vuMeterLeft2;
+ int _vuMeterRight1, _vuMeterRight2;
+
+ bool _resetAnims;
+ bool _rockTunePlaying;
+
+ int _currButtonNum;
+ int _buttonClickTicks;
+
+ int *_currFrameIndex;
+ int _btn3KindToggle;
+
+ const BBPolygon *_currPianoKeyArea;
+ const Rect *_currPlayerButtonRect;
+
+ bool _movingTrackBar;
+ int _trackBarMouseX;
+ int _trackBarX;
+ Rect _trackBarThumbRect;
+
+ int _currTrackPos, _totalTrackLength;
+ int _ticksDelta;
+
+ int _actionStartTrackPos, _actionTrackPos;
+ int _actionStartTime;
+
+ int _currNoteNum;
+ int _currPatchNum;
+
+ const ObjAnimation *getAnimation(int animIndex);
+ bool ptInRect(const Rect *r, int x, int y);
+ bool ptInPoly(const BBPolygon *poly, int x, int y);
+
+ void buildDrawList(DrawList &drawList);
+ void buildDrawList0(DrawList &drawList);
+ void buildDrawList1(DrawList &drawList);
+
+ void drawSprites();
+
+ void initObjs();
+ Obj *getFreeObject();
+
+ void initObjects();
+ void initObjects0();
+ void initObjects1();
+
+ bool updateStatus(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus0(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus1(int mouseX, int mouseY, uint mouseButtons);
+
+ void updateObjs();
+
+ void update();
+
+ void play();
+ void record();
+ void setPlayerMode3();
+ void stop();
+ void changePatch(int patchNum);
+ void afterButtonReleased();
+ void calcTotalTicks2();
+ void calcTotalTicks1();
+ void noteOn(int noteNum);
+ void noteOff(int noteNum);
+ void resetObjs();
+
+ void loadSounds();
+ void playNote(int noteNum);
+ void stopNote(int noteNum);
+
+};
+
+} // End of namespace Bbvs
+
+#endif // BBVS_H
diff --git a/engines/bbvs/minigames/bbairguitar_anims.cpp b/engines/bbvs/minigames/bbairguitar_anims.cpp
new file mode 100644
index 0000000..4f87eb5
--- /dev/null
+++ b/engines/bbvs/minigames/bbairguitar_anims.cpp
@@ -0,0 +1,186 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/minigames/bbairguitar.h"
+
+namespace Bbvs {
+
+static const int kAnim0FrameIndices[] = {0, 1};
+static const int16 kAnim0FrameTicks[] = {6, 6};
+static const BBRect kAnim0FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim1FrameIndices[] = {2, 3};
+static const int16 kAnim1FrameTicks[] = {6, 6};
+static const BBRect kAnim1FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim2FrameIndices[] = {4, 5};
+static const int16 kAnim2FrameTicks[] = {6, 6};
+static const BBRect kAnim2FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim3FrameIndices[] = {6};
+static const int16 kAnim3FrameTicks[] = {6};
+static const BBRect kAnim3FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim4FrameIndices[] = {7};
+static const int16 kAnim4FrameTicks[] = {6};
+static const BBRect kAnim4FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim5FrameIndices[] = {8};
+static const int16 kAnim5FrameTicks[] = {6};
+static const BBRect kAnim5FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim6FrameIndices[] = {9, 10, 11};
+static const int16 kAnim6FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim6FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim7FrameIndices[] = {12, 13, 14, 15};
+static const int16 kAnim7FrameTicks[] = {10, 10, 10, 10};
+static const BBRect kAnim7FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim8FrameIndices[] = {16};
+static const int16 kAnim8FrameTicks[] = {10};
+static const BBRect kAnim8FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim9FrameIndices[] = {17};
+static const int16 kAnim9FrameTicks[] = {10};
+static const BBRect kAnim9FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim10FrameIndices[] = {18};
+static const int16 kAnim10FrameTicks[] = {6};
+static const BBRect kAnim10FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim11FrameIndices[] = {19, 20, 21, 22, 23, 24, 25, 26, 27};
+static const int16 kAnim11FrameTicks[] = {6, 6, 6, 6, 6, 6, 6, 6, 6};
+static const BBRect kAnim11FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim12FrameIndices[] = {28, 29, 30, 31, 32, 33};
+static const int16 kAnim12FrameTicks[] = {10, 10, 10, 10, 10, 10};
+static const BBRect kAnim12FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim13FrameIndices[] = {34, 35};
+static const int16 kAnim13FrameTicks[] = {6, 6};
+static const BBRect kAnim13FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim14FrameIndices[] = {36, 37};
+static const int16 kAnim14FrameTicks[] = {6, 6};
+static const BBRect kAnim14FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim15FrameIndices[] = {38, 39};
+static const int16 kAnim15FrameTicks[] = {6, 6};
+static const BBRect kAnim15FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim16FrameIndices[] = {40, 41};
+static const int16 kAnim16FrameTicks[] = {6, 6};
+static const BBRect kAnim16FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim17FrameIndices[] = {42};
+static const int16 kAnim17FrameTicks[] = {6};
+static const BBRect kAnim17FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim18FrameIndices[] = {43};
+static const int16 kAnim18FrameTicks[] = {6};
+static const BBRect kAnim18FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim19FrameIndices[] = {44, 45};
+static const int16 kAnim19FrameTicks[] = {6, 6};
+static const BBRect kAnim19FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim20FrameIndices[] = {46, 47};
+static const int16 kAnim20FrameTicks[] = {6, 6};
+static const BBRect kAnim20FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim21FrameIndices[] = {48, 49};
+static const int16 kAnim21FrameTicks[] = {6, 6};
+static const BBRect kAnim21FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim22FrameIndices[] = {50, 51};
+static const int16 kAnim22FrameTicks[] = {10, 10};
+static const BBRect kAnim22FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim23FrameIndices[] = {52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64};
+static const int16 kAnim23FrameTicks[] = {8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8};
+static const BBRect kAnim23FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim24FrameIndices[] = {65, 66, 67};
+static const int16 kAnim24FrameTicks[] = {11, 16, 6};
+static const BBRect kAnim24FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim25FrameIndices[] = {68, 67, 69, 67};
+static const int16 kAnim25FrameTicks[] = {6, 6, 11, 6};
+static const BBRect kAnim25FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim26FrameIndices[] = {70, 71, 72, 71};
+static const int16 kAnim26FrameTicks[] = {6, 6, 6, 6};
+static const BBRect kAnim26FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim27FrameIndices[] = {73, 74, 75, 74};
+static const int16 kAnim27FrameTicks[] = {6, 6, 6, 6};
+static const BBRect kAnim27FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim28FrameIndices[] = {76};
+static const int16 kAnim28FrameTicks[] = {6};
+static const BBRect kAnim28FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim29FrameIndices[] = {77, 78, 79, 78};
+static const int16 kAnim29FrameTicks[] = {6, 6, 18, 6};
+static const BBRect kAnim29FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim30FrameIndices[] = {77, 80, 81, 80};
+static const int16 kAnim30FrameTicks[] = {6, 6, 10, 6};
+static const BBRect kAnim30FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim31FrameIndices[] = {82, 83, 84, 83};
+static const int16 kAnim31FrameTicks[] = {6, 6, 6, 6};
+static const BBRect kAnim31FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim32FrameIndices[] = {85, 86, 87, 86};
+static const int16 kAnim32FrameTicks[] = {6, 6, 6, 6};
+static const BBRect kAnim32FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim33FrameIndices[] = {88};
+static const int16 kAnim33FrameTicks[] = {6};
+static const BBRect kAnim33FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim34FrameIndices[] = {89};
+static const int16 kAnim34FrameTicks[] = {6};
+static const BBRect kAnim34FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim35FrameIndices[] = {90};
+static const int16 kAnim35FrameTicks[] = {6};
+static const BBRect kAnim35FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim36FrameIndices[] = {91, 92, 93, 91, 93, 91, 92, 93, 92, 91, 92, 93, 91, 93, 91, 92, 93, 92};
+static const int16 kAnim36FrameTicks[] = {10, 6, 8, 6, 6, 8, 6, 6, 6, 10, 6, 8, 6, 6, 8, 6, 6, 6};
+static const BBRect kAnim36FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim37FrameIndices[] = {94, 95, 96, 94, 96, 94, 95, 96, 95, 94, 95, 96, 94, 96, 94, 95, 96, 95};
+static const int16 kAnim37FrameTicks[] = {10, 6, 8, 6, 6, 8, 6, 6, 6, 10, 6, 8, 6, 6, 8, 6, 6, 6};
+static const BBRect kAnim37FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const ObjAnimation kAnimations[] = {
+ {2, kAnim0FrameIndices, kAnim0FrameTicks, kAnim0FrameRects},
+ {2, kAnim1FrameIndices, kAnim1FrameTicks, kAnim1FrameRects},
+ {2, kAnim2FrameIndices, kAnim2FrameTicks, kAnim2FrameRects},
+ {1, kAnim3FrameIndices, kAnim3FrameTicks, kAnim3FrameRects},
+ {1, kAnim4FrameIndices, kAnim4FrameTicks, kAnim4FrameRects},
+ {1, kAnim5FrameIndices, kAnim5FrameTicks, kAnim5FrameRects},
+ {3, kAnim6FrameIndices, kAnim6FrameTicks, kAnim6FrameRects},
+ {4, kAnim7FrameIndices, kAnim7FrameTicks, kAnim7FrameRects},
+ {1, kAnim8FrameIndices, kAnim8FrameTicks, kAnim8FrameRects},
+ {1, kAnim9FrameIndices, kAnim9FrameTicks, kAnim9FrameRects},
+ {1, kAnim10FrameIndices, kAnim10FrameTicks, kAnim10FrameRects},
+ {9, kAnim11FrameIndices, kAnim11FrameTicks, kAnim11FrameRects},
+ {6, kAnim12FrameIndices, kAnim12FrameTicks, kAnim12FrameRects},
+ {2, kAnim13FrameIndices, kAnim13FrameTicks, kAnim13FrameRects},
+ {2, kAnim14FrameIndices, kAnim14FrameTicks, kAnim14FrameRects},
+ {2, kAnim15FrameIndices, kAnim15FrameTicks, kAnim15FrameRects},
+ {2, kAnim16FrameIndices, kAnim16FrameTicks, kAnim16FrameRects},
+ {1, kAnim17FrameIndices, kAnim17FrameTicks, kAnim17FrameRects},
+ {1, kAnim18FrameIndices, kAnim18FrameTicks, kAnim18FrameRects},
+ {2, kAnim19FrameIndices, kAnim19FrameTicks, kAnim19FrameRects},
+ {2, kAnim20FrameIndices, kAnim20FrameTicks, kAnim20FrameRects},
+ {2, kAnim21FrameIndices, kAnim21FrameTicks, kAnim21FrameRects},
+ {2, kAnim22FrameIndices, kAnim22FrameTicks, kAnim22FrameRects},
+ {13, kAnim23FrameIndices, kAnim23FrameTicks, kAnim23FrameRects},
+ {3, kAnim24FrameIndices, kAnim24FrameTicks, kAnim24FrameRects},
+ {4, kAnim25FrameIndices, kAnim25FrameTicks, kAnim25FrameRects},
+ {4, kAnim26FrameIndices, kAnim26FrameTicks, kAnim26FrameRects},
+ {4, kAnim27FrameIndices, kAnim27FrameTicks, kAnim27FrameRects},
+ {1, kAnim28FrameIndices, kAnim28FrameTicks, kAnim28FrameRects},
+ {4, kAnim29FrameIndices, kAnim29FrameTicks, kAnim29FrameRects},
+ {4, kAnim30FrameIndices, kAnim30FrameTicks, kAnim30FrameRects},
+ {4, kAnim31FrameIndices, kAnim31FrameTicks, kAnim31FrameRects},
+ {4, kAnim32FrameIndices, kAnim32FrameTicks, kAnim32FrameRects},
+ {1, kAnim33FrameIndices, kAnim33FrameTicks, kAnim33FrameRects},
+ {1, kAnim34FrameIndices, kAnim34FrameTicks, kAnim34FrameRects},
+ {1, kAnim35FrameIndices, kAnim35FrameTicks, kAnim35FrameRects},
+ {18, kAnim36FrameIndices, kAnim36FrameTicks, kAnim36FrameRects},
+ {18, kAnim37FrameIndices, kAnim37FrameTicks, kAnim37FrameRects}
+};
+
+const ObjAnimation *MinigameBbAirGuitar::getAnimation(int animIndex) {
+ return &kAnimations[animIndex];
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/bbant.cpp b/engines/bbvs/minigames/bbant.cpp
new file mode 100644
index 0000000..24dbd45
--- /dev/null
+++ b/engines/bbvs/minigames/bbant.cpp
@@ -0,0 +1,1340 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/minigames/bbant.h"
+
+namespace Bbvs {
+
+struct Point {
+ int x, y;
+};
+
+static const Point kPosIncrTbl1[] = {
+ {0, -1}, {-1, -1}, {-1, 0}, {-1, 1},
+ { 0, 1}, { 1, 1}, { 1, 0}, { 1, -1}
+};
+
+static const Point kPosIncrTbl2[] = {
+ {0, -2}, {-2, -2}, {-2, 0}, {-2, 2},
+ { 0, 2}, { 2, 2}, { 2, 0}, { 2, -2}
+};
+
+static const int kScoreTbl[] = {
+ 0, 1, 1, 3, 2, 4
+};
+
+static const char *kSoundFilenames[] = {
+ "ant1.aif", "ant2.aif", "ant3.aif", "ant4.aif", "ant5.aif",
+ "ant6.aif", "ant7.aif", "ant8.aif", "ant9.aif", "ant10.aif",
+ "ant11.aif", "antmus1.aif", "fryant.aif", "stomp.aif", "bing.aif",
+ "bvyell.aif"
+};
+
+static const uint kSoundFilenamesCount = ARRAYSIZE(kSoundFilenames);
+
+static const uint kSoundTbl1[] = {
+ 2, 3, 4, 6
+};
+
+static const uint kSoundTbl2[] = {
+ 5, 7, 11
+};
+
+static const uint kSoundTbl3[] = {
+ 8, 10, 11
+};
+
+static const uint kSoundTbl4[] = {
+ 2, 3, 4, 6, 8, 10, 11, 5, 7, 16
+};
+
+void MinigameBbAnt::buildDrawList0(DrawList &drawList) {
+
+ if (_titleScreenSpriteIndex)
+ drawList.add(_titleScreenSpriteIndex, 0, 0, 0);
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind)
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, obj->priority);
+ }
+
+}
+
+void MinigameBbAnt::buildDrawList1(DrawList &drawList) {
+
+ if (_backgroundSpriteIndex)
+ drawList.add(_backgroundSpriteIndex, _stompX, _stompY, 0);
+
+ for (int i = 1; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind) {
+ drawList.add(obj->anim->frameIndices[obj->frameIndex],
+ _stompX + (obj->x >> 16), _stompY + (obj->y >> 16),
+ obj->priority);
+ }
+ }
+
+ drawList.add(getAnimation(164)->frameIndices[0], 5, 2, 2000);
+ drawNumber(drawList, _score, 68, 16);
+ drawList.add(getAnimation(166)->frameIndices[0], 230, 2, 2000);
+ drawNumber(drawList, _levelTimeLeft, 280, 16);
+
+ for (int i = 0; i < _stompCount; ++i)
+ drawList.add(getAnimation(130)->frameIndices[0], 20 + i * 30, 230, 2000);
+
+}
+
+void MinigameBbAnt::buildDrawList2(DrawList &drawList) {
+ buildDrawList1(drawList);
+ drawList.add(getAnimation(168)->frameIndices[0], 40, 100, 2000);
+ drawNumber(drawList, _counter1, 190, 112);
+ drawNumber(drawList, _countdown5, 258, 112);
+ drawList.add(getAnimation(169)->frameIndices[0], 120, 120, 2000);
+ drawNumber(drawList, _counter4, 192, 132);
+}
+
+void MinigameBbAnt::buildDrawList3(DrawList &drawList) {
+ buildDrawList1(drawList);
+ drawList.add(getAnimation(163)->frameIndices[0], 120, 70, 2000);
+ drawList.add(getAnimation(165)->frameIndices[0], 95, 95, 2000);
+ drawNumber(drawList, _hiScore, 208, 107);
+}
+
+void MinigameBbAnt::drawMagnifyingGlass(DrawList &drawList) {
+ scale2x(_objects[0].x - 28, _objects[0].y - 27);
+ drawList.clear();
+ drawList.add(_objects[0].anim->frameIndices[0], _objects[0].x, _objects[0].y, _objects[0].priority);
+ drawList.add(_objects[0].anim->frameIndices[1], _objects[0].x, _objects[0].y, _objects[0].priority);
+ drawList.add(_objects[0].anim->frameIndices[2], _objects[0].x, _objects[0].y, _objects[0].priority);
+}
+
+void MinigameBbAnt::drawSprites() {
+ switch (_gameState) {
+ case 0:
+ drawSprites0();
+ break;
+ case 1:
+ drawSprites1();
+ break;
+ case 2:
+ drawSprites2();
+ break;
+ case 3:
+ drawSprites3();
+ break;
+ }
+}
+
+void MinigameBbAnt::drawSprites0() {
+ DrawList drawList;
+ buildDrawList0(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ _vm->_screen->copyToScreen();
+}
+
+void MinigameBbAnt::drawSprites1() {
+ DrawList drawList;
+ buildDrawList1(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ drawMagnifyingGlass(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ _vm->_screen->copyToScreen();
+}
+
+void MinigameBbAnt::drawSprites2() {
+ DrawList drawList;
+ buildDrawList2(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ drawMagnifyingGlass(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ _vm->_screen->copyToScreen();
+}
+
+void MinigameBbAnt::drawSprites3() {
+ DrawList drawList;
+ buildDrawList3(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ _vm->_screen->copyToScreen();
+}
+
+MinigameBbAnt::Obj *MinigameBbAnt::getFreeObject() {
+ for (int i = 12; i < kMaxObjectsCount; ++i)
+ if (_objects[i].kind == 0)
+ return &_objects[i];
+ return 0;
+}
+
+void MinigameBbAnt::initObjects() {
+ switch (_gameState) {
+ case 0:
+ initObjects0();
+ break;
+ case 1:
+ initObjects1();
+ break;
+ case 2:
+ case 3:
+ // Nothing
+ break;
+ }
+}
+
+void MinigameBbAnt::initObjects0() {
+ _objects[0].anim = getAnimation(172);
+ _objects[0].frameIndex = 0;
+ _objects[0].ticks = getAnimation(172)->frameTicks[0];
+ _objects[0].x = 160;
+ _objects[0].y = 120;
+ _objects[0].priority = 2000;
+ _objects[0].kind = 1;
+ _objects[1].anim = getAnimation(170);
+ _objects[1].frameIndex = 0;
+ _objects[1].ticks = getAnimation(170)->frameTicks[0];
+ _objects[1].x = 40;
+ _objects[1].y = 240;
+ _objects[1].priority = 100;
+ _objects[1].kind = 2;
+ _objects[2].anim = getAnimation(171);
+ _objects[2].frameIndex = 0;
+ _objects[2].ticks = getAnimation(171)->frameTicks[0];
+ _objects[2].x = 280;
+ _objects[2].y = 240;
+ _objects[2].priority = 100;
+ _objects[2].kind = 2;
+}
+
+void MinigameBbAnt::initObjects1() {
+ _objects[0].kind = 0;
+ _objects[0].x = 160;
+ _objects[0].y = 120;
+ _objects[0].xIncr = 0;
+ _objects[0].yIncr = 0;
+ _objects[0].anim = getAnimation(159);
+ _objects[0].frameIndex = 0;
+ _objects[0].ticks = _objects[0].anim->frameTicks[0];
+ _objects[0].priority = 1000;
+ _objects[1].kind = 8;
+ _objects[1].x = 0x1E0000;
+ _objects[1].y = 0x280000;
+ _objects[1].xIncr = 0;
+ _objects[1].yIncr = 0;
+ _objects[1].anim = getAnimation(160);
+ _objects[1].frameIndex = 0;
+ _objects[1].ticks = _objects[0].anim->frameTicks[0];
+ _objects[1].priority = 900;
+ _objects[1].smokeCtr = 0;
+ _objects[1].hasSmoke = false;
+ _objects[1].status = 0;
+ _objects[2].kind = 8;
+ _objects[2].x = 0x280000;
+ _objects[2].y = 0x4B0000;
+ _objects[2].xIncr = 0;
+ _objects[2].yIncr = 0;
+ _objects[2].anim = getAnimation(161);
+ _objects[2].frameIndex = 0;
+ _objects[2].ticks = _objects[0].anim->frameTicks[0];
+ _objects[2].priority = 900;
+ _objects[2].smokeCtr = 0;
+ _objects[2].hasSmoke = false;
+ _objects[2].status = 0;
+ for (int i = 3; i < 12; ++i) {
+ const ObjInit *objInit = getObjInit(i - 3);
+ _objects[i].kind = 6;
+ _objects[i].x = objInit->x << 16;
+ _objects[i].y = objInit->y << 16;
+ _objects[i].xIncr = 0;
+ _objects[i].yIncr = 0;
+ _objects[i].anim = objInit->anim1;
+ _objects[i].frameIndex = 0;
+ _objects[i].ticks = _objects[0].anim->frameTicks[0];
+ _objects[i].priority = 600;
+ _objects[i].status = 9;
+ _objects[i].damageCtr = 0;
+
+ }
+}
+
+void MinigameBbAnt::initVars() {
+ switch (_gameState) {
+ case 0:
+ // Nothing
+ break;
+ case 1:
+ initVars1();
+ break;
+ case 2:
+ initVars2();
+ break;
+ case 3:
+ initVars3();
+ break;
+ }
+}
+
+void MinigameBbAnt::initVars1() {
+ _stompX = 0;
+ _stompY = 0;
+ _stompDelay1 = 0;
+ _stompCount = 1;
+ _stompCounter1 = 80;
+ _stompCounter2 = 80;
+ _totalBugsCount = 0;
+ _hasLastStompObj = false;
+ _counter1 = 9;
+ _countdown10 = 140;
+ _score = 0;
+ _counter4 = 1;
+ _gameTicks = 0;
+ _skullBugCtr = 500;
+ _levelTimeDelay = 58;
+ _levelTimeLeft = 30;
+ _bugsChanceByKind[0] = 0;
+ _bugsChanceByKind[1] = 20;
+ _bugsChanceByKind[2] = 20;
+ _bugsChanceByKind[3] = 5;
+ _bugsChanceByKind[4] = 7;
+ _bugsCountByKind[0] = 0;
+ _bugsCountByKind[1] = 0;
+ _bugsCountByKind[2] = 0;
+ _bugsCountByKind[3] = 0;
+ _bugsCountByKind[4] = 0;
+ _bugsCountByKind[5] = 0;
+}
+
+void MinigameBbAnt::initVars2() {
+ _countdown4 = 0;
+ _countdown3 = 0;
+ _levelTimeDelay = 58;
+ _countdown6 = 60;
+ _countdown5 = 50 * _counter1;
+}
+
+void MinigameBbAnt::initVars3() {
+ if (_score > _hiScore)
+ _hiScore = _score;
+ playSound(9);
+}
+
+bool MinigameBbAnt::updateStatus(int mouseX, int mouseY, uint mouseButtons) {
+ switch (_gameState) {
+ case 0:
+ return updateStatus0(mouseX, mouseY, mouseButtons);
+ case 1:
+ return updateStatus1(mouseX, mouseY, mouseButtons);
+ case 2:
+ return updateStatus2(mouseX, mouseY, mouseButtons);
+ case 3:
+ return updateStatus3(mouseX, mouseY, mouseButtons);
+ }
+ return false;
+}
+
+bool MinigameBbAnt::updateStatus0(int mouseX, int mouseY, uint mouseButtons) {
+
+ _objects[0].x = mouseX;
+ _objects[0].y = mouseY;
+
+ if (_objects[0].x >= 320)
+ _objects[0].x = 320 - 1;
+ if (_objects[0].y >= 240)
+ _objects[0].y = 240 - 1;
+ if (_objects[0].x < 0)
+ _objects[0].x = 0;
+ if (_objects[0].y < 0)
+ _objects[0].y = 0;
+
+ if ((mouseButtons & kLeftButtonDown) || (mouseButtons & kRightButtonDown)) {
+ _gameState = 1;
+ initObjects();
+ initVars();
+ _gameTicks = 0;
+ playSound(1);
+ } else {
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind == 2) {
+ if (--obj->ticks == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex >= obj->anim->frameCount)
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ }
+ }
+ }
+ }
+
+ return true;
+}
+
+bool MinigameBbAnt::updateStatus1(int mouseX, int mouseY, uint mouseButtons) {
+ //const int kMaxBugsCount = 52;
+ const int kMaxBugsCount = 1;//DEBUG
+
+ --_levelTimeDelay;
+ if (!_levelTimeDelay) {
+ _levelTimeDelay = 58;
+ --_levelTimeLeft;
+ }
+
+ _objects[0].x = mouseX;
+ _objects[0].y = mouseY;
+
+ if (_objects[0].x >= 320)
+ _objects[0].x = 320 - 1;
+ if (_objects[0].y >= 240)
+ _objects[0].y = 240 - 1;
+ if (_objects[0].x < 0)
+ _objects[0].x = 0;
+ if (_objects[0].y < 0)
+ _objects[0].y = 0;
+
+ if (!_levelTimeLeft) {
+ _gameState = 2;
+ initVars();
+ initObjects();
+ _gameTicks = 0;
+ return true;
+ }
+
+ if (_counter1 == 0) {
+ _gameState = 3;
+ initVars();
+ initObjects();
+ _gameTicks = 0;
+ return true;
+ }
+
+debug(0, "updateStatus1 #2");
+ if ((mouseButtons & kRightButtonClicked) && (_stompCount > 0|| _hasLastStompObj) && !_objects[2].status) {
+ if (_hasLastStompObj)
+ removeStompObj(_lastStompObj);
+ --_stompCount;
+ _objects[2].status = 1;
+ }
+
+debug(0, "updateStatus1 #3");
+ if ((mouseButtons & kLeftButtonClicked) && _objects[2].status == 0 && isMagGlassAtBeavisLeg(2)) {
+ if (_vm->getRandom(10) == 1 && !isAnySoundPlaying(kSoundTbl4, 10))
+ playSound(16);
+ insertSmokeObj(_objects[0].x << 16, _objects[0].y << 16);
+ }
+
+debug(0, "updateStatus1 #4");
+ if (_skullBugCtr > 0) {
+ if (--_skullBugCtr == 0) {
+ _skullBugCtr = _vm->getRandom(150) + 500;
+ insertRandomBugObj(5);
+ }
+ }
+
+ if (_stompCounter2 > 0)
+ --_stompCounter2;
+
+debug(0, "updateStatus1 #5");
+ if (_totalBugsCount < kMaxBugsCount && _vm->getRandom(_stompCounter2) == 0) {
+ int testTbl[4];
+ int maxKindCount = 0, objKind = 0;
+
+ _stompCounter2 = _stompCounter1;
+
+debug(0, "updateStatus1 #6");
+ for (int i = 0; i < 4; ++i)
+ testTbl[i] = _vm->getRandom(_bugsChanceByKind[i] - _bugsCountByKind[i]);
+
+debug(0, "updateStatus1 #7");
+ for (int i = 0; i < 4; ++i) {
+ if (testTbl[i] >= maxKindCount) {
+ maxKindCount = testTbl[i];
+ objKind = i + 1;
+ }
+ }
+
+debug(0, "updateStatus1 #8");
+ if (objKind)
+ insertRandomBugObj(objKind);
+
+ }
+
+debug(0, "updateStatus1 #9");
+ updateObjs(mouseButtons);
+debug(0, "updateStatus1 #10");
+ updateFootObj(2);
+
+ if (--_countdown10 == 0) {
+ _countdown10 = 140;
+ if (_stompCounter1 > 20)
+ --_stompCounter1;
+ }
+
+debug(0, "updateStatus1 #XXX");
+ return true;
+}
+
+bool MinigameBbAnt::updateStatus2(int mouseX, int mouseY, uint mouseButtons) {
+
+ _objects[0].x = mouseX;
+ _objects[0].y = mouseY;
+
+ if (_objects[0].x >= 320)
+ _objects[0].x = 320 - 1;
+ if (_objects[0].y >= 240)
+ _objects[0].y = 240 - 1;
+ if (_objects[0].x < 0)
+ _objects[0].x = 0;
+ if (_objects[0].y < 0)
+ _objects[0].y = 0;
+
+ if (_countdown6 > 0) {
+ if (--_countdown6 == 0) {
+ _countdown4 = 150;
+ playSound(15, true);
+ }
+ } else if (_countdown4 > 0) {
+ if (--_countdown4 == 0) {
+ _countdown3 = 150;
+ } else if (_countdown5 > 0) {
+ ++_countdown4;
+ ++_score;
+ if (--_countdown5 == 0) {
+ stopSound(15);
+ _bugsChanceByKind[5] = 10;
+ _countdown7 = 40;
+ _countdown4 = 10 * (13 - _counter1);
+ return true;
+ }
+ } else {
+ if (--_countdown7 == 0) {
+ bool flag1 = false;
+ _countdown7 = _bugsChanceByKind[5];
+ for (int i = 3; i < 12 && !flag1; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->status == 13) {
+ const ObjInit *objInit = getObjInit(i - 3);
+ obj->x = objInit->x << 16;
+ obj->y = objInit->y << 16;
+ obj->anim = objInit->anim3;
+ obj->frameIndex = 0;
+ obj->ticks = _objects[0].anim->frameTicks[0];
+ obj->status = 9;
+ obj->damageCtr = 0;
+ obj->priority = 600;
+ ++_counter1;
+ playSound(15);
+ flag1 = true;
+ }
+ }
+ }
+ }
+ } else if (_countdown3 > 0) {
+ if ((mouseButtons & kLeftButtonDown) || (mouseButtons & kRightButtonDown) || (--_countdown3 == 0)) {
+ _levelTimeDelay = 58;
+ _levelTimeLeft = 30;
+ _gameState = 1;
+ _gameTicks = 0;
+ ++_counter4;
+ }
+ }
+
+ return true;
+}
+
+bool MinigameBbAnt::updateStatus3(int mouseX, int mouseY, uint mouseButtons) {
+ if (!isSoundPlaying(9) && _fromMainGame) {
+ _vm->_system->delayMillis(1000);
+ _gameDone = true;
+ }
+ return true;
+}
+
+void MinigameBbAnt::getRandomBugObjValues(int &x, int &y, int &animIndexIncr, int &field30) {
+ field30 = _vm->getRandom(4);
+ switch (field30) {
+ case 0:
+ y = -5;
+ x = _vm->getRandom(190) + 120;
+ animIndexIncr = 4;
+ break;
+ case 1:
+ x = 325;
+ y = _vm->getRandom(220) + 10;
+ animIndexIncr = 2;
+ break;
+ case 2:
+ y = 245;
+ x = _vm->getRandom(300) + 10;
+ animIndexIncr = 0;
+ break;
+ case 3:
+ x = -5;
+ y = _vm->getRandom(190) + 120;
+ animIndexIncr = 6;
+ break;
+ }
+}
+
+void MinigameBbAnt::insertBugSmokeObj(int x, int y, int bugObjIndex) {
+ Obj *obj = getFreeObject();
+ if (obj) {
+ Obj *bugObj = &_objects[bugObjIndex];
+ bugObj->hasSmoke = true;
+ obj->kind = 7;
+ obj->x = x;
+ obj->y = y;
+ obj->priority = 950;
+ if (bugObj->status >= 4 && (bugObj->status <= 6 || bugObj->status == 8)) {
+ obj->xIncr = 0;
+ obj->yIncr = (-1 << 16);
+ } else {
+ obj->xIncr = bugObj->xIncr / 8;
+ obj->yIncr = bugObj->yIncr / 8;
+ }
+ obj->anim = getAnimation(158);
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ }
+}
+
+void MinigameBbAnt::insertSmokeObj(int x, int y) {
+ Obj *obj = getFreeObject();
+ if (obj) {
+ obj->kind = 7;
+ obj->x = x;
+ obj->y = y;
+ obj->priority = 950;
+ obj->xIncr = 0x2000;
+ obj->yIncr = -0xC000;
+ obj->anim = getAnimation(158);
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ }
+}
+
+void MinigameBbAnt::resetObj(int objIndex) {
+ _objects[objIndex].kind = 0;
+}
+
+void MinigameBbAnt::insertStompObj(int x, int y) {
+ Obj *obj = getFreeObject();
+ if (obj) {
+ obj->kind = 9;
+ obj->x = x;
+ obj->y = y;
+ obj->priority = 2000;
+ obj->xIncr = (0x1E0000 * _stompCount - x + 0x140000) / 15;
+ obj->yIncr = (0xE60000 - y) / 15;
+ obj->anim = getAnimation(130);
+ debug("obj->anim(130): %d", obj->anim->frameIndices[0]);
+ obj->frameIndex = 0;
+ obj->ticks = 15;
+ _lastStompObj = obj;
+ _hasLastStompObj = true;
+ }
+}
+
+void MinigameBbAnt::removeStompObj(Obj *obj) {
+ ++_stompCount;
+ _hasLastStompObj = false;
+ obj->kind = 0;
+}
+
+void MinigameBbAnt::insertBugObj(int kind, int animIndexIncr, int always0, int x, int y, int field30, int always1) {
+ Obj *obj = getFreeObject();
+ if (obj) {
+ const ObjAnimation **objKindAnimTable = getObjKindAnimTable(kind);
+ obj->field30 = field30;
+ obj->animIndexIncr = animIndexIncr;
+ obj->kind = kind;
+ obj->x = x << 16;
+ obj->y = y << 16;
+ obj->priority = 610;
+ obj->xIncr = kPosIncrTbl1[0].x << 16;
+ obj->yIncr = kPosIncrTbl1[0].y << 16;
+ obj->anim = objKindAnimTable[0];
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ obj->animIndex = 0;
+ obj->status = 1;
+ obj->damageCtr = 0;
+ obj->hasSmoke = false;
+ obj->flag = 0;
+ ++_bugsCountByKind[kind];
+ ++_totalBugsCount;
+ }
+}
+
+void MinigameBbAnt::removeBugObj(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+ --_totalBugsCount;
+ --_bugsCountByKind[obj->kind];
+ obj->hasSmoke = false;
+ obj->kind = 0;
+}
+
+void MinigameBbAnt::updateBugObjAnim(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ switch (obj->field30) {
+ case 0:
+ obj->animIndexIncr = 4;
+ break;
+ case 1:
+ obj->animIndexIncr = 2;
+ break;
+ case 2:
+ obj->animIndexIncr = 0;
+ break;
+ case 3:
+ obj->animIndexIncr = 6;
+ break;
+ }
+ const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ obj->xIncr = kPosIncrTbl1[obj->animIndexIncr].x << 16;
+ obj->yIncr = kPosIncrTbl1[obj->animIndexIncr].y << 16;
+ obj->anim = objKindAnimTable[obj->animIndexIncr];
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+}
+
+void MinigameBbAnt::updateObjAnim2(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ obj->animIndexIncr += _vm->getRandom(3) - 1;
+ if (obj->animIndexIncr < 0)
+ obj->animIndexIncr = 7;
+ if (obj->animIndexIncr > 7)
+ obj->animIndexIncr = 0;
+ obj->animIndexIncr += 4;
+ if (obj->animIndexIncr >= 8)
+ obj->animIndexIncr %= 8;
+ const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ obj->xIncr = kPosIncrTbl1[obj->animIndex + obj->animIndexIncr].x << 16;
+ obj->yIncr = kPosIncrTbl1[obj->animIndex + obj->animIndexIncr].y << 16;
+ obj->anim = objKindAnimTable[obj->animIndex + obj->animIndexIncr];
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+}
+
+void MinigameBbAnt::insertRandomBugObj(int kind) {
+ int x, y, animIndexIncr, field30;
+ getRandomBugObjValues(x, y, animIndexIncr, field30);
+ insertBugObj(kind, animIndexIncr, 0, x, y, field30, 1);
+}
+
+bool MinigameBbAnt::isBugOutOfScreen(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ return
+ obj->x < (-10 << 16) || obj->x > (330 << 16) ||
+ obj->y < (-10 << 16) || obj->y > (250 << 16);
+}
+
+void MinigameBbAnt::updateObjAnim3(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ obj->animIndexIncr += _vm->getRandom(3) - 1;
+ if (obj->animIndexIncr < 0)
+ obj->animIndexIncr = 7;
+ if (obj->animIndexIncr > 7)
+ obj->animIndexIncr = 0;
+ const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ obj->xIncr = kPosIncrTbl1[obj->animIndexIncr].x << 16;
+ obj->yIncr = kPosIncrTbl1[obj->animIndexIncr].y << 16;
+ obj->anim = objKindAnimTable[obj->animIndexIncr];
+}
+
+void MinigameBbAnt::updateBugObj1(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+ bool flag1 = false;
+ bool flag2 = false;
+
+ if (--obj->ticks == 0) {
+ ++obj->frameIndex;
+ if (obj->anim->frameCount == obj->frameIndex) {
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ flag1 = true;
+ } else {
+ obj->ticks = obj->anim->frameTicks[obj->frameIndex];
+ flag2 = true;
+ }
+ }
+
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+
+ if (obj->status != 7) {
+ if (obj->damageCtr <= 5) {
+ obj->hasSmoke = false;
+ } else if (!obj->hasSmoke) {
+ obj->smokeCtr = 6;
+ insertBugSmokeObj(obj->x, obj->y, objIndex);
+ } else if (obj->damageCtr > 200 && obj->status != 4 && obj->status != 6) {
+ _score += kScoreTbl[obj->kind];
+ if (obj->status == 3) {
+ _objects[obj->otherObjIndex].status = 9;
+ _objects[obj->otherObjIndex].priority = 600;
+ if (_vm->getRandom(3) == 1 && !isAnySoundPlaying(kSoundTbl4, 10))
+ playSound(kSoundTbl3[_vm->getRandom(3)]);
+ } else {
+ if (_vm->getRandom(3) == 1 && !isAnySoundPlaying(kSoundTbl4, 10))
+ playSound(kSoundTbl2[_vm->getRandom(3)]);
+ }
+ flag1 = false;
+ const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ obj->hasSmoke = false;
+ obj->status = 4;
+ obj->xIncr = 0;
+ obj->yIncr = 0;
+ obj->anim = objKindAnimTable[16];
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ obj->priority = 605;
+ if (obj->kind == 5) {
+ // Skull Beetle
+ if (_stompCount < 10)
+ insertStompObj(obj->x, obj->y);
+ obj->kind = 4;
+ obj->anim = getObjAnim(70);
+ obj->ticks = obj->anim->frameTicks[0];
+ }
+ } else if (--obj->smokeCtr == 0) {
+ obj->smokeCtr = 6;
+ insertBugSmokeObj(obj->x, obj->y, objIndex);
+ }
+ }
+
+ switch (obj->status) {
+
+ case 1:
+ if (isBugOutOfScreen(objIndex))
+ removeBugObj(objIndex);
+ else if (flag1 && !obj->flag)
+ updateObjAnim3(objIndex);
+ break;
+
+ case 3:
+ // Bug carries candy
+ _objects[obj->otherObjIndex].x = obj->x;
+ _objects[obj->otherObjIndex].y = obj->y;
+ if (isBugOutOfScreen(objIndex)) {
+ _objects[obj->otherObjIndex].status = 13;
+ _objects[obj->otherObjIndex].x = (500 << 16);
+ _objects[obj->otherObjIndex].y = (500 << 16);
+ removeBugObj(objIndex);
+ --_counter1;
+ }
+ break;
+
+ case 4:
+ if (flag1) {
+ const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ obj->status = 6;
+ obj->xIncr = 0;
+ obj->yIncr = 0;
+ obj->anim = objKindAnimTable[17];
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ }
+ break;
+
+ case 6:
+ if (flag1) {
+ const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ obj->status = 7;
+ obj->xIncr = kPosIncrTbl2[obj->animIndexIncr].x << 16;
+ obj->yIncr = kPosIncrTbl2[obj->animIndexIncr].y << 16;
+ obj->anim = objKindAnimTable[obj->animIndexIncr + 8];
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[0];
+ obj->animIndex = 8;
+ obj->priority = 610;
+ }
+ break;
+
+ case 7:
+ if (isBugOutOfScreen(objIndex))
+ removeBugObj(objIndex);
+ break;
+
+ case 8:
+ if (--obj->counter != 0) {
+ if (flag2 && obj->frameIndex == 13) {
+ obj->frameIndex = 4;
+ obj->ticks = obj->anim->frameTicks[4];
+ }
+ } else {
+ obj->status = obj->status2;
+ obj->anim = obj->anim2;
+ obj->frameIndex = obj->frameIndex2;
+ obj->ticks = obj->ticks2;
+ obj->xIncr = kPosIncrTbl1[obj->animIndex + obj->animIndexIncr].x << 16;
+ obj->yIncr = kPosIncrTbl1[obj->animIndex + obj->animIndexIncr].y << 16;
+ obj->priority = 610;
+ }
+ break;
+
+ }
+
+}
+
+void MinigameBbAnt::updateObjKind2(int objIndex) {
+ updateBugObj1(objIndex);
+}
+
+void MinigameBbAnt::updateObjKind3(int objIndex) {
+ updateBugObj1(objIndex);
+}
+
+void MinigameBbAnt::updateObjKind4(int objIndex) {
+ updateBugObj1(objIndex);
+}
+
+void MinigameBbAnt::updateObjKind5(int objIndex) {
+ ++_skullBugCtr;
+ updateBugObj1(objIndex);
+}
+
+void MinigameBbAnt::updateStompObj(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+ if (--obj->ticks == 0)
+ removeStompObj(obj);
+}
+
+void MinigameBbAnt::updateSmokeObj(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+
+ if (--obj->ticks == 0) {
+ ++obj->frameIndex;
+ if (obj->anim->frameCount == obj->frameIndex)
+ resetObj(objIndex);
+ else
+ obj->ticks = obj->anim->frameTicks[obj->frameIndex];
+ }
+}
+
+void MinigameBbAnt::updateFootObj(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ switch (obj->status) {
+
+ case 1:
+ obj->xIncr = -0x8000;
+ obj->yIncr = (-4 << 16);
+ obj->status = 2;
+ _stompCounter1 += 5;
+ _stompCounter2 = 100;
+ break;
+
+ case 2:
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+ obj->yIncr += 0x2000;
+ if (obj->y < (20 << 16)) {
+ obj->xIncr = 0x8000;
+ obj->yIncr = (7 << 16);
+ obj->status = 3;
+ }
+ break;
+
+ case 3:
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+ obj->yIncr += 0x2000;
+ if (obj->y >= 0x4B0000) {
+ obj->x = (40 << 16);
+ obj->y = (75 << 16);
+ obj->status = 4;
+ _stompDelay1 = 6;
+ _stompY = 0;
+ playSound(14);
+ }
+ break;
+
+ case 4:
+ if (--_stompDelay1 == 0) {
+ _gameTicks = 0;
+ if (_stompDelay1 % 2)
+ _stompY = _stompY < 1 ? -8 : 0;
+ } else {
+ obj->status = 0;
+ _stompX = 0;
+ _stompY = 0;
+ // Stun all bugs
+ for (int i = 12; i < kMaxObjectsCount; ++i) {
+ Obj *bugObj = &_objects[i];
+ if (bugObj->kind >= 1 && bugObj->kind <= 5) {
+ bugObj->counter = _vm->getRandom(200) + 360;
+ const ObjAnimation **objKindAnimTable = getObjKindAnimTable(bugObj->kind);
+ if (bugObj->status == 8) {
+ bugObj->hasSmoke = false;
+ bugObj->xIncr = 0;
+ bugObj->yIncr = 0;
+ bugObj->status2 = 7;
+ bugObj->anim2 = objKindAnimTable[bugObj->animIndexIncr + 8];
+ bugObj->frameIndex2 = 0;
+ bugObj->ticks2 = obj->anim->frameTicks[0];
+ bugObj->anim = objKindAnimTable[17];
+ bugObj->frameIndex = 0;
+ bugObj->ticks = _vm->getRandom(4) + obj->anim->frameTicks[0];
+ bugObj->animIndex = 8;
+ } else {
+ if (bugObj->status == 3) {
+ bugObj->priority = 610;
+ _objects[bugObj->otherObjIndex].status = 9;
+ _objects[bugObj->otherObjIndex].priority = 600;
+ }
+ bugObj->hasSmoke = false;
+ bugObj->xIncr = 0;
+ bugObj->yIncr = 0;
+ bugObj->status2 = 1;
+ bugObj->anim2 = bugObj->anim;
+ bugObj->frameIndex2 = bugObj->frameIndex;
+ bugObj->ticks2 = bugObj->ticks;
+ bugObj->anim = objKindAnimTable[17];
+ bugObj->frameIndex = 0;
+ bugObj->ticks = _vm->getRandom(4) + obj->anim->frameTicks[0];
+ }
+ bugObj->status = 8;
+ bugObj->priority = 605;
+ }
+ }
+ }
+ break;
+
+ }
+
+}
+
+bool MinigameBbAnt::isBugAtCandy(int objIndex, int &candyObjIndex) {
+ Obj *obj = &_objects[objIndex];
+ bool result = false;
+
+ if (obj->kind >= 1 && obj->kind <= 4) {
+ const BBRect &frameRect1 = obj->anim->frameRects[obj->frameIndex];
+ const int obj1X1 = frameRect1.x + (obj->x >> 16);
+ const int obj1Y1 = frameRect1.y + (obj->y >> 16);
+ const int obj1X2 = obj1X1 + frameRect1.width;
+ const int obj1Y2 = obj1Y1 + frameRect1.height;
+ for (int i = 3; i < 12 && !result; ++i) {
+ Obj *obj2 = &_objects[i];
+ const BBRect &frameRect2 = obj->anim->frameRects[obj2->frameIndex]; // sic
+ const int obj2X1 = (obj2->x >> 16) + frameRect2.x;
+ const int obj2Y1 = (obj2->y >> 16) + frameRect2.y;
+ const int obj2X2 = obj2X1 + frameRect2.width;
+ const int obj2Y2 = obj2Y1 + frameRect2.height;
+ if (obj2->status == 9 && obj1X1 <= obj2X2 && obj1X2 >= obj2X1 && obj1Y1 <= obj2Y2 && obj1Y2 >= obj2Y1) {
+ result = true;
+ candyObjIndex = i;
+ }
+ }
+ }
+ return result;
+}
+
+bool MinigameBbAnt::isMagGlassAtBug(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+ Obj *obj0 = &_objects[0];
+ bool result = false;
+
+ if (obj->kind >= 1 && obj->kind <= 5) {
+ const BBRect &frameRect1 = obj0->anim->frameRects[0];
+ const int obj1X1 = obj0->x + frameRect1.x;
+ const int obj1Y1 = obj0->y + frameRect1.y;
+ const int obj1X2 = obj1X1 + frameRect1.width;
+ const int obj1Y2 = obj1Y1 + frameRect1.height;
+ const BBRect &frameRect2 = obj->anim->frameRects[obj->frameIndex];
+ const int obj2X1 = (obj->x >> 16) + frameRect2.x;
+ const int obj2Y1 = (obj->y >> 16) + frameRect2.y;
+ const int obj2X2 = obj2X1 + frameRect2.width;
+ const int obj2Y2 = obj2Y1 + frameRect2.height;
+ if (obj2X2 >= obj1X1 && obj1X2 >= obj2X1 && obj1Y1 <= obj2Y2 && obj1Y2 >= obj2Y1)
+ result = true;
+ }
+ return result;
+}
+
+bool MinigameBbAnt::isMagGlassAtBeavisLeg(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+ Obj *magGlassObj = &_objects[0];
+ bool result = false;
+
+ const BBRect &frameRect1 = magGlassObj->anim->frameRects[0];
+ const int obj1X1 = magGlassObj->x + frameRect1.x;
+ const int obj1Y1 = magGlassObj->y + frameRect1.y;
+ const int obj1X2 = obj1X1 + frameRect1.width;
+ const int obj1Y2 = obj1Y1 + frameRect1.height;
+ const BBRect &frameRect2 = obj->anim->frameRects[obj->frameIndex];
+ const int obj2X1 = (obj->x >> 16) + frameRect2.x;
+ const int obj2Y1 = (obj->y >> 16) + frameRect2.y;
+ const int obj2X2 = obj2X1 + frameRect2.width;
+ const int obj2Y2 = obj2Y1 + frameRect2.height;
+ if (obj2X2 >= obj1X1 && obj1X2 >= obj2X1 && obj1Y1 <= obj2Y2 && obj1Y2 >= obj2Y1)
+ result = true;
+ return result;
+}
+
+bool MinigameBbAnt::testObj5(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+ bool result = false;
+ if (obj->kind >= 1 && obj->kind <= 5) {
+ const int x = obj->x >> 16;
+ const int y = obj->y >> 16;
+ if (x < 0 || x >= 110 || y < 0 || y >= 110) {
+ obj->flag = 0;
+ } else if (!obj->flag) {
+ obj->flag = 1;
+ result = true;
+ }
+ }
+ return result;
+}
+
+void MinigameBbAnt::updateObjs(uint mouseButtons) {
+
+ for (int i = 12; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+
+ if (obj->kind) {
+
+ if ((mouseButtons & kLeftButtonClicked) && isMagGlassAtBug(i))
+ obj->damageCtr += 100;
+
+ if (obj->status == 1) {
+ int candyObjIndex;
+ if (isBugAtCandy(i, candyObjIndex)) {
+ obj->status = 3;
+ debug("bug %d has candy %d", i, candyObjIndex);
+ obj->otherObjIndex = candyObjIndex;
+ _objects[candyObjIndex].otherObjIndex = i;
+ _objects[candyObjIndex].status = 10;
+ _objects[candyObjIndex].priority = 620;
+ _objects[candyObjIndex].status = 11;
+ _objects[candyObjIndex].anim = getObjInit(candyObjIndex - 3)->anim3;
+ updateBugObjAnim(i);
+ if (_vm->getRandom(3) == 1 && !isAnySoundPlaying(kSoundTbl4, 10))
+ playSound(kSoundTbl1[_vm->getRandom(4)]);
+ }
+ }
+
+ if (testObj5(i)) {
+ debug("yes");
+ updateObjAnim2(i);
+ }
+
+ if (obj->damageCtr) {
+ --obj->damageCtr;
+ if (!isSoundPlaying(13))
+ playSound(13);
+ }
+
+ switch (obj->kind) {
+ case 1:
+ updateBugObj1(i);
+ break;
+ case 2:
+ updateObjKind2(i);
+ break;
+ case 3:
+ updateObjKind3(i);
+ break;
+ case 4:
+ updateObjKind4(i);
+ break;
+ case 5:
+ updateObjKind5(i);
+ break;
+ case 7:
+ updateSmokeObj(i);
+ break;
+ case 9:
+ updateStompObj(i);
+ break;
+ }
+
+ }
+
+ }
+
+}
+
+int MinigameBbAnt::run(uint flags) {
+
+ memset(_objects, 0, sizeof(_objects));
+
+ _numbersAnim = getAnimation(167);
+
+ _backgroundSpriteIndex = 303;
+ _titleScreenSpriteIndex = 304;
+
+ _fromMainGame = false;
+ if (flags & 1)
+ _fromMainGame = true;
+
+ _hiScore = 0;
+ _gameState = 0;
+ _gameResult = 0;
+ _gameDone = false;
+ initObjects();
+ initVars();
+
+ _spriteModule = new SpriteModule();
+ _spriteModule->load("bbant/bbant.000");
+
+ Palette palette = _spriteModule->getPalette();
+ _vm->_screen->setPalette(palette);
+
+ // Load sounds
+ loadSounds();
+
+ _gameTicks = 0;
+ playSound(12, true);
+
+ while (!_vm->shouldQuit() &&!_gameDone) {
+ _vm->updateEvents();
+ update();
+ }
+
+ // Unload sounds
+ _vm->_sound->unloadSounds();
+
+ delete _spriteModule;
+
+ return _gameResult;
+}
+
+void MinigameBbAnt::update() {
+
+ int currTicks, inputTicks;
+
+ if (_gameTicks > 0) {
+ currTicks = _vm->_system->getMillis();
+ inputTicks = 3 * (currTicks - _gameTicks) / 50;
+ _gameTicks = currTicks - (currTicks - _gameTicks - 50 * inputTicks / 3);
+ } else {
+ inputTicks = 1;
+ _gameTicks = _vm->_system->getMillis();
+ }
+
+ if (_vm->_keyCode == Common::KEYCODE_ESCAPE) {
+ _gameDone = true;
+ return;
+ }
+
+ if (inputTicks == 0)
+ return;
+
+ bool done;
+
+ do {
+ done = !updateStatus(_vm->_mouseX, _vm->_mouseY, _vm->_mouseButtons);
+ _vm->_mouseButtons &= ~kLeftButtonClicked;
+ _vm->_mouseButtons &= ~kRightButtonClicked;
+ _vm->_keyCode = Common::KEYCODE_INVALID;
+ } while (--inputTicks && _gameTicks > 0 && !done);
+
+ drawSprites();
+
+}
+
+void MinigameBbAnt::scale2x(int x, int y) {
+ Graphics::Surface *surface = _vm->_screen->_surface;
+
+ int srcX = x + 14, srcY = y + 14;
+ int srcW = kScaleDim, srcH = kScaleDim;
+
+ if (srcX < 0) {
+ srcW += srcX;
+ srcX = 0;
+ }
+
+ if (srcY < 0) {
+ srcH += srcY;
+ srcY = 0;
+ }
+
+ for (int yc = 0; yc < srcH; ++yc) {
+ byte *src = (byte*)surface->getBasePtr(srcX, srcY + yc);
+ memcpy(&_scaleBuf[yc * kScaleDim], src, srcW);
+ }
+
+ int dstX = x, dstY = y;
+ int dstW = 2 * kScaleDim, dstH = 2 * kScaleDim;
+
+ if (dstX < 0) {
+ dstW += dstX;
+ dstX = 0;
+ }
+
+ if (dstY < 0) {
+ dstH += dstY;
+ dstY = 0;
+ }
+
+ int w = MIN(srcW * 2, dstW), h = MIN(srcH * 2, dstH);
+
+ for (int yc = 0; yc < h; ++yc) {
+ byte *src = _scaleBuf + + kScaleDim * (yc / 2);
+ byte *dst = (byte*)surface->getBasePtr(dstX, dstY + yc);
+ for (int xc = 0; xc < w; ++xc)
+ dst[xc] = src[xc / 2];
+ }
+
+}
+
+void MinigameBbAnt::loadSounds() {
+ for (uint i = 0; i < kSoundFilenamesCount; ++i) {
+ Common::String filename = Common::String::format("bbant/%s", kSoundFilenames[i]);
+ _vm->_sound->loadSound(filename.c_str());
+ }
+}
+
+void MinigameBbAnt::playSound(uint index, bool loop) {
+ if (index > 0)
+ _vm->_sound->playSound(index - 1, loop);
+}
+
+void MinigameBbAnt::stopSound(uint index) {
+ if (index > 0)
+ _vm->_sound->stopSound(index - 1);
+}
+
+bool MinigameBbAnt::isSoundPlaying(uint index) {
+ return index > 0 && _vm->_sound->isSoundPlaying(index - 1);
+}
+
+bool MinigameBbAnt::isAnySoundPlaying(const uint *indices, uint count) {
+ for (uint i = 0; i < count; ++i)
+ if (isSoundPlaying(indices[i]))
+ return true;
+ return false;
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/bbant.h b/engines/bbvs/minigames/bbant.h
new file mode 100644
index 0000000..b9919ee
--- /dev/null
+++ b/engines/bbvs/minigames/bbant.h
@@ -0,0 +1,177 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef BBVS_MINIGAMES_BBANT_H
+#define BBVS_MINIGAMES_BBANT_H
+
+#include "bbvs/minigames/minigame.h"
+
+namespace Bbvs {
+
+class MinigameBbAnt : public Minigame {
+public:
+ MinigameBbAnt(BbvsEngine *vm) : Minigame(vm) {};
+ int run(uint flags);
+public:
+
+ struct Obj {
+ int kind;
+ int x, y, priority;
+ int xIncr, yIncr;
+ const ObjAnimation *anim;
+ int frameIndex;
+ int ticks;
+ int otherObjIndex;
+ int animIndex;
+ int animIndexIncr;
+ int status;
+ int field30;
+ int damageCtr;
+ int smokeCtr;
+ int counter;
+ int hasSmoke;
+ const ObjAnimation *anim2;
+ int frameIndex2;
+ int ticks2;
+ int status2;
+ int flag;
+ };
+
+ enum {
+ kMaxObjectsCount = 256,
+ kScaleDim = 28
+ };
+
+ struct ObjInit {
+ const ObjAnimation *anim1;
+ const ObjAnimation *anim2;
+ const ObjAnimation *anim3;
+ int x, y;
+ };
+
+ Obj _objects[kMaxObjectsCount];
+
+ int _score, _hiScore;
+
+ int _totalBugsCount;
+ int _bugsChanceByKind[6], _bugsCountByKind[6];
+ int _skullBugCtr;
+
+ int _stompX, _stompY;
+ int _stompDelay1;
+ int _stompCounter1;
+ int _stompCounter2;
+
+ int _stompCount;
+ int _hasLastStompObj;
+ Obj *_lastStompObj;
+
+ int _counter1;
+ int _countdown10;
+ int _counter4;
+ int _levelTimeDelay;
+ int _levelTimeLeft;
+
+ int _countdown4;
+ int _countdown3;
+ int _countdown6;
+ int _countdown5;
+ int _countdown7;
+
+ byte _scaleBuf[kScaleDim * kScaleDim];
+
+ const ObjAnimation *getAnimation(int animIndex);
+ const ObjInit *getObjInit(int index);
+ const ObjAnimation **getObjKindAnimTable(int kind);
+ const ObjAnimation *getObjAnim(int index);
+
+ void buildDrawList0(DrawList &drawList);
+ void buildDrawList1(DrawList &drawList);
+ void buildDrawList2(DrawList &drawList);
+ void buildDrawList3(DrawList &drawList);
+ void drawMagnifyingGlass(DrawList &drawList);
+
+ void drawSprites();
+ void drawSprites0();
+ void drawSprites1();
+ void drawSprites2();
+ void drawSprites3();
+
+ Obj *getFreeObject();
+
+ void initObjects();
+ void initObjects0();
+ void initObjects1();
+
+ void initVars();
+ void initVars1();
+ void initVars2();
+ void initVars3();
+
+ bool updateStatus(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus0(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus1(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus2(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus3(int mouseX, int mouseY, uint mouseButtons);
+
+ void getRandomBugObjValues(int &x, int &y, int &animIndexIncr, int &field30);
+ void insertBugSmokeObj(int x, int y, int bugObjIndex);
+ void insertSmokeObj(int x, int y);
+ void resetObj(int objIndex);
+ void insertStompObj(int x, int y);
+ void removeStompObj(Obj *obj);
+ void insertBugObj(int kind, int animIndexIncr, int always0, int x, int y, int field30, int always1);
+ void removeBugObj(int objIndex);
+ void updateBugObjAnim(int objIndex);
+ void updateObjAnim2(int objIndex);
+ void insertRandomBugObj(int kind);
+ bool isBugOutOfScreen(int objIndex);
+ void updateObjAnim3(int objIndex);
+ void updateBugObj1(int objIndex);
+ void updateObjKind2(int objIndex);
+ void updateObjKind3(int objIndex);
+ void updateObjKind4(int objIndex);
+ void updateObjKind5(int objIndex);
+ void updateStompObj(int objIndex);
+ void updateSmokeObj(int objIndex);
+ void updateFootObj(int objIndex);
+ bool isBugAtCandy(int objIndex, int &candyObjIndex);
+ bool isMagGlassAtBug(int objIndex);
+ bool isMagGlassAtBeavisLeg(int objIndex);
+ bool testObj5(int objIndex);
+ void updateObjs(uint mouseButtons);
+
+ void update();
+
+ void scale2x(int x, int y);
+
+ void loadSounds();
+ void playSound(uint index, bool loop = false);
+ void stopSound(uint index);
+ bool isSoundPlaying(uint index);
+ bool isAnySoundPlaying(const uint *indices, uint count);
+
+};
+
+} // End of namespace Bbvs
+
+#endif // BBVS_H
diff --git a/engines/bbvs/minigames/bbant_anims.cpp b/engines/bbvs/minigames/bbant_anims.cpp
new file mode 100644
index 0000000..9527b7a
--- /dev/null
+++ b/engines/bbvs/minigames/bbant_anims.cpp
@@ -0,0 +1,757 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/minigames/bbant.h"
+
+namespace Bbvs {
+
+static const int kAnim0FrameIndices[] = {0, 1, 2};
+static const int16 kAnim0FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim0FrameRects[] = {{-3, -8, 6, 14}, {-3, -8, 6, 13}, {-3, -7, 6, 12}};
+static const int kAnim1FrameIndices[] = {3, 4, 5};
+static const int16 kAnim1FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim1FrameRects[] = {{-5, -6, 13, 9}, {-5, -6, 13, 10}, {-5, -6, 13, 10}};
+static const int kAnim2FrameIndices[] = {6, 7, 8};
+static const int16 kAnim2FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim2FrameRects[] = {{-6, -6, 17, 7}, {-6, -6, 15, 6}, {-7, -6, 17, 6}};
+static const int kAnim3FrameIndices[] = {9, 10, 11};
+static const int16 kAnim3FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim3FrameRects[] = {{-5, -7, 13, 8}, {-5, -7, 12, 7}, {-5, -7, 12, 9}};
+static const int kAnim4FrameIndices[] = {12, 13, 14};
+static const int16 kAnim4FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim4FrameRects[] = {{-3, -9, 7, 11}, {-3, -9, 7, 11}, {-3, -9, 7, 11}};
+static const int kAnim5FrameIndices[] = {15, 16, 17};
+static const int16 kAnim5FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim5FrameRects[] = {{-7, -8, 13, 9}, {-7, -7, 13, 8}, {-7, -7, 13, 8}};
+static const int kAnim6FrameIndices[] = {18, 19, 20};
+static const int16 kAnim6FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim6FrameRects[] = {{-10, -6, 17, 7}, {-11, -6, 18, 7}, {-11, -6, 18, 6}};
+static const int kAnim7FrameIndices[] = {21, 22, 23};
+static const int16 kAnim7FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim7FrameRects[] = {{-7, -6, 13, 8}, {-7, -7, 12, 9}, {-7, -7, 13, 9}};
+static const int kAnim8FrameIndices[] = {24};
+static const int16 kAnim8FrameTicks[] = {8};
+static const BBRect kAnim8FrameRects[] = {{-3, -9, 6, 12}};
+static const int kAnim9FrameIndices[] = {25};
+static const int16 kAnim9FrameTicks[] = {8};
+static const BBRect kAnim9FrameRects[] = {{-5, -6, 12, 7}};
+static const int kAnim10FrameIndices[] = {26};
+static const int16 kAnim10FrameTicks[] = {8};
+static const BBRect kAnim10FrameRects[] = {{-4, -6, 13, 6}};
+static const int kAnim11FrameIndices[] = {27};
+static const int16 kAnim11FrameTicks[] = {8};
+static const BBRect kAnim11FrameRects[] = {{-5, -7, 11, 8}};
+static const int kAnim12FrameIndices[] = {28};
+static const int16 kAnim12FrameTicks[] = {8};
+static const BBRect kAnim12FrameRects[] = {{-2, -10, 5, 12}};
+static const int kAnim13FrameIndices[] = {29};
+static const int16 kAnim13FrameTicks[] = {8};
+static const BBRect kAnim13FrameRects[] = {{-6, -8, 13, 9}};
+static const int kAnim14FrameIndices[] = {30};
+static const int16 kAnim14FrameTicks[] = {8};
+static const BBRect kAnim14FrameRects[] = {{-8, -6, 13, 6}};
+static const int kAnim15FrameIndices[] = {31};
+static const int16 kAnim15FrameTicks[] = {8};
+static const BBRect kAnim15FrameRects[] = {{-7, -7, 12, 8}};
+static const int kAnim16FrameIndices[] = {0, 1, 2};
+static const int16 kAnim16FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim16FrameRects[] = {{-3, -8, 6, 14}, {-3, -8, 6, 13}, {-3, -7, 6, 12}};
+static const int kAnim17FrameIndices[] = {3, 4, 5};
+static const int16 kAnim17FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim17FrameRects[] = {{-5, -6, 13, 9}, {-5, -6, 13, 10}, {-5, -6, 13, 10}};
+static const int kAnim18FrameIndices[] = {6, 7, 8};
+static const int16 kAnim18FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim18FrameRects[] = {{-6, -6, 17, 7}, {-6, -6, 15, 6}, {-7, -6, 17, 6}};
+static const int kAnim19FrameIndices[] = {9, 10, 11};
+static const int16 kAnim19FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim19FrameRects[] = {{-5, -7, 13, 8}, {-5, -7, 12, 7}, {-5, -7, 12, 9}};
+static const int kAnim20FrameIndices[] = {12, 13, 14};
+static const int16 kAnim20FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim20FrameRects[] = {{-3, -9, 7, 11}, {-3, -9, 7, 11}, {-3, -9, 7, 11}};
+static const int kAnim21FrameIndices[] = {15, 16, 17};
+static const int16 kAnim21FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim21FrameRects[] = {{-7, -8, 13, 9}, {-7, -7, 13, 8}, {-7, -7, 13, 8}};
+static const int kAnim22FrameIndices[] = {18, 19, 20};
+static const int16 kAnim22FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim22FrameRects[] = {{-10, -6, 17, 7}, {-11, -6, 18, 7}, {-11, -6, 18, 6}};
+static const int kAnim23FrameIndices[] = {21, 22, 23};
+static const int16 kAnim23FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim23FrameRects[] = {{-7, -6, 13, 8}, {-7, -7, 12, 9}, {-7, -7, 13, 9}};
+static const int kAnim24FrameIndices[] = {32, 33, 34, 35, 36, 37, 36, 37, 36, 37, 36, 37, 36, 38};
+static const int16 kAnim24FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim24FrameRects[] = {{-3, -14, 12, 10}, {-2, -21, 11, 11}, {0, -23, 8, 14}, {-6, -15, 13, 11}, {-8, -4, 15, 5}, {-9, -4, 16, 6}, {-8, -4, 15, 5}, {-9, -4, 16, 6}, {-8, -4, 15, 5}, {-9, -4, 16, 6}, {-8, -4, 15, 5}, {-9, -4, 16, 6}, {-8, -4, 15, 5}, {-9, -4, 16, 5}};
+static const int kAnim25FrameIndices[] = {39, 40, 41, 42, 43, 44, 43, 44, 43, 44, 43, 44, 43, 45};
+static const int16 kAnim25FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim25FrameRects[] = {{-9, -14, 13, 10}, {-8, -22, 12, 12}, {-8, -24, 8, 15}, {-7, -15, 13, 10}, {-6, -4, 15, 7}, {-7, -4, 16, 6}, {-6, -4, 15, 7}, {-7, -4, 16, 6}, {-6, -4, 15, 7}, {-7, -4, 16, 6}, {-6, -4, 15, 7}, {-7, -4, 16, 6}, {-6, -4, 15, 7}, {-7, -4, 16, 6}};
+static const int kAnim26FrameIndices[] = {46, 47, 48};
+static const int16 kAnim26FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim26FrameRects[] = {{-3, -8, 6, 14}, {-3, -8, 6, 13}, {-3, -7, 6, 12}};
+static const int kAnim27FrameIndices[] = {49, 50, 51};
+static const int16 kAnim27FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim27FrameRects[] = {{-5, -6, 13, 9}, {-5, -6, 13, 10}, {-5, -6, 13, 10}};
+static const int kAnim28FrameIndices[] = {52, 53, 54};
+static const int16 kAnim28FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim28FrameRects[] = {{-6, -6, 17, 7}, {-6, -6, 15, 6}, {-7, -6, 17, 6}};
+static const int kAnim29FrameIndices[] = {55, 56, 57};
+static const int16 kAnim29FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim29FrameRects[] = {{-5, -7, 13, 8}, {-5, -7, 12, 7}, {-5, -7, 12, 9}};
+static const int kAnim30FrameIndices[] = {58, 59, 60};
+static const int16 kAnim30FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim30FrameRects[] = {{-3, -9, 7, 11}, {-3, -9, 7, 11}, {-3, -9, 7, 11}};
+static const int kAnim31FrameIndices[] = {61, 62, 63};
+static const int16 kAnim31FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim31FrameRects[] = {{-7, -8, 13, 9}, {-7, -7, 13, 8}, {-7, -7, 13, 8}};
+static const int kAnim32FrameIndices[] = {64, 65, 66};
+static const int16 kAnim32FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim32FrameRects[] = {{-10, -6, 17, 7}, {-11, -6, 18, 7}, {-11, -6, 18, 6}};
+static const int kAnim33FrameIndices[] = {67, 68, 69};
+static const int16 kAnim33FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim33FrameRects[] = {{-7, -6, 13, 8}, {-7, -7, 12, 9}, {-7, -7, 13, 9}};
+static const int kAnim34FrameIndices[] = {70};
+static const int16 kAnim34FrameTicks[] = {8};
+static const BBRect kAnim34FrameRects[] = {{-3, -9, 6, 12}};
+static const int kAnim35FrameIndices[] = {71};
+static const int16 kAnim35FrameTicks[] = {8};
+static const BBRect kAnim35FrameRects[] = {{-5, -6, 12, 7}};
+static const int kAnim36FrameIndices[] = {72};
+static const int16 kAnim36FrameTicks[] = {8};
+static const BBRect kAnim36FrameRects[] = {{-4, -6, 13, 6}};
+static const int kAnim37FrameIndices[] = {73};
+static const int16 kAnim37FrameTicks[] = {8};
+static const BBRect kAnim37FrameRects[] = {{-5, -7, 11, 8}};
+static const int kAnim38FrameIndices[] = {74};
+static const int16 kAnim38FrameTicks[] = {8};
+static const BBRect kAnim38FrameRects[] = {{-2, -10, 5, 12}};
+static const int kAnim39FrameIndices[] = {75};
+static const int16 kAnim39FrameTicks[] = {8};
+static const BBRect kAnim39FrameRects[] = {{-6, -8, 13, 9}};
+static const int kAnim40FrameIndices[] = {76};
+static const int16 kAnim40FrameTicks[] = {8};
+static const BBRect kAnim40FrameRects[] = {{-8, -6, 13, 6}};
+static const int kAnim41FrameIndices[] = {77};
+static const int16 kAnim41FrameTicks[] = {8};
+static const BBRect kAnim41FrameRects[] = {{-7, -7, 12, 8}};
+static const int kAnim42FrameIndices[] = {46, 47, 48};
+static const int16 kAnim42FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim42FrameRects[] = {{-3, -8, 6, 14}, {-3, -8, 6, 13}, {-3, -7, 6, 12}};
+static const int kAnim43FrameIndices[] = {49, 50, 51};
+static const int16 kAnim43FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim43FrameRects[] = {{-5, -6, 13, 9}, {-5, -6, 13, 10}, {-5, -6, 13, 10}};
+static const int kAnim44FrameIndices[] = {52, 53, 54};
+static const int16 kAnim44FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim44FrameRects[] = {{-6, -6, 17, 7}, {-6, -6, 15, 6}, {-7, -6, 17, 6}};
+static const int kAnim45FrameIndices[] = {55, 56, 57};
+static const int16 kAnim45FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim45FrameRects[] = {{-5, -7, 13, 8}, {-5, -7, 12, 7}, {-5, -7, 12, 9}};
+static const int kAnim46FrameIndices[] = {58, 59, 60};
+static const int16 kAnim46FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim46FrameRects[] = {{-3, -9, 7, 11}, {-3, -9, 7, 11}, {-3, -9, 7, 11}};
+static const int kAnim47FrameIndices[] = {61, 62, 63};
+static const int16 kAnim47FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim47FrameRects[] = {{-7, -8, 13, 9}, {-7, -7, 13, 8}, {-7, -7, 13, 8}};
+static const int kAnim48FrameIndices[] = {64, 65, 66};
+static const int16 kAnim48FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim48FrameRects[] = {{-10, -6, 17, 7}, {-11, -6, 18, 7}, {-11, -6, 18, 6}};
+static const int kAnim49FrameIndices[] = {67, 68, 69};
+static const int16 kAnim49FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim49FrameRects[] = {{-7, -6, 13, 8}, {-7, -7, 12, 9}, {-7, -7, 13, 9}};
+static const int kAnim50FrameIndices[] = {78, 79, 80, 81, 82, 83, 82, 83, 82, 83, 82, 83, 82, 84};
+static const int16 kAnim50FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim50FrameRects[] = {{-3, -14, 12, 10}, {-2, -21, 11, 11}, {0, -23, 8, 14}, {-6, -15, 13, 11}, {-8, -4, 15, 5}, {-9, -4, 16, 6}, {-8, -4, 15, 5}, {-9, -4, 16, 6}, {-8, -4, 15, 5}, {-9, -4, 16, 6}, {-8, -4, 15, 5}, {-9, -4, 16, 6}, {-8, -4, 15, 5}, {-9, -4, 16, 5}};
+static const int kAnim51FrameIndices[] = {85, 86, 87, 88, 89, 90, 89, 90, 89, 90, 89, 90, 89, 91};
+static const int16 kAnim51FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim51FrameRects[] = {{-9, -14, 13, 10}, {-8, -22, 12, 12}, {-8, -24, 8, 15}, {-7, -15, 13, 10}, {-6, -4, 15, 7}, {-7, -4, 16, 6}, {-6, -4, 15, 7}, {-7, -4, 16, 6}, {-6, -4, 15, 7}, {-7, -4, 16, 6}, {-6, -4, 15, 7}, {-7, -4, 16, 6}, {-6, -4, 15, 7}, {-7, -4, 16, 6}};
+static const int kAnim52FrameIndices[] = {92, 93, 94};
+static const int16 kAnim52FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim52FrameRects[] = {{-6, -14, 13, 24}, {-7, -13, 14, 23}, {-6, -13, 12, 22}};
+static const int kAnim53FrameIndices[] = {95, 96, 97};
+static const int16 kAnim53FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim53FrameRects[] = {{-4, -12, 19, 17}, {-3, -12, 18, 18}, {-2, -12, 17, 18}};
+static const int kAnim54FrameIndices[] = {98, 99, 100};
+static const int16 kAnim54FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim54FrameRects[] = {{-6, -16, 23, 14}, {-6, -15, 24, 13}, {-7, -15, 25, 14}};
+static const int kAnim55FrameIndices[] = {101, 102, 103};
+static const int16 kAnim55FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim55FrameRects[] = {{-4, -22, 16, 20}, {-3, -23, 14, 22}, {-4, -23, 14, 22}};
+static const int kAnim56FrameIndices[] = {104, 105, 106};
+static const int16 kAnim56FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim56FrameRects[] = {{-5, -24, 11, 23}, {-5, -25, 11, 25}, {-5, -25, 11, 26}};
+static const int kAnim57FrameIndices[] = {107, 108, 109};
+static const int16 kAnim57FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim57FrameRects[] = {{-10, -23, 15, 21}, {-11, -22, 16, 20}, {-11, -23, 17, 21}};
+static const int kAnim58FrameIndices[] = {110, 111, 112};
+static const int16 kAnim58FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim58FrameRects[] = {{-17, -15, 25, 15}, {-17, -15, 25, 14}, {-17, -15, 25, 14}};
+static const int kAnim59FrameIndices[] = {113, 114, 115};
+static const int16 kAnim59FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim59FrameRects[] = {{-14, -12, 20, 17}, {-14, -13, 19, 18}, {-14, -13, 19, 18}};
+static const int kAnim60FrameIndices[] = {116};
+static const int16 kAnim60FrameTicks[] = {6};
+static const BBRect kAnim60FrameRects[] = {{-6, -12, 12, 23}};
+static const int kAnim61FrameIndices[] = {117};
+static const int16 kAnim61FrameTicks[] = {6};
+static const BBRect kAnim61FrameRects[] = {{-5, -11, 20, 19}};
+static const int kAnim62FrameIndices[] = {118};
+static const int16 kAnim62FrameTicks[] = {6};
+static const BBRect kAnim62FrameRects[] = {{-8, -14, 27, 15}};
+static const int kAnim63FrameIndices[] = {119};
+static const int16 kAnim63FrameTicks[] = {6};
+static const BBRect kAnim63FrameRects[] = {{-4, -22, 17, 20}};
+static const int kAnim64FrameIndices[] = {120};
+static const int16 kAnim64FrameTicks[] = {6};
+static const BBRect kAnim64FrameRects[] = {{-6, -25, 13, 25}};
+static const int kAnim65FrameIndices[] = {121};
+static const int16 kAnim65FrameTicks[] = {6};
+static const BBRect kAnim65FrameRects[] = {{-11, -23, 17, 23}};
+static const int kAnim66FrameIndices[] = {122};
+static const int16 kAnim66FrameTicks[] = {6};
+static const BBRect kAnim66FrameRects[] = {{-18, -13, 29, 13}};
+static const int kAnim67FrameIndices[] = {123};
+static const int16 kAnim67FrameTicks[] = {6};
+static const BBRect kAnim67FrameRects[] = {{-14, -12, 21, 19}};
+static const int kAnim68FrameIndices[] = {92, 93, 94};
+static const int16 kAnim68FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim68FrameRects[] = {{-6, -14, 13, 24}, {-7, -13, 14, 23}, {-6, -13, 12, 22}};
+static const int kAnim69FrameIndices[] = {95, 96, 97};
+static const int16 kAnim69FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim69FrameRects[] = {{-4, -12, 19, 17}, {-3, -12, 18, 18}, {-2, -12, 17, 18}};
+static const int kAnim70FrameIndices[] = {98, 99, 100};
+static const int16 kAnim70FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim70FrameRects[] = {{-6, -16, 23, 14}, {-6, -15, 24, 13}, {-7, -15, 25, 14}};
+static const int kAnim71FrameIndices[] = {101, 102, 103};
+static const int16 kAnim71FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim71FrameRects[] = {{-4, -22, 16, 20}, {-3, -23, 14, 22}, {-4, -23, 14, 22}};
+static const int kAnim72FrameIndices[] = {104, 105, 106};
+static const int16 kAnim72FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim72FrameRects[] = {{-5, -24, 11, 23}, {-5, -25, 11, 25}, {-5, -25, 11, 26}};
+static const int kAnim73FrameIndices[] = {107, 108, 109};
+static const int16 kAnim73FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim73FrameRects[] = {{-10, -23, 15, 21}, {-11, -22, 16, 20}, {-11, -23, 17, 21}};
+static const int kAnim74FrameIndices[] = {110, 111, 112};
+static const int16 kAnim74FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim74FrameRects[] = {{-17, -15, 25, 15}, {-17, -15, 25, 14}, {-17, -15, 25, 14}};
+static const int kAnim75FrameIndices[] = {113, 114, 115};
+static const int16 kAnim75FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim75FrameRects[] = {{-14, -12, 20, 17}, {-14, -13, 19, 18}, {-14, -13, 19, 18}};
+static const int kAnim76FrameIndices[] = {124, 125, 126, 127, 128, 129, 128, 129, 128, 129, 128, 129, 128, 130};
+static const int16 kAnim76FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim76FrameRects[] = {{-14, -23, 23, 18}, {-12, -32, 18, 23}, {-16, -29, 18, 22}, {-17, -17, 23, 17}, {-17, -10, 26, 14}, {-17, -12, 25, 15}, {-17, -10, 26, 14}, {-17, -12, 25, 15}, {-17, -10, 26, 14}, {-17, -12, 25, 15}, {-17, -10, 26, 14}, {-17, -12, 25, 15}, {-17, -10, 26, 14}, {-18, -13, 28, 14}};
+static const int kAnim77FrameIndices[] = {131, 132, 133, 134, 135, 136, 135, 136, 135, 136, 135, 136, 135, 137};
+static const int16 kAnim77FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim77FrameRects[] = {{-6, -24, 21, 19}, {-5, -33, 19, 24}, {-1, -29, 18, 22}, {-5, -17, 22, 17}, {-6, -10, 23, 14}, {-7, -10, 26, 13}, {-6, -10, 23, 14}, {-7, -10, 26, 13}, {-6, -10, 23, 14}, {-7, -10, 26, 13}, {-6, -10, 23, 14}, {-7, -10, 26, 13}, {-6, -10, 23, 14}, {-7, -12, 26, 14}};
+static const int kAnim78FrameIndices[] = {138, 139, 140};
+static const int16 kAnim78FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim78FrameRects[] = {{-3, -17, 7, 20}, {-3, -16, 7, 19}, {-3, -16, 7, 19}};
+static const int kAnim79FrameIndices[] = {141, 142, 143};
+static const int16 kAnim79FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim79FrameRects[] = {{-6, -14, 13, 15}, {-7, -13, 14, 14}, {-6, -13, 13, 14}};
+static const int kAnim80FrameIndices[] = {144, 145, 146};
+static const int16 kAnim80FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim80FrameRects[] = {{-10, -10, 20, 9}, {-9, -9, 19, 8}, {-9, -9, 19, 8}};
+static const int kAnim81FrameIndices[] = {147, 148, 149};
+static const int16 kAnim81FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim81FrameRects[] = {{-7, -11, 16, 10}, {-7, -11, 16, 10}, {-7, -11, 16, 10}};
+static const int kAnim82FrameIndices[] = {150, 151, 152};
+static const int16 kAnim82FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim82FrameRects[] = {{-3, -13, 7, 16}, {-3, -13, 7, 16}, {-3, -12, 7, 15}};
+static const int kAnim83FrameIndices[] = {153, 154, 155};
+static const int16 kAnim83FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim83FrameRects[] = {{-8, -11, 18, 10}, {-7, -11, 16, 11}, {-7, -10, 17, 9}};
+static const int kAnim84FrameIndices[] = {156, 157, 158};
+static const int16 kAnim84FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim84FrameRects[] = {{-8, -9, 20, 7}, {-9, -9, 21, 8}, {-9, -9, 21, 8}};
+static const int kAnim85FrameIndices[] = {159, 160, 161};
+static const int16 kAnim85FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim85FrameRects[] = {{-6, -14, 15, 15}, {-5, -13, 12, 14}, {-6, -13, 14, 14}};
+static const int kAnim86FrameIndices[] = {162};
+static const int16 kAnim86FrameTicks[] = {6};
+static const BBRect kAnim86FrameRects[] = {{-3, -15, 8, 18}};
+static const int kAnim87FrameIndices[] = {163};
+static const int16 kAnim87FrameTicks[] = {6};
+static const BBRect kAnim87FrameRects[] = {{-7, -13, 14, 14}};
+static const int kAnim88FrameIndices[] = {164};
+static const int16 kAnim88FrameTicks[] = {6};
+static const BBRect kAnim88FrameRects[] = {{-11, -9, 21, 8}};
+static const int kAnim89FrameIndices[] = {165};
+static const int16 kAnim89FrameTicks[] = {6};
+static const BBRect kAnim89FrameRects[] = {{-9, -11, 18, 11}};
+static const int kAnim90FrameIndices[] = {166};
+static const int16 kAnim90FrameTicks[] = {6};
+static const BBRect kAnim90FrameRects[] = {{-3, -12, 7, 15}};
+static const int kAnim91FrameIndices[] = {167};
+static const int16 kAnim91FrameTicks[] = {6};
+static const BBRect kAnim91FrameRects[] = {{-8, -11, 17, 12}};
+static const int kAnim92FrameIndices[] = {168};
+static const int16 kAnim92FrameTicks[] = {6};
+static const BBRect kAnim92FrameRects[] = {{-9, -10, 21, 9}};
+static const int kAnim93FrameIndices[] = {169};
+static const int16 kAnim93FrameTicks[] = {6};
+static const BBRect kAnim93FrameRects[] = {{-6, -14, 14, 15}};
+static const int kAnim94FrameIndices[] = {138, 139, 140};
+static const int16 kAnim94FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim94FrameRects[] = {{-3, -17, 7, 20}, {-3, -16, 7, 19}, {-3, -16, 7, 19}};
+static const int kAnim95FrameIndices[] = {141, 142, 143};
+static const int16 kAnim95FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim95FrameRects[] = {{-6, -14, 13, 15}, {-7, -13, 14, 14}, {-6, -13, 13, 14}};
+static const int kAnim96FrameIndices[] = {144, 145, 146};
+static const int16 kAnim96FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim96FrameRects[] = {{-10, -10, 20, 9}, {-9, -9, 19, 8}, {-9, -9, 19, 8}};
+static const int kAnim97FrameIndices[] = {147, 148, 149};
+static const int16 kAnim97FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim97FrameRects[] = {{-7, -11, 16, 10}, {-7, -11, 16, 10}, {-7, -11, 16, 10}};
+static const int kAnim98FrameIndices[] = {150, 151, 152};
+static const int16 kAnim98FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim98FrameRects[] = {{-3, -13, 7, 16}, {-3, -13, 7, 16}, {-3, -12, 7, 15}};
+static const int kAnim99FrameIndices[] = {153, 154, 155};
+static const int16 kAnim99FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim99FrameRects[] = {{-8, -11, 18, 10}, {-7, -11, 16, 11}, {-7, -10, 17, 9}};
+static const int kAnim100FrameIndices[] = {156, 157, 158};
+static const int16 kAnim100FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim100FrameRects[] = {{-8, -9, 20, 7}, {-9, -9, 21, 8}, {-9, -9, 21, 8}};
+static const int kAnim101FrameIndices[] = {159, 160, 161};
+static const int16 kAnim101FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim101FrameRects[] = {{-6, -14, 15, 15}, {-5, -13, 12, 14}, {-6, -13, 14, 14}};
+static const int kAnim102FrameIndices[] = {170, 171, 172, 173, 174, 175, 174, 175, 174, 175, 174, 175, 174, 176};
+static const int16 kAnim102FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim102FrameRects[] = {{-7, -18, 15, 14}, {-6, -24, 11, 18}, {-6, -24, 9, 17}, {-5, -14, 16, 11}, {-7, -6, 18, 7}, {-8, -7, 19, 8}, {-7, -6, 18, 7}, {-8, -7, 19, 8}, {-7, -6, 18, 7}, {-8, -7, 19, 8}, {-7, -6, 18, 7}, {-8, -7, 19, 8}, {-7, -6, 18, 7}, {-8, -7, 19, 8}};
+static const int kAnim103FrameIndices[] = {177, 178, 179, 180, 181, 182, 181, 182, 181, 182, 181, 182, 181, 183};
+static const int16 kAnim103FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim103FrameRects[] = {{-9, -18, 16, 15}, {-6, -24, 12, 18}, {-6, -24, 13, 16}, {-12, -15, 17, 13}, {-10, -7, 19, 8}, {-11, -7, 21, 9}, {-10, -7, 19, 8}, {-11, -7, 21, 9}, {-10, -7, 19, 8}, {-11, -7, 21, 9}, {-10, -7, 19, 8}, {-11, -7, 21, 9}, {-10, -7, 19, 8}, {-11, -6, 21, 6}};
+static const int kAnim104FrameIndices[] = {184, 185, 186};
+static const int16 kAnim104FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim104FrameRects[] = {{-3, -17, 7, 20}, {-3, -16, 7, 19}, {-3, -16, 7, 19}};
+static const int kAnim105FrameIndices[] = {187, 188, 189};
+static const int16 kAnim105FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim105FrameRects[] = {{-6, -14, 13, 15}, {-7, -13, 14, 14}, {-6, -13, 13, 14}};
+static const int kAnim106FrameIndices[] = {190, 191, 192};
+static const int16 kAnim106FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim106FrameRects[] = {{-10, -10, 20, 9}, {-9, -9, 19, 8}, {-9, -9, 19, 8}};
+static const int kAnim107FrameIndices[] = {193, 194, 195};
+static const int16 kAnim107FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim107FrameRects[] = {{-7, -11, 16, 10}, {-7, -11, 16, 10}, {-7, -11, 16, 10}};
+static const int kAnim108FrameIndices[] = {196, 197, 198};
+static const int16 kAnim108FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim108FrameRects[] = {{-3, -13, 7, 16}, {-3, -13, 7, 16}, {-3, -12, 7, 15}};
+static const int kAnim109FrameIndices[] = {199, 200, 201};
+static const int16 kAnim109FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim109FrameRects[] = {{-8, -11, 18, 10}, {-7, -11, 16, 11}, {-7, -10, 17, 9}};
+static const int kAnim110FrameIndices[] = {202, 203, 204};
+static const int16 kAnim110FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim110FrameRects[] = {{-8, -9, 20, 7}, {-9, -9, 21, 8}, {-9, -9, 21, 8}};
+static const int kAnim111FrameIndices[] = {205, 206, 207};
+static const int16 kAnim111FrameTicks[] = {10, 8, 8};
+static const BBRect kAnim111FrameRects[] = {{-6, -14, 15, 15}, {-5, -13, 12, 14}, {-6, -13, 14, 14}};
+static const int kAnim112FrameIndices[] = {208};
+static const int16 kAnim112FrameTicks[] = {6};
+static const BBRect kAnim112FrameRects[] = {{-3, -15, 8, 18}};
+static const int kAnim113FrameIndices[] = {209};
+static const int16 kAnim113FrameTicks[] = {6};
+static const BBRect kAnim113FrameRects[] = {{-7, -13, 14, 14}};
+static const int kAnim114FrameIndices[] = {210};
+static const int16 kAnim114FrameTicks[] = {6};
+static const BBRect kAnim114FrameRects[] = {{-11, -9, 21, 8}};
+static const int kAnim115FrameIndices[] = {211};
+static const int16 kAnim115FrameTicks[] = {6};
+static const BBRect kAnim115FrameRects[] = {{-9, -11, 18, 11}};
+static const int kAnim116FrameIndices[] = {212};
+static const int16 kAnim116FrameTicks[] = {6};
+static const BBRect kAnim116FrameRects[] = {{-3, -12, 7, 15}};
+static const int kAnim117FrameIndices[] = {213};
+static const int16 kAnim117FrameTicks[] = {6};
+static const BBRect kAnim117FrameRects[] = {{-8, -11, 17, 12}};
+static const int kAnim118FrameIndices[] = {214};
+static const int16 kAnim118FrameTicks[] = {6};
+static const BBRect kAnim118FrameRects[] = {{-9, -10, 21, 9}};
+static const int kAnim119FrameIndices[] = {215};
+static const int16 kAnim119FrameTicks[] = {6};
+static const BBRect kAnim119FrameRects[] = {{-6, -14, 14, 15}};
+static const int kAnim120FrameIndices[] = {184, 185, 186};
+static const int16 kAnim120FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim120FrameRects[] = {{-3, -17, 7, 20}, {-3, -16, 7, 19}, {-3, -16, 7, 19}};
+static const int kAnim121FrameIndices[] = {187, 188, 189};
+static const int16 kAnim121FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim121FrameRects[] = {{-6, -14, 13, 15}, {-7, -13, 14, 14}, {-6, -13, 13, 14}};
+static const int kAnim122FrameIndices[] = {190, 191, 192};
+static const int16 kAnim122FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim122FrameRects[] = {{-10, -10, 20, 9}, {-9, -9, 19, 8}, {-9, -9, 19, 8}};
+static const int kAnim123FrameIndices[] = {193, 194, 195};
+static const int16 kAnim123FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim123FrameRects[] = {{-7, -11, 16, 10}, {-7, -11, 16, 10}, {-7, -11, 16, 10}};
+static const int kAnim124FrameIndices[] = {196, 197, 198};
+static const int16 kAnim124FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim124FrameRects[] = {{-3, -13, 7, 16}, {-3, -13, 7, 16}, {-3, -12, 7, 15}};
+static const int kAnim125FrameIndices[] = {199, 200, 201};
+static const int16 kAnim125FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim125FrameRects[] = {{-8, -11, 18, 10}, {-7, -11, 16, 11}, {-7, -10, 17, 9}};
+static const int kAnim126FrameIndices[] = {202, 203, 204};
+static const int16 kAnim126FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim126FrameRects[] = {{-8, -9, 20, 7}, {-9, -9, 21, 8}, {-9, -9, 21, 8}};
+static const int kAnim127FrameIndices[] = {205, 206, 207};
+static const int16 kAnim127FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim127FrameRects[] = {{-6, -14, 15, 15}, {-5, -13, 12, 14}, {-6, -13, 14, 14}};
+static const int kAnim128FrameIndices[] = {216, 217, 218, 219, 220, 221, 220, 221, 220, 221, 220, 221, 220, 222};
+static const int16 kAnim128FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim128FrameRects[] = {{-7, -18, 15, 14}, {-6, -24, 11, 18}, {-6, -24, 9, 17}, {-5, -14, 16, 11}, {-7, -6, 18, 7}, {-8, -7, 19, 8}, {-7, -6, 18, 7}, {-8, -7, 19, 8}, {-7, -6, 18, 7}, {-8, -7, 19, 8}, {-7, -6, 18, 7}, {-8, -7, 19, 8}, {-7, -6, 18, 7}, {-8, -7, 19, 8}};
+static const int kAnim129FrameIndices[] = {223, 224, 225, 226, 227, 228, 227, 228, 227, 228, 227, 228, 227, 229};
+static const int16 kAnim129FrameTicks[] = {6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
+static const BBRect kAnim129FrameRects[] = {{-9, -18, 16, 15}, {-6, -24, 12, 18}, {-6, -24, 13, 16}, {-12, -15, 17, 13}, {-10, -7, 19, 8}, {-11, -7, 21, 9}, {-10, -7, 19, 8}, {-11, -7, 21, 9}, {-10, -7, 19, 8}, {-11, -7, 21, 9}, {-10, -7, 19, 8}, {-11, -7, 21, 9}, {-10, -7, 19, 8}, {-11, -6, 21, 6}};
+static const int kAnim130FrameIndices[] = {230};
+static const int16 kAnim130FrameTicks[] = {6};
+static const BBRect kAnim130FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim131FrameIndices[] = {231};
+static const int16 kAnim131FrameTicks[] = {6};
+static const BBRect kAnim131FrameRects[] = {{-8, -9, 16, 12}};
+static const int kAnim132FrameIndices[] = {231, 232, 233};
+static const int16 kAnim132FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim132FrameRects[] = {{-8, -9, 16, 12}, {-8, -11, 16, 12}, {-8, -13, 16, 12}};
+static const int kAnim133FrameIndices[] = {233};
+static const int16 kAnim133FrameTicks[] = {6};
+static const BBRect kAnim133FrameRects[] = {{-8, -13, 16, 12}};
+static const int kAnim134FrameIndices[] = {234};
+static const int16 kAnim134FrameTicks[] = {6};
+static const BBRect kAnim134FrameRects[] = {{-7, -6, 14, 10}};
+static const int kAnim135FrameIndices[] = {234, 235, 236};
+static const int16 kAnim135FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim135FrameRects[] = {{-7, -6, 14, 10}, {-7, -9, 14, 9}, {-7, -12, 14, 9}};
+static const int kAnim136FrameIndices[] = {236};
+static const int16 kAnim136FrameTicks[] = {6};
+static const BBRect kAnim136FrameRects[] = {{-7, -12, 14, 9}};
+static const int kAnim137FrameIndices[] = {237};
+static const int16 kAnim137FrameTicks[] = {6};
+static const BBRect kAnim137FrameRects[] = {{-7, -8, 16, 13}};
+static const int kAnim138FrameIndices[] = {237, 238, 239};
+static const int16 kAnim138FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim138FrameRects[] = {{-7, -8, 16, 13}, {-7, -11, 16, 12}, {-7, -14, 16, 13}};
+static const int kAnim139FrameIndices[] = {239};
+static const int16 kAnim139FrameTicks[] = {6};
+static const BBRect kAnim139FrameRects[] = {{-7, -14, 16, 13}};
+static const int kAnim140FrameIndices[] = {240};
+static const int16 kAnim140FrameTicks[] = {6};
+static const BBRect kAnim140FrameRects[] = {{-4, -4, 11, 7}};
+static const int kAnim141FrameIndices[] = {240, 241, 242};
+static const int16 kAnim141FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim141FrameRects[] = {{-4, -4, 11, 7}, {-5, -7, 12, 7}, {-5, -10, 12, 7}};
+static const int kAnim142FrameIndices[] = {242};
+static const int16 kAnim142FrameTicks[] = {6};
+static const BBRect kAnim142FrameRects[] = {{-5, -10, 12, 7}};
+static const int kAnim143FrameIndices[] = {243};
+static const int16 kAnim143FrameTicks[] = {6};
+static const BBRect kAnim143FrameRects[] = {{-5, -4, 12, 7}};
+static const int kAnim144FrameIndices[] = {243, 244, 245};
+static const int16 kAnim144FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim144FrameRects[] = {{-5, -4, 12, 7}, {-5, -7, 12, 7}, {-5, -10, 11, 7}};
+static const int kAnim145FrameIndices[] = {245};
+static const int16 kAnim145FrameTicks[] = {6};
+static const BBRect kAnim145FrameRects[] = {{-5, -10, 11, 7}};
+static const int kAnim146FrameIndices[] = {246};
+static const int16 kAnim146FrameTicks[] = {6};
+static const BBRect kAnim146FrameRects[] = {{-9, -11, 19, 15}};
+static const int kAnim147FrameIndices[] = {246, 247, 248};
+static const int16 kAnim147FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim147FrameRects[] = {{-9, -11, 19, 15}, {-9, -13, 19, 14}, {-9, -17, 19, 15}};
+static const int kAnim148FrameIndices[] = {248};
+static const int16 kAnim148FrameTicks[] = {6};
+static const BBRect kAnim148FrameRects[] = {{-9, -17, 19, 15}};
+static const int kAnim149FrameIndices[] = {249};
+static const int16 kAnim149FrameTicks[] = {6};
+static const BBRect kAnim149FrameRects[] = {{-9, -12, 22, 17}};
+static const int kAnim150FrameIndices[] = {249, 250, 251};
+static const int16 kAnim150FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim150FrameRects[] = {{-9, -12, 22, 17}, {-9, -15, 22, 17}, {-9, -18, 22, 17}};
+static const int kAnim151FrameIndices[] = {251};
+static const int16 kAnim151FrameTicks[] = {6};
+static const BBRect kAnim151FrameRects[] = {{-9, -18, 22, 17}};
+static const int kAnim152FrameIndices[] = {252};
+static const int16 kAnim152FrameTicks[] = {6};
+static const BBRect kAnim152FrameRects[] = {{-8, -5, 18, 9}};
+static const int kAnim153FrameIndices[] = {252, 253, 254};
+static const int16 kAnim153FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim153FrameRects[] = {{-8, -5, 18, 9}, {-7, -9, 17, 9}, {-8, -11, 19, 9}};
+static const int kAnim154FrameIndices[] = {254};
+static const int16 kAnim154FrameTicks[] = {6};
+static const BBRect kAnim154FrameRects[] = {{-8, -11, 19, 9}};
+static const int kAnim155FrameIndices[] = {255};
+static const int16 kAnim155FrameTicks[] = {6};
+static const BBRect kAnim155FrameRects[] = {{-8, -9, 18, 13}};
+static const int kAnim156FrameIndices[] = {255, 256, 257};
+static const int16 kAnim156FrameTicks[] = {6, 6, 6};
+static const BBRect kAnim156FrameRects[] = {{-8, -9, 18, 13}, {-8, -12, 18, 13}, {-7, -15, 17, 13}};
+static const int kAnim157FrameIndices[] = {257};
+static const int16 kAnim157FrameTicks[] = {6};
+static const BBRect kAnim157FrameRects[] = {{-7, -15, 17, 13}};
+static const int kAnim158FrameIndices[] = {258, 259, 260, 261, 262, 263};
+static const int16 kAnim158FrameTicks[] = {6, 8, 8, 8, 6, 6};
+static const BBRect kAnim158FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim159FrameIndices[] = {264, 265, 266};
+static const int16 kAnim159FrameTicks[] = {1, 1, 1};
+static const BBRect kAnim159FrameRects[] = {{-9, -8, 18, 16}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim160FrameIndices[] = {267};
+static const int16 kAnim160FrameTicks[] = {6};
+static const BBRect kAnim160FrameRects[] = {{-25, -83, 43, 54}};
+static const int kAnim161FrameIndices[] = {268};
+static const int16 kAnim161FrameTicks[] = {6};
+static const BBRect kAnim161FrameRects[] = {{-33, -93, 41, 60}};
+static const int kAnim162FrameIndices[] = {269};
+static const int16 kAnim162FrameTicks[] = {1};
+static const BBRect kAnim162FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim163FrameIndices[] = {270};
+static const int16 kAnim163FrameTicks[] = {5};
+static const BBRect kAnim163FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim164FrameIndices[] = {271};
+static const int16 kAnim164FrameTicks[] = {1};
+static const BBRect kAnim164FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim165FrameIndices[] = {272};
+static const int16 kAnim165FrameTicks[] = {1};
+static const BBRect kAnim165FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim166FrameIndices[] = {273};
+static const int16 kAnim166FrameTicks[] = {2};
+static const BBRect kAnim166FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim167FrameIndices[] = {274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286};
+static const int16 kAnim167FrameTicks[] = {6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
+static const BBRect kAnim167FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim168FrameIndices[] = {287};
+static const int16 kAnim168FrameTicks[] = {1};
+static const BBRect kAnim168FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim169FrameIndices[] = {288};
+static const int16 kAnim169FrameTicks[] = {6};
+static const BBRect kAnim169FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim170FrameIndices[] = {289, 290, 291, 292, 293, 294};
+static const int16 kAnim170FrameTicks[] = {6, 6, 6, 6, 6, 6};
+static const BBRect kAnim170FrameRects[] = {{-22, -91, 45, 93}, {-21, -92, 43, 95}, {-21, -92, 43, 95}, {-21, -92, 43, 95}, {-21, -92, 43, 95}, {-21, -92, 43, 95}};
+static const int kAnim171FrameIndices[] = {295, 296, 297, 298, 299, 300};
+static const int16 kAnim171FrameTicks[] = {6, 6, 6, 6, 6, 6};
+static const BBRect kAnim171FrameRects[] = {{-21, -85, 38, 86}, {-21, -85, 38, 86}, {-21, -85, 38, 86}, {-21, -85, 38, 86}, {-21, -85, 38, 86}, {-21, -85, 38, 86}};
+static const int kAnim172FrameIndices[] = {301, 302};
+static const int16 kAnim172FrameTicks[] = {6, 6};
+static const BBRect kAnim172FrameRects[] = {{-9, -9, 17, 15}, {-11, -10, 19, 16}};
+static const ObjAnimation kAnimations[] = {
+ {3, kAnim0FrameIndices, kAnim0FrameTicks, kAnim0FrameRects},
+ {3, kAnim1FrameIndices, kAnim1FrameTicks, kAnim1FrameRects},
+ {3, kAnim2FrameIndices, kAnim2FrameTicks, kAnim2FrameRects},
+ {3, kAnim3FrameIndices, kAnim3FrameTicks, kAnim3FrameRects},
+ {3, kAnim4FrameIndices, kAnim4FrameTicks, kAnim4FrameRects},
+ {3, kAnim5FrameIndices, kAnim5FrameTicks, kAnim5FrameRects},
+ {3, kAnim6FrameIndices, kAnim6FrameTicks, kAnim6FrameRects},
+ {3, kAnim7FrameIndices, kAnim7FrameTicks, kAnim7FrameRects},
+ {1, kAnim8FrameIndices, kAnim8FrameTicks, kAnim8FrameRects},
+ {1, kAnim9FrameIndices, kAnim9FrameTicks, kAnim9FrameRects},
+ {1, kAnim10FrameIndices, kAnim10FrameTicks, kAnim10FrameRects},
+ {1, kAnim11FrameIndices, kAnim11FrameTicks, kAnim11FrameRects},
+ {1, kAnim12FrameIndices, kAnim12FrameTicks, kAnim12FrameRects},
+ {1, kAnim13FrameIndices, kAnim13FrameTicks, kAnim13FrameRects},
+ {1, kAnim14FrameIndices, kAnim14FrameTicks, kAnim14FrameRects},
+ {1, kAnim15FrameIndices, kAnim15FrameTicks, kAnim15FrameRects},
+ {3, kAnim16FrameIndices, kAnim16FrameTicks, kAnim16FrameRects},
+ {3, kAnim17FrameIndices, kAnim17FrameTicks, kAnim17FrameRects},
+ {3, kAnim18FrameIndices, kAnim18FrameTicks, kAnim18FrameRects},
+ {3, kAnim19FrameIndices, kAnim19FrameTicks, kAnim19FrameRects},
+ {3, kAnim20FrameIndices, kAnim20FrameTicks, kAnim20FrameRects},
+ {3, kAnim21FrameIndices, kAnim21FrameTicks, kAnim21FrameRects},
+ {3, kAnim22FrameIndices, kAnim22FrameTicks, kAnim22FrameRects},
+ {3, kAnim23FrameIndices, kAnim23FrameTicks, kAnim23FrameRects},
+ {14, kAnim24FrameIndices, kAnim24FrameTicks, kAnim24FrameRects},
+ {14, kAnim25FrameIndices, kAnim25FrameTicks, kAnim25FrameRects},
+ {3, kAnim26FrameIndices, kAnim26FrameTicks, kAnim26FrameRects},
+ {3, kAnim27FrameIndices, kAnim27FrameTicks, kAnim27FrameRects},
+ {3, kAnim28FrameIndices, kAnim28FrameTicks, kAnim28FrameRects},
+ {3, kAnim29FrameIndices, kAnim29FrameTicks, kAnim29FrameRects},
+ {3, kAnim30FrameIndices, kAnim30FrameTicks, kAnim30FrameRects},
+ {3, kAnim31FrameIndices, kAnim31FrameTicks, kAnim31FrameRects},
+ {3, kAnim32FrameIndices, kAnim32FrameTicks, kAnim32FrameRects},
+ {3, kAnim33FrameIndices, kAnim33FrameTicks, kAnim33FrameRects},
+ {1, kAnim34FrameIndices, kAnim34FrameTicks, kAnim34FrameRects},
+ {1, kAnim35FrameIndices, kAnim35FrameTicks, kAnim35FrameRects},
+ {1, kAnim36FrameIndices, kAnim36FrameTicks, kAnim36FrameRects},
+ {1, kAnim37FrameIndices, kAnim37FrameTicks, kAnim37FrameRects},
+ {1, kAnim38FrameIndices, kAnim38FrameTicks, kAnim38FrameRects},
+ {1, kAnim39FrameIndices, kAnim39FrameTicks, kAnim39FrameRects},
+ {1, kAnim40FrameIndices, kAnim40FrameTicks, kAnim40FrameRects},
+ {1, kAnim41FrameIndices, kAnim41FrameTicks, kAnim41FrameRects},
+ {3, kAnim42FrameIndices, kAnim42FrameTicks, kAnim42FrameRects},
+ {3, kAnim43FrameIndices, kAnim43FrameTicks, kAnim43FrameRects},
+ {3, kAnim44FrameIndices, kAnim44FrameTicks, kAnim44FrameRects},
+ {3, kAnim45FrameIndices, kAnim45FrameTicks, kAnim45FrameRects},
+ {3, kAnim46FrameIndices, kAnim46FrameTicks, kAnim46FrameRects},
+ {3, kAnim47FrameIndices, kAnim47FrameTicks, kAnim47FrameRects},
+ {3, kAnim48FrameIndices, kAnim48FrameTicks, kAnim48FrameRects},
+ {3, kAnim49FrameIndices, kAnim49FrameTicks, kAnim49FrameRects},
+ {14, kAnim50FrameIndices, kAnim50FrameTicks, kAnim50FrameRects},
+ {14, kAnim51FrameIndices, kAnim51FrameTicks, kAnim51FrameRects},
+ {3, kAnim52FrameIndices, kAnim52FrameTicks, kAnim52FrameRects},
+ {3, kAnim53FrameIndices, kAnim53FrameTicks, kAnim53FrameRects},
+ {3, kAnim54FrameIndices, kAnim54FrameTicks, kAnim54FrameRects},
+ {3, kAnim55FrameIndices, kAnim55FrameTicks, kAnim55FrameRects},
+ {3, kAnim56FrameIndices, kAnim56FrameTicks, kAnim56FrameRects},
+ {3, kAnim57FrameIndices, kAnim57FrameTicks, kAnim57FrameRects},
+ {3, kAnim58FrameIndices, kAnim58FrameTicks, kAnim58FrameRects},
+ {3, kAnim59FrameIndices, kAnim59FrameTicks, kAnim59FrameRects},
+ {1, kAnim60FrameIndices, kAnim60FrameTicks, kAnim60FrameRects},
+ {1, kAnim61FrameIndices, kAnim61FrameTicks, kAnim61FrameRects},
+ {1, kAnim62FrameIndices, kAnim62FrameTicks, kAnim62FrameRects},
+ {1, kAnim63FrameIndices, kAnim63FrameTicks, kAnim63FrameRects},
+ {1, kAnim64FrameIndices, kAnim64FrameTicks, kAnim64FrameRects},
+ {1, kAnim65FrameIndices, kAnim65FrameTicks, kAnim65FrameRects},
+ {1, kAnim66FrameIndices, kAnim66FrameTicks, kAnim66FrameRects},
+ {1, kAnim67FrameIndices, kAnim67FrameTicks, kAnim67FrameRects},
+ {3, kAnim68FrameIndices, kAnim68FrameTicks, kAnim68FrameRects},
+ {3, kAnim69FrameIndices, kAnim69FrameTicks, kAnim69FrameRects},
+ {3, kAnim70FrameIndices, kAnim70FrameTicks, kAnim70FrameRects},
+ {3, kAnim71FrameIndices, kAnim71FrameTicks, kAnim71FrameRects},
+ {3, kAnim72FrameIndices, kAnim72FrameTicks, kAnim72FrameRects},
+ {3, kAnim73FrameIndices, kAnim73FrameTicks, kAnim73FrameRects},
+ {3, kAnim74FrameIndices, kAnim74FrameTicks, kAnim74FrameRects},
+ {3, kAnim75FrameIndices, kAnim75FrameTicks, kAnim75FrameRects},
+ {14, kAnim76FrameIndices, kAnim76FrameTicks, kAnim76FrameRects},
+ {14, kAnim77FrameIndices, kAnim77FrameTicks, kAnim77FrameRects},
+ {3, kAnim78FrameIndices, kAnim78FrameTicks, kAnim78FrameRects},
+ {3, kAnim79FrameIndices, kAnim79FrameTicks, kAnim79FrameRects},
+ {3, kAnim80FrameIndices, kAnim80FrameTicks, kAnim80FrameRects},
+ {3, kAnim81FrameIndices, kAnim81FrameTicks, kAnim81FrameRects},
+ {3, kAnim82FrameIndices, kAnim82FrameTicks, kAnim82FrameRects},
+ {3, kAnim83FrameIndices, kAnim83FrameTicks, kAnim83FrameRects},
+ {3, kAnim84FrameIndices, kAnim84FrameTicks, kAnim84FrameRects},
+ {3, kAnim85FrameIndices, kAnim85FrameTicks, kAnim85FrameRects},
+ {1, kAnim86FrameIndices, kAnim86FrameTicks, kAnim86FrameRects},
+ {1, kAnim87FrameIndices, kAnim87FrameTicks, kAnim87FrameRects},
+ {1, kAnim88FrameIndices, kAnim88FrameTicks, kAnim88FrameRects},
+ {1, kAnim89FrameIndices, kAnim89FrameTicks, kAnim89FrameRects},
+ {1, kAnim90FrameIndices, kAnim90FrameTicks, kAnim90FrameRects},
+ {1, kAnim91FrameIndices, kAnim91FrameTicks, kAnim91FrameRects},
+ {1, kAnim92FrameIndices, kAnim92FrameTicks, kAnim92FrameRects},
+ {1, kAnim93FrameIndices, kAnim93FrameTicks, kAnim93FrameRects},
+ {3, kAnim94FrameIndices, kAnim94FrameTicks, kAnim94FrameRects},
+ {3, kAnim95FrameIndices, kAnim95FrameTicks, kAnim95FrameRects},
+ {3, kAnim96FrameIndices, kAnim96FrameTicks, kAnim96FrameRects},
+ {3, kAnim97FrameIndices, kAnim97FrameTicks, kAnim97FrameRects},
+ {3, kAnim98FrameIndices, kAnim98FrameTicks, kAnim98FrameRects},
+ {3, kAnim99FrameIndices, kAnim99FrameTicks, kAnim99FrameRects},
+ {3, kAnim100FrameIndices, kAnim100FrameTicks, kAnim100FrameRects},
+ {3, kAnim101FrameIndices, kAnim101FrameTicks, kAnim101FrameRects},
+ {14, kAnim102FrameIndices, kAnim102FrameTicks, kAnim102FrameRects},
+ {14, kAnim103FrameIndices, kAnim103FrameTicks, kAnim103FrameRects},
+ {3, kAnim104FrameIndices, kAnim104FrameTicks, kAnim104FrameRects},
+ {3, kAnim105FrameIndices, kAnim105FrameTicks, kAnim105FrameRects},
+ {3, kAnim106FrameIndices, kAnim106FrameTicks, kAnim106FrameRects},
+ {3, kAnim107FrameIndices, kAnim107FrameTicks, kAnim107FrameRects},
+ {3, kAnim108FrameIndices, kAnim108FrameTicks, kAnim108FrameRects},
+ {3, kAnim109FrameIndices, kAnim109FrameTicks, kAnim109FrameRects},
+ {3, kAnim110FrameIndices, kAnim110FrameTicks, kAnim110FrameRects},
+ {3, kAnim111FrameIndices, kAnim111FrameTicks, kAnim111FrameRects},
+ {1, kAnim112FrameIndices, kAnim112FrameTicks, kAnim112FrameRects},
+ {1, kAnim113FrameIndices, kAnim113FrameTicks, kAnim113FrameRects},
+ {1, kAnim114FrameIndices, kAnim114FrameTicks, kAnim114FrameRects},
+ {1, kAnim115FrameIndices, kAnim115FrameTicks, kAnim115FrameRects},
+ {1, kAnim116FrameIndices, kAnim116FrameTicks, kAnim116FrameRects},
+ {1, kAnim117FrameIndices, kAnim117FrameTicks, kAnim117FrameRects},
+ {1, kAnim118FrameIndices, kAnim118FrameTicks, kAnim118FrameRects},
+ {1, kAnim119FrameIndices, kAnim119FrameTicks, kAnim119FrameRects},
+ {3, kAnim120FrameIndices, kAnim120FrameTicks, kAnim120FrameRects},
+ {3, kAnim121FrameIndices, kAnim121FrameTicks, kAnim121FrameRects},
+ {3, kAnim122FrameIndices, kAnim122FrameTicks, kAnim122FrameRects},
+ {3, kAnim123FrameIndices, kAnim123FrameTicks, kAnim123FrameRects},
+ {3, kAnim124FrameIndices, kAnim124FrameTicks, kAnim124FrameRects},
+ {3, kAnim125FrameIndices, kAnim125FrameTicks, kAnim125FrameRects},
+ {3, kAnim126FrameIndices, kAnim126FrameTicks, kAnim126FrameRects},
+ {3, kAnim127FrameIndices, kAnim127FrameTicks, kAnim127FrameRects},
+ {14, kAnim128FrameIndices, kAnim128FrameTicks, kAnim128FrameRects},
+ {14, kAnim129FrameIndices, kAnim129FrameTicks, kAnim129FrameRects},
+ {1, kAnim130FrameIndices, kAnim130FrameTicks, kAnim130FrameRects},
+ {1, kAnim131FrameIndices, kAnim131FrameTicks, kAnim131FrameRects},
+ {3, kAnim132FrameIndices, kAnim132FrameTicks, kAnim132FrameRects},
+ {1, kAnim133FrameIndices, kAnim133FrameTicks, kAnim133FrameRects},
+ {1, kAnim134FrameIndices, kAnim134FrameTicks, kAnim134FrameRects},
+ {3, kAnim135FrameIndices, kAnim135FrameTicks, kAnim135FrameRects},
+ {1, kAnim136FrameIndices, kAnim136FrameTicks, kAnim136FrameRects},
+ {1, kAnim137FrameIndices, kAnim137FrameTicks, kAnim137FrameRects},
+ {3, kAnim138FrameIndices, kAnim138FrameTicks, kAnim138FrameRects},
+ {1, kAnim139FrameIndices, kAnim139FrameTicks, kAnim139FrameRects},
+ {1, kAnim140FrameIndices, kAnim140FrameTicks, kAnim140FrameRects},
+ {3, kAnim141FrameIndices, kAnim141FrameTicks, kAnim141FrameRects},
+ {1, kAnim142FrameIndices, kAnim142FrameTicks, kAnim142FrameRects},
+ {1, kAnim143FrameIndices, kAnim143FrameTicks, kAnim143FrameRects},
+ {3, kAnim144FrameIndices, kAnim144FrameTicks, kAnim144FrameRects},
+ {1, kAnim145FrameIndices, kAnim145FrameTicks, kAnim145FrameRects},
+ {1, kAnim146FrameIndices, kAnim146FrameTicks, kAnim146FrameRects},
+ {3, kAnim147FrameIndices, kAnim147FrameTicks, kAnim147FrameRects},
+ {1, kAnim148FrameIndices, kAnim148FrameTicks, kAnim148FrameRects},
+ {1, kAnim149FrameIndices, kAnim149FrameTicks, kAnim149FrameRects},
+ {3, kAnim150FrameIndices, kAnim150FrameTicks, kAnim150FrameRects},
+ {1, kAnim151FrameIndices, kAnim151FrameTicks, kAnim151FrameRects},
+ {1, kAnim152FrameIndices, kAnim152FrameTicks, kAnim152FrameRects},
+ {3, kAnim153FrameIndices, kAnim153FrameTicks, kAnim153FrameRects},
+ {1, kAnim154FrameIndices, kAnim154FrameTicks, kAnim154FrameRects},
+ {1, kAnim155FrameIndices, kAnim155FrameTicks, kAnim155FrameRects},
+ {3, kAnim156FrameIndices, kAnim156FrameTicks, kAnim156FrameRects},
+ {1, kAnim157FrameIndices, kAnim157FrameTicks, kAnim157FrameRects},
+ {6, kAnim158FrameIndices, kAnim158FrameTicks, kAnim158FrameRects},
+ {3, kAnim159FrameIndices, kAnim159FrameTicks, kAnim159FrameRects},
+ {1, kAnim160FrameIndices, kAnim160FrameTicks, kAnim160FrameRects},
+ {1, kAnim161FrameIndices, kAnim161FrameTicks, kAnim161FrameRects},
+ {1, kAnim162FrameIndices, kAnim162FrameTicks, kAnim162FrameRects},
+ {1, kAnim163FrameIndices, kAnim163FrameTicks, kAnim163FrameRects},
+ {1, kAnim164FrameIndices, kAnim164FrameTicks, kAnim164FrameRects},
+ {1, kAnim165FrameIndices, kAnim165FrameTicks, kAnim165FrameRects},
+ {1, kAnim166FrameIndices, kAnim166FrameTicks, kAnim166FrameRects},
+ {13, kAnim167FrameIndices, kAnim167FrameTicks, kAnim167FrameRects},
+ {1, kAnim168FrameIndices, kAnim168FrameTicks, kAnim168FrameRects},
+ {1, kAnim169FrameIndices, kAnim169FrameTicks, kAnim169FrameRects},
+ {6, kAnim170FrameIndices, kAnim170FrameTicks, kAnim170FrameRects},
+ {6, kAnim171FrameIndices, kAnim171FrameTicks, kAnim171FrameRects},
+ {2, kAnim172FrameIndices, kAnim172FrameTicks, kAnim172FrameRects}
+};
+
+static const MinigameBbAnt::ObjInit kObjInits[] = {
+ {&kAnimations[131], &kAnimations[132], &kAnimations[133], 160, 120},
+ {&kAnimations[134], &kAnimations[135], &kAnimations[136], 155, 130},
+ {&kAnimations[137], &kAnimations[138], &kAnimations[139], 150, 100},
+ {&kAnimations[140], &kAnimations[141], &kAnimations[142], 195, 150},
+ {&kAnimations[143], &kAnimations[144], &kAnimations[145], 120, 110},
+ {&kAnimations[146], &kAnimations[147], &kAnimations[148], 170, 170},
+ {&kAnimations[149], &kAnimations[150], &kAnimations[151], 175, 95},
+ {&kAnimations[152], &kAnimations[153], &kAnimations[154], 145, 165},
+ {&kAnimations[155], &kAnimations[156], &kAnimations[157], 110, 175}
+};
+static const ObjAnimation *kAnimationsTbl[] = {&kAnimations[0], &kAnimations[1], &kAnimations[2], &kAnimations[3], &kAnimations[4], &kAnimations[5], &kAnimations[6], &kAnimations[7], &kAnimations[16], &kAnimations[17], &kAnimations[18], &kAnimations[19], &kAnimations[20], &kAnimations[21], &kAnimations[22], &kAnimations[23], &kAnimations[24], &kAnimations[25], &kAnimations[26], &kAnimations[27], &kAnimations[28], &kAnimations[29], &kAnimations[30], &kAnimations[31], &kAnimations[32], &kAnimations[33], &kAnimations[42], &kAnimations[43], &kAnimations[44], &kAnimations[45], &kAnimations[46], &kAnimations[47], &kAnimations[48], &kAnimations[49], &kAnimations[50], &kAnimations[51], &kAnimations[52], &kAnimations[53], &kAnimations[54], &kAnimations[55], &kAnimations[56], &kAnimations[57], &kAnimations[58], &kAnimations[59], &kAnimations[68], &kAnimations[69], &kAnimations[70], &kAnimations[71], &kAnimations[72], &kAnimations[73], &kAnimations[74], &kAnimations[75], &kAnimations[7
6], &kAnimations[77], &kAnimations[78], &kAnimations[79], &kAnimations[80], &kAnimations[81], &kAnimations[82], &kAnimations[83], &kAnimations[84], &kAnimations[85], &kAnimations[94], &kAnimations[95], &kAnimations[96], &kAnimations[97], &kAnimations[98], &kAnimations[99], &kAnimations[100], &kAnimations[101], &kAnimations[102], &kAnimations[103], &kAnimations[104], &kAnimations[105], &kAnimations[106], &kAnimations[107], &kAnimations[108], &kAnimations[109], &kAnimations[110], &kAnimations[111], &kAnimations[120], &kAnimations[121], &kAnimations[122], &kAnimations[123], &kAnimations[124], &kAnimations[125], &kAnimations[126], &kAnimations[127], &kAnimations[128], &kAnimations[129]};
+
+static const ObjAnimation **kObjKindAnimTables[] = {
+ 0, &kAnimationsTbl[0],
+ &kAnimationsTbl[18], &kAnimationsTbl[36],
+ &kAnimationsTbl[54], &kAnimationsTbl[72]
+};
+
+const ObjAnimation *MinigameBbAnt::getAnimation(int animIndex) {
+ return &kAnimations[animIndex];
+}
+
+const MinigameBbAnt::ObjInit *MinigameBbAnt::getObjInit(int index) {
+ return &kObjInits[index];
+}
+
+const ObjAnimation **MinigameBbAnt::getObjKindAnimTable(int kind) {
+ return kObjKindAnimTables[kind];
+}
+
+const ObjAnimation *MinigameBbAnt::getObjAnim(int index) {
+ return kAnimationsTbl[index];
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/bbloogie.cpp b/engines/bbvs/minigames/bbloogie.cpp
new file mode 100644
index 0000000..4098eb2
--- /dev/null
+++ b/engines/bbvs/minigames/bbloogie.cpp
@@ -0,0 +1,1361 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/minigames/bbloogie.h"
+
+namespace Bbvs {
+
+static const int kLoogieOffY[16] = {
+ 0, 1, 1, 2, 2, 3, 3, 4,
+ 4, 5, 5, 6, 6, 7, 7, 0
+};
+
+static const int kSquirrelOffX[] = {
+ -43, -43, -38, -33, -33, -27, -23, -23,
+ -23, -23, -23, -23, -18, -14, -8, -4,
+ 2, 8, 12, 18, 20, 20, 26, 31,
+ 37, 37, 37, 37, 37, 37, 37, 32,
+ 29, 26, 21, 14, 10, 6, 6, 6,
+ 6, 6, 6, 6, 0, -6, -15, -20,
+ -27, -37, -41, -41, -41, -41
+};
+
+static const int kPlaneOffX[] = {
+ 0, -1, -1, -1, 0, 1, 1, 1
+};
+
+static const int kPlaneOffY[] = {
+ -1, -1, 0, 1, 1, 1, 0, -1
+};
+
+static const int kLevelScores[] = {
+ 20, 50, 90, 140, 200, 270, 350, 440, 540, 10000
+};
+
+static const int kLevelTimes[] = {
+ 120, 110, 100, 90, 80, 70, 60, 50, 40, 30
+};
+
+static const uint kBeavisSounds1[] = {
+ 14, 15, 19, 20, 22, 23, 24, 26
+};
+
+static const uint kButtheadSounds1[] = {
+ 16, 14, 15, 22, 23
+};
+
+static const uint kBeavisSounds2[] = {
+ 9, 3, 4, 5, 7, 14, 15, 19, 20, 22, 23, 24, 26
+};
+
+static const uint kButtheadSounds2[] = {
+ 9, 3, 4, 5, 7, 16, 14, 15, 22, 23
+};
+
+static const uint kPrincipalSounds[] = {
+ 3, 4, 5, 7
+};
+
+static const char *kSoundFilenames[] = {
+ "loog1.aif", "loog2.aif", "loog3.aif", "loog4.aif", "loog5.aif",
+ "loog6.aif", "loog7.aif", "loog8.aif", "loog9.aif", "loog10.aif",
+ "loog11.aif", "loog12.aif", "loog13.aif", "loog14.aif", "loog15.aif",
+ "loog16.aif", "loog17.aif", "loog18.aif", "loog19.aif", "loog20.aif",
+ "loog21.aif", "loog22.aif", "loog23.aif", "loog24.aif", "loog25.aif",
+ "loog26.aif", "loog27.aif", "meghoker.aif", "spit1.aif", "megaloog.aif",
+ "megaspit.aif", "gamemuse.aif", "bing.aif", "carhit.aif", "bikehit.aif",
+ "squirhit.aif", "planehit.aif", "bing2.aif"
+};
+
+static const uint kSoundFilenamesCount = ARRAYSIZE(kSoundFilenames);
+
+void MinigameBbloogie::buildDrawList(DrawList &drawList) {
+ switch (_gameState) {
+ case kGSTitleScreen:
+ buildDrawList0(drawList);
+ break;
+ case kGSMainGame:
+ buildDrawList1(drawList);
+ break;
+ case kGSStandaloneGame:
+ buildDrawList2(drawList);
+ break;
+ case kGSScoreCountUp:
+ buildDrawList3(drawList);
+ break;
+ }
+}
+
+void MinigameBbloogie::buildDrawList0(DrawList &drawList) {
+ drawList.add(_objects[0].anim->frameIndices[_objects[0].frameIndex], _objects[0].x, _objects[0].y, 2000);
+ for (int i = 1; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind != 0)
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, obj->y + 16);
+ }
+ if (_titleScreenSpriteIndex)
+ drawList.add(_titleScreenSpriteIndex, 0, 0, 0);
+}
+
+void MinigameBbloogie::buildDrawList1(DrawList &drawList) {
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ switch (obj->kind) {
+ case 0:
+ // Empty object
+ break;
+ case 2:
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, 400);
+ break;
+ case 3:
+ drawList.add(obj->anim->frameIndices[obj->frameIndex + obj->frameIndexAdd], obj->x, obj->y, 1000);
+ break;
+ case 7:
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, 390);
+ break;
+ case 8:
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, 1000);
+ break;
+ default:
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, obj->y + 16);
+ break;
+ }
+ }
+
+ if (_backgroundSpriteIndex)
+ drawList.add(_backgroundSpriteIndex, 0, 0, 0);
+
+ if (_fromMainGame) {
+ drawList.add(getAnimation(8)->frameIndices[0], 8, 2, 2000);
+ drawNumber(drawList, _numberOfHits, 56, 16);
+ } else {
+ drawList.add(getAnimation(10)->frameIndices[0], 230, 2, 2000);
+ drawNumber(drawList, _levelTimeLeft, 280, 16);
+ drawList.add(getAnimation(15)->frameIndices[0], 5, 2, 2000);
+ int numberX2 = drawNumber(drawList, _currScore, 68, 16);
+ drawList.add(getAnimation(9)->frameIndices[10], numberX2, 16, 2000);
+ drawNumber(drawList, _dispLevelScore, numberX2 + 10, 16);
+ }
+
+ for (int i = 0; i < _megaLoogieCount; ++i)
+ drawList.add(getAnimation(19)->frameIndices[0], 20 + i * 25, 236, 2000);
+
+}
+
+void MinigameBbloogie::buildDrawList2(DrawList &drawList) {
+
+ buildDrawList1(drawList);
+
+ if (_level > 0 && (_bonusDisplayDelay1 > 0 || _bonusDisplayDelay2 > 0)) {
+ drawList.add(getAnimation(12)->frameIndices[0], 100, 80, 2000);
+ drawNumber(drawList, _timeBonusCtr, 212, 94);
+ }
+
+ if (_bonusDisplayDelay3 > 0) {
+ drawList.add(getAnimation(14)->frameIndices[0], 65, 80, 2000);
+ int numberX2 = drawNumber(drawList, _nextLevelScore, 170, 92);
+ drawList.add(getAnimation(11)->frameIndices[0], numberX2, 80, 2000);
+ }
+
+}
+
+void MinigameBbloogie::buildDrawList3(DrawList &drawList) {
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind == 2)
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, 400);
+ else
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, obj->y + 16);
+ }
+
+ if (_backgroundSpriteIndex)
+ drawList.add(_backgroundSpriteIndex, 0, 0, 0);
+
+ drawList.add(getAnimation(10)->frameIndices[0], 230, 2, 2000);
+
+ drawNumber(drawList, _levelTimeLeft, 280, 16);
+
+ drawList.add(getAnimation(15)->frameIndices[0], 5, 2, 2000);
+
+ int numberX2 = drawNumber(drawList, _currScore, 68, 16);
+ drawList.add(getAnimation(9)->frameIndices[10], numberX2, 16, 2000);
+ drawNumber(drawList, _dispLevelScore, numberX2 + 10, 16);
+
+ drawList.add(getAnimation(20)->frameIndices[0], 120, 70, 2000);
+ drawList.add(getAnimation(13)->frameIndices[0], 95, 95, 2000);
+
+ drawNumber(drawList, _hiScore, 210, 109);
+
+}
+
+void MinigameBbloogie::drawSprites() {
+ DrawList drawList;
+ buildDrawList(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ _vm->_screen->copyToScreen();
+}
+
+void MinigameBbloogie::initObjs() {
+ for (int i = 0; i < kMaxObjectsCount; ++i)
+ _objects[i].kind = 0;
+}
+
+MinigameBbloogie::Obj *MinigameBbloogie::getFreeObject() {
+ for (int i = 0; i < kMaxObjectsCount; ++i)
+ if (_objects[i].kind == 0)
+ return &_objects[i];
+ return 0;
+}
+
+MinigameBbloogie::Obj *MinigameBbloogie::findLoogieObj(int startObjIndex) {
+ for (int i = startObjIndex; i < kMaxObjectsCount; ++i)
+ if (_objects[i].kind == 3)
+ return &_objects[i];
+ return 0;
+}
+
+bool MinigameBbloogie::isHit(Obj *obj1, Obj *obj2) {
+ const BBRect &frameRect1 = obj1->anim->frameRects[obj1->frameIndex];
+ const BBRect &frameRect2 = obj2->anim->frameRects[obj2->frameIndex];
+ const int obj1X1 = obj1->x + frameRect1.x;
+ const int obj1Y1 = obj1->y + frameRect1.y;
+ const int obj1X2 = obj1X1 + frameRect1.width;
+ const int obj1Y2 = obj1Y1 + frameRect1.height;
+ const int obj2X1 = obj2->x + frameRect2.x;
+ const int obj2Y1 = obj2->y + frameRect2.y;
+ const int obj2X2 = obj2X1 + frameRect2.width;
+ const int obj2Y2 = obj2Y1 + frameRect2.height;
+ return obj1X1 <= obj2X2 && obj1X2 >= obj2X1 && obj1Y1 <= obj2Y2 && obj1Y2 >= obj2Y1;
+}
+
+bool MinigameBbloogie::isCursorAtObj(int objIndex) {
+ return isHit(&_objects[0], &_objects[objIndex]);
+}
+
+void MinigameBbloogie::initObjects() {
+ switch (_gameState) {
+ case kGSTitleScreen:
+ initObjects0();
+ break;
+ case kGSMainGame:
+ initObjects1();
+ break;
+ case kGSStandaloneGame:
+ // Nothing
+ break;
+ case kGSScoreCountUp:
+ initObjects3();
+ break;
+ }
+}
+
+void MinigameBbloogie::initObjects0() {
+ initObjs();
+ _objects[0].anim = getAnimation(25);
+ _objects[0].frameIndex = 0;
+ _objects[0].ticks = getAnimation(25)->frameTicks[0];
+ _objects[0].x = 160;
+ _objects[0].y = 120;
+ _objects[0].kind = 1;
+ _objects[1].anim = getAnimation(21);
+ _objects[1].frameIndex = 0;
+ _objects[1].ticks = getAnimation(21)->frameTicks[0];
+ _objects[1].x = 40;
+ _objects[1].y = 240;
+ _objects[1].kind = 1;
+ _objects[2].anim = getAnimation(23);
+ _objects[2].frameIndex = 0;
+ _objects[2].ticks = getAnimation(23)->frameTicks[0];
+ _objects[2].x = 280;
+ _objects[2].y = 240;
+ _objects[2].kind = 1;
+ _objects[3].anim = getAnimation(22);
+ _objects[3].frameIndex = 0;
+ _objects[3].ticks = getAnimation(22)->frameTicks[0];
+ _objects[3].x = 40;
+ _objects[3].y = 240;
+ _objects[3].kind = 0;
+ _objects[4].anim = getAnimation(24);
+ _objects[4].frameIndex = 0;
+ _objects[4].ticks = getAnimation(24)->frameTicks[0];
+ _objects[4].x = 280;
+ _objects[4].y = 240;
+ _objects[4].kind = 0;
+}
+
+void MinigameBbloogie::initObjects1() {
+ initObjs();
+ _objects[0].anim = _playerAnim;
+ _objects[0].frameIndex = 0;
+ _objects[0].ticks = _playerAnim->frameTicks[0];
+ _objects[0].status = 0;
+ _objects[0].x = 160;
+ _objects[0].y = 240;
+ _objects[0].kind = 1;
+ _objects[1].anim = getAnimation(4);
+ _objects[1].frameIndex = 0;
+ _objects[1].ticks = getAnimation(4)->frameTicks[0];
+ _objects[1].x = 248;
+ _objects[1].y = 24;
+ _objects[1].kind = 2;
+}
+
+void MinigameBbloogie::initObjects3() {
+ initObjs();
+ _objects[0].anim = _playerAnim;
+ _objects[0].frameIndex = 0;
+ _objects[0].ticks = _playerAnim->frameTicks[0];
+ _objects[0].status = 0;
+ _objects[0].kind = 1;
+ _objects[1].anim = getAnimation(4);
+ _objects[1].frameIndex = 0;
+ _objects[1].ticks = getAnimation(4)->frameTicks[0];
+ _objects[1].x = 248;
+ _objects[1].y = 24;
+ _objects[1].kind = 2;
+}
+
+void MinigameBbloogie::initVars() {
+ switch (_gameState) {
+ case kGSTitleScreen:
+ initVars0();
+ break;
+ case kGSMainGame:
+ initVars1();
+ break;
+ case kGSStandaloneGame:
+ initVars2();
+ break;
+ case kGSScoreCountUp:
+ initVars3();
+ break;
+ }
+}
+
+void MinigameBbloogie::initVars0() {
+ _carDelay = 120;
+ _bikeDelay = 250;
+ _squirrelDelay = 40;
+ _paperPlaneDelay = 400; // Uninitialized in the original
+ _principalDelay = 1750;
+ _levelTimeDelay = 58;
+ _principalAngry = false;
+ _squirrelDirection = false;
+ _numberOfHits = 0;
+ _megaLoogieCount = 0;
+ _level = 0;
+ _levelTimeLeft = 0;
+ _currScore = 0;
+ _dispLevelScore = 0;
+}
+
+void MinigameBbloogie::initVars1() {
+ _carDelay = 120;
+ _bikeDelay = 250;
+ _squirrelDelay = 40;
+ _paperPlaneDelay = 400; // Uninitialized in the original
+ _principalDelay = 1750;
+ _squirrelDirection = false;
+ _numberOfHits = 0;
+ _megaLoogieCount = 0;
+}
+
+void MinigameBbloogie::initVars2() {
+ _timeBonusCtr = _levelTimeLeft;
+ _levelTimeDelay = 58;
+ _bonusDisplayDelay1 = 60;
+ _levelTimeLeft = kLevelTimes[_level];
+ _nextLevelScore = kLevelScores[_level] + _currScore;
+ _bonusDisplayDelay2 = 0;
+ _bonusDisplayDelay3 = 0;
+}
+
+void MinigameBbloogie::initVars3() {
+ if (_currScore > _hiScore)
+ _hiScore = _currScore;
+ if (_playerKind) {
+ playSound(11);
+ } else {
+ playSound(21);
+ }
+}
+
+bool MinigameBbloogie::updateStatus(int mouseX, int mouseY, uint mouseButtons) {
+ switch (_gameState) {
+ case kGSTitleScreen:
+ return updateStatus0(mouseX, mouseY, mouseButtons);
+ case kGSMainGame:
+ return updateStatus1(mouseX, mouseY, mouseButtons);
+ case kGSStandaloneGame:
+ return updateStatus2(mouseX, mouseY, mouseButtons);
+ case kGSScoreCountUp:
+ return updateStatus3(mouseX, mouseY, mouseButtons);
+ }
+ return false;
+}
+
+bool MinigameBbloogie::updateStatus0(int mouseX, int mouseY, uint mouseButtons) {
+
+ _objects[0].x = mouseX;
+ _objects[0].y = mouseY;
+
+ if (_objects[1].kind != 0 && isCursorAtObj(1)) {
+ _objects[0].frameIndex = 1;
+ _objects[1].kind = 0;
+ _objects[3].kind = 11;
+ _objects[3].frameIndex = 0;
+ _objects[3].ticks = _objects[3].anim->frameTicks[0];
+ } else if (!isCursorAtObj(3)) {
+ if (_objects[4].kind == 0)
+ _objects[0].frameIndex = 0;
+ _objects[3].kind = 0;
+ _objects[1].kind = 1;
+ }
+
+ if (_objects[2].kind && isCursorAtObj(2)) {
+ _objects[0].frameIndex = 1;
+ _objects[2].kind = 0;
+ _objects[4].kind = 11;
+ _objects[4].frameIndex = 0;
+ _objects[4].ticks = _objects[4].anim->frameTicks[0];
+ } else if (!isCursorAtObj(4)) {
+ if (_objects[3].kind == 0)
+ _objects[0].frameIndex = 0;
+ _objects[4].kind = 0;
+ _objects[2].kind = 1;
+ }
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind == 11) {
+ if (--obj->ticks == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex >= obj->anim->frameCount)
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[obj->frameIndex];
+ }
+ }
+ }
+
+ if ((mouseButtons & kLeftButtonDown) &&
+ (_objects[3].kind != 0 || _objects[4].kind != 0)) {
+ if (_objects[4].kind != 0) {
+ // Beavis
+ _playerKind = 0;
+ _playerAnim = getAnimation(0);
+ _playerSounds1 = kBeavisSounds1;
+ _playerSounds1Count = 8;
+ _playerSounds2 = kBeavisSounds2;
+ _playerSounds2Count = 13;
+ playSound(15);
+ while (isSoundPlaying(15)) { }
+ } else {
+ // Butt-head
+ _playerKind = 1;
+ _playerAnim = getAnimation(1);
+ _playerSounds1 = kButtheadSounds1;
+ _playerSounds1Count = 5;
+ _playerSounds2 = kButtheadSounds2;
+ _playerSounds2Count = 10;
+ playSound(23);
+ while (isSoundPlaying(23)) { }
+ }
+ _gameState = kGSMainGame;
+ if (!_fromMainGame)
+ _gameState = kGSStandaloneGame;
+ initObjects1();
+ initObjects();
+ initVars();
+ _gameTicks = 0;
+ }
+
+ return true;
+}
+
+bool MinigameBbloogie::updateStatus1(int mouseX, int mouseY, uint mouseButtons) {
+
+ if (--_levelTimeDelay == 0) {
+ _levelTimeDelay = 58;
+ --_levelTimeLeft;
+ }
+
+ if (!_fromMainGame && _levelTimeLeft == 0) {
+ _gameState = kGSScoreCountUp;
+ initObjects();
+ initVars();
+ } else if (_fromMainGame || _currScore < _nextLevelScore) {
+ _objects->x = CLIP(mouseX, 0, 319);
+ _objects->y = 240;
+ if (!_principalAngry &&
+ ((mouseButtons & kLeftButtonDown) || ((mouseButtons & kRightButtonDown) && _megaLoogieCount)) &&
+ _objects[0].status == 0 && mouseX != 32512 && mouseY != 32512) {
+ _objects[0].ticks = _playerAnim->frameTicks[13];
+ _objects[0].frameIndex = 14;
+ _objects[0].status = 1;
+ _objects[0].unk2 = 0;
+ Obj *newObj = getFreeObject();
+ newObj->anim = getAnimation(17);
+ newObj->frameIndex = 0;
+ newObj->ticks = 1;
+ newObj->x = 0;
+ newObj->y = 140;
+ newObj->kind = 8;
+ if (mouseButtons & kLeftButtonDown) {
+ _doubleScore = 0;
+ playSound(28);
+ } else {
+ _doubleScore = 17;
+ playSound(30);
+ }
+ }
+ updateObjs(mouseButtons);
+ } else {
+ _gameState = kGSStandaloneGame;
+ ++_level;
+ initObjects();
+ initVars();
+ }
+ return true;
+}
+
+bool MinigameBbloogie::updateStatus2(int mouseX, int mouseY, uint mouseButtons) {
+
+ _objects[0].x = mouseX;
+
+ if (_bonusDisplayDelay1 > 0) {
+ if (--_bonusDisplayDelay1 == 0) {
+ _bonusDisplayDelay2 = 60;
+ if (_timeBonusCtr)
+ playSound(33, true);
+ }
+ } else if (_bonusDisplayDelay2 > 0) {
+ if (--_bonusDisplayDelay2 == 0) {
+ _bonusDisplayDelay3 = 150;
+ playSound(38);
+ } else if (_timeBonusCtr > 0) {
+ ++_bonusDisplayDelay2;
+ ++_levelTimeLeft;
+ if (--_timeBonusCtr == 0)
+ stopSound(33);
+ }
+ } else if (_bonusDisplayDelay3 > 0) {
+ if ((mouseButtons & kAnyButtonDown) || (--_bonusDisplayDelay3 == 0)) {
+ _dispLevelScore = _nextLevelScore;
+ _gameState = kGSMainGame;
+ _gameTicks = 0;
+ }
+ }
+ return true;
+}
+
+bool MinigameBbloogie::updateStatus3(int mouseX, int mouseY, uint mouseButtons) {
+
+ _objects[0].x = mouseX;
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind == 2) {
+ if (--obj->ticks == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex >= obj->anim->frameCount)
+ obj->frameIndex = 0;
+ obj->ticks = obj->anim->frameTicks[obj->frameIndex];
+ }
+ }
+ }
+
+ return true;
+}
+
+void MinigameBbloogie::updateObjs(uint mouseButtons) {
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ switch (obj->kind) {
+ case 1:
+ updatePlayer(i, mouseButtons);
+ break;
+ case 2:
+ updateObjKind2(i);
+ break;
+ case 3:
+ updateLoogie(i);
+ break;
+ case 4:
+ updateCar(i);
+ break;
+ case 5:
+ updateBike(i);
+ break;
+ case 6:
+ updateSquirrel(i);
+ break;
+ case 7:
+ updatePaperPlane(i);
+ break;
+ case 8:
+ updateIndicator(i);
+ break;
+ case 9:
+ updatePrincipal(i);
+ break;
+ }
+ }
+
+ if (--_carDelay == 0) {
+ // Car
+ Obj *obj = getFreeObject();
+ obj->anim = getAnimation(2);
+ obj->kind = 4;
+ obj->frameIndex = 0;
+ obj->x = 379;
+ obj->y = 22;
+ obj->xIncr = -2;
+ obj->yIncr = 0;
+ _carDelay = _vm->getRandom(256) + 800;
+ }
+
+ if (--_bikeDelay == 0) {
+ // Bike
+ Obj *obj = getFreeObject();
+ obj->kind = 5;
+ obj->anim = getAnimation(3);
+ obj->frameIndex = 0;
+ obj->x = 360;
+ obj->y = _vm->getRandom(32) + 82;
+ obj->xIncr = -1;
+ obj->yIncr = 0;
+ _bikeDelay = _vm->getRandom(512) + 500;
+ }
+
+ if (--_squirrelDelay == 0) {
+ // Squirrel
+ Obj *obj = getFreeObject();
+ obj->kind = 6;
+ obj->anim = getAnimation(7);
+ obj->frameIndex = !_squirrelDirection ? 0 : 29;
+ obj->x = 160;
+ obj->y = 36;
+ obj->xIncr = 0;
+ obj->yIncr = 0;
+ _squirrelDirection = !_squirrelDirection;
+ if (_vm->getRandom(5) == 1 && !isAnySoundPlaying(_playerSounds2, _playerSounds2Count))
+ playSound(9);
+ _squirrelDelay = _vm->getRandom(512) + 300;
+ }
+
+ if (--_paperPlaneDelay == 0) {
+ // Paper plane
+ Obj *obj = getFreeObject();
+ obj->kind = 7;
+ obj->anim = getAnimation(16);
+ obj->frameIndex = 0;
+ obj->x = 86;
+ obj->y = 187;
+ obj->xIncr = 0;
+ obj->yIncr = -1;
+ switch (_vm->getRandom(3)) {
+ case 1:
+ obj->frameIndex = 1;
+ obj->xIncr = -1;
+ break;
+ case 2:
+ obj->frameIndex = 7;
+ obj->xIncr = 1;
+ break;
+ }
+ _paperPlaneDelay = 400;
+ }
+
+ if (_principalDelay >= 0 && --_principalDelay == 0) {
+ // Principal
+ Obj *obj = getFreeObject();
+ obj->kind = 9;
+ obj->anim = getAnimation(18);
+ obj->frameIndex = 11;
+ obj->x = -20;
+ obj->y = 130;
+ obj->xIncr = 1;
+ obj->yIncr = 0;
+ obj->status = 0;
+ obj->frameIndexAdd = 0;
+ obj->unk2 = _vm->getRandom(256) + 100;
+ _principalCtr = 0;
+ _principalFirstFrameIndex = 11;
+ _principalLastFrameIndex = 16;
+ }
+
+}
+
+void MinigameBbloogie::updatePlayer(int objIndex, uint mouseButtons) {
+
+ Obj *obj = &_objects[0];
+
+ switch (obj->status) {
+
+ case 1:
+ if (obj->ticks-- == 0) {
+ if (obj->frameIndex != 15) {
+ ++obj->frameIndex;
+ obj->ticks = _playerAnim->frameTicks[obj->frameIndex];
+ }
+ }
+ if ((((mouseButtons & kLeftButtonDown) && _doubleScore == 0) ||
+ ((mouseButtons & kRightButtonDown) && _doubleScore == 17))
+ && obj->unk2 != 61) {
+ ++obj->unk2;
+ } else {
+ obj->status = 2;
+ obj->frameIndex = 16;
+ obj->ticks = _playerAnim->frameTicks[16];
+ if (obj->unk2 >= 30) {
+ obj->status = 3;
+ obj->frameIndex = 21;
+ obj->ticks = _playerAnim->frameTicks[21];
+ }
+ if (obj->unk2 < 30) {
+ Obj *newObj = getFreeObject();
+ newObj->kind = 3;
+ newObj->anim = getAnimation(5);
+ newObj->frameIndex = 0;
+ newObj->ticks = getAnimation(5)->frameTicks[0];
+ newObj->x = obj->x;
+ newObj->y = 172;
+ newObj->unk2 = obj->unk2;
+ newObj->frameIndexAdd = _doubleScore;
+ if (_doubleScore)
+ --_megaLoogieCount;
+ }
+ if (_doubleScore) {
+ stopSound(30);
+ playSound(31);
+ } else {
+ stopSound(28);
+ playSound(29);
+ }
+ }
+ break;
+
+ case 2:
+ if (obj->ticks-- == 0) {
+ if (obj->frameIndex == 17) {
+ obj->frameIndex = 0;
+ obj->status = 0;
+ } else {
+ ++obj->frameIndex;
+ obj->ticks = _playerAnim->frameTicks[obj->frameIndex];
+ }
+ }
+ break;
+
+ case 3:
+ if (obj->ticks-- == 0) {
+ if (obj->frameIndex == 23) {
+ obj->frameIndex = 0;
+ obj->status = 0;
+ } else {
+ ++obj->frameIndex;
+ obj->ticks = _playerAnim->frameTicks[obj->frameIndex];
+ if (obj->frameIndex == 22) {
+ Obj *newObj = getFreeObject();
+ newObj->kind = 3;
+ newObj->anim = getAnimation(5);
+ newObj->frameIndex = 0;
+ newObj->ticks = getAnimation(5)->frameTicks[0];
+ newObj->x = obj->x;
+ newObj->y = 154;
+ newObj->unk2 = obj->unk2;
+ newObj->frameIndexAdd = _doubleScore;
+ if (_doubleScore)
+ --_megaLoogieCount;
+ }
+ }
+ }
+ break;
+
+ }
+
+}
+
+void MinigameBbloogie::updateObjKind2(int objIndex) {
+
+ Obj *obj = &_objects[objIndex];
+
+ if (obj->ticks-- == 0) {
+ obj->ticks = getAnimation(4)->frameTicks[0];
+ if (obj->frameIndex > 7)
+ obj->frameIndex = 1;
+ if (obj->frameIndex++ >= 7)
+ obj->frameIndex = 0;
+ }
+
+}
+
+void MinigameBbloogie::updateLoogie(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ if (obj->unk2 > 0) {
+ obj->y -= kLoogieOffY[obj->unk2 / 8];
+ --obj->unk2;
+ }
+
+ if (obj->ticks-- == 0) {
+ obj->ticks = getAnimation(5)->frameTicks[0];
+ ++obj->frameIndex;
+ if (obj->frameIndex >= 17) {
+ obj->kind = 0;
+ obj->anim = getAnimation(6);
+ obj->frameIndex = 0;
+ }
+ }
+
+}
+
+void MinigameBbloogie::updateCar(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ obj->x += obj->xIncr;
+
+ if (obj->ticks-- == 0) {
+ if (obj->frameIndex++ == 3 || obj->frameIndex == 6)
+ obj->frameIndex = 0;
+ obj->ticks = getAnimation(2)->frameTicks[obj->frameIndex];
+ }
+
+ if (obj->x <= -60) {
+ obj->kind = 0;
+ obj->anim = getAnimation(6);
+ obj->frameIndex = 0;
+ } else if (!_principalAngry && obj->frameIndex <= 3) {
+ int loogieObjIndex = 0;
+ Obj *loogieObj = findLoogieObj(loogieObjIndex++);
+ while (loogieObj) {
+ if (loogieObj->frameIndex >= 8 && loogieObj->frameIndex <= 10 && isHit(obj, loogieObj)) {
+ incNumberOfHits();
+ incScore(7);
+ loogieObj->frameIndex = 13;
+ loogieObj->ticks = getAnimation(5)->frameTicks[12];
+ obj->frameIndex = 4;
+ obj->ticks = getAnimation(2)->frameTicks[4];
+ playSound(34);
+ playRndSound();
+ }
+ loogieObj = findLoogieObj(loogieObjIndex++);
+ }
+ }
+
+}
+
+void MinigameBbloogie::updateBike(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ obj->x += obj->xIncr;
+
+ if (obj->ticks-- == 0) {
+ if (obj->frameIndex++ == 3 || obj->frameIndex == 7)
+ obj->frameIndex = 0;
+ obj->ticks = getAnimation(3)->frameTicks[obj->frameIndex];
+ }
+
+ if (obj->x == -40) {
+ obj->kind = 0;
+ obj->anim = getAnimation(6);
+ obj->frameIndex = 0;
+ } else if (!_principalAngry && obj->frameIndex <= 3) {
+ int loogieObjIndex = 0;
+ Obj *loogieObj = findLoogieObj(loogieObjIndex++);
+ while (loogieObj) {
+ if (loogieObj->frameIndex >= 7 && loogieObj->frameIndex <= 11 && isHit(obj, loogieObj)) {
+ incNumberOfHits();
+ incScore(2);
+ loogieObj->frameIndex = 13;
+ loogieObj->ticks = getAnimation(5)->frameTicks[12];
+ obj->frameIndex = 4;
+ obj->ticks = getAnimation(3)->frameTicks[4];
+ playSound(35);
+ playRndSound();
+ }
+ loogieObj = findLoogieObj(loogieObjIndex++);
+ }
+ }
+
+}
+
+void MinigameBbloogie::updateSquirrel(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ if (obj->ticks-- == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex == 29 || obj->frameIndex == 54 ||
+ obj->frameIndex == 58 || obj->frameIndex == 62) {
+ obj->kind = 0;
+ obj->anim = getAnimation(6);
+ obj->frameIndex = 0;
+ }
+ obj->ticks = getAnimation(7)->frameTicks[obj->frameIndex];
+ }
+
+ if (!_principalAngry && obj->frameIndex <= 53) {
+ int loogieObjIndex = 0;
+ Obj *loogieObj = findLoogieObj(loogieObjIndex++);
+ while (loogieObj) {
+ if (loogieObj->frameIndex >= 7 && loogieObj->frameIndex <= 9 && isHit(obj, loogieObj)) {
+ incNumberOfHits();
+ incScore(10);
+ loogieObj->frameIndex = 13;
+ loogieObj->ticks = getAnimation(5)->frameTicks[12];
+ obj->x += kSquirrelOffX[obj->frameIndex];
+ obj->frameIndex = obj->frameIndex < 29 ? 54 : 58;
+ obj->ticks = getAnimation(7)->frameTicks[obj->frameIndex];
+ playSound(36);
+ playRndSound();
+ }
+ loogieObj = findLoogieObj(loogieObjIndex++);
+ }
+ }
+
+}
+
+void MinigameBbloogie::updatePaperPlane(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+
+ if (obj->x == -16 || obj->x == 336 || obj->y == -16) {
+ obj->kind = 0;
+ obj->anim = getAnimation(6);
+ obj->frameIndex = 0;
+ }
+
+ if (!_principalAngry && obj->frameIndex <= 53) {
+ int loogieObjIndex = 0;
+ Obj *loogieObj = findLoogieObj(loogieObjIndex++);
+ while (loogieObj) {
+ if (loogieObj->frameIndex >= 4 && loogieObj->frameIndex <= 7 && isHit(obj, loogieObj)) {
+ incNumberOfHits();
+ incScore(5);
+ loogieObj->frameIndex = 13;
+ loogieObj->ticks = getAnimation(5)->frameTicks[12];
+ obj->frameIndex = (obj->frameIndex + 1) % 8;
+ obj->xIncr = kPlaneOffX[obj->frameIndex];
+ obj->yIncr = kPlaneOffY[obj->frameIndex];
+ playSound(37);
+ playRndSound();
+ }
+ loogieObj = findLoogieObj(loogieObjIndex++);
+ }
+ }
+
+}
+
+void MinigameBbloogie::updateIndicator(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+ Obj *loogieObj = &_objects[0];
+
+ if (obj->ticks-- == 0) {
+ obj->frameIndex = (obj->frameIndex + 1) % 2;
+ obj->ticks = getAnimation(17)->frameTicks[0];
+ }
+
+ if (loogieObj->status != 0) {
+ int unk2mod = loogieObj->unk2 / 8;
+ int unk2div = loogieObj->unk2 / 8 * 8;
+ int v6 = 0;
+ if (unk2div >= 8) {
+ int v7 = 1;
+ if (unk2div != 8) {
+ do {
+ v6 += 8 * kLoogieOffY[v7++];
+ } while (v7 != unk2mod);
+ }
+ }
+ int yOfs = (loogieObj->unk2 % 8 + 1) * kLoogieOffY[loogieObj->unk2 / 8] + v6;
+ if (loogieObj->unk2 >= 30)
+ yOfs += 18;
+ obj->y = 140 - yOfs;
+ } else {
+ obj->kind = 0;
+ obj->anim = getAnimation(6);
+ }
+
+}
+
+void MinigameBbloogie::updatePrincipal(int objIndex) {
+ Obj *obj = &_objects[objIndex];
+
+ switch (obj->status) {
+
+ case 0:
+ if (obj->unk2--) {
+ if (obj->ticks-- == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex == _principalLastFrameIndex)
+ obj->frameIndex = _principalFirstFrameIndex;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ ++_principalCtr;
+ if (_principalCtr % 2 != 0) {
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+ if (obj->xIncr > 0 && obj->x == 340) {
+ obj->xIncr = -1;
+ _principalLastFrameIndex = 34;
+ _principalFirstFrameIndex = 29;
+ obj->frameIndex = 29;
+ obj->status = 2;
+ obj->ticks = _vm->getRandom(256) + 60;
+ }
+ if (obj->xIncr < 0 && obj->x == -20) {
+ obj->xIncr = 1;
+ _principalLastFrameIndex = 16;
+ _principalFirstFrameIndex = 11;
+ obj->frameIndex = 11;
+ obj->status = 2;
+ obj->ticks = _vm->getRandom(256) + 60;
+ }
+ }
+ } else {
+ obj->unk2 = _vm->getRandom(64) + 20;
+ ++obj->status;
+ if (_vm->getRandom(2) == 1) {
+ obj->frameIndex = _principalFirstFrameIndex < 11 ? 17 : 26;
+ _principalFirstFrameIndex = 19;
+ } else {
+ obj->frameIndex = _principalFirstFrameIndex < 11 ? 8 : 35;
+ _principalFirstFrameIndex = 1;
+ }
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ break;
+
+ case 1:
+ if (obj->unk2--) {
+ if (obj->ticks-- == 0)
+ obj->frameIndex = _principalFirstFrameIndex;
+ } else {
+ obj->unk2 = _vm->getRandom(256) + 100;
+ ++obj->status;
+ if (_vm->getRandom(2) == 1) {
+ _principalLastFrameIndex = 16;
+ _principalFirstFrameIndex = 11;
+ obj->frameIndex = obj->frameIndex < 1 ? 8 : 17;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ obj->xIncr = 1;
+ } else {
+ _principalLastFrameIndex = 34;
+ _principalFirstFrameIndex = 29;
+ obj->frameIndex = obj->frameIndex < 1 ? 35 : 26;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ obj->xIncr = -1;
+ }
+ }
+ break;
+
+ case 2:
+ if (obj->ticks-- == 0) {
+ obj->status = 0;
+ obj->frameIndex = _principalFirstFrameIndex;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ break;
+
+ case 3:
+ if (obj->ticks-- == 0) {
+ obj->status = _prevPrincipalStatus;
+ obj->frameIndex = _principalFirstFrameIndex;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ break;
+
+ case 4:
+ if (obj->ticks-- == 0) {
+ switch (obj->frameIndex) {
+ case 8:
+ obj->frameIndex = 36;
+ break;
+ case 26:
+ obj->frameIndex = 28;
+ break;
+ case 28:
+ obj->frameIndex = 35;
+ break;
+ case 35:
+ ++obj->frameIndex;
+ break;
+ case 36:
+ obj->status = 5;
+ ++obj->frameIndex;
+ break;
+ }
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ break;
+
+ case 5:
+ if (obj->ticks-- == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex == 48)
+ obj->frameIndex = 36;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ if (!isSoundPlaying(1)) {
+ _gameResult = 1;
+ if (_fromMainGame) {
+ _principalAngry = true;
+ if (obj->x <= 140 || obj->x >= 165) {
+ obj->status = 6;
+ if (obj->x >= 160) {
+ _principalLastFrameIndex = 34;
+ _principalFirstFrameIndex = 29;
+ obj->frameIndex = 29;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ obj->xIncr = -1;
+ } else {
+ _principalLastFrameIndex = 16;
+ _principalFirstFrameIndex = 11;
+ obj->frameIndex = 11;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ obj->xIncr = 1;
+ }
+ } else {
+ obj->status = 7;
+ _principalFirstFrameIndex = 2;
+ _principalLastFrameIndex = 7;
+ obj->frameIndex = 2;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ obj->xIncr = 0;
+ obj->yIncr = 1;
+ }
+ } else {
+ obj->status = _prevPrincipalStatus;
+ obj->frameIndex = _principalFirstFrameIndex;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ }
+ break;
+
+ case 6:
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+ if (obj->ticks-- == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex == _principalLastFrameIndex)
+ obj->frameIndex = _principalFirstFrameIndex;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ if (obj->x > 145 && obj->x < 160) {
+ obj->status = 7;
+ _principalFirstFrameIndex = 2;
+ _principalLastFrameIndex = 7;
+ obj->frameIndex = 2;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ obj->xIncr = 0;
+ obj->yIncr = 1;
+ }
+ break;
+
+ case 7:
+ obj->x += obj->xIncr;
+ obj->y += obj->yIncr;
+ if (obj->ticks-- == 0) {
+ ++obj->frameIndex;
+ if (obj->frameIndex == _principalLastFrameIndex)
+ obj->frameIndex = _principalFirstFrameIndex;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ }
+ if (obj->y > 175) {
+ // Angry principal enters school, end the minigame
+ _gameDone = true;
+ }
+ break;
+
+ }
+
+ if (!_principalAngry) {
+ int loogieObjIndex = 0;
+ Obj *loogieObj = findLoogieObj(loogieObjIndex++);
+ while (loogieObj) {
+ if (loogieObj->frameIndex >= 7 && loogieObj->frameIndex <= 12 && isHit(obj, loogieObj)) {
+ incNumberOfHits();
+ incScore(1);
+ loogieObj->frameIndex = 13;
+ loogieObj->ticks = getAnimation(5)->frameTicks[12];
+ if (obj->status != 3 && obj->status != 4 && obj->status != 5) {
+ _prevPrincipalStatus = obj->status;
+ obj->status = 3;
+ if (_principalFirstFrameIndex == 1 || _principalFirstFrameIndex == 19)
+ obj->frameIndex = _principalFirstFrameIndex - 1;
+ else
+ obj->frameIndex = _principalFirstFrameIndex - 2;
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ if (loogieObj->frameIndexAdd > 0) {
+ obj->status = 4;
+ switch (obj->frameIndex) {
+ case 0:
+ obj->frameIndex = 36;
+ break;
+ case 9:
+ obj->frameIndex = 8;
+ break;
+ case 27:
+ obj->frameIndex = 35;
+ break;
+ case 18:
+ obj->frameIndex = 26;
+ break;
+ }
+ obj->ticks = getAnimation(18)->frameTicks[obj->frameIndex];
+ playSound(1);
+ } else {
+ if (!isAnySoundPlaying(_playerSounds2, _playerSounds2Count))
+ playSound(kPrincipalSounds[_vm->getRandom(4)]);
+ playRndSound();
+ }
+ }
+ }
+ loogieObj = findLoogieObj(loogieObjIndex++);
+ }
+ }
+
+}
+
+void MinigameBbloogie::incNumberOfHits() {
+ ++_numberOfHits;
+ if (_numberOfHits == 1000)
+ _numberOfHits = 0;
+ if (_numberOfHits % 10 == 0) {
+ ++_megaLoogieCount;
+ if (_megaLoogieCount > 11)
+ _megaLoogieCount = 11;
+ }
+}
+
+void MinigameBbloogie::incScore(int incrAmount) {
+ if (_doubleScore)
+ _currScore += 2 * incrAmount;
+ else
+ _currScore += incrAmount;
+}
+
+void MinigameBbloogie::playRndSound() {
+ if (!isAnySoundPlaying(_playerSounds2, _playerSounds2Count))
+ playSound(_playerSounds1[_vm->getRandom(_playerSounds1Count)]);
+}
+
+int MinigameBbloogie::run(uint flags) {
+
+ memset(_objects, 0, sizeof(_objects));
+
+ _numbersAnim = getAnimation(9);
+
+ _backgroundSpriteIndex = 210;
+ _titleScreenSpriteIndex = 211;
+
+ _fromMainGame = false;
+ if (flags & 1)
+ _fromMainGame = true;
+
+ _hiScore = 0;
+ if (!_fromMainGame) {
+ // TODO Load LoogieHiScore
+ }
+
+ _gameState = kGSTitleScreen;
+ _gameTicks = 0;
+ _gameResult = 0;
+ _gameDone = false;
+ initObjects();
+ initVars();
+
+ _spriteModule = new SpriteModule();
+ _spriteModule->load("bbloogie/bbloogie.000");
+
+ Palette palette = _spriteModule->getPalette();
+ _vm->_screen->setPalette(palette);
+
+ // Load sounds
+ loadSounds();
+
+ playSound(32, true);
+
+ while (!_vm->shouldQuit() &&!_gameDone) {
+ _vm->updateEvents();
+ update();
+ }
+
+ // Unload sounds
+ _vm->_sound->unloadSounds();
+
+ if (!_fromMainGame) {
+ // TODO Save LoogieHiScore
+ }
+
+ delete _spriteModule;
+
+ return _gameResult;
+}
+
+void MinigameBbloogie::update() {
+
+ int currTicks, inputTicks;
+
+ if (_gameTicks > 0) {
+ currTicks = _vm->_system->getMillis();
+ inputTicks = (currTicks - _gameTicks) / 17;
+ _gameTicks = currTicks - (currTicks - _gameTicks) % 17;
+ } else {
+ inputTicks = 1;
+ _gameTicks = _vm->_system->getMillis();
+ }
+
+ if (_vm->_keyCode == Common::KEYCODE_ESCAPE) {
+ _gameDone = true;
+ return;
+ }
+
+ if (inputTicks == 0)
+ return;
+
+ bool done;
+
+ do {
+ done = !updateStatus(_vm->_mouseX, _vm->_mouseY, _vm->_mouseButtons);
+ _vm->_mouseButtons &= ~kLeftButtonClicked;
+ _vm->_mouseButtons &= ~kRightButtonClicked;
+ _vm->_keyCode = Common::KEYCODE_INVALID;
+ } while (--inputTicks && _gameTicks > 0 && !done);
+
+ drawSprites();
+
+}
+
+void MinigameBbloogie::loadSounds() {
+ for (uint i = 0; i < kSoundFilenamesCount; ++i) {
+ Common::String filename = Common::String::format("bbloogie/%s", kSoundFilenames[i]);
+ _vm->_sound->loadSound(filename.c_str());
+ }
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/bbloogie.h b/engines/bbvs/minigames/bbloogie.h
new file mode 100644
index 0000000..b05536b
--- /dev/null
+++ b/engines/bbvs/minigames/bbloogie.h
@@ -0,0 +1,141 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#ifndef BBVS_MINIGAMES_BBLOOGIE_H
+#define BBVS_MINIGAMES_BBLOOGIE_H
+
+#include "bbvs/minigames/minigame.h"
+
+namespace Bbvs {
+
+class MinigameBbloogie : public Minigame {
+public:
+ MinigameBbloogie(BbvsEngine *vm) : Minigame(vm) {};
+ int run(uint flags);
+public:
+
+ struct Obj {
+ int kind;
+ int x, y;
+ int xIncr, yIncr;
+ const ObjAnimation *anim;
+ int frameIndex;
+ int ticks;
+ int status;
+ int16 frameIndexAdd;
+ int16 unk2;
+ };
+
+ enum {
+ kMaxObjectsCount = 256
+ };
+
+ enum {
+ kGSTitleScreen = 0, // Title screen
+ kGSMainGame = 1, // Game when called as part of the main game
+ kGSStandaloneGame = 2, // Game when called as standalone game
+ kGSScoreCountUp = 3 // Score countup and next level text
+ };
+
+ Obj _objects[kMaxObjectsCount];
+
+ int _playerKind;
+ const ObjAnimation *_playerAnim;
+ const uint *_playerSounds1, *_playerSounds2;
+ uint _playerSounds1Count, _playerSounds2Count;
+
+ int _level, _levelTimeLeft, _levelTimeDelay;
+ int _numberOfHits, _currScore, _hiScore;
+ int _doubleScore, _megaLoogieCount;
+
+ int _dispLevelScore, _nextLevelScore;
+
+ int _timeBonusCtr, _bonusDisplayDelay1, _bonusDisplayDelay2, _bonusDisplayDelay3;
+
+ int _carDelay;
+ int _bikeDelay;
+ int _squirrelDelay;
+ bool _squirrelDirection;
+ int _paperPlaneDelay;
+ int _principalDelay;
+
+ int _prevPrincipalStatus;
+ int _principalCtr, _principalFirstFrameIndex, _principalLastFrameIndex;
+ bool _principalAngry;
+
+ const ObjAnimation *getAnimation(int animIndex);
+
+ void buildDrawList(DrawList &drawList);
+ void buildDrawList0(DrawList &drawList);
+ void buildDrawList1(DrawList &drawList);
+ void buildDrawList2(DrawList &drawList);
+ void buildDrawList3(DrawList &drawList);
+
+ void drawSprites();
+
+ void initObjs();
+ Obj *getFreeObject();
+ Obj *findLoogieObj(int startObjIndex);
+ bool isHit(Obj *obj1, Obj *obj2);
+ bool isCursorAtObj(int objIndex);
+
+ void initObjects();
+ void initObjects0();
+ void initObjects1();
+ void initObjects3();
+
+ void initVars();
+ void initVars0();
+ void initVars1();
+ void initVars2();
+ void initVars3();
+
+ bool updateStatus(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus0(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus1(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus2(int mouseX, int mouseY, uint mouseButtons);
+ bool updateStatus3(int mouseX, int mouseY, uint mouseButtons);
+
+ void updateObjs(uint mouseButtons);
+ void updatePlayer(int objIndex, uint mouseButtons);
+ void updateObjKind2(int objIndex);
+ void updateLoogie(int objIndex);
+ void updateCar(int objIndex);
+ void updateBike(int objIndex);
+ void updateSquirrel(int objIndex);
+ void updatePaperPlane(int objIndex);
+ void updateIndicator(int objIndex);
+ void updatePrincipal(int objIndex);
+
+ void incNumberOfHits();
+ void incScore(int incrAmount);
+ void playRndSound();
+
+ void update();
+
+ void loadSounds();
+
+};
+
+} // End of namespace Bbvs
+
+#endif // BBVS_H
diff --git a/engines/bbvs/minigames/bbloogie_anims.cpp b/engines/bbvs/minigames/bbloogie_anims.cpp
new file mode 100644
index 0000000..61a2e48
--- /dev/null
+++ b/engines/bbvs/minigames/bbloogie_anims.cpp
@@ -0,0 +1,138 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/minigames/bbloogie.h"
+
+namespace Bbvs {
+
+static const int kAnim0FrameIndices[] = {0, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 0, 5, 6, 7, 0, 0, 5, 6, 7, 8, 0, 4, 3, 2, 1, 4, 3, 2, 1, 4, 3, 2, 1, 0};
+static const int16 kAnim0FrameTicks[] = {22, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 20, 8, 8, 10, 10, 10, 8, 22, 6, 12, 20, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 22};
+static const BBRect kAnim0FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim1FrameIndices[] = {9, 10, 11, 12, 13, 10, 11, 12, 13, 10, 11, 12, 13, 9, 14, 15, 16, 9, 9, 14, 15, 16, 17, 9, 13, 12, 11, 10, 13, 12, 11, 10, 13, 12, 11, 10, 9};
+static const int16 kAnim1FrameTicks[] = {22, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 20, 8, 8, 10, 10, 10, 8, 22, 6, 12, 20, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 22};
+static const BBRect kAnim1FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim2FrameIndices[] = {18, 19, 20, 18, 21, 22};
+static const int16 kAnim2FrameTicks[] = {6, 6, 6, 6, 6, 6};
+static const BBRect kAnim2FrameRects[] = {{-45, -43, 86, 38}, {-45, -43, 86, 38}, {-45, -43, 86, 38}, {-45, -43, 86, 38}, {-45, -43, 86, 38}, {-45, -43, 86, 38}};
+static const int kAnim3FrameIndices[] = {23, 24, 25, 26, 27, 28, 27};
+static const int16 kAnim3FrameTicks[] = {6, 6, 6, 6, 6, 7, 6};
+static const BBRect kAnim3FrameRects[] = {{-24, -17, 48, 14}, {-24, -17, 48, 14}, {-24, -17, 48, 14}, {-24, -17, 48, 14}, {-24, -17, 48, 14}, {-24, -17, 48, 14}, {-24, -17, 48, 14}};
+static const int kAnim4FrameIndices[] = {29, 30, 31, 32, 33, 34, 35, 36};
+static const int16 kAnim4FrameTicks[] = {6, 6, 6, 6, 6, 6, 6, 6};
+static const BBRect kAnim4FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim5FrameIndices[] = {37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70};
+static const int16 kAnim5FrameTicks[] = {6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
+static const BBRect kAnim5FrameRects[] = {{-1, -11, 4, 11}, {-2, -15, 6, 8}, {-3, -24, 8, 8}, {-3, -31, 7, 9}, {-3, -33, 8, 8}, {-3, -34, 8, 10}, {-2, -34, 7, 8}, {-1, -34, 6, 7}, {-1, -34, 5, 6}, {-1, -34, 4, 4}, {0, -34, 3, 4}, {-1, -34, 4, 3}, {0, -34, 3, 4}, {0, -33, 3, 3}, {-1, -35, 5, 5}, {-3, -37, 9, 9}, {-4, -39, 12, 13}, {-3, -11, 7, 8}, {-3, -15, 8, 9}, {-5, -24, 11, 13}, {-4, -31, 10, 13}, {-5, -34, 11, 13}, {-5, -34, 11, 11}, {-4, -34, 9, 10}, {-4, -34, 9, 9}, {-3, -34, 7, 8}, {-2, -34, 6, 7}, {-2, -34, 5, 6}, {-2, -34, 4, 5}, {-7, -38, 13, 13}, {-10, -44, 22, 22}, {-13, -47, 27, 27}, {-17, -49, 32, 30}, {-17, -50, 34, 33}};
+static const int kAnim6FrameIndices[] = {71};
+static const int16 kAnim6FrameTicks[] = {1};
+static const BBRect kAnim6FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim7FrameIndices[] = {72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 80, 79, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 110, 109, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129};
+static const int16 kAnim7FrameTicks[] = {6, 6, 6, 6, 6, 6, 6, 30, 6, 20, 6, 30, 6, 6, 6, 6, 6, 6, 6, 6, 6, 30, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 30, 6, 20, 6, 30, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
+static const BBRect kAnim7FrameRects[] = {{-46, -6, 7, 6}, {-46, -12, 11, 12}, {-47, -15, 17, 15}, {-46, -14, 20, 12}, {-47, -10, 24, 10}, {-41, -11, 22, 11}, {-33, -10, 15, 10}, {-32, -10, 14, 10}, {-32, -9, 13, 9}, {-32, -9, 13, 9}, {-32, -9, 13, 9}, {-32, -10, 13, 10}, {-34, -11, 24, 11}, {-30, -12, 25, 9}, {-24, -10, 24, 10}, {-18, -11, 22, 11}, {-14, -11, 24, 10}, {-9, -12, 25, 9}, {-3, -10, 24, 10}, {4, -11, 22, 11}, {11, -10, 15, 10}, {12, -10, 13, 10}, {10, -11, 24, 11}, {15, -12, 25, 9}, {22, -16, 22, 16}, {34, -16, 9, 16}, {35, -12, 9, 12}, {38, -6, 6, 6}, {38, -6, 4, 4}, {36, -6, 7, 6}, {31, -12, 12, 12}, {27, -15, 17, 15}, {24, -12, 20, 12}, {19, -11, 22, 11}, {13, -11, 24, 11}, {7, -11, 25, 9}, {4, -10, 24, 10}, {1, -11, 22, 11}, {1, -10, 15, 10}, {2, -10, 13, 10}, {2, -10, 13, 10}, {2, -9, 13, 9}, {2, -10, 13, 10}, {2, -10, 13, 10}, {-7, -11, 24, 11}, {-14, -11, 25, 9}, {-21, -10, 24, 11}, {-27, -11, 23, 11}, {-34, -12, 24, 11}, {-44, -18, 22, 16}, {-44, -16, 9
, 16}, {-46, -12, 9, 12}, {-45, -6, 7, 6}, {-45, -4, 6, 5}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim8FrameIndices[] = {130};
+static const int16 kAnim8FrameTicks[] = {6};
+static const BBRect kAnim8FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim9FrameIndices[] = {131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141};
+static const int16 kAnim9FrameTicks[] = {6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
+static const BBRect kAnim9FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim10FrameIndices[] = {142};
+static const int16 kAnim10FrameTicks[] = {2};
+static const BBRect kAnim10FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim11FrameIndices[] = {143};
+static const int16 kAnim11FrameTicks[] = {1};
+static const BBRect kAnim11FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim12FrameIndices[] = {144};
+static const int16 kAnim12FrameTicks[] = {1};
+static const BBRect kAnim12FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim13FrameIndices[] = {145};
+static const int16 kAnim13FrameTicks[] = {1};
+static const BBRect kAnim13FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim14FrameIndices[] = {146};
+static const int16 kAnim14FrameTicks[] = {1};
+static const BBRect kAnim14FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim15FrameIndices[] = {147};
+static const int16 kAnim15FrameTicks[] = {1};
+static const BBRect kAnim15FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim16FrameIndices[] = {148, 149, 150, 151, 152, 153, 154, 155};
+static const int16 kAnim16FrameTicks[] = {6, 6, 6, 6, 6, 6, 6, 6};
+static const BBRect kAnim16FrameRects[] = {{-5, -5, 9, 9}, {-6, -5, 11, 11}, {-6, -4, 9, 9}, {-5, -5, 10, 10}, {-5, -3, 9, 9}, {-6, -5, 10, 10}, {-4, -4, 9, 9}, {-6, -4, 10, 10}};
+static const int kAnim17FrameIndices[] = {156, 157};
+static const int16 kAnim17FrameTicks[] = {6, 6};
+static const BBRect kAnim17FrameRects[] = {{0, 0, 0, 0}, {0, 0, 0, 0}};
+static const int kAnim18FrameIndices[] = {158, 159, 160, 161, 160, 162, 163, 162, 164, 165, 166, 167, 168, 167, 169, 170, 169, 171, 172, 173, 174, 175, 174, 176, 177, 176, 178, 179, 180, 181, 182, 181, 183, 184, 183, 185, 186, 187, 188, 189, 190, 188, 189, 191, 188, 190, 189, 187, 186};
+static const int16 kAnim18FrameTicks[] = {10, 20, 8, 8, 8, 8, 8, 8, 6, 10, 20, 8, 8, 8, 8, 8, 8, 6, 10, 20, 8, 8, 8, 8, 8, 8, 6, 10, 20, 8, 8, 8, 8, 8, 8, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6};
+static const BBRect kAnim18FrameRects[] = {{-13, -16, 26, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-10, -19, 18, 20}, {-8, -20, 15, 23}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-10, -18, 19, 20}, {-12, -17, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-12, -16, 24, 16}, {-10, -18, 20, 19}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-8, -20, 16, 22}, {-9, -19, 18, 20}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-12, -17, 24, 17}, {-1
2, -17, 24, 17}};
+static const int kAnim19FrameIndices[] = {192};
+static const int16 kAnim19FrameTicks[] = {8};
+static const BBRect kAnim19FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim20FrameIndices[] = {193};
+static const int16 kAnim20FrameTicks[] = {5};
+static const BBRect kAnim20FrameRects[] = {{0, 0, 0, 0}};
+static const int kAnim21FrameIndices[] = {194};
+static const int16 kAnim21FrameTicks[] = {6};
+static const BBRect kAnim21FrameRects[] = {{-7, -80, 17, 81}};
+static const int kAnim22FrameIndices[] = {195, 196, 197, 198, 199, 200};
+static const int16 kAnim22FrameTicks[] = {6, 6, 6, 6, 6, 6};
+static const BBRect kAnim22FrameRects[] = {{-22, -91, 45, 93}, {-21, -92, 43, 95}, {-21, -92, 43, 95}, {-21, -92, 43, 95}, {-21, -92, 43, 95}, {-21, -92, 43, 95}};
+static const int kAnim23FrameIndices[] = {201};
+static const int16 kAnim23FrameTicks[] = {6};
+static const BBRect kAnim23FrameRects[] = {{-12, -75, 21, 75}};
+static const int kAnim24FrameIndices[] = {202, 203, 204, 205, 206, 207};
+static const int16 kAnim24FrameTicks[] = {6, 6, 6, 6, 6, 6};
+static const BBRect kAnim24FrameRects[] = {{-21, -85, 38, 86}, {-21, -85, 38, 86}, {-21, -85, 38, 86}, {-21, -85, 38, 86}, {-21, -85, 38, 86}, {-21, -85, 38, 86}};
+static const int kAnim25FrameIndices[] = {208, 209};
+static const int16 kAnim25FrameTicks[] = {6, 6};
+static const BBRect kAnim25FrameRects[] = {{-9, -9, 17, 15}, {-11, -10, 19, 16}};
+static const ObjAnimation kAnimations[] = {
+ {37, kAnim0FrameIndices, kAnim0FrameTicks, kAnim0FrameRects},
+ {37, kAnim1FrameIndices, kAnim1FrameTicks, kAnim1FrameRects},
+ {6, kAnim2FrameIndices, kAnim2FrameTicks, kAnim2FrameRects},
+ {7, kAnim3FrameIndices, kAnim3FrameTicks, kAnim3FrameRects},
+ {8, kAnim4FrameIndices, kAnim4FrameTicks, kAnim4FrameRects},
+ {34, kAnim5FrameIndices, kAnim5FrameTicks, kAnim5FrameRects},
+ {1, kAnim6FrameIndices, kAnim6FrameTicks, kAnim6FrameRects},
+ {62, kAnim7FrameIndices, kAnim7FrameTicks, kAnim7FrameRects},
+ {1, kAnim8FrameIndices, kAnim8FrameTicks, kAnim8FrameRects},
+ {11, kAnim9FrameIndices, kAnim9FrameTicks, kAnim9FrameRects},
+ {1, kAnim10FrameIndices, kAnim10FrameTicks, kAnim10FrameRects},
+ {1, kAnim11FrameIndices, kAnim11FrameTicks, kAnim11FrameRects},
+ {1, kAnim12FrameIndices, kAnim12FrameTicks, kAnim12FrameRects},
+ {1, kAnim13FrameIndices, kAnim13FrameTicks, kAnim13FrameRects},
+ {1, kAnim14FrameIndices, kAnim14FrameTicks, kAnim14FrameRects},
+ {1, kAnim15FrameIndices, kAnim15FrameTicks, kAnim15FrameRects},
+ {8, kAnim16FrameIndices, kAnim16FrameTicks, kAnim16FrameRects},
+ {2, kAnim17FrameIndices, kAnim17FrameTicks, kAnim17FrameRects},
+ {49, kAnim18FrameIndices, kAnim18FrameTicks, kAnim18FrameRects},
+ {1, kAnim19FrameIndices, kAnim19FrameTicks, kAnim19FrameRects},
+ {1, kAnim20FrameIndices, kAnim20FrameTicks, kAnim20FrameRects},
+ {1, kAnim21FrameIndices, kAnim21FrameTicks, kAnim21FrameRects},
+ {6, kAnim22FrameIndices, kAnim22FrameTicks, kAnim22FrameRects},
+ {1, kAnim23FrameIndices, kAnim23FrameTicks, kAnim23FrameRects},
+ {6, kAnim24FrameIndices, kAnim24FrameTicks, kAnim24FrameRects},
+ {2, kAnim25FrameIndices, kAnim25FrameTicks, kAnim25FrameRects}
+};
+
+const ObjAnimation *MinigameBbloogie::getAnimation(int animIndex) {
+ return &kAnimations[animIndex];
+}
+
+} // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/bbtennis.cpp b/engines/bbvs/minigames/bbtennis.cpp
new file mode 100644
index 0000000..87ea355
--- /dev/null
+++ b/engines/bbvs/minigames/bbtennis.cpp
@@ -0,0 +1,1278 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ */
+
+#include "bbvs/sound.h"
+#include "bbvs/minigames/bbtennis.h"
+
+namespace Bbvs {
+
+static const int kLeftPlayerOffX[] = {
+ -44, -44, -44, -44, -39, -39, -34,
+ -26, -26, -14, -6, -6, -6, -6
+};
+
+static const int kLeftPlayerOffY[] = {
+ -31, -31, -31, -31, -23, -23, -21,
+ -18, -18, -14, -11, -11, -11, -11
+};
+
+static const char *kSoundFilenames[] = {
+ "tenis9.aif", "tenis10.aif", "tenis11.aif", "tenis12.aif", "tenis13.aif",
+ "tenis14.aif", "tenis15.aif", "tenis16.aif", "tenis17.aif", "tenis18.aif",
+ "tenis19.aif", "tenis20.aif", "tenis21.aif", "1ahh.aif", "1dammit.aif",
+ "1getawy.aif", "1getthem.aif", "1owww.aif", "1pardon.aif", "1rcktbll.aif",
+ "1yourout.aif", "2hey.aif", "2inhere.aif", "2stoptht.aif", "2theyare.aif",
+ "3oh.aif", "3ow.aif", "3upunks.aif", "tenismus.aif", "canon1.aif",
+ "canon2.aif"
+};
+
+static const uint kSoundFilenamesCount = ARRAYSIZE(kSoundFilenames);
+
+static const int kLeftNetPlayAnims[] = {
+ 13, 15, 17
+};
+
+static const int kRightNetPlayAnims[] = {
+ 14, 16, 18
+};
+
+static const uint kYuppieHitSounds[] = {
+ 14, 15, 18, 22, 26, 27
+};
+
+static const uint kYuppieEnteringCourtSounds[] = {
+ 19, 20
+};
+
+static const uint kYuppieChargeSounds[] = {
+ 16, 17, 23, 24, 28, 0
+};
+
+static const uint kAllSounds[] = {
+ 3, 4, 7, 9, 19, 20, 16, 17, 23, 24, 28
+};
+
+void MinigameBbTennis::buildDrawList(DrawList &drawList) {
+ switch (_gameState) {
+ case 0:
+ buildDrawList0(drawList);
+ break;
+ case 1:
+ buildDrawList1(drawList);
+ break;
+ case 2:
+ buildDrawList2(drawList);
+ break;
+ }
+}
+
+void MinigameBbTennis::buildDrawList0(DrawList &drawList) {
+
+ drawList.add(_objects[0].anim->frameIndices[_objects[0].frameIndex], _objects[0].x, _objects[0].y, 2000);
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind)
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, obj->y + 16);
+ }
+
+ if (_titleScreenSpriteIndex > 0)
+ drawList.add(_titleScreenSpriteIndex, 0, 0, 0);
+
+}
+
+void MinigameBbTennis::buildDrawList1(DrawList &drawList) {
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+
+ if (obj->kind) {
+ int index = obj->anim->frameIndices[obj->frameIndex];
+ int x = obj->x;
+ int y = obj->y;
+ int priority = obj->y + 16;
+
+ switch (obj->kind) {
+
+ case 1:
+ priority = 3000;
+ break;
+
+ case 2:
+ priority = 550;
+ if (obj->frameIndex == 0)
+ drawList.add(obj->anim->frameIndices[8], obj->x, obj->y, 550);
+ break;
+
+ case 6:
+ if (obj->frameIndex == 31) {
+ y = 640;
+ index = obj->anim->frameIndices[26];
+ }
+ if (obj->status == 4) {
+ --obj->blinkCtr;
+ if (obj->blinkCtr % 2)
+ y = 600;
+ if (obj->blinkCtr == 0)
+ obj->kind = 0;
+ }
+ break;
+
+ case 7:
+ priority = 540;
+ if (obj->frameIndex == 0)
+ drawList.add(obj->anim->frameIndices[8], obj->x, obj->y, 550);
+ break;
+
+ case 4:
+ if (obj->status == 8) {
+ --obj->blinkCtr;
+ if (obj->blinkCtr % 2)
+ y = 600;
+ if (obj->blinkCtr == 0)
+ obj->kind = 0;
+ }
+ break;
+
+ }
+
+ drawList.add(index, x, y, priority);
+
+ }
+ }
+
+ if (_rapidFireBallsCount > 0) {
+ drawList.add(getAnimation(19)->frameIndices[0], 24, 208, 990);
+ drawList.add(getAnimation(20)->frameIndices[_rapidFireBallsCount / 10 % 10], 19, 198, 2000);
+ drawList.add(getAnimation(20)->frameIndices[_rapidFireBallsCount % 10], 29, 198, 2000);
+
+ }
+
+ if (_backgroundSpriteIndex > 0)
+ drawList.add(_backgroundSpriteIndex, 0, 0, 0);
+
+ drawList.add(getAnimation(8)->frameIndices[0], 9, 53, 500);
+ drawList.add(getAnimation(9)->frameIndices[0], 256, 52, 500);
+ drawList.add(getAnimation(10)->frameIndices[0], 60, 162, 500);
+ drawList.add(getAnimation(21)->frameIndices[0], 36, 18, 2000);
+
+ drawNumber(drawList, _score, 70, 18);
+
+ for (int i = 0; i < _numHearts; ++i)
+ drawList.add(getAnimation(7)->frameIndices[0], 20 + i * 20, 236, 990);
+
+}
+
+void MinigameBbTennis::buildDrawList2(DrawList &drawList) {
+
+ for (int i = 0; i < kMaxObjectsCount; ++i) {
+ Obj *obj = &_objects[i];
+ if (obj->kind)
+ drawList.add(obj->anim->frameIndices[obj->frameIndex], obj->x, obj->y, obj->y + 16);
+ }
+
+ if (_backgroundSpriteIndex > 0)
+ drawList.add(_backgroundSpriteIndex, 0, 0, 0);
+
+ drawList.add(getAnimation(21)->frameIndices[0], 36, 18, 2000);
+
+ drawNumber(drawList, _score, 70, 18);
+
+ drawList.add(getAnimation(22)->frameIndices[0], 120, 70, 2000);
+ drawList.add(getAnimation(23)->frameIndices[0], 95, 95, 2000);
+
+ drawNumber(drawList, _hiScore, 210, 109);
+
+}
+
+void MinigameBbTennis::drawSprites() {
+ DrawList drawList;
+ buildDrawList(drawList);
+ _vm->_screen->drawDrawList(drawList, _spriteModule);
+ _vm->_screen->copyToScreen();
+}
+
+void MinigameBbTennis::initObjs() {
+ for (int i = 0; i < kMaxObjectsCount; ++i)
+ _objects[i].kind = 0;
+}
+
+MinigameBbTennis::Obj *MinigameBbTennis::getFreeObject() {
+ for (int i = 0; i < kMaxObjectsCount; ++i)
+ if (_objects[i].kind == 0)
+ return &_objects[i];
+ return 0;
+}
+
+MinigameBbTennis::Obj *MinigameBbTennis::findTennisBall(int startObjIndex) {
+ for (int i = startObjIndex; i < kMaxObjectsCount; ++i)
+ if (_objects[i].kind == 2)
+ return &_objects[i];
+ return 0;
+}
+
+bool MinigameBbTennis::isHit(Obj *obj1, Obj *obj2) {
+ const BBRect &frameRect1 = obj1->anim->frameRects[obj1->frameIndex];
+ const BBRect &frameRect2 = obj2->anim->frameRects[obj2->frameIndex];
+ const int obj1X1 = obj1->x + frameRect1.x;
+ const int obj1Y1 = obj1->y + frameRect1.y;
+ const int obj1X2 = obj1X1 + frameRect1.width;
+ const int obj1Y2 = obj1Y1 + frameRect1.height;
+ const int obj2X1 = obj2->x + frameRect2.x;
+ const int obj2Y1 = obj2->y + frameRect2.y;
+ const int obj2X2 = obj2X1 + frameRect2.width;
+ const int obj2Y2 = obj2Y1 + frameRect2.height;
+ return obj1X1 <= obj2X2 && obj1X2 >= obj2X1 && obj1Y1 <= obj2Y2 && obj1Y2 >= obj2Y1;
+}
+
+void MinigameBbTennis::initObjects() {
+ switch (_gameState) {
+ case 0:
+ initObjects0();
+ break;
+ case 1:
+ initObjects1();
+ break;
+ case 2:
+ initObjects2();
+ break;
+ }
+}
+
+void MinigameBbTennis::initObjects0() {
+ _objects[0].anim = getAnimation(24);
+ _objects[0].frameIndex = 0;
+ _objects[0].ticks = getAnimation(24)->frameTicks[0];
+ _objects[0].x = 160;
+ _objects[0].y = 100;
+ _objects[0].kind = 1;
+ _objects[1].anim = getAnimation(25);
+ _objects[1].frameIndex = 0;
+ _objects[1].ticks = getAnimation(25)->frameTicks[0];
+ _objects[1].x = 40;
+ _objects[1].y = 240;
+ _objects[1].kind = 2;
+ _objects[2].anim = getAnimation(26);
+ _objects[2].frameIndex = 0;
+ _objects[2].ticks = getAnimation(26)->frameTicks[0];
+ _objects[2].x = 280;
+ _objects[2].y = 240;
+ _objects[2].kind = 2;
+}
+
+void MinigameBbTennis::initObjects1() {
+ _objects[0].anim = getAnimation(5);
+ _objects[0].frameIndex = 0;
+ _objects[0].ticks = getAnimation(5)->frameTicks[0];
+ _objects[0].status = 0;
+ _objects[0].x = 160;
+ _objects[0].y = 100;
+ _objects[0].kind = 1;
+ for (int i = 1; i < kMaxObjectsCount; ++i)
+ _objects[i].kind = 0;
+}
+
+void MinigameBbTennis::initObjects2() {
+ // Nothing
+}
+
+void MinigameBbTennis::initVars() {
+ switch (_gameState) {
+ case 0:
+ initVars0();
+ break;
+ case 1:
+ initVars1();
+ break;
+ case 2:
+ initVars2();
+ break;
+ }
+}
+
+void MinigameBbTennis::initVars0() {
+ // Nothing
+}
+
Commit: 11a58071101d84bc02ac5e9a4e3dee209d0d5df9
https://github.com/scummvm/scummvm/commit/11a58071101d84bc02ac5e9a4e3dee209d0d5df9
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-29T04:27:48-08:00
Commit Message:
BBVS: Remove obsolete code in BbAnt minigame
Changed paths:
engines/bbvs/minigames/bbant.cpp
engines/bbvs/minigames/bbant.h
diff --git a/engines/bbvs/minigames/bbant.cpp b/engines/bbvs/minigames/bbant.cpp
index 24dbd45..1313556 100644
--- a/engines/bbvs/minigames/bbant.cpp
+++ b/engines/bbvs/minigames/bbant.cpp
@@ -1316,25 +1316,4 @@ void MinigameBbAnt::loadSounds() {
}
}
-void MinigameBbAnt::playSound(uint index, bool loop) {
- if (index > 0)
- _vm->_sound->playSound(index - 1, loop);
-}
-
-void MinigameBbAnt::stopSound(uint index) {
- if (index > 0)
- _vm->_sound->stopSound(index - 1);
-}
-
-bool MinigameBbAnt::isSoundPlaying(uint index) {
- return index > 0 && _vm->_sound->isSoundPlaying(index - 1);
-}
-
-bool MinigameBbAnt::isAnySoundPlaying(const uint *indices, uint count) {
- for (uint i = 0; i < count; ++i)
- if (isSoundPlaying(indices[i]))
- return true;
- return false;
-}
-
} // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/bbant.h b/engines/bbvs/minigames/bbant.h
index b9919ee..cdf358f 100644
--- a/engines/bbvs/minigames/bbant.h
+++ b/engines/bbvs/minigames/bbant.h
@@ -165,10 +165,6 @@ public:
void scale2x(int x, int y);
void loadSounds();
- void playSound(uint index, bool loop = false);
- void stopSound(uint index);
- bool isSoundPlaying(uint index);
- bool isAnySoundPlaying(const uint *indices, uint count);
};
Commit: ef55f5b774b55bd085b05ab704ff9418af960670
https://github.com/scummvm/scummvm/commit/ef55f5b774b55bd085b05ab704ff9418af960670
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-29T04:27:48-08:00
Commit Message:
BBVS: Replace minigame flags parameter
Changed paths:
engines/bbvs/bbvs.cpp
engines/bbvs/minigames/bbairguitar.cpp
engines/bbvs/minigames/bbairguitar.h
engines/bbvs/minigames/bbant.cpp
engines/bbvs/minigames/bbant.h
engines/bbvs/minigames/bbloogie.cpp
engines/bbvs/minigames/bbloogie.h
engines/bbvs/minigames/bbtennis.cpp
engines/bbvs/minigames/bbtennis.h
engines/bbvs/minigames/minigame.h
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 2b0a4a5..091bcd6 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -26,6 +26,7 @@
#include "bbvs/graphics.h"
#include "bbvs/sound.h"
#include "bbvs/spritemodule.h"
+#include "bbvs/minigames/minigame.h"
#include "bbvs/minigames/bbairguitar.h"
#include "bbvs/minigames/bbant.h"
#include "bbvs/minigames/bbloogie.h"
@@ -2145,26 +2146,23 @@ void BbvsEngine::stopSounds() {
bool BbvsEngine::runMinigame(int minigameNum) {
debug("BbvsEngine::runMinigame() minigameNum: %d", minigameNum);
- int callFlags = 0;
+ bool fromMainGame = _currSceneNum != kMainMenu;
- if (_currSceneNum != kMainMenu)
- callFlags = 1;
-
_sound->unloadSounds();
Minigame *minigame = 0;
switch (minigameNum) {
- case 0:
+ case kMinigameBbloogie:
minigame = new MinigameBbloogie(this);
break;
- case 1:
+ case kMinigameBbTennis:
minigame = new MinigameBbTennis(this);
break;
- case 2:
+ case kMinigameBbAnt:
minigame = new MinigameBbAnt(this);
break;
- case 3:
+ case kMinigameBbAirGuitar:
minigame = new MinigameBbAirGuitar(this);
break;
default:
@@ -2172,7 +2170,7 @@ bool BbvsEngine::runMinigame(int minigameNum) {
break;
}
- int minigameResult = minigame->run(callFlags);
+ int minigameResult = minigame->run(fromMainGame);
delete minigame;
@@ -2180,9 +2178,11 @@ bool BbvsEngine::runMinigame(int minigameNum) {
if (minigameNum == 0 && minigameResult == 1)
_gameVars[42] = 1;
+#if 0
//DEBUG Fake it :)
if (minigameNum == 0)
_gameVars[42] = 1;
+#endif
return true;
}
diff --git a/engines/bbvs/minigames/bbairguitar.cpp b/engines/bbvs/minigames/bbairguitar.cpp
index f81bb49..b5d9d2a 100644
--- a/engines/bbvs/minigames/bbairguitar.cpp
+++ b/engines/bbvs/minigames/bbairguitar.cpp
@@ -732,7 +732,7 @@ void MinigameBbAirGuitar::updateObjs() {
}
}
-int MinigameBbAirGuitar::run(uint flags) {
+int MinigameBbAirGuitar::run(bool fromMainGame) {
memset(_objects, 0, sizeof(_objects));
@@ -762,9 +762,7 @@ int MinigameBbAirGuitar::run(uint flags) {
_backgroundSpriteIndex = 97;
_titleScreenSpriteIndex = 98;
- _fromMainGame = false;
- if (flags & 1)
- _fromMainGame = true;
+ _fromMainGame = fromMainGame;
_gameState = 0;
_gameTicks = 0;
diff --git a/engines/bbvs/minigames/bbairguitar.h b/engines/bbvs/minigames/bbairguitar.h
index 70ba580..5c1eb00 100644
--- a/engines/bbvs/minigames/bbairguitar.h
+++ b/engines/bbvs/minigames/bbairguitar.h
@@ -30,7 +30,7 @@ namespace Bbvs {
class MinigameBbAirGuitar : public Minigame {
public:
MinigameBbAirGuitar(BbvsEngine *vm) : Minigame(vm) {};
- int run(uint flags);
+ int run(bool fromMainGame);
public:
struct Obj {
diff --git a/engines/bbvs/minigames/bbant.cpp b/engines/bbvs/minigames/bbant.cpp
index 1313556..fa36c7d 100644
--- a/engines/bbvs/minigames/bbant.cpp
+++ b/engines/bbvs/minigames/bbant.cpp
@@ -1185,7 +1185,7 @@ void MinigameBbAnt::updateObjs(uint mouseButtons) {
}
-int MinigameBbAnt::run(uint flags) {
+int MinigameBbAnt::run(bool fromMainGame) {
memset(_objects, 0, sizeof(_objects));
@@ -1194,9 +1194,7 @@ int MinigameBbAnt::run(uint flags) {
_backgroundSpriteIndex = 303;
_titleScreenSpriteIndex = 304;
- _fromMainGame = false;
- if (flags & 1)
- _fromMainGame = true;
+ _fromMainGame = fromMainGame;
_hiScore = 0;
_gameState = 0;
diff --git a/engines/bbvs/minigames/bbant.h b/engines/bbvs/minigames/bbant.h
index cdf358f..a133d66 100644
--- a/engines/bbvs/minigames/bbant.h
+++ b/engines/bbvs/minigames/bbant.h
@@ -30,7 +30,7 @@ namespace Bbvs {
class MinigameBbAnt : public Minigame {
public:
MinigameBbAnt(BbvsEngine *vm) : Minigame(vm) {};
- int run(uint flags);
+ int run(bool fromMainGame);
public:
struct Obj {
diff --git a/engines/bbvs/minigames/bbloogie.cpp b/engines/bbvs/minigames/bbloogie.cpp
index 4098eb2..b79e8c7 100644
--- a/engines/bbvs/minigames/bbloogie.cpp
+++ b/engines/bbvs/minigames/bbloogie.cpp
@@ -1264,7 +1264,7 @@ void MinigameBbloogie::playRndSound() {
playSound(_playerSounds1[_vm->getRandom(_playerSounds1Count)]);
}
-int MinigameBbloogie::run(uint flags) {
+int MinigameBbloogie::run(bool fromMainGame) {
memset(_objects, 0, sizeof(_objects));
@@ -1273,9 +1273,7 @@ int MinigameBbloogie::run(uint flags) {
_backgroundSpriteIndex = 210;
_titleScreenSpriteIndex = 211;
- _fromMainGame = false;
- if (flags & 1)
- _fromMainGame = true;
+ _fromMainGame = fromMainGame;
_hiScore = 0;
if (!_fromMainGame) {
diff --git a/engines/bbvs/minigames/bbloogie.h b/engines/bbvs/minigames/bbloogie.h
index b05536b..d01149a 100644
--- a/engines/bbvs/minigames/bbloogie.h
+++ b/engines/bbvs/minigames/bbloogie.h
@@ -30,7 +30,7 @@ namespace Bbvs {
class MinigameBbloogie : public Minigame {
public:
MinigameBbloogie(BbvsEngine *vm) : Minigame(vm) {};
- int run(uint flags);
+ int run(bool fromMainGame);
public:
struct Obj {
diff --git a/engines/bbvs/minigames/bbtennis.cpp b/engines/bbvs/minigames/bbtennis.cpp
index 87ea355..edf9cab 100644
--- a/engines/bbvs/minigames/bbtennis.cpp
+++ b/engines/bbvs/minigames/bbtennis.cpp
@@ -1181,7 +1181,7 @@ void MinigameBbTennis::hitSomething() {
++_score;
}
-int MinigameBbTennis::run(uint flags) {
+int MinigameBbTennis::run(bool fromMainGame) {
memset(_objects, 0, sizeof(_objects));
@@ -1190,9 +1190,7 @@ int MinigameBbTennis::run(uint flags) {
_backgroundSpriteIndex = 272;
_titleScreenSpriteIndex = 273;
- _fromMainGame = false;
- if (flags & 1)
- _fromMainGame = true;
+ _fromMainGame = fromMainGame;
_hiScore = 0;
if (!_fromMainGame) {
diff --git a/engines/bbvs/minigames/bbtennis.h b/engines/bbvs/minigames/bbtennis.h
index 63617c9..644eec7 100644
--- a/engines/bbvs/minigames/bbtennis.h
+++ b/engines/bbvs/minigames/bbtennis.h
@@ -30,7 +30,7 @@ namespace Bbvs {
class MinigameBbTennis : public Minigame {
public:
MinigameBbTennis(BbvsEngine *vm) : Minigame(vm) {};
- int run(uint flags);
+ int run(bool fromMainGame);
public:
struct Obj {
diff --git a/engines/bbvs/minigames/minigame.h b/engines/bbvs/minigames/minigame.h
index 09630ae..33498be 100644
--- a/engines/bbvs/minigames/minigame.h
+++ b/engines/bbvs/minigames/minigame.h
@@ -30,6 +30,13 @@
namespace Bbvs {
+enum {
+ kMinigameBbloogie = 0,
+ kMinigameBbTennis = 1,
+ kMinigameBbAnt = 2,
+ kMinigameBbAirGuitar = 3
+};
+
struct ObjAnimation {
int frameCount;
const int *frameIndices;
@@ -41,7 +48,7 @@ class Minigame {
public:
Minigame(BbvsEngine *vm);
virtual ~Minigame();
- virtual int run(uint flags) = 0;
+ virtual int run(bool fromMainGame) = 0;
public:
BbvsEngine *_vm;
SpriteModule *_spriteModule;
Commit: 24fd6587959e2e7db805fcde13bb0e0fe005a8b2
https://github.com/scummvm/scummvm/commit/24fd6587959e2e7db805fcde13bb0e0fe005a8b2
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-29T04:27:49-08:00
Commit Message:
BBVS: Add loading/saving of minigame hiscores
Changed paths:
engines/bbvs/bbvs.cpp
engines/bbvs/bbvs.h
engines/bbvs/minigames/bbairguitar.cpp
engines/bbvs/minigames/bbant.cpp
engines/bbvs/minigames/bbloogie.cpp
engines/bbvs/minigames/bbloogie.h
engines/bbvs/minigames/bbloogie_anims.cpp
engines/bbvs/minigames/bbtennis.cpp
engines/bbvs/minigames/minigame.cpp
engines/bbvs/minigames/minigame.h
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 091bcd6..e8db691 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -2153,8 +2153,8 @@ bool BbvsEngine::runMinigame(int minigameNum) {
Minigame *minigame = 0;
switch (minigameNum) {
- case kMinigameBbloogie:
- minigame = new MinigameBbloogie(this);
+ case kMinigameBbLoogie:
+ minigame = new MinigameBbLoogie(this);
break;
case kMinigameBbTennis:
minigame = new MinigameBbTennis(this);
diff --git a/engines/bbvs/bbvs.h b/engines/bbvs/bbvs.h
index eaeb529..8d9ccc0 100644
--- a/engines/bbvs/bbvs.h
+++ b/engines/bbvs/bbvs.h
@@ -216,6 +216,7 @@ public:
void newGame();
void continueGameFromQuickSave();
void setNewSceneNum(int newSceneNum);
+ const Common::String getTargetName() { return _targetName; }
private:
const ADGameDescription *_gameDescription;
Graphics::PixelFormat _pixelFormat;
diff --git a/engines/bbvs/minigames/bbairguitar.cpp b/engines/bbvs/minigames/bbairguitar.cpp
index b5d9d2a..f65c1b5 100644
--- a/engines/bbvs/minigames/bbairguitar.cpp
+++ b/engines/bbvs/minigames/bbairguitar.cpp
@@ -736,6 +736,7 @@ int MinigameBbAirGuitar::run(bool fromMainGame) {
memset(_objects, 0, sizeof(_objects));
+ _modified = false;
_currPatchNum = -1;
_btn3KindToggle = 0;
_currButtonNum = 27;
@@ -783,7 +784,6 @@ int MinigameBbAirGuitar::run(bool fromMainGame) {
update();
}
- // Unload sounds
_vm->_sound->unloadSounds();
delete _spriteModule;
@@ -923,7 +923,7 @@ void MinigameBbAirGuitar::afterButtonReleased() {
break;
case 4:
*_currFrameIndex = 1;
- // TODO PostMessageA(hWndParent, WM_COMMAND, 0x9C6Du, 0);
+ // TODO Run load dialog
break;
case 5:
_objects[3].kind = 0;
@@ -948,7 +948,7 @@ void MinigameBbAirGuitar::afterButtonReleased() {
break;
case 12:
*_currFrameIndex = 1;
- // TODO PostMessageA(hWndParent, WM_COMMAND, 0x9C6Eu, 0);
+ // TODO Run save dialog
break;
case 13:
_objects[4].kind = 0;
diff --git a/engines/bbvs/minigames/bbant.cpp b/engines/bbvs/minigames/bbant.cpp
index fa36c7d..f2d3ad2 100644
--- a/engines/bbvs/minigames/bbant.cpp
+++ b/engines/bbvs/minigames/bbant.cpp
@@ -387,8 +387,7 @@ bool MinigameBbAnt::updateStatus0(int mouseX, int mouseY, uint mouseButtons) {
}
bool MinigameBbAnt::updateStatus1(int mouseX, int mouseY, uint mouseButtons) {
- //const int kMaxBugsCount = 52;
- const int kMaxBugsCount = 1;//DEBUG
+ const int kMaxBugsCount = 52;
--_levelTimeDelay;
if (!_levelTimeDelay) {
@@ -424,7 +423,6 @@ bool MinigameBbAnt::updateStatus1(int mouseX, int mouseY, uint mouseButtons) {
return true;
}
-debug(0, "updateStatus1 #2");
if ((mouseButtons & kRightButtonClicked) && (_stompCount > 0|| _hasLastStompObj) && !_objects[2].status) {
if (_hasLastStompObj)
removeStompObj(_lastStompObj);
@@ -432,14 +430,12 @@ debug(0, "updateStatus1 #2");
_objects[2].status = 1;
}
-debug(0, "updateStatus1 #3");
if ((mouseButtons & kLeftButtonClicked) && _objects[2].status == 0 && isMagGlassAtBeavisLeg(2)) {
if (_vm->getRandom(10) == 1 && !isAnySoundPlaying(kSoundTbl4, 10))
playSound(16);
insertSmokeObj(_objects[0].x << 16, _objects[0].y << 16);
}
-debug(0, "updateStatus1 #4");
if (_skullBugCtr > 0) {
if (--_skullBugCtr == 0) {
_skullBugCtr = _vm->getRandom(150) + 500;
@@ -450,18 +446,15 @@ debug(0, "updateStatus1 #4");
if (_stompCounter2 > 0)
--_stompCounter2;
-debug(0, "updateStatus1 #5");
if (_totalBugsCount < kMaxBugsCount && _vm->getRandom(_stompCounter2) == 0) {
int testTbl[4];
int maxKindCount = 0, objKind = 0;
_stompCounter2 = _stompCounter1;
-debug(0, "updateStatus1 #6");
for (int i = 0; i < 4; ++i)
testTbl[i] = _vm->getRandom(_bugsChanceByKind[i] - _bugsCountByKind[i]);
-debug(0, "updateStatus1 #7");
for (int i = 0; i < 4; ++i) {
if (testTbl[i] >= maxKindCount) {
maxKindCount = testTbl[i];
@@ -469,15 +462,12 @@ debug(0, "updateStatus1 #7");
}
}
-debug(0, "updateStatus1 #8");
if (objKind)
insertRandomBugObj(objKind);
}
-debug(0, "updateStatus1 #9");
updateObjs(mouseButtons);
-debug(0, "updateStatus1 #10");
updateFootObj(2);
if (--_countdown10 == 0) {
@@ -486,7 +476,6 @@ debug(0, "updateStatus1 #10");
--_stompCounter1;
}
-debug(0, "updateStatus1 #XXX");
return true;
}
@@ -643,7 +632,6 @@ void MinigameBbAnt::insertStompObj(int x, int y) {
obj->xIncr = (0x1E0000 * _stompCount - x + 0x140000) / 15;
obj->yIncr = (0xE60000 - y) / 15;
obj->anim = getAnimation(130);
- debug("obj->anim(130): %d", obj->anim->frameIndices[0]);
obj->frameIndex = 0;
obj->ticks = 15;
_lastStompObj = obj;
@@ -1131,7 +1119,6 @@ void MinigameBbAnt::updateObjs(uint mouseButtons) {
int candyObjIndex;
if (isBugAtCandy(i, candyObjIndex)) {
obj->status = 3;
- debug("bug %d has candy %d", i, candyObjIndex);
obj->otherObjIndex = candyObjIndex;
_objects[candyObjIndex].otherObjIndex = i;
_objects[candyObjIndex].status = 10;
@@ -1145,7 +1132,6 @@ void MinigameBbAnt::updateObjs(uint mouseButtons) {
}
if (testObj5(i)) {
- debug("yes");
updateObjAnim2(i);
}
@@ -1197,6 +1183,9 @@ int MinigameBbAnt::run(bool fromMainGame) {
_fromMainGame = fromMainGame;
_hiScore = 0;
+ if (!_fromMainGame)
+ _hiScore = loadHiscore(kMinigameBbAnt);
+
_gameState = 0;
_gameResult = 0;
_gameDone = false;
@@ -1209,7 +1198,6 @@ int MinigameBbAnt::run(bool fromMainGame) {
Palette palette = _spriteModule->getPalette();
_vm->_screen->setPalette(palette);
- // Load sounds
loadSounds();
_gameTicks = 0;
@@ -1220,9 +1208,11 @@ int MinigameBbAnt::run(bool fromMainGame) {
update();
}
- // Unload sounds
_vm->_sound->unloadSounds();
+ if (!_fromMainGame)
+ saveHiscore(kMinigameBbAnt, _hiScore);
+
delete _spriteModule;
return _gameResult;
@@ -1240,15 +1230,15 @@ void MinigameBbAnt::update() {
inputTicks = 1;
_gameTicks = _vm->_system->getMillis();
}
-
+
if (_vm->_keyCode == Common::KEYCODE_ESCAPE) {
_gameDone = true;
return;
}
-
+
if (inputTicks == 0)
return;
-
+
bool done;
do {
@@ -1277,7 +1267,13 @@ void MinigameBbAnt::scale2x(int x, int y) {
srcH += srcY;
srcY = 0;
}
-
+
+ if (srcX + srcW >= 320)
+ srcW = 320 - srcX - 1;
+
+ if (srcY + srcH >= 240)
+ srcH = 240 - srcY - 1;
+
for (int yc = 0; yc < srcH; ++yc) {
byte *src = (byte*)surface->getBasePtr(srcX, srcY + yc);
memcpy(&_scaleBuf[yc * kScaleDim], src, srcW);
@@ -1296,10 +1292,16 @@ void MinigameBbAnt::scale2x(int x, int y) {
dstY = 0;
}
+ if (dstX + dstW >= 320)
+ dstW = 320 - dstX - 1;
+
+ if (dstY + dstH >= 240)
+ dstH = 240 - dstY - 1;
+
int w = MIN(srcW * 2, dstW), h = MIN(srcH * 2, dstH);
for (int yc = 0; yc < h; ++yc) {
- byte *src = _scaleBuf + + kScaleDim * (yc / 2);
+ byte *src = _scaleBuf + kScaleDim * (yc / 2);
byte *dst = (byte*)surface->getBasePtr(dstX, dstY + yc);
for (int xc = 0; xc < w; ++xc)
dst[xc] = src[xc / 2];
diff --git a/engines/bbvs/minigames/bbloogie.cpp b/engines/bbvs/minigames/bbloogie.cpp
index b79e8c7..0d3fc1d 100644
--- a/engines/bbvs/minigames/bbloogie.cpp
+++ b/engines/bbvs/minigames/bbloogie.cpp
@@ -88,7 +88,7 @@ static const char *kSoundFilenames[] = {
static const uint kSoundFilenamesCount = ARRAYSIZE(kSoundFilenames);
-void MinigameBbloogie::buildDrawList(DrawList &drawList) {
+void MinigameBbLoogie::buildDrawList(DrawList &drawList) {
switch (_gameState) {
case kGSTitleScreen:
buildDrawList0(drawList);
@@ -105,7 +105,7 @@ void MinigameBbloogie::buildDrawList(DrawList &drawList) {
}
}
-void MinigameBbloogie::buildDrawList0(DrawList &drawList) {
+void MinigameBbLoogie::buildDrawList0(DrawList &drawList) {
drawList.add(_objects[0].anim->frameIndices[_objects[0].frameIndex], _objects[0].x, _objects[0].y, 2000);
for (int i = 1; i < kMaxObjectsCount; ++i) {
Obj *obj = &_objects[i];
@@ -116,7 +116,7 @@ void MinigameBbloogie::buildDrawList0(DrawList &drawList) {
drawList.add(_titleScreenSpriteIndex, 0, 0, 0);
}
-void MinigameBbloogie::buildDrawList1(DrawList &drawList) {
+void MinigameBbLoogie::buildDrawList1(DrawList &drawList) {
for (int i = 0; i < kMaxObjectsCount; ++i) {
Obj *obj = &_objects[i];
@@ -162,7 +162,7 @@ void MinigameBbloogie::buildDrawList1(DrawList &drawList) {
}
-void MinigameBbloogie::buildDrawList2(DrawList &drawList) {
+void MinigameBbLoogie::buildDrawList2(DrawList &drawList) {
buildDrawList1(drawList);
@@ -179,7 +179,7 @@ void MinigameBbloogie::buildDrawList2(DrawList &drawList) {
}
-void MinigameBbloogie::buildDrawList3(DrawList &drawList) {
+void MinigameBbLoogie::buildDrawList3(DrawList &drawList) {
for (int i = 0; i < kMaxObjectsCount; ++i) {
Obj *obj = &_objects[i];
@@ -209,33 +209,33 @@ void MinigameBbloogie::buildDrawList3(DrawList &drawList) {
}
-void MinigameBbloogie::drawSprites() {
+void MinigameBbLoogie::drawSprites() {
DrawList drawList;
buildDrawList(drawList);
_vm->_screen->drawDrawList(drawList, _spriteModule);
_vm->_screen->copyToScreen();
}
-void MinigameBbloogie::initObjs() {
+void MinigameBbLoogie::initObjs() {
for (int i = 0; i < kMaxObjectsCount; ++i)
_objects[i].kind = 0;
}
-MinigameBbloogie::Obj *MinigameBbloogie::getFreeObject() {
+MinigameBbLoogie::Obj *MinigameBbLoogie::getFreeObject() {
for (int i = 0; i < kMaxObjectsCount; ++i)
if (_objects[i].kind == 0)
return &_objects[i];
return 0;
}
-MinigameBbloogie::Obj *MinigameBbloogie::findLoogieObj(int startObjIndex) {
+MinigameBbLoogie::Obj *MinigameBbLoogie::findLoogieObj(int startObjIndex) {
for (int i = startObjIndex; i < kMaxObjectsCount; ++i)
if (_objects[i].kind == 3)
return &_objects[i];
return 0;
}
-bool MinigameBbloogie::isHit(Obj *obj1, Obj *obj2) {
+bool MinigameBbLoogie::isHit(Obj *obj1, Obj *obj2) {
const BBRect &frameRect1 = obj1->anim->frameRects[obj1->frameIndex];
const BBRect &frameRect2 = obj2->anim->frameRects[obj2->frameIndex];
const int obj1X1 = obj1->x + frameRect1.x;
@@ -249,11 +249,11 @@ bool MinigameBbloogie::isHit(Obj *obj1, Obj *obj2) {
return obj1X1 <= obj2X2 && obj1X2 >= obj2X1 && obj1Y1 <= obj2Y2 && obj1Y2 >= obj2Y1;
}
-bool MinigameBbloogie::isCursorAtObj(int objIndex) {
+bool MinigameBbLoogie::isCursorAtObj(int objIndex) {
return isHit(&_objects[0], &_objects[objIndex]);
}
-void MinigameBbloogie::initObjects() {
+void MinigameBbLoogie::initObjects() {
switch (_gameState) {
case kGSTitleScreen:
initObjects0();
@@ -270,7 +270,7 @@ void MinigameBbloogie::initObjects() {
}
}
-void MinigameBbloogie::initObjects0() {
+void MinigameBbLoogie::initObjects0() {
initObjs();
_objects[0].anim = getAnimation(25);
_objects[0].frameIndex = 0;
@@ -304,7 +304,7 @@ void MinigameBbloogie::initObjects0() {
_objects[4].kind = 0;
}
-void MinigameBbloogie::initObjects1() {
+void MinigameBbLoogie::initObjects1() {
initObjs();
_objects[0].anim = _playerAnim;
_objects[0].frameIndex = 0;
@@ -321,7 +321,7 @@ void MinigameBbloogie::initObjects1() {
_objects[1].kind = 2;
}
-void MinigameBbloogie::initObjects3() {
+void MinigameBbLoogie::initObjects3() {
initObjs();
_objects[0].anim = _playerAnim;
_objects[0].frameIndex = 0;
@@ -336,7 +336,7 @@ void MinigameBbloogie::initObjects3() {
_objects[1].kind = 2;
}
-void MinigameBbloogie::initVars() {
+void MinigameBbLoogie::initVars() {
switch (_gameState) {
case kGSTitleScreen:
initVars0();
@@ -353,7 +353,7 @@ void MinigameBbloogie::initVars() {
}
}
-void MinigameBbloogie::initVars0() {
+void MinigameBbLoogie::initVars0() {
_carDelay = 120;
_bikeDelay = 250;
_squirrelDelay = 40;
@@ -370,7 +370,7 @@ void MinigameBbloogie::initVars0() {
_dispLevelScore = 0;
}
-void MinigameBbloogie::initVars1() {
+void MinigameBbLoogie::initVars1() {
_carDelay = 120;
_bikeDelay = 250;
_squirrelDelay = 40;
@@ -381,7 +381,7 @@ void MinigameBbloogie::initVars1() {
_megaLoogieCount = 0;
}
-void MinigameBbloogie::initVars2() {
+void MinigameBbLoogie::initVars2() {
_timeBonusCtr = _levelTimeLeft;
_levelTimeDelay = 58;
_bonusDisplayDelay1 = 60;
@@ -391,7 +391,7 @@ void MinigameBbloogie::initVars2() {
_bonusDisplayDelay3 = 0;
}
-void MinigameBbloogie::initVars3() {
+void MinigameBbLoogie::initVars3() {
if (_currScore > _hiScore)
_hiScore = _currScore;
if (_playerKind) {
@@ -401,7 +401,7 @@ void MinigameBbloogie::initVars3() {
}
}
-bool MinigameBbloogie::updateStatus(int mouseX, int mouseY, uint mouseButtons) {
+bool MinigameBbLoogie::updateStatus(int mouseX, int mouseY, uint mouseButtons) {
switch (_gameState) {
case kGSTitleScreen:
return updateStatus0(mouseX, mouseY, mouseButtons);
@@ -415,7 +415,7 @@ bool MinigameBbloogie::updateStatus(int mouseX, int mouseY, uint mouseButtons) {
return false;
}
-bool MinigameBbloogie::updateStatus0(int mouseX, int mouseY, uint mouseButtons) {
+bool MinigameBbLoogie::updateStatus0(int mouseX, int mouseY, uint mouseButtons) {
_objects[0].x = mouseX;
_objects[0].y = mouseY;
@@ -481,9 +481,7 @@ bool MinigameBbloogie::updateStatus0(int mouseX, int mouseY, uint mouseButtons)
playSound(23);
while (isSoundPlaying(23)) { }
}
- _gameState = kGSMainGame;
- if (!_fromMainGame)
- _gameState = kGSStandaloneGame;
+ _gameState = _fromMainGame ? kGSMainGame : kGSStandaloneGame;
initObjects1();
initObjects();
initVars();
@@ -493,7 +491,7 @@ bool MinigameBbloogie::updateStatus0(int mouseX, int mouseY, uint mouseButtons)
return true;
}
-bool MinigameBbloogie::updateStatus1(int mouseX, int mouseY, uint mouseButtons) {
+bool MinigameBbLoogie::updateStatus1(int mouseX, int mouseY, uint mouseButtons) {
if (--_levelTimeDelay == 0) {
_levelTimeDelay = 58;
@@ -539,7 +537,7 @@ bool MinigameBbloogie::updateStatus1(int mouseX, int mouseY, uint mouseButtons)
return true;
}
-bool MinigameBbloogie::updateStatus2(int mouseX, int mouseY, uint mouseButtons) {
+bool MinigameBbLoogie::updateStatus2(int mouseX, int mouseY, uint mouseButtons) {
_objects[0].x = mouseX;
@@ -569,7 +567,7 @@ bool MinigameBbloogie::updateStatus2(int mouseX, int mouseY, uint mouseButtons)
return true;
}
-bool MinigameBbloogie::updateStatus3(int mouseX, int mouseY, uint mouseButtons) {
+bool MinigameBbLoogie::updateStatus3(int mouseX, int mouseY, uint mouseButtons) {
_objects[0].x = mouseX;
@@ -588,7 +586,7 @@ bool MinigameBbloogie::updateStatus3(int mouseX, int mouseY, uint mouseButtons)
return true;
}
-void MinigameBbloogie::updateObjs(uint mouseButtons) {
+void MinigameBbLoogie::updateObjs(uint mouseButtons) {
for (int i = 0; i < kMaxObjectsCount; ++i) {
Obj *obj = &_objects[i];
@@ -708,7 +706,7 @@ void MinigameBbloogie::updateObjs(uint mouseButtons) {
}
-void MinigameBbloogie::updatePlayer(int objIndex, uint mouseButtons) {
+void MinigameBbLoogie::updatePlayer(int objIndex, uint mouseButtons) {
Obj *obj = &_objects[0];
@@ -798,7 +796,7 @@ void MinigameBbloogie::updatePlayer(int objIndex, uint mouseButtons) {
}
-void MinigameBbloogie::updateObjKind2(int objIndex) {
+void MinigameBbLoogie::updateObjKind2(int objIndex) {
Obj *obj = &_objects[objIndex];
@@ -812,7 +810,7 @@ void MinigameBbloogie::updateObjKind2(int objIndex) {
}
-void MinigameBbloogie::updateLoogie(int objIndex) {
+void MinigameBbLoogie::updateLoogie(int objIndex) {
Obj *obj = &_objects[objIndex];
if (obj->unk2 > 0) {
@@ -832,7 +830,7 @@ void MinigameBbloogie::updateLoogie(int objIndex) {
}
-void MinigameBbloogie::updateCar(int objIndex) {
+void MinigameBbLoogie::updateCar(int objIndex) {
Obj *obj = &_objects[objIndex];
obj->x += obj->xIncr;
@@ -867,7 +865,7 @@ void MinigameBbloogie::updateCar(int objIndex) {
}
-void MinigameBbloogie::updateBike(int objIndex) {
+void MinigameBbLoogie::updateBike(int objIndex) {
Obj *obj = &_objects[objIndex];
obj->x += obj->xIncr;
@@ -902,7 +900,7 @@ void MinigameBbloogie::updateBike(int objIndex) {
}
-void MinigameBbloogie::updateSquirrel(int objIndex) {
+void MinigameBbLoogie::updateSquirrel(int objIndex) {
Obj *obj = &_objects[objIndex];
if (obj->ticks-- == 0) {
@@ -937,7 +935,7 @@ void MinigameBbloogie::updateSquirrel(int objIndex) {
}
-void MinigameBbloogie::updatePaperPlane(int objIndex) {
+void MinigameBbLoogie::updatePaperPlane(int objIndex) {
Obj *obj = &_objects[objIndex];
obj->x += obj->xIncr;
@@ -970,7 +968,7 @@ void MinigameBbloogie::updatePaperPlane(int objIndex) {
}
-void MinigameBbloogie::updateIndicator(int objIndex) {
+void MinigameBbLoogie::updateIndicator(int objIndex) {
Obj *obj = &_objects[objIndex];
Obj *loogieObj = &_objects[0];
@@ -1002,7 +1000,7 @@ void MinigameBbloogie::updateIndicator(int objIndex) {
}
-void MinigameBbloogie::updatePrincipal(int objIndex) {
+void MinigameBbLoogie::updatePrincipal(int objIndex) {
Obj *obj = &_objects[objIndex];
switch (obj->status) {
@@ -1241,7 +1239,7 @@ void MinigameBbloogie::updatePrincipal(int objIndex) {
}
-void MinigameBbloogie::incNumberOfHits() {
+void MinigameBbLoogie::incNumberOfHits() {
++_numberOfHits;
if (_numberOfHits == 1000)
_numberOfHits = 0;
@@ -1252,19 +1250,19 @@ void MinigameBbloogie::incNumberOfHits() {
}
}
-void MinigameBbloogie::incScore(int incrAmount) {
+void MinigameBbLoogie::incScore(int incrAmount) {
if (_doubleScore)
_currScore += 2 * incrAmount;
else
_currScore += incrAmount;
}
-void MinigameBbloogie::playRndSound() {
+void MinigameBbLoogie::playRndSound() {
if (!isAnySoundPlaying(_playerSounds2, _playerSounds2Count))
playSound(_playerSounds1[_vm->getRandom(_playerSounds1Count)]);
}
-int MinigameBbloogie::run(bool fromMainGame) {
+int MinigameBbLoogie::run(bool fromMainGame) {
memset(_objects, 0, sizeof(_objects));
@@ -1276,9 +1274,8 @@ int MinigameBbloogie::run(bool fromMainGame) {
_fromMainGame = fromMainGame;
_hiScore = 0;
- if (!_fromMainGame) {
- // TODO Load LoogieHiScore
- }
+ if (!_fromMainGame)
+ _hiScore = loadHiscore(kMinigameBbLoogie);
_gameState = kGSTitleScreen;
_gameTicks = 0;
@@ -1293,7 +1290,6 @@ int MinigameBbloogie::run(bool fromMainGame) {
Palette palette = _spriteModule->getPalette();
_vm->_screen->setPalette(palette);
- // Load sounds
loadSounds();
playSound(32, true);
@@ -1303,19 +1299,17 @@ int MinigameBbloogie::run(bool fromMainGame) {
update();
}
- // Unload sounds
_vm->_sound->unloadSounds();
- if (!_fromMainGame) {
- // TODO Save LoogieHiScore
- }
+ if (!_fromMainGame)
+ saveHiscore(kMinigameBbLoogie, _hiScore);
delete _spriteModule;
return _gameResult;
}
-void MinigameBbloogie::update() {
+void MinigameBbLoogie::update() {
int currTicks, inputTicks;
@@ -1349,7 +1343,7 @@ void MinigameBbloogie::update() {
}
-void MinigameBbloogie::loadSounds() {
+void MinigameBbLoogie::loadSounds() {
for (uint i = 0; i < kSoundFilenamesCount; ++i) {
Common::String filename = Common::String::format("bbloogie/%s", kSoundFilenames[i]);
_vm->_sound->loadSound(filename.c_str());
diff --git a/engines/bbvs/minigames/bbloogie.h b/engines/bbvs/minigames/bbloogie.h
index d01149a..fb745c1 100644
--- a/engines/bbvs/minigames/bbloogie.h
+++ b/engines/bbvs/minigames/bbloogie.h
@@ -27,9 +27,9 @@
namespace Bbvs {
-class MinigameBbloogie : public Minigame {
+class MinigameBbLoogie : public Minigame {
public:
- MinigameBbloogie(BbvsEngine *vm) : Minigame(vm) {};
+ MinigameBbLoogie(BbvsEngine *vm) : Minigame(vm) {};
int run(bool fromMainGame);
public:
diff --git a/engines/bbvs/minigames/bbloogie_anims.cpp b/engines/bbvs/minigames/bbloogie_anims.cpp
index 61a2e48..a82be8a 100644
--- a/engines/bbvs/minigames/bbloogie_anims.cpp
+++ b/engines/bbvs/minigames/bbloogie_anims.cpp
@@ -131,7 +131,7 @@ static const ObjAnimation kAnimations[] = {
{2, kAnim25FrameIndices, kAnim25FrameTicks, kAnim25FrameRects}
};
-const ObjAnimation *MinigameBbloogie::getAnimation(int animIndex) {
+const ObjAnimation *MinigameBbLoogie::getAnimation(int animIndex) {
return &kAnimations[animIndex];
}
diff --git a/engines/bbvs/minigames/bbtennis.cpp b/engines/bbvs/minigames/bbtennis.cpp
index edf9cab..fd02573 100644
--- a/engines/bbvs/minigames/bbtennis.cpp
+++ b/engines/bbvs/minigames/bbtennis.cpp
@@ -1193,9 +1193,8 @@ int MinigameBbTennis::run(bool fromMainGame) {
_fromMainGame = fromMainGame;
_hiScore = 0;
- if (!_fromMainGame) {
- // TODO Load HiScore
- }
+ if (!_fromMainGame)
+ _hiScore = loadHiscore(kMinigameBbTennis);
_gameState = 0;
_gameResult = 0;
@@ -1209,7 +1208,6 @@ int MinigameBbTennis::run(bool fromMainGame) {
Palette palette = _spriteModule->getPalette();
_vm->_screen->setPalette(palette);
- // Load sounds
loadSounds();
_gameTicks = 0;
@@ -1220,12 +1218,10 @@ int MinigameBbTennis::run(bool fromMainGame) {
update();
}
- // Unload sounds
_vm->_sound->unloadSounds();
- if (!_fromMainGame) {
- // TODO Save HiScore
- }
+ if (!_fromMainGame)
+ saveHiscore(kMinigameBbTennis, _hiScore);
delete _spriteModule;
diff --git a/engines/bbvs/minigames/minigame.cpp b/engines/bbvs/minigames/minigame.cpp
index 299836a..888040f 100644
--- a/engines/bbvs/minigames/minigame.cpp
+++ b/engines/bbvs/minigames/minigame.cpp
@@ -21,11 +21,14 @@
*/
#include "bbvs/minigames/minigame.h"
+#include "common/savefile.h"
namespace Bbvs {
Minigame::Minigame(BbvsEngine *vm)
: _vm(vm), _spriteModule(0) {
+
+ memset(_hiScoreTable, 0, sizeof(_hiScoreTable));
}
Minigame::~Minigame() {
@@ -71,4 +74,31 @@ bool Minigame::isAnySoundPlaying(const uint *indices, uint count) {
return false;
}
+void Minigame::saveHiscore(int minigameNum, int score) {
+ Common::String filename = _vm->getTargetName() + "-highscore.dat";
+ Common::OutSaveFile *file = g_system->getSavefileManager()->openForSaving(filename);
+ if (file) {
+ // Reserve a byte for future usage (rarely a bad idea, you never know...)
+ file->writeByte(0);
+ _hiScoreTable[minigameNum] = score;
+ for (int i = 0; i < kMinigameCount; ++i)
+ file->writeUint32LE(_hiScoreTable[i]);
+ delete file;
+ }
+}
+
+int Minigame::loadHiscore(int minigameNum) {
+ int score = 0;
+ Common::String filename = _vm->getTargetName() + "-highscore.dat";
+ Common::InSaveFile *file = g_system->getSavefileManager()->openForLoading(filename);
+ if (file) {
+ file->readByte();
+ for (int i = 0; i < kMinigameCount; ++i)
+ _hiScoreTable[i] = file->readUint32LE();
+ delete file;
+ score = _hiScoreTable[minigameNum];
+ }
+ return score;
+}
+
} // End of namespace Bbvs
diff --git a/engines/bbvs/minigames/minigame.h b/engines/bbvs/minigames/minigame.h
index 33498be..1e1a469 100644
--- a/engines/bbvs/minigames/minigame.h
+++ b/engines/bbvs/minigames/minigame.h
@@ -31,10 +31,11 @@
namespace Bbvs {
enum {
- kMinigameBbloogie = 0,
+ kMinigameBbLoogie = 0,
kMinigameBbTennis = 1,
kMinigameBbAnt = 2,
- kMinigameBbAirGuitar = 3
+ kMinigameBbAirGuitar = 3,
+ kMinigameCount
};
struct ObjAnimation {
@@ -49,7 +50,7 @@ public:
Minigame(BbvsEngine *vm);
virtual ~Minigame();
virtual int run(bool fromMainGame) = 0;
-public:
+protected:
BbvsEngine *_vm;
SpriteModule *_spriteModule;
@@ -58,6 +59,7 @@ public:
int _gameResult;
bool _gameDone;
bool _fromMainGame;
+ int _hiScoreTable[kMinigameCount];
int _backgroundSpriteIndex, _titleScreenSpriteIndex;
@@ -69,7 +71,10 @@ public:
void stopSound(uint index);
bool isSoundPlaying(uint index);
bool isAnySoundPlaying(const uint *indices, uint count);
-
+
+ void saveHiscore(int minigameNum, int score);
+ int loadHiscore(int minigameNum);
+
};
} // End of namespace Bbvs
Commit: bb1dc9136b4683a9c587b8b6c2ca19588944a33e
https://github.com/scummvm/scummvm/commit/bb1dc9136b4683a9c587b8b6c2ca19588944a33e
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-29T04:27:50-08:00
Commit Message:
BBVS: Remove some debug output
Changed paths:
engines/bbvs/bbvs.cpp
engines/bbvs/saveload.cpp
engines/bbvs/videoplayer.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index e8db691..b2a9666 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -541,7 +541,7 @@ void BbvsEngine::updateBackgroundSounds() {
}
void BbvsEngine::loadScene(int sceneNum) {
- debug("BbvsEngine::loadScene() sceneNum: %d", sceneNum);
+ debug(0, "BbvsEngine::loadScene() sceneNum: %d", sceneNum);
Common::String sprFilename = Common::String::format("vnm/vspr%04d.vnm", sceneNum);
Common::String gamFilename = Common::String::format("vnm/game%04d.vnm", sceneNum);
@@ -2144,7 +2144,7 @@ void BbvsEngine::stopSounds() {
}
bool BbvsEngine::runMinigame(int minigameNum) {
- debug("BbvsEngine::runMinigame() minigameNum: %d", minigameNum);
+ debug(0, "BbvsEngine::runMinigame() minigameNum: %d", minigameNum);
bool fromMainGame = _currSceneNum != kMainMenu;
diff --git a/engines/bbvs/saveload.cpp b/engines/bbvs/saveload.cpp
index 6714cd0..3bb9800 100644
--- a/engines/bbvs/saveload.cpp
+++ b/engines/bbvs/saveload.cpp
@@ -165,14 +165,6 @@ void BbvsEngine::loadgame(const char *filename) {
obj->walkDestPt.x = in->readUint16LE();
obj->walkDestPt.y = in->readUint16LE();
obj->anim = obj->animIndex > 0 ? _gameModule->getAnimation(obj->animIndex) : 0;
-#if 0
- debug("obj(%d) [%s]:", i, obj->sceneObjectDef->name);
- debug("\tx: %d; y: %d; animIndex: %d", obj->x, obj->y, obj->animIndex);
- debug("\tframeIndex: %d; frameTicks: %d", obj->frameIndex, obj->frameTicks);
- debug("\twalkCount: %d; xIncr: %d; yIncr: %d", obj->walkCount, obj->xIncr, obj->yIncr);
- debug("\tturnValue: %d; turnValue: %d; turnTicks: %d", obj->turnValue, obj->turnCount, obj->turnTicks);
- debug("\twalkDestPt.x: %d; walkDestPt.y: %d", obj->walkDestPt.x, obj->walkDestPt.y);
-#endif
}
updateWalkableRects();
diff --git a/engines/bbvs/videoplayer.cpp b/engines/bbvs/videoplayer.cpp
index 2da4cd0..71cb7dd 100644
--- a/engines/bbvs/videoplayer.cpp
+++ b/engines/bbvs/videoplayer.cpp
@@ -29,7 +29,6 @@
namespace Bbvs {
void BbvsEngine::playVideo(int videoNum) {
- debug("BbvsEngine::playVideo() videoNum: %d", videoNum);
Common::String videoFilename;
if (videoNum >= 100)
@@ -37,8 +36,6 @@ void BbvsEngine::playVideo(int videoNum) {
else
videoFilename = Common::String::format("vid/video%03d.avi", videoNum - 1);
- debug("BbvsEngine::playVideo() videoFilename: %s", videoFilename.c_str());
-
// Set the correct video mode
Common::List<Graphics::PixelFormat> formats;
// RGB565 16bit
Commit: 8fcfe6100396b4ae02d53b546cd57693152c3dda
https://github.com/scummvm/scummvm/commit/8fcfe6100396b4ae02d53b546cd57693152c3dda
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-30T11:16:33-08:00
Commit Message:
BBVS: Add delayMillis to update loops to save some cpu time
Changed paths:
engines/bbvs/bbvs.cpp
engines/bbvs/minigames/bbairguitar.cpp
engines/bbvs/minigames/bbant.cpp
engines/bbvs/minigames/bbloogie.cpp
engines/bbvs/minigames/bbtennis.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index b2a9666..88d40fe 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -309,6 +309,8 @@ void BbvsEngine::updateGame() {
_screen->drawDrawList(drawList, _spriteModule);
drawScreen();
}
+
+ _system->delayMillis(10);
}
diff --git a/engines/bbvs/minigames/bbairguitar.cpp b/engines/bbvs/minigames/bbairguitar.cpp
index f65c1b5..0453ec5 100644
--- a/engines/bbvs/minigames/bbairguitar.cpp
+++ b/engines/bbvs/minigames/bbairguitar.cpp
@@ -823,6 +823,8 @@ void MinigameBbAirGuitar::update() {
drawSprites();
+ _vm->_system->delayMillis(10);
+
}
void MinigameBbAirGuitar::play() {
diff --git a/engines/bbvs/minigames/bbant.cpp b/engines/bbvs/minigames/bbant.cpp
index f2d3ad2..a51a9d8 100644
--- a/engines/bbvs/minigames/bbant.cpp
+++ b/engines/bbvs/minigames/bbant.cpp
@@ -1250,6 +1250,8 @@ void MinigameBbAnt::update() {
drawSprites();
+ _vm->_system->delayMillis(10);
+
}
void MinigameBbAnt::scale2x(int x, int y) {
diff --git a/engines/bbvs/minigames/bbloogie.cpp b/engines/bbvs/minigames/bbloogie.cpp
index 0d3fc1d..70e7e7d 100644
--- a/engines/bbvs/minigames/bbloogie.cpp
+++ b/engines/bbvs/minigames/bbloogie.cpp
@@ -1341,6 +1341,8 @@ void MinigameBbLoogie::update() {
drawSprites();
+ _vm->_system->delayMillis(10);
+
}
void MinigameBbLoogie::loadSounds() {
diff --git a/engines/bbvs/minigames/bbtennis.cpp b/engines/bbvs/minigames/bbtennis.cpp
index fd02573..82c9037 100644
--- a/engines/bbvs/minigames/bbtennis.cpp
+++ b/engines/bbvs/minigames/bbtennis.cpp
@@ -1260,6 +1260,8 @@ void MinigameBbTennis::update() {
drawSprites();
+ _vm->_system->delayMillis(10);
+
}
void MinigameBbTennis::loadSounds() {
Commit: c31762d0c4fb1ea90de6ca725509a8ec61e26955
https://github.com/scummvm/scummvm/commit/c31762d0c4fb1ea90de6ca725509a8ec61e26955
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-30T11:16:38-08:00
Commit Message:
BBVS: Add easter egg videos handling
Changed paths:
engines/bbvs/bbvs.cpp
engines/bbvs/bbvs.h
engines/bbvs/videoplayer.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 88d40fe..6ffac2e 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -94,13 +94,12 @@ static const byte kTurnTbl[] = {
};
static const int kAfterVideoSceneNum[] = {
-// 0, 43, 23, 12, 4, 44, 2,
-// 16, 4, 4, 4, 44, 12, 44
0, 43, 23, 12, 4, 44, 2,
16, 4, 4, 4, 44, 12, 32
};
const int kMainMenu = 44;
+const int kCredits = 45;
bool WalkArea::contains(const Common::Point &pt) const {
return Common::Rect(x, y, x + width, y + height).contains(pt);
@@ -147,6 +146,7 @@ Common::Error BbvsEngine::run() {
_sound = new SoundMan();
allocSnapshot();
+ memset(_easterEggInput, 0, sizeof(_easterEggInput));
_gameTicks = 0;
_playVideoNumber = 0;
@@ -181,6 +181,12 @@ Common::Error BbvsEngine::run() {
updateGame();
else if (_currSceneNum == kMainMenu)
runMainMenu();
+ else if (_currSceneNum == kCredits &&
+ (_mouseButtons & (kLeftButtonClicked | kRightButtonClicked))) {
+ _mouseButtons &= ~kLeftButtonClicked;
+ _mouseButtons &= ~kRightButtonClicked;
+ _newSceneNum = kMainMenu;
+ }
if (_playVideoNumber > 0) {
playVideo(_playVideoNumber);
_playVideoNumber = 0;
@@ -217,6 +223,7 @@ void BbvsEngine::updateEvents() {
_keyCode = event.kbd.keycode;
break;
case Common::EVENT_KEYUP:
+ checkEasterEgg(event.kbd.ascii);
_keyCode = Common::KEYCODE_INVALID;
break;
case Common::EVENT_MOUSEMOVE:
@@ -702,7 +709,7 @@ void BbvsEngine::initScene(bool sounds) {
bool BbvsEngine::changeScene() {
writeContinueSavegame();
-
+
if (_newSceneNum >= 27 && _newSceneNum <= 30) {
// Run minigames
stopSpeech();
@@ -719,12 +726,12 @@ bool BbvsEngine::changeScene() {
_playVideoNumber = _newSceneNum - 30;
_currSceneNum = _newSceneNum;
_newSceneNum = kAfterVideoSceneNum[_playVideoNumber];
- } else if (_newSceneNum >= 100 && _currSceneNum == 45) {
+ } else if (_newSceneNum >= 100 && _currSceneNum == kCredits) {
// Play secret video
stopSounds();
_playVideoNumber = _newSceneNum;
_currSceneNum = 49;
- _newSceneNum = 45;
+ _newSceneNum = kCredits;
} else {
// Normal scene
initScene(true);
@@ -2195,4 +2202,31 @@ void BbvsEngine::runMainMenu() {
delete mainMenu;
}
+void BbvsEngine::checkEasterEgg(char key) {
+
+ static const char *kEasterEggStrings[] = {
+ "BOIDUTS",
+ "YNNIF",
+ "SKCUS",
+ "NAMTAH"
+ };
+
+ static const int kEasterEggLengths[] = {
+ 7, 5, 5, 6
+ };
+
+ if (_currSceneNum == kCredits) {
+ memcpy(&_easterEggInput[1], &_easterEggInput[0], 6);
+ _easterEggInput[0] = key;
+ for (int i = 0; i < ARRAYSIZE(kEasterEggStrings); ++i) {
+ if (!scumm_strnicmp(kEasterEggStrings[i], _easterEggInput, kEasterEggLengths[i])) {
+ _easterEggInput[0] = 0;
+ _newSceneNum = 100 + i;
+ break;
+ }
+ }
+ }
+
+}
+
} // End of namespace Bbvs
diff --git a/engines/bbvs/bbvs.h b/engines/bbvs/bbvs.h
index 8d9ccc0..a896e9d 100644
--- a/engines/bbvs/bbvs.h
+++ b/engines/bbvs/bbvs.h
@@ -300,6 +300,8 @@ public:
byte *_snapshot;
Common::SeekableMemoryWriteStream *_snapshotStream;
+ char _easterEggInput[7];
+
void updateEvents();
int getRandom(int max);
@@ -366,6 +368,7 @@ public:
void playVideo(int videoNum);
void runMainMenu();
+ void checkEasterEgg(char key);
// Savegame API
diff --git a/engines/bbvs/videoplayer.cpp b/engines/bbvs/videoplayer.cpp
index 71cb7dd..0b6f011 100644
--- a/engines/bbvs/videoplayer.cpp
+++ b/engines/bbvs/videoplayer.cpp
@@ -32,7 +32,7 @@ void BbvsEngine::playVideo(int videoNum) {
Common::String videoFilename;
if (videoNum >= 100)
- videoFilename = Common::String::format("snd/snd%05d.avi", videoNum + 1400);
+ videoFilename = Common::String::format("snd/snd%05d.aif", videoNum + 1400);
else
videoFilename = Common::String::format("vid/video%03d.avi", videoNum - 1);
Commit: 7c8b7467c2bf8f0ac9f739b0961c8247893d28bc
https://github.com/scummvm/scummvm/commit/7c8b7467c2bf8f0ac9f739b0961c8247893d28bc
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-30T11:16:39-08:00
Commit Message:
BBVS: Fix mainmenu after intro videos
Changed paths:
engines/bbvs/bbvs.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 6ffac2e..ed89a9e 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -95,7 +95,7 @@ static const byte kTurnTbl[] = {
static const int kAfterVideoSceneNum[] = {
0, 43, 23, 12, 4, 44, 2,
- 16, 4, 4, 4, 44, 12, 32
+ 16, 4, 4, 4, 44, 12, 44
};
const int kMainMenu = 44;
@@ -164,10 +164,10 @@ Common::Error BbvsEngine::run() {
_currInventoryItem = -1;
_currTalkObjectIndex = -1;
_currSceneNum = 0;
- //_newSceneNum = 31;
+ _newSceneNum = 31;
//_newSceneNum = 23; // Class room
- _newSceneNum = kMainMenu; // Main menu (TODO Buttons etc.)
+ //_newSceneNum = kMainMenu; // Main menu (TODO Buttons etc.)
//_newSceneNum = 25;// Tank and crash
//_newSceneNum = 7;
//_newSceneNum = 12;
Commit: 4d2a42eec792bcb3121022770afb8968f7e09f39
https://github.com/scummvm/scummvm/commit/4d2a42eec792bcb3121022770afb8968f7e09f39
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-30T11:16:39-08:00
Commit Message:
BBVS: Disable gamemodule debug output
Changed paths:
engines/bbvs/gamemodule.cpp
diff --git a/engines/bbvs/gamemodule.cpp b/engines/bbvs/gamemodule.cpp
index abc5086..97522ab 100644
--- a/engines/bbvs/gamemodule.cpp
+++ b/engines/bbvs/gamemodule.cpp
@@ -25,7 +25,7 @@
namespace Bbvs {
-#define DEBUG_DUMP
+//#define DEBUG_DUMP
GameModule::GameModule()
: _bgSpriteCount(0), _bgSpriteIndices(0), _bgSpritePriorities(0), _walkRectsCount(0),
Commit: ea519818e21dadbe18a8943962ba22b1b9574559
https://github.com/scummvm/scummvm/commit/ea519818e21dadbe18a8943962ba22b1b9574559
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-30T11:16:40-08:00
Commit Message:
BBVS: Wrap some long lines
Changed paths:
engines/bbvs/bbvs.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index ed89a9e..57284a5 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -166,8 +166,9 @@ Common::Error BbvsEngine::run() {
_currSceneNum = 0;
_newSceneNum = 31;
+ // DEBUG Jump directly to rooms
//_newSceneNum = 23; // Class room
- //_newSceneNum = kMainMenu; // Main menu (TODO Buttons etc.)
+ //_newSceneNum = kMainMenu;
//_newSceneNum = 25;// Tank and crash
//_newSceneNum = 7;
//_newSceneNum = 12;
@@ -202,8 +203,6 @@ Common::Error BbvsEngine::run() {
delete _gameModule;
delete _screen;
- debug(0, "run() done");
-
return Common::kNoError;
}
@@ -327,16 +326,26 @@ bool BbvsEngine::evalCondition(Conditions &conditions) {
const Condition &condition = conditions.conditions[i];
switch (condition.cond) {
case kCondSceneObjectVerb:
- result = _activeItemType == KITSceneObject && condition.value1 == _currVerbNum && condition.value2 == _activeItemIndex;
+ result = _activeItemType == KITSceneObject &&
+ condition.value1 == _currVerbNum &&
+ condition.value2 == _activeItemIndex;
break;
case kCondBgObjectVerb:
- result = _activeItemType == kITBgObject && condition.value1 == _currVerbNum && condition.value2 == _activeItemIndex;
+ result = _activeItemType == kITBgObject &&
+ condition.value1 == _currVerbNum &&
+ condition.value2 == _activeItemIndex;
break;
case kCondSceneObjectInventory:
- result = _activeItemType == KITSceneObject && _currVerbNum == kVerbInvItem && condition.value1 == _currInventoryItem && condition.value2 == _activeItemIndex;
+ result = _activeItemType == KITSceneObject &&
+ _currVerbNum == kVerbInvItem &&
+ condition.value1 == _currInventoryItem &&
+ condition.value2 == _activeItemIndex;
break;
case kCondBgObjectInventory:
- result = _activeItemType == kITBgObject && _currVerbNum == kVerbInvItem && condition.value1 == _currInventoryItem && condition.value2 == _activeItemIndex;
+ result = _activeItemType == kITBgObject &&
+ _currVerbNum == kVerbInvItem &&
+ condition.value1 == _currInventoryItem &&
+ condition.value2 == _activeItemIndex;
break;
case kCondHasInventoryItem:
result = _inventoryItemStatus[condition.value1] != 0;
@@ -357,7 +366,8 @@ bool BbvsEngine::evalCondition(Conditions &conditions) {
result = condition.value2 == _currTalkObjectIndex;
break;
case kCondIsDialogItem:
- result = _activeItemType == kITDialog && condition.value1 == _activeItemIndex;
+ result = _activeItemType == kITDialog &&
+ condition.value1 == _activeItemIndex;
break;
case kCondIsCameraNum:
result = condition.value1 == _currCameraNum;
@@ -366,7 +376,8 @@ bool BbvsEngine::evalCondition(Conditions &conditions) {
result = condition.value2 != _prevSceneNum;
break;
case kCondIsButtheadAtBgObject:
- result = _buttheadObject && _gameModule->getBgObject(condition.value2)->rect.contains(_buttheadObject->x >> 16, _buttheadObject->y >> 16);
+ result = _buttheadObject &&
+ _gameModule->getBgObject(condition.value2)->rect.contains(_buttheadObject->x >> 16, _buttheadObject->y >> 16);
break;
case kCondIsNotSceneVisited:
result = _sceneVisited[_currSceneNum] == 0;
@@ -414,7 +425,8 @@ bool BbvsEngine::evalCameraCondition(Conditions &conditions, int value) {
result = _sceneVisited[_currSceneNum] != 0;
break;
case kCondIsCameraNumTransition:
- result = condition.value1 == _currCameraNum && condition.value2 == value;
+ result = condition.value1 == _currCameraNum &&
+ condition.value2 == value;
break;
case kCondUnused:
case kCondSceneObjectVerb:
@@ -442,16 +454,26 @@ int BbvsEngine::evalDialogCondition(Conditions &conditions) {
const Condition &condition = conditions.conditions[i];
switch (condition.cond) {
case kCondSceneObjectVerb:
- success = _activeItemType == KITSceneObject && condition.value1 == _currVerbNum && condition.value2 == _activeItemIndex;
+ success = _activeItemType == KITSceneObject &&
+ condition.value1 == _currVerbNum &&
+ condition.value2 == _activeItemIndex;
break;
case kCondBgObjectVerb:
- success = _activeItemType == kITBgObject && condition.value1 == _currVerbNum && condition.value2 == _activeItemIndex;
+ success = _activeItemType == kITBgObject &&
+ condition.value1 == _currVerbNum &&
+ condition.value2 == _activeItemIndex;
break;
case kCondSceneObjectInventory:
- success = _activeItemType == KITSceneObject && _currVerbNum == kVerbInvItem && condition.value1 == _currInventoryItem && condition.value2 == _activeItemIndex;
+ success = _activeItemType == KITSceneObject &&
+ _currVerbNum == kVerbInvItem &&
+ condition.value1 == _currInventoryItem &&
+ condition.value2 == _activeItemIndex;
break;
case kCondBgObjectInventory:
- success = _activeItemType == kITBgObject && _currVerbNum == kVerbInvItem && condition.value1 == _currInventoryItem && condition.value2 == _activeItemIndex;
+ success = _activeItemType == kITBgObject &&
+ _currVerbNum == kVerbInvItem &&
+ condition.value1 == _currInventoryItem &&
+ condition.value2 == _activeItemIndex;
break;
case kCondHasInventoryItem:
success = _inventoryItemStatus[condition.value1] != 0;
@@ -481,7 +503,8 @@ int BbvsEngine::evalDialogCondition(Conditions &conditions) {
success = condition.value2 != _prevSceneNum;
break;
case kCondIsButtheadAtBgObject:
- success = _buttheadObject && _gameModule->getBgObject(condition.value2)->rect.contains(_buttheadObject->x >> 16, _buttheadObject->y >> 16);
+ success = _buttheadObject &&
+ _gameModule->getBgObject(condition.value2)->rect.contains(_buttheadObject->x >> 16, _buttheadObject->y >> 16);
break;
case kCondIsNotSceneVisited:
success = _sceneVisited[_currSceneNum] == 0;
Commit: 542197a891eac799855571fe2849e0dca43bdd2b
https://github.com/scummvm/scummvm/commit/542197a891eac799855571fe2849e0dca43bdd2b
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-30T11:16:40-08:00
Commit Message:
BBVS: Very small cleanup
Changed paths:
engines/bbvs/bbvs.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 57284a5..5f433e0 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -183,9 +183,8 @@ Common::Error BbvsEngine::run() {
else if (_currSceneNum == kMainMenu)
runMainMenu();
else if (_currSceneNum == kCredits &&
- (_mouseButtons & (kLeftButtonClicked | kRightButtonClicked))) {
- _mouseButtons &= ~kLeftButtonClicked;
- _mouseButtons &= ~kRightButtonClicked;
+ (_mouseButtons & kAnyButtonClicked)) {
+ _mouseButtons &= ~kAnyButtonClicked;
_newSceneNum = kMainMenu;
}
if (_playVideoNumber > 0) {
@@ -2042,8 +2041,6 @@ void BbvsEngine::walkFoundPath(int count) {
Common::Point destPt = _destWalkAreaPt, newDestPt;
- // TODO This needs some cleanup but seems to work
-
while (1) {
int index = 0;
Commit: cf51529cfd0fedb33b1b0c70beb59997b21cfc5b
https://github.com/scummvm/scummvm/commit/cf51529cfd0fedb33b1b0c70beb59997b21cfc5b
Author: johndoe123 (john_doe at techie.com)
Date: 2014-01-30T11:18:55-08:00
Commit Message:
Merge remote-tracking branch 'origin/master' into bbvs
Changed paths:
A backends/graphics/opengl/debug.cpp
A backends/graphics/opengl/debug.h
A backends/graphics/opengl/extensions.cpp
A backends/graphics/opengl/extensions.h
A backends/graphics/opengl/opengl-sys.h
A backends/graphics/opengl/texture.cpp
A backends/graphics/opengl/texture.h
A backends/platform/symbian/help/Custom.xml
A backends/platform/symbian/help/ScummVM.rtf
A backends/platform/symbian/help/ScummVM.xml
A backends/platform/symbian/help/build_help.mk
A backends/platform/symbian/mmp/scummvm_avalanche.mmp.in
A backends/platform/symbian/mmp/scummvm_dreamweb.mmp.in
A backends/platform/symbian/mmp/scummvm_fullpipe.mmp.in
A backends/platform/symbian/mmp/scummvm_mortevielle.mmp.in
A backends/platform/symbian/mmp/scummvm_neverhood.mmp.in
A backends/platform/symbian/mmp/scummvm_sword25.mmp.in
A backends/platform/symbian/mmp/scummvm_testbed.mmp.in
A backends/platform/symbian/mmp/scummvm_zvision.mmp.in
A common/ustr.cpp
A common/ustr.h
A devtools/create_project/scripts/install-natvis.bat
A devtools/create_project/scripts/scummvm.natvis
A dists/android/res-ouya/values-television/margins.xml
A dists/android/res/drawable-xhdpi/ouya_icon.png
A dists/android/res/values/margins.xml
A engines/agi/configure.engine
A engines/agos/configure.engine
A engines/avalanche/animation.cpp
A engines/avalanche/animation.h
A engines/avalanche/avalanche.cpp
A engines/avalanche/avalanche.h
A engines/avalanche/avalot.cpp
A engines/avalanche/avalot.h
A engines/avalanche/background.cpp
A engines/avalanche/background.h
A engines/avalanche/clock.cpp
A engines/avalanche/clock.h
A engines/avalanche/closing.cpp
A engines/avalanche/closing.h
A engines/avalanche/configure.engine
A engines/avalanche/console.cpp
A engines/avalanche/console.h
A engines/avalanche/detection.cpp
A engines/avalanche/dialogs.cpp
A engines/avalanche/dialogs.h
A engines/avalanche/enums.h
A engines/avalanche/graphics.cpp
A engines/avalanche/graphics.h
A engines/avalanche/menu.cpp
A engines/avalanche/menu.h
A engines/avalanche/module.mk
A engines/avalanche/nim.cpp
A engines/avalanche/nim.h
A engines/avalanche/parser.cpp
A engines/avalanche/parser.h
A engines/avalanche/pingo.cpp
A engines/avalanche/pingo.h
A engines/avalanche/sequence.cpp
A engines/avalanche/sequence.h
A engines/avalanche/sound.cpp
A engines/avalanche/sound.h
A engines/avalanche/timer.cpp
A engines/avalanche/timer.h
A engines/cge/configure.engine
A engines/cine/configure.engine
A engines/composer/configure.engine
A engines/composer/console.cpp
A engines/composer/console.h
A engines/cruise/configure.engine
A engines/draci/configure.engine
A engines/drascula/configure.engine
A engines/dreamweb/configure.engine
A engines/fullpipe/configure.engine
A engines/fullpipe/console.cpp
A engines/fullpipe/console.h
A engines/fullpipe/floaters.cpp
A engines/fullpipe/floaters.h
A engines/fullpipe/messagehandlers.cpp
A engines/fullpipe/scenes/scene01.cpp
A engines/fullpipe/scenes/scene02.cpp
A engines/fullpipe/scenes/scene03.cpp
A engines/fullpipe/scenes/scene04.cpp
A engines/fullpipe/scenes/scene05.cpp
A engines/fullpipe/scenes/scene06.cpp
A engines/fullpipe/scenes/scene07.cpp
A engines/fullpipe/scenes/scene08.cpp
A engines/fullpipe/scenes/scene10.cpp
A engines/fullpipe/scenes/scene11.cpp
A engines/fullpipe/scenes/scene12.cpp
A engines/fullpipe/scenes/scene13.cpp
A engines/fullpipe/scenes/scene14.cpp
A engines/fullpipe/scenes/scene15.cpp
A engines/fullpipe/scenes/scene16.cpp
A engines/fullpipe/scenes/scene17.cpp
A engines/fullpipe/scenes/scene18and19.cpp
A engines/fullpipe/scenes/scene20.cpp
A engines/fullpipe/scenes/scene21.cpp
A engines/fullpipe/scenes/scene22.cpp
A engines/fullpipe/scenes/scene23.cpp
A engines/fullpipe/scenes/scene24.cpp
A engines/fullpipe/scenes/scene25.cpp
A engines/fullpipe/scenes/scene26.cpp
A engines/fullpipe/scenes/scene28.cpp
A engines/fullpipe/scenes/scene30.cpp
A engines/fullpipe/scenes/scene31.cpp
A engines/fullpipe/scenes/scene32.cpp
A engines/fullpipe/scenes/scene33.cpp
A engines/fullpipe/scenes/scene34.cpp
A engines/fullpipe/scenes/scene35.cpp
A engines/fullpipe/scenes/scene36.cpp
A engines/fullpipe/scenes/scene37.cpp
A engines/fullpipe/scenes/scene38.cpp
A engines/fullpipe/scenes/sceneDbg.cpp
A engines/fullpipe/scenes/sceneFinal.cpp
A engines/fullpipe/scenes/sceneIntro.cpp
A engines/gob/configure.engine
A engines/groovie/configure.engine
A engines/hopkins/configure.engine
A engines/hugo/configure.engine
A engines/kyra/configure.engine
A engines/lastexpress/configure.engine
A engines/lure/configure.engine
A engines/made/configure.engine
A engines/mohawk/configure.engine
A engines/mortevielle/configure.engine
A engines/neverhood/configure.engine
A engines/neverhood/modules/module1000_sprites.cpp
A engines/neverhood/modules/module1000_sprites.h
A engines/neverhood/modules/module1100_sprites.cpp
A engines/neverhood/modules/module1100_sprites.h
A engines/neverhood/modules/module1200_sprites.cpp
A engines/neverhood/modules/module1200_sprites.h
A engines/neverhood/modules/module1300_sprites.cpp
A engines/neverhood/modules/module1300_sprites.h
A engines/neverhood/modules/module1400_sprites.cpp
A engines/neverhood/modules/module1400_sprites.h
A engines/neverhood/modules/module1600_sprites.cpp
A engines/neverhood/modules/module1600_sprites.h
A engines/neverhood/modules/module1700_sprites.cpp
A engines/neverhood/modules/module1700_sprites.h
A engines/neverhood/modules/module1900_sprites.cpp
A engines/neverhood/modules/module1900_sprites.h
A engines/neverhood/modules/module2000_sprites.cpp
A engines/neverhood/modules/module2000_sprites.h
A engines/neverhood/modules/module2100_sprites.cpp
A engines/neverhood/modules/module2100_sprites.h
A engines/neverhood/modules/module2200_sprites.cpp
A engines/neverhood/modules/module2200_sprites.h
A engines/neverhood/modules/module2400_sprites.cpp
A engines/neverhood/modules/module2400_sprites.h
A engines/neverhood/modules/module2500_sprites.cpp
A engines/neverhood/modules/module2500_sprites.h
A engines/neverhood/modules/module2600_sprites.cpp
A engines/neverhood/modules/module2600_sprites.h
A engines/neverhood/modules/module2700_sprites.cpp
A engines/neverhood/modules/module2700_sprites.h
A engines/neverhood/modules/module2900_sprites.cpp
A engines/neverhood/modules/module2900_sprites.h
A engines/neverhood/modules/module3000_sprites.cpp
A engines/neverhood/modules/module3000_sprites.h
A engines/parallaction/configure.engine
A engines/pegasus/configure.engine
A engines/queen/configure.engine
A engines/saga/configure.engine
A engines/sci/configure.engine
A engines/sci/engine/script_patches.h
A engines/scumm/configure.engine
A engines/scumm/players/player_ad.cpp
A engines/scumm/players/player_ad.h
A engines/scumm/players/player_apple2.cpp
A engines/scumm/players/player_apple2.h
A engines/scumm/players/player_mac.cpp
A engines/scumm/players/player_mac.h
A engines/scumm/players/player_mod.cpp
A engines/scumm/players/player_mod.h
A engines/scumm/players/player_nes.cpp
A engines/scumm/players/player_nes.h
A engines/scumm/players/player_pce.cpp
A engines/scumm/players/player_pce.h
A engines/scumm/players/player_sid.cpp
A engines/scumm/players/player_sid.h
A engines/scumm/players/player_towns.cpp
A engines/scumm/players/player_towns.h
A engines/scumm/players/player_v1.cpp
A engines/scumm/players/player_v1.h
A engines/scumm/players/player_v2.cpp
A engines/scumm/players/player_v2.h
A engines/scumm/players/player_v2a.cpp
A engines/scumm/players/player_v2a.h
A engines/scumm/players/player_v2base.cpp
A engines/scumm/players/player_v2base.h
A engines/scumm/players/player_v2cms.cpp
A engines/scumm/players/player_v2cms.h
A engines/scumm/players/player_v3a.cpp
A engines/scumm/players/player_v3a.h
A engines/scumm/players/player_v3m.cpp
A engines/scumm/players/player_v3m.h
A engines/scumm/players/player_v4a.cpp
A engines/scumm/players/player_v4a.h
A engines/scumm/players/player_v5m.cpp
A engines/scumm/players/player_v5m.h
A engines/sky/configure.engine
A engines/sword1/configure.engine
A engines/sword2/configure.engine
A engines/sword25/configure.engine
A engines/teenagent/configure.engine
A engines/testbed/configure.engine
A engines/tinsel/configure.engine
A engines/toltecs/configure.engine
A engines/tony/configure.engine
A engines/toon/configure.engine
A engines/touche/configure.engine
A engines/tsage/configure.engine
A engines/tucker/configure.engine
A engines/wintermute/configure.engine
A engines/zvision/animation/rlf_animation.cpp
A engines/zvision/animation/rlf_animation.h
A engines/zvision/archives/zfs_archive.cpp
A engines/zvision/archives/zfs_archive.h
A engines/zvision/configure.engine
A engines/zvision/core/console.cpp
A engines/zvision/core/console.h
A engines/zvision/core/events.cpp
A engines/zvision/core/menu.h
A engines/zvision/core/save_manager.cpp
A engines/zvision/core/save_manager.h
A engines/zvision/cursors/cursor.cpp
A engines/zvision/cursors/cursor.h
A engines/zvision/cursors/cursor_manager.cpp
A engines/zvision/cursors/cursor_manager.h
A engines/zvision/detection.cpp
A engines/zvision/detection.h
A engines/zvision/fonts/truetype_font.cpp
A engines/zvision/fonts/truetype_font.h
A engines/zvision/graphics/render_manager.cpp
A engines/zvision/graphics/render_manager.h
A engines/zvision/graphics/render_table.cpp
A engines/zvision/graphics/render_table.h
A engines/zvision/inventory/inventory_manager.h
A engines/zvision/module.mk
A engines/zvision/scripting/actions.cpp
A engines/zvision/scripting/actions.h
A engines/zvision/scripting/control.cpp
A engines/zvision/scripting/control.h
A engines/zvision/scripting/controls/animation_control.cpp
A engines/zvision/scripting/controls/animation_control.h
A engines/zvision/scripting/controls/input_control.cpp
A engines/zvision/scripting/controls/input_control.h
A engines/zvision/scripting/controls/lever_control.cpp
A engines/zvision/scripting/controls/lever_control.h
A engines/zvision/scripting/controls/push_toggle_control.cpp
A engines/zvision/scripting/controls/push_toggle_control.h
A engines/zvision/scripting/controls/timer_node.cpp
A engines/zvision/scripting/controls/timer_node.h
A engines/zvision/scripting/puzzle.h
A engines/zvision/scripting/scr_file_handling.cpp
A engines/zvision/scripting/script_manager.cpp
A engines/zvision/scripting/script_manager.h
A engines/zvision/sound/zork_raw.cpp
A engines/zvision/sound/zork_raw.h
A engines/zvision/strings/string_manager.cpp
A engines/zvision/strings/string_manager.h
A engines/zvision/subtitles/subtitles.h
A engines/zvision/utility/clock.cpp
A engines/zvision/utility/clock.h
A engines/zvision/utility/lzss_read_stream.cpp
A engines/zvision/utility/lzss_read_stream.h
A engines/zvision/utility/single_value_container.cpp
A engines/zvision/utility/single_value_container.h
A engines/zvision/utility/utility.cpp
A engines/zvision/utility/utility.h
A engines/zvision/video/video.cpp
A engines/zvision/video/zork_avi_decoder.cpp
A engines/zvision/video/zork_avi_decoder.h
A engines/zvision/zvision.cpp
A engines/zvision/zvision.h
A video/codecs/jpeg.cpp
A video/codecs/jpeg.h
R backends/graphics/opengl/gltexture.cpp
R backends/graphics/opengl/gltexture.h
R backends/graphics/opengl/glerrorcheck.cpp
R engines/configure.engines
R engines/engines.mk
R engines/plugins_table.h
R engines/scumm/player_ad.cpp
R engines/scumm/player_ad.h
R engines/scumm/player_apple2.cpp
R engines/scumm/player_apple2.h
R engines/scumm/player_mac.cpp
R engines/scumm/player_mac.h
R engines/scumm/player_mod.cpp
R engines/scumm/player_mod.h
R engines/scumm/player_nes.cpp
R engines/scumm/player_nes.h
R engines/scumm/player_pce.cpp
R engines/scumm/player_pce.h
R engines/scumm/player_sid.cpp
R engines/scumm/player_sid.h
R engines/scumm/player_towns.cpp
R engines/scumm/player_towns.h
R engines/scumm/player_v1.cpp
R engines/scumm/player_v1.h
R engines/scumm/player_v2.cpp
R engines/scumm/player_v2.h
R engines/scumm/player_v2a.cpp
R engines/scumm/player_v2a.h
R engines/scumm/player_v2base.cpp
R engines/scumm/player_v2base.h
R engines/scumm/player_v2cms.cpp
R engines/scumm/player_v2cms.h
R engines/scumm/player_v3a.cpp
R engines/scumm/player_v3a.h
R engines/scumm/player_v3m.cpp
R engines/scumm/player_v3m.h
R engines/scumm/player_v4a.cpp
R engines/scumm/player_v4a.h
R engines/scumm/player_v5m.cpp
R engines/scumm/player_v5m.h
R backends/graphics/opengl/glerrorcheck.h
.gitignore
AUTHORS
COPYRIGHT
Makefile
Makefile.common
NEWS
README
audio/decoders/voc.cpp
audio/midiparser.cpp
audio/midiparser.h
audio/softsynth/eas.cpp
audio/softsynth/fluidsynth.cpp
audio/softsynth/mt32.cpp
backends/events/maemosdl/maemosdl-events.cpp
backends/events/sdl/sdl-events.cpp
backends/fs/amigaos4/amigaos4-fs.cpp
backends/fs/amigaos4/amigaos4-fs.h
backends/fs/wii/wii-fs-factory.cpp
backends/fs/wii/wii-fs.cpp
backends/fs/wii/wii-fs.h
backends/graphics/opengl/opengl-graphics.cpp
backends/graphics/opengl/opengl-graphics.h
backends/graphics/openglsdl/openglsdl-graphics.cpp
backends/graphics/openglsdl/openglsdl-graphics.h
backends/graphics/sdl/sdl-graphics.cpp
backends/graphics/sdl/sdl-graphics.h
backends/graphics/surfacesdl/surfacesdl-graphics.cpp
backends/graphics/surfacesdl/surfacesdl-graphics.h
backends/module.mk
backends/platform/android/android.cpp
backends/platform/android/android.h
backends/platform/android/android.mk
backends/platform/android/events.cpp
backends/platform/android/gfx.cpp
backends/platform/android/org/scummvm/scummvm/MouseHelper.java
backends/platform/android/org/scummvm/scummvm/ScummVMActivity.java
backends/platform/android/org/scummvm/scummvm/ScummVMEvents.java
backends/platform/android/texture.cpp
backends/platform/android/texture.h
backends/platform/dc/dc-fs.cpp
backends/platform/dc/dc.h
backends/platform/dc/dcmain.cpp
backends/platform/dc/icon.cpp
backends/platform/dc/input.cpp
backends/platform/dc/ip.txt.in
backends/platform/dc/softkbd.h
backends/platform/gph/gph-backend.cpp
backends/platform/null/null.cpp
backends/platform/openpandora/op-backend.cpp
backends/platform/sdl/posix/posix.cpp
backends/platform/sdl/sdl.cpp
backends/platform/sdl/sdl.h
backends/platform/symbian/AdaptAllMMPs.pl
backends/platform/symbian/BuildPackageUpload_AllVersions.pl
backends/platform/symbian/BuildPackageUpload_LocalSettings.pl
backends/platform/symbian/README
backends/platform/symbian/S60/ScummVM_S60.mmp.in
backends/platform/symbian/S60/ScummVM_S60_App.mmp
backends/platform/symbian/S60v3/BLD.INF.in
backends/platform/symbian/S60v3/ScummVM_A0000658_S60v3.mmp.in
backends/platform/symbian/S60v3/ScummVM_S60v3.mmp.in
backends/platform/symbian/S60v3/scummvm-CVS-SymbianS60v3.pkg
backends/platform/symbian/S60v3/scummvm-CVS-SymbianS60v3_split.pkg
backends/platform/symbian/S80/ScummVM_S80.mmp.in
backends/platform/symbian/S80/ScummVM_S80_App.mmp
backends/platform/symbian/S90/Scummvm_S90.mmp.in
backends/platform/symbian/S90/Scummvm_S90_App.mmp
backends/platform/symbian/UIQ2/ScummVM.rss
backends/platform/symbian/UIQ2/ScummVM_UIQ2.mmp.in
backends/platform/symbian/UIQ3/ScummVM.rss
backends/platform/symbian/UIQ3/ScummVM_A0000658.rss
backends/platform/symbian/UIQ3/ScummVM_A0000658_UIQ3.mmp.in
backends/platform/symbian/UIQ3/ScummVM_UIQ3.mmp.in
backends/platform/symbian/UIQ3/scummvm-CVS-SymbianUIQ3.pkg
backends/platform/symbian/UIQ3/scummvm-CVS-SymbianUIQ3_split.pkg
backends/platform/symbian/UIQ3/scummvm_A0000658_loc.rss
backends/platform/symbian/mmp/scummvm_agi.mmp.in
backends/platform/symbian/mmp/scummvm_agos.mmp.in
backends/platform/symbian/mmp/scummvm_base.mmp.in
backends/platform/symbian/mmp/scummvm_cge.mmp.in
backends/platform/symbian/mmp/scummvm_cine.mmp.in
backends/platform/symbian/mmp/scummvm_composer.mmp.in
backends/platform/symbian/mmp/scummvm_cruise.mmp.in
backends/platform/symbian/mmp/scummvm_draci.mmp.in
backends/platform/symbian/mmp/scummvm_drascula.mmp.in
backends/platform/symbian/mmp/scummvm_gob.mmp.in
backends/platform/symbian/mmp/scummvm_groovie.mmp.in
backends/platform/symbian/mmp/scummvm_hopkins.mmp.in
backends/platform/symbian/mmp/scummvm_hugo.mmp.in
backends/platform/symbian/mmp/scummvm_kyra.mmp.in
backends/platform/symbian/mmp/scummvm_lastexpress.mmp.in
backends/platform/symbian/mmp/scummvm_lure.mmp.in
backends/platform/symbian/mmp/scummvm_m4.mmp.in
backends/platform/symbian/mmp/scummvm_made.mmp.in
backends/platform/symbian/mmp/scummvm_mohawk.mmp.in
backends/platform/symbian/mmp/scummvm_parallaction.mmp.in
backends/platform/symbian/mmp/scummvm_pegasus.mmp.in
backends/platform/symbian/mmp/scummvm_queen.mmp.in
backends/platform/symbian/mmp/scummvm_saga.mmp.in
backends/platform/symbian/mmp/scummvm_sci.mmp.in
backends/platform/symbian/mmp/scummvm_scumm.mmp.in
backends/platform/symbian/mmp/scummvm_sky.mmp.in
backends/platform/symbian/mmp/scummvm_sword1.mmp.in
backends/platform/symbian/mmp/scummvm_sword2.mmp.in
backends/platform/symbian/mmp/scummvm_teenagent.mmp.in
backends/platform/symbian/mmp/scummvm_tinsel.mmp.in
backends/platform/symbian/mmp/scummvm_toltecs.mmp.in
backends/platform/symbian/mmp/scummvm_tony.mmp.in
backends/platform/symbian/mmp/scummvm_toon.mmp.in
backends/platform/symbian/mmp/scummvm_touche.mmp.in
backends/platform/symbian/mmp/scummvm_tsage.mmp.in
backends/platform/symbian/mmp/scummvm_tucker.mmp.in
backends/platform/symbian/mmp/scummvm_wintermute.mmp.in
backends/platform/symbian/res/ScummVmAif.rss
backends/platform/symbian/res/scummvm.rss
backends/platform/symbian/res/scummvm_A0000658.rss
backends/platform/symbian/src/ScummVm.hrh
backends/platform/symbian/src/SymbianOS.cpp
backends/platform/symbian/src/portdefs.h
backends/platform/tizen/graphics.cpp
backends/platform/tizen/graphics.h
backends/platform/tizen/system.cpp
backends/platform/wii/main.cpp
backends/platform/wii/osystem_events.cpp
backends/platform/wii/wii.mk
backends/platform/wince/CEActionsPocket.cpp
backends/platform/wince/CEActionsSmartphone.cpp
backends/platform/wince/CELauncherDialog.cpp
backends/platform/wince/wince-sdl.cpp
backends/taskbar/unity/unity-taskbar.cpp
backends/taskbar/unity/unity-taskbar.h
base/main.cpp
base/plugins.cpp
base/plugins.h
common/c++11-compat.h
common/ini-file.cpp
common/ini-file.h
common/language.cpp
common/language.h
common/module.mk
common/quicktime.cpp
common/recorderfile.cpp
common/scummsys.h
common/str.h
common/unarj.cpp
common/winexe_ne.cpp
common/winexe_ne.h
common/zlib.cpp
configure
devtools/convbdf.cpp
devtools/create_mortdat/create_mortdat.cpp
devtools/create_neverhood/create_neverhood.cpp
devtools/create_project/codeblocks.cpp
devtools/create_project/config.h
devtools/create_project/create_project.cpp
devtools/create_project/create_project.h
devtools/create_project/msbuild.cpp
devtools/create_project/visualstudio.cpp
devtools/create_project/xcode.cpp
devtools/create_translations/create_translations.cpp
devtools/create_translations/create_translations.h
devtools/credits.pl
devtools/extract_mort/extract_mort.cpp
devtools/scumm-md5.txt
dists/android/AndroidManifest.xml
dists/android/AndroidManifest.xml.in
dists/android/res/layout/main.xml
dists/debian/copyright
dists/engine-data/README
dists/macosx/Info.plist
dists/macosx/Info.plist.in
dists/msvc11/readme.txt
dists/msvc12/readme.txt
dists/scummvm.rc
dists/scummvm.rc.in
dists/win32/ScummVM.iss
dists/win32/migration.bat
dists/win32/scummvm.nsi
dists/win32/scummvm.nsi.in
engines/agi/detection_tables.h
engines/agi/loader_v1.cpp
engines/agi/loader_v2.cpp
engines/agi/loader_v3.cpp
engines/agi/opcodes.cpp
engines/agi/preagi_mickey.cpp
engines/agi/words.cpp
engines/agos/agos.h
engines/agos/animation.cpp
engines/agos/detection.cpp
engines/agos/detection_tables.h
engines/agos/icons.cpp
engines/agos/res.cpp
engines/agos/res_snd.cpp
engines/agos/saveload.cpp
engines/agos/subroutine.cpp
engines/cge/bitmap.cpp
engines/cge/cge_main.cpp
engines/cge/detection.cpp
engines/cge/fileio.cpp
engines/cge/fileio.h
engines/cge/sound.cpp
engines/cge/text.cpp
engines/cge/vga13h.cpp
engines/cine/script_fw.cpp
engines/cine/sound.cpp
engines/composer/composer.cpp
engines/composer/composer.h
engines/composer/module.mk
engines/draci/barchive.cpp
engines/draci/draci.cpp
engines/draci/game.cpp
engines/draci/script.cpp
engines/draci/sprite.cpp
engines/draci/surface.cpp
engines/draci/walking.cpp
engines/draci/walking.h
engines/drascula/animation.cpp
engines/drascula/converse.cpp
engines/drascula/drascula.cpp
engines/drascula/drascula.h
engines/drascula/graphics.cpp
engines/drascula/objects.cpp
engines/dreamweb/dreamweb.cpp
engines/dreamweb/dreamweb.h
engines/engine.cpp
engines/engine.h
engines/fullpipe/behavior.cpp
engines/fullpipe/behavior.h
engines/fullpipe/constants.h
engines/fullpipe/fullpipe.cpp
engines/fullpipe/fullpipe.h
engines/fullpipe/gameloader.cpp
engines/fullpipe/gameloader.h
engines/fullpipe/gfx.cpp
engines/fullpipe/gfx.h
engines/fullpipe/init.cpp
engines/fullpipe/input.cpp
engines/fullpipe/interaction.cpp
engines/fullpipe/interaction.h
engines/fullpipe/inventory.cpp
engines/fullpipe/inventory.h
engines/fullpipe/lift.cpp
engines/fullpipe/messages.cpp
engines/fullpipe/messages.h
engines/fullpipe/modal.cpp
engines/fullpipe/modal.h
engines/fullpipe/module.mk
engines/fullpipe/motion.cpp
engines/fullpipe/motion.h
engines/fullpipe/ngiarchive.cpp
engines/fullpipe/objectnames.h
engines/fullpipe/objects.h
engines/fullpipe/scene.cpp
engines/fullpipe/scene.h
engines/fullpipe/scenes.cpp
engines/fullpipe/scenes.h
engines/fullpipe/sound.cpp
engines/fullpipe/sound.h
engines/fullpipe/stateloader.cpp
engines/fullpipe/statics.cpp
engines/fullpipe/statics.h
engines/fullpipe/utils.cpp
engines/fullpipe/utils.h
engines/groovie/font.cpp
engines/groovie/font.h
engines/hopkins/computer.cpp
engines/hopkins/dialogs.cpp
engines/hopkins/events.cpp
engines/hopkins/globals.cpp
engines/hopkins/graphics.cpp
engines/hopkins/hopkins.cpp
engines/hopkins/hopkins.h
engines/hopkins/menu.cpp
engines/hopkins/objects.cpp
engines/hopkins/script.cpp
engines/hopkins/sound.cpp
engines/hopkins/talk.cpp
engines/hugo/dialogs.cpp
engines/hugo/display.cpp
engines/hugo/file.cpp
engines/hugo/hugo.cpp
engines/hugo/hugo.h
engines/hugo/intro.cpp
engines/hugo/inventory.cpp
engines/hugo/mouse.cpp
engines/hugo/object.cpp
engines/hugo/parser.cpp
engines/hugo/route.cpp
engines/hugo/route.h
engines/hugo/schedule.cpp
engines/hugo/sound.cpp
engines/hugo/text.cpp
engines/kyra/animator_lok.cpp
engines/kyra/chargen.cpp
engines/kyra/kyra_mr.cpp
engines/kyra/resource.cpp
engines/kyra/screen_v2.cpp
engines/kyra/sequences_lok.cpp
engines/kyra/sound_towns.cpp
engines/kyra/staticres.cpp
engines/kyra/vqa.cpp
engines/kyra/vqa.h
engines/lastexpress/entities/abbot.cpp
engines/lastexpress/entities/abbot.h
engines/lastexpress/entities/alexei.cpp
engines/lastexpress/entities/alexei.h
engines/lastexpress/entities/alouan.cpp
engines/lastexpress/entities/alouan.h
engines/lastexpress/entities/anna.cpp
engines/lastexpress/entities/anna.h
engines/lastexpress/entities/august.cpp
engines/lastexpress/entities/chapters.cpp
engines/lastexpress/entities/coudert.cpp
engines/lastexpress/entities/entity.cpp
engines/lastexpress/entities/entity.h
engines/lastexpress/entities/francois.cpp
engines/lastexpress/entities/francois.h
engines/lastexpress/entities/gendarmes.cpp
engines/lastexpress/entities/kahina.cpp
engines/lastexpress/entities/kronos.cpp
engines/lastexpress/entities/mertens.cpp
engines/lastexpress/entities/milos.cpp
engines/lastexpress/entities/rebecca.cpp
engines/lastexpress/entities/servers0.cpp
engines/lastexpress/entities/tatiana.cpp
engines/lastexpress/entities/vassili.cpp
engines/lastexpress/entities/verges.cpp
engines/lastexpress/entities/yasmin.cpp
engines/lastexpress/entities/yasmin.h
engines/lastexpress/fight/fight.cpp
engines/lastexpress/game/action.cpp
engines/lastexpress/game/action.h
engines/lastexpress/game/entities.h
engines/lastexpress/game/inventory.cpp
engines/lastexpress/game/inventory.h
engines/lastexpress/game/logic.cpp
engines/lastexpress/game/logic.h
engines/lastexpress/game/object.cpp
engines/lastexpress/game/object.h
engines/lastexpress/game/savegame.h
engines/lastexpress/game/scenes.cpp
engines/lastexpress/game/state.h
engines/lastexpress/shared.h
engines/lastexpress/sound/sound.cpp
engines/made/detection.cpp
engines/made/made.cpp
engines/made/screenfx.cpp
engines/made/sound.cpp
engines/mohawk/cstime.cpp
engines/mohawk/cstime_game.cpp
engines/mohawk/cstime_ui.cpp
engines/mohawk/cstime_ui.h
engines/mortevielle/actions.cpp
engines/mortevielle/debugger.cpp
engines/mortevielle/debugger.h
engines/mortevielle/dialogs.cpp
engines/mortevielle/dialogs.h
engines/mortevielle/graphics.cpp
engines/mortevielle/graphics.h
engines/mortevielle/menu.cpp
engines/mortevielle/menu.h
engines/mortevielle/mortevielle.cpp
engines/mortevielle/mortevielle.h
engines/mortevielle/mouse.cpp
engines/mortevielle/mouse.h
engines/mortevielle/outtext.cpp
engines/mortevielle/outtext.h
engines/mortevielle/saveload.cpp
engines/mortevielle/saveload.h
engines/mortevielle/sound.cpp
engines/mortevielle/sound.h
engines/mortevielle/utils.cpp
engines/neverhood/console.cpp
engines/neverhood/detection.cpp
engines/neverhood/diskplayerscene.cpp
engines/neverhood/gamemodule.cpp
engines/neverhood/gamemodule.h
engines/neverhood/graphics.cpp
engines/neverhood/klaymen.cpp
engines/neverhood/klaymen.h
engines/neverhood/menumodule.cpp
engines/neverhood/messages.h
engines/neverhood/module.cpp
engines/neverhood/module.mk
engines/neverhood/modules/module1000.cpp
engines/neverhood/modules/module1000.h
engines/neverhood/modules/module1100.cpp
engines/neverhood/modules/module1100.h
engines/neverhood/modules/module1200.cpp
engines/neverhood/modules/module1200.h
engines/neverhood/modules/module1300.cpp
engines/neverhood/modules/module1300.h
engines/neverhood/modules/module1400.cpp
engines/neverhood/modules/module1400.h
engines/neverhood/modules/module1500.cpp
engines/neverhood/modules/module1600.cpp
engines/neverhood/modules/module1600.h
engines/neverhood/modules/module1700.cpp
engines/neverhood/modules/module1700.h
engines/neverhood/modules/module1800.cpp
engines/neverhood/modules/module1900.cpp
engines/neverhood/modules/module1900.h
engines/neverhood/modules/module2000.cpp
engines/neverhood/modules/module2000.h
engines/neverhood/modules/module2100.cpp
engines/neverhood/modules/module2100.h
engines/neverhood/modules/module2200.cpp
engines/neverhood/modules/module2200.h
engines/neverhood/modules/module2300.cpp
engines/neverhood/modules/module2400.cpp
engines/neverhood/modules/module2400.h
engines/neverhood/modules/module2500.cpp
engines/neverhood/modules/module2500.h
engines/neverhood/modules/module2600.cpp
engines/neverhood/modules/module2600.h
engines/neverhood/modules/module2700.cpp
engines/neverhood/modules/module2700.h
engines/neverhood/modules/module2800.cpp
engines/neverhood/modules/module2800_sprites.cpp
engines/neverhood/modules/module2800_sprites.h
engines/neverhood/modules/module2900.cpp
engines/neverhood/modules/module2900.h
engines/neverhood/modules/module3000.cpp
engines/neverhood/modules/module3000.h
engines/neverhood/navigationscene.cpp
engines/neverhood/neverhood.cpp
engines/neverhood/neverhood.h
engines/neverhood/palette.cpp
engines/neverhood/palette.h
engines/neverhood/resourceman.cpp
engines/neverhood/scene.cpp
engines/neverhood/scene.h
engines/neverhood/screen.cpp
engines/neverhood/screen.h
engines/neverhood/smackerplayer.cpp
engines/neverhood/smackerscene.cpp
engines/neverhood/sound.cpp
engines/neverhood/sound.h
engines/neverhood/sprite.cpp
engines/neverhood/staticdata.cpp
engines/parallaction/debug.cpp
engines/parallaction/exec.h
engines/parallaction/font.cpp
engines/parallaction/graphics.cpp
engines/parallaction/graphics.h
engines/parallaction/gui.h
engines/parallaction/gui_br.cpp
engines/parallaction/gui_ns.cpp
engines/parallaction/input.h
engines/parallaction/objects.h
engines/parallaction/parallaction.cpp
engines/parallaction/parallaction.h
engines/parallaction/parallaction_br.cpp
engines/parallaction/parallaction_ns.cpp
engines/parallaction/parser.h
engines/parallaction/sound.h
engines/parallaction/sound_br.cpp
engines/parallaction/sound_ns.cpp
engines/pegasus/neighborhood/caldoria/caldoria.cpp
engines/pegasus/neighborhood/mars/mars.cpp
engines/pegasus/neighborhood/norad/delta/globegame.cpp
engines/pegasus/neighborhood/norad/delta/noraddelta.cpp
engines/pegasus/neighborhood/prehistoric/prehistoric.cpp
engines/pegasus/neighborhood/tsa/fulltsa.cpp
engines/pegasus/neighborhood/tsa/tinytsa.cpp
engines/pegasus/neighborhood/wsc/wsc.cpp
engines/pegasus/pegasus.cpp
engines/pegasus/pegasus.h
engines/pegasus/timers.cpp
engines/saga/introproc_ite.cpp
engines/saga/saga.h
engines/saga/sprite.cpp
engines/sci/console.cpp
engines/sci/detection_tables.h
engines/sci/engine/kernel.cpp
engines/sci/engine/kernel.h
engines/sci/engine/kernel_tables.h
engines/sci/engine/kfile.cpp
engines/sci/engine/kgraphics.cpp
engines/sci/engine/object.cpp
engines/sci/engine/savegame.cpp
engines/sci/engine/script.cpp
engines/sci/engine/script.h
engines/sci/engine/script_patches.cpp
engines/sci/engine/scriptdebug.cpp
engines/sci/engine/seg_manager.cpp
engines/sci/engine/seg_manager.h
engines/sci/engine/state.cpp
engines/sci/engine/vm.cpp
engines/sci/engine/workarounds.cpp
engines/sci/engine/workarounds.h
engines/sci/graphics/picture.cpp
engines/sci/graphics/picture.h
engines/sci/graphics/portrait.cpp
engines/sci/graphics/portrait.h
engines/sci/graphics/ports.cpp
engines/sci/graphics/view.cpp
engines/sci/parser/vocabulary.cpp
engines/sci/resource.cpp
engines/sci/resource.h
engines/sci/resource_audio.cpp
engines/sci/sci.cpp
engines/sci/sci.h
engines/sci/sound/midiparser_sci.cpp
engines/sci/sound/midiparser_sci.h
engines/sci/sound/music.cpp
engines/sci/sound/music.h
engines/sci/sound/soundcmd.cpp
engines/scumm/detection.cpp
engines/scumm/he/animation_he.cpp
engines/scumm/he/animation_he.h
engines/scumm/he/intern_he.h
engines/scumm/he/logic/football.cpp
engines/scumm/he/script_v100he.cpp
engines/scumm/he/script_v60he.cpp
engines/scumm/he/script_v72he.cpp
engines/scumm/he/script_v80he.cpp
engines/scumm/he/script_v90he.cpp
engines/scumm/he/wiz_he.cpp
engines/scumm/imuse_digi/dimuse_sndmgr.cpp
engines/scumm/module.mk
engines/scumm/saveload.cpp
engines/scumm/script_v5.cpp
engines/scumm/scumm-md5.h
engines/scumm/scumm.cpp
engines/scumm/scumm.h
engines/scumm/sound.cpp
engines/sword1/music.cpp
engines/sword1/music.h
engines/sword1/screen.cpp
engines/sword1/sound.cpp
engines/sword1/sword1.cpp
engines/sword25/gfx/animation.cpp
engines/sword25/gfx/animation.h
engines/sword25/gfx/animationdescription.cpp
engines/sword25/gfx/animationdescription.h
engines/sword25/gfx/animationtemplate.cpp
engines/sword25/gfx/animationtemplateregistry.cpp
engines/sword25/gfx/bitmap.h
engines/sword25/gfx/image/art.cpp
engines/sword25/gfx/image/renderedimage.cpp
engines/sword25/gfx/panel.cpp
engines/sword25/gfx/panel.h
engines/sword25/gfx/renderobject.cpp
engines/sword25/gfx/renderobject.h
engines/sword25/gfx/renderobjectmanager.cpp
engines/sword25/gfx/text.cpp
engines/sword25/gfx/text.h
engines/sword25/input/inputengine.cpp
engines/sword25/kernel/inputpersistenceblock.cpp
engines/sword25/kernel/inputpersistenceblock.h
engines/sword25/kernel/objectregistry.h
engines/sword25/kernel/outputpersistenceblock.cpp
engines/sword25/kernel/outputpersistenceblock.h
engines/sword25/kernel/persistenceservice.cpp
engines/sword25/math/polygon.cpp
engines/sword25/math/polygon.h
engines/sword25/math/region.cpp
engines/sword25/math/regionregistry.cpp
engines/sword25/math/walkregion.cpp
engines/sword25/sfx/soundengine.cpp
engines/sword25/sfx/soundengine.h
engines/sword25/util/lua/lcode.cpp
engines/sword25/util/lua/ldebug.cpp
engines/sword25/util/lua/lfunc.cpp
engines/sword25/util/lua/lgc.cpp
engines/sword25/util/lua/llimits.h
engines/sword25/util/lua/lmem.cpp
engines/sword25/util/lua/lopcodes.cpp
engines/sword25/util/lua/lparser.cpp
engines/sword25/util/lua/lstate.cpp
engines/sword25/util/lua/lstring.cpp
engines/sword25/util/lua/lstrlib.cpp
engines/sword25/util/lua/ltablib.cpp
engines/sword25/util/lua/lua.h
engines/sword25/util/pluto/pluto.cpp
engines/teenagent/callbacks.cpp
engines/teenagent/teenagent.h
engines/testbed/config-params.cpp
engines/testbed/config.h
engines/testbed/events.cpp
engines/tinsel/detection_tables.h
engines/tinsel/music.cpp
engines/tinsel/scene.cpp
engines/tinsel/tinsel.cpp
engines/tinsel/tinsel.h
engines/toltecs/render.cpp
engines/toltecs/saveload.cpp
engines/toltecs/screen.cpp
engines/toltecs/script.cpp
engines/toltecs/toltecs.cpp
engines/toltecs/toltecs.h
engines/tony/gfxcore.cpp
engines/tony/mpal/mpal.cpp
engines/tony/sound.cpp
engines/tony/tony.h
engines/tony/window.cpp
engines/tony/window.h
engines/toon/anim.cpp
engines/toon/audio.cpp
engines/toon/character.cpp
engines/toon/font.cpp
engines/toon/movie.cpp
engines/toon/movie.h
engines/toon/path.cpp
engines/toon/picture.cpp
engines/toon/resource.cpp
engines/toon/resource.h
engines/toon/script.cpp
engines/toon/script_func.cpp
engines/toon/state.cpp
engines/toon/tools.cpp
engines/toon/toon.cpp
engines/touche/touche.cpp
engines/touche/touche.h
engines/tsage/blue_force/blueforce_logic.cpp
engines/tsage/blue_force/blueforce_logic.h
engines/tsage/blue_force/blueforce_scenes0.cpp
engines/tsage/blue_force/blueforce_scenes0.h
engines/tsage/blue_force/blueforce_scenes1.cpp
engines/tsage/blue_force/blueforce_scenes2.cpp
engines/tsage/blue_force/blueforce_scenes3.cpp
engines/tsage/blue_force/blueforce_scenes3.h
engines/tsage/blue_force/blueforce_scenes4.cpp
engines/tsage/blue_force/blueforce_scenes4.h
engines/tsage/blue_force/blueforce_scenes5.cpp
engines/tsage/blue_force/blueforce_scenes5.h
engines/tsage/blue_force/blueforce_scenes6.cpp
engines/tsage/blue_force/blueforce_scenes7.cpp
engines/tsage/blue_force/blueforce_scenes8.cpp
engines/tsage/blue_force/blueforce_scenes8.h
engines/tsage/blue_force/blueforce_scenes9.cpp
engines/tsage/blue_force/blueforce_scenes9.h
engines/tsage/blue_force/blueforce_speakers.cpp
engines/tsage/blue_force/blueforce_speakers.h
engines/tsage/converse.cpp
engines/tsage/converse.h
engines/tsage/core.cpp
engines/tsage/core.h
engines/tsage/debugger.cpp
engines/tsage/debugger.h
engines/tsage/detection.cpp
engines/tsage/detection_tables.h
engines/tsage/events.cpp
engines/tsage/globals.cpp
engines/tsage/globals.h
engines/tsage/graphics.cpp
engines/tsage/graphics.h
engines/tsage/ringworld/ringworld_logic.cpp
engines/tsage/ringworld/ringworld_scenes1.cpp
engines/tsage/ringworld/ringworld_scenes1.h
engines/tsage/ringworld/ringworld_scenes10.cpp
engines/tsage/ringworld/ringworld_scenes3.cpp
engines/tsage/ringworld/ringworld_scenes3.h
engines/tsage/ringworld/ringworld_scenes5.cpp
engines/tsage/ringworld/ringworld_scenes5.h
engines/tsage/ringworld/ringworld_scenes6.cpp
engines/tsage/ringworld/ringworld_scenes6.h
engines/tsage/ringworld/ringworld_scenes8.cpp
engines/tsage/ringworld/ringworld_scenes8.h
engines/tsage/ringworld2/ringworld2_dialogs.cpp
engines/tsage/ringworld2/ringworld2_dialogs.h
engines/tsage/ringworld2/ringworld2_logic.cpp
engines/tsage/ringworld2/ringworld2_logic.h
engines/tsage/ringworld2/ringworld2_scenes0.cpp
engines/tsage/ringworld2/ringworld2_scenes0.h
engines/tsage/ringworld2/ringworld2_scenes1.cpp
engines/tsage/ringworld2/ringworld2_scenes1.h
engines/tsage/ringworld2/ringworld2_scenes2.cpp
engines/tsage/ringworld2/ringworld2_scenes2.h
engines/tsage/ringworld2/ringworld2_scenes3.cpp
engines/tsage/ringworld2/ringworld2_scenes3.h
engines/tsage/ringworld2/ringworld2_speakers.cpp
engines/tsage/ringworld2/ringworld2_speakers.h
engines/tsage/saveload.cpp
engines/tsage/saveload.h
engines/tsage/scenes.cpp
engines/tsage/scenes.h
engines/tsage/sound.cpp
engines/tsage/sound.h
engines/tsage/staticres.cpp
engines/tsage/staticres.h
engines/tsage/tsage.cpp
engines/tsage/tsage.h
engines/tsage/user_interface.cpp
engines/tsage/user_interface.h
engines/wintermute/ad/ad_actor.cpp
engines/wintermute/ad/ad_actor.h
engines/wintermute/ad/ad_entity.cpp
engines/wintermute/ad/ad_entity.h
engines/wintermute/ad/ad_game.cpp
engines/wintermute/ad/ad_game.h
engines/wintermute/ad/ad_inventory.cpp
engines/wintermute/ad/ad_inventory_box.cpp
engines/wintermute/ad/ad_inventory_box.h
engines/wintermute/ad/ad_item.cpp
engines/wintermute/ad/ad_item.h
engines/wintermute/ad/ad_layer.cpp
engines/wintermute/ad/ad_layer.h
engines/wintermute/ad/ad_node_state.cpp
engines/wintermute/ad/ad_object.cpp
engines/wintermute/ad/ad_object.h
engines/wintermute/ad/ad_path.cpp
engines/wintermute/ad/ad_path_point.cpp
engines/wintermute/ad/ad_region.cpp
engines/wintermute/ad/ad_region.h
engines/wintermute/ad/ad_response.cpp
engines/wintermute/ad/ad_response_box.cpp
engines/wintermute/ad/ad_response_box.h
engines/wintermute/ad/ad_response_context.cpp
engines/wintermute/ad/ad_rot_level.cpp
engines/wintermute/ad/ad_rot_level.h
engines/wintermute/ad/ad_scale_level.cpp
engines/wintermute/ad/ad_scale_level.h
engines/wintermute/ad/ad_scene.cpp
engines/wintermute/ad/ad_scene.h
engines/wintermute/ad/ad_scene_node.cpp
engines/wintermute/ad/ad_scene_state.cpp
engines/wintermute/ad/ad_sentence.cpp
engines/wintermute/ad/ad_sprite_set.cpp
engines/wintermute/ad/ad_sprite_set.h
engines/wintermute/ad/ad_talk_def.cpp
engines/wintermute/ad/ad_talk_def.h
engines/wintermute/ad/ad_talk_node.cpp
engines/wintermute/ad/ad_talk_node.h
engines/wintermute/ad/ad_waypoint_group.cpp
engines/wintermute/ad/ad_waypoint_group.h
engines/wintermute/base/base.cpp
engines/wintermute/base/base.h
engines/wintermute/base/base_active_rect.cpp
engines/wintermute/base/base_fader.cpp
engines/wintermute/base/base_file_manager.cpp
engines/wintermute/base/base_frame.cpp
engines/wintermute/base/base_frame.h
engines/wintermute/base/base_game.cpp
engines/wintermute/base/base_game.h
engines/wintermute/base/base_game_music.cpp
engines/wintermute/base/base_game_settings.cpp
engines/wintermute/base/base_keyboard_state.cpp
engines/wintermute/base/base_object.cpp
engines/wintermute/base/base_object.h
engines/wintermute/base/base_parser.cpp
engines/wintermute/base/base_persistence_manager.cpp
engines/wintermute/base/base_persistence_manager.h
engines/wintermute/base/base_point.cpp
engines/wintermute/base/base_region.cpp
engines/wintermute/base/base_region.h
engines/wintermute/base/base_script_holder.cpp
engines/wintermute/base/base_script_holder.h
engines/wintermute/base/base_scriptable.cpp
engines/wintermute/base/base_sprite.cpp
engines/wintermute/base/base_sprite.h
engines/wintermute/base/base_sub_frame.cpp
engines/wintermute/base/base_sub_frame.h
engines/wintermute/base/base_viewport.cpp
engines/wintermute/base/file/base_disk_file.cpp
engines/wintermute/base/font/base_font.cpp
engines/wintermute/base/font/base_font_bitmap.cpp
engines/wintermute/base/font/base_font_bitmap.h
engines/wintermute/base/font/base_font_truetype.cpp
engines/wintermute/base/font/base_font_truetype.h
engines/wintermute/base/gfx/base_renderer.cpp
engines/wintermute/base/gfx/base_surface.h
engines/wintermute/base/gfx/osystem/base_render_osystem.cpp
engines/wintermute/base/gfx/osystem/base_render_osystem.h
engines/wintermute/base/gfx/osystem/base_surface_osystem.cpp
engines/wintermute/base/gfx/osystem/base_surface_osystem.h
engines/wintermute/base/gfx/osystem/render_ticket.cpp
engines/wintermute/base/gfx/osystem/render_ticket.h
engines/wintermute/base/particles/part_emitter.cpp
engines/wintermute/base/particles/part_force.cpp
engines/wintermute/base/particles/part_particle.cpp
engines/wintermute/base/saveload.cpp
engines/wintermute/base/scriptables/script.cpp
engines/wintermute/base/scriptables/script_ext_array.cpp
engines/wintermute/base/scriptables/script_ext_date.cpp
engines/wintermute/base/scriptables/script_ext_file.cpp
engines/wintermute/base/scriptables/script_ext_mem_buffer.cpp
engines/wintermute/base/scriptables/script_ext_string.cpp
engines/wintermute/base/scriptables/script_stack.cpp
engines/wintermute/base/scriptables/script_value.cpp
engines/wintermute/base/sound/base_sound.cpp
engines/wintermute/base/sound/base_sound_buffer.cpp
engines/wintermute/base/sound/base_sound_buffer.h
engines/wintermute/base/timer.cpp
engines/wintermute/coll_templ.h
engines/wintermute/dctypes.h
engines/wintermute/detection.cpp
engines/wintermute/detection_tables.h
engines/wintermute/graphics/transform_struct.cpp
engines/wintermute/graphics/transform_struct.h
engines/wintermute/graphics/transform_tools.cpp
engines/wintermute/graphics/transform_tools.h
engines/wintermute/graphics/transparent_surface.cpp
engines/wintermute/graphics/transparent_surface.h
engines/wintermute/math/rect32.h
engines/wintermute/platform_osystem.cpp
engines/wintermute/platform_osystem.h
engines/wintermute/ui/ui_button.cpp
engines/wintermute/ui/ui_button.h
engines/wintermute/ui/ui_edit.cpp
engines/wintermute/ui/ui_edit.h
engines/wintermute/ui/ui_entity.cpp
engines/wintermute/ui/ui_entity.h
engines/wintermute/ui/ui_object.cpp
engines/wintermute/ui/ui_object.h
engines/wintermute/ui/ui_text.cpp
engines/wintermute/ui/ui_text.h
engines/wintermute/ui/ui_tiled_image.cpp
engines/wintermute/ui/ui_tiled_image.h
engines/wintermute/ui/ui_window.cpp
engines/wintermute/ui/ui_window.h
engines/wintermute/utils/string_util.cpp
engines/wintermute/utils/string_util.h
engines/wintermute/video/video_theora_player.cpp
engines/wintermute/video/video_theora_player.h
graphics/VectorRendererSpec.cpp
graphics/cursorman.cpp
graphics/decoders/iff.cpp
graphics/decoders/iff.h
graphics/decoders/image_decoder.h
graphics/decoders/png.cpp
graphics/decoders/tga.cpp
graphics/decoders/tga.h
graphics/font.cpp
graphics/font.h
graphics/fonts/bdf.cpp
graphics/fonts/bdf.h
graphics/fonts/ttf.cpp
graphics/fonts/ttf.h
graphics/fonts/winfont.cpp
graphics/fonts/winfont.h
graphics/sjis.cpp
graphics/surface.cpp
graphics/surface.h
gui/ThemeEngine.cpp
gui/about.cpp
gui/console.cpp
gui/console.h
gui/credits.h
gui/debugger.cpp
gui/gui-manager.cpp
gui/predictivedialog.cpp
gui/recorderdialog.h
gui/themes/default.inc
gui/themes/scummclassic.zip
gui/themes/scummclassic/classic_layout_lowres.stx
gui/widgets/editable.cpp
gui/widgets/editable.h
gui/widgets/edittext.cpp
gui/widgets/list.cpp
po/be_BY.po
po/ca_ES.po
po/cs_CZ.po
po/da_DA.po
po/de_DE.po
po/es_ES.po
po/eu.po
po/fi_FI.po
po/fr_FR.po
po/gl_ES.po
po/hu_HU.po
po/it_IT.po
po/nb_NO.po
po/nn_NO.po
po/pl_PL.po
po/pt_BR.po
po/ru_RU.po
po/se_SE.po
po/uk_UA.po
ports.mk
video/avi_decoder.cpp
video/avi_decoder.h
video/bink_decoder.cpp
video/bink_decoder.h
video/codecs/mjpeg.cpp
video/codecs/mjpeg.h
video/codecs/mpeg.h
video/codecs/truemotion1.h
video/module.mk
video/qt_decoder.cpp
video/smk_decoder.cpp
video/smk_decoder.h
video/video_decoder.cpp
video/video_decoder.h
Commit: 46593461d2b860b63d63b769100e65761e7ad8d7
https://github.com/scummvm/scummvm/commit/46593461d2b860b63d63b769100e65761e7ad8d7
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-02T03:11:14-08:00
Commit Message:
BBVS: Fix detection
- Use AD_ENTRY1 macro
- Use the correct game name in bbvsGames
Changed paths:
engines/bbvs/detection.cpp
diff --git a/engines/bbvs/detection.cpp b/engines/bbvs/detection.cpp
index 698380d..98565c8 100644
--- a/engines/bbvs/detection.cpp
+++ b/engines/bbvs/detection.cpp
@@ -30,7 +30,7 @@
#include "graphics/thumbnail.h"
static const PlainGameDescriptor bbvsGames[] = {
- { "bbvs", "Bbvs" },
+ { "bbvs", "Beavis and Butthead in Virtual Stupidity" },
{ 0, 0 }
};
@@ -38,12 +38,13 @@ namespace Bbvs {
static const ADGameDescription gameDescriptions[] = {
{
- "bbvs", "",
- {
- {"game0001.vnm", 0, "637e5411751c7065bc385dd73d224561", 64004},
- AD_LISTEND
- },
- Common::EN_ANY, Common::kPlatformWindows, ADGF_NO_FLAGS, GUIO0()
+ "bbvs",
+ 0,
+ AD_ENTRY1s("game0001.vnm", "637e5411751c7065bc385dd73d224561", 64004),
+ Common::EN_ANY,
+ Common::kPlatformWindows,
+ ADGF_NO_FLAGS,
+ GUIO0()
},
AD_TABLE_END_MARKER
Commit: d0690dfbb12247ef0a04048b5b41c2a0510f8338
https://github.com/scummvm/scummvm/commit/d0690dfbb12247ef0a04048b5b41c2a0510f8338
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-02T03:14:05-08:00
Commit Message:
BBVS: Remove debug output code from GameModule methods
Changed paths:
engines/bbvs/gamemodule.cpp
diff --git a/engines/bbvs/gamemodule.cpp b/engines/bbvs/gamemodule.cpp
index 97522ab..d634308 100644
--- a/engines/bbvs/gamemodule.cpp
+++ b/engines/bbvs/gamemodule.cpp
@@ -25,8 +25,6 @@
namespace Bbvs {
-//#define DEBUG_DUMP
-
GameModule::GameModule()
: _bgSpriteCount(0), _bgSpriteIndices(0), _bgSpritePriorities(0), _walkRectsCount(0),
_walkRects(0), _sceneExitsCount(0), _sceneExits(0), _bgObjectsCount(0), _bgObjects(0),
@@ -273,12 +271,6 @@ void GameModule::loadBgSprites(Common::SeekableReadStream &s) {
for (int i = 0; i < _bgSpriteCount; ++i)
_bgSpritePriorities[i] = s.readUint16LE();
-#ifdef DEBUG_DUMP
- for (int i = 0; i < _bgSpriteCount; ++i) {
- debug(0, "BgSprite(%d) %04X %d", i, _bgSpriteIndices[i], _bgSpritePriorities[i]);
- }
-#endif
-
}
void GameModule::loadCameraInits(Common::SeekableReadStream &s) {
@@ -293,21 +285,6 @@ void GameModule::loadCameraInits(Common::SeekableReadStream &s) {
for (int j = 0; j < 8; ++j)
cameraInit.rects[j] = readRect(s);
}
-
-#ifdef DEBUG_DUMP
- for (int i = 0; i < 4; ++i) {
- CameraInit &cameraInit = _cameraInits[i];
- debug(0, "CameraInit(%d) (%d, %d)", i, cameraInit.cameraPos.x, cameraInit.cameraPos.y);
- debugN(0, "CameraInit(%d) ", i);
- for (int j = 0; j < 8; ++j)
- debugN(0, "%d ", cameraInit.cameraLinks[j]);
- debug(0, ".");
- for (int j = 0; j < 8; ++j)
- debug(0, "CameraInit(%d) (%d, %d, %d, %d)", i, cameraInit.rects[j].left,
- cameraInit.rects[j].top, cameraInit.rects[j].right, cameraInit.rects[j].bottom);
- }
-#endif
-
}
void GameModule::loadWalkRects(Common::SeekableReadStream &s) {
@@ -320,10 +297,6 @@ void GameModule::loadWalkRects(Common::SeekableReadStream &s) {
s.seek(offs);
for (int i = 0; i < _walkRectsCount; ++i)
_walkRects[i] = readRect(s);
-
-#ifdef DEBUG_DUMP
-#endif
-
}
void GameModule::loadSceneExits(Common::SeekableReadStream &s) {
@@ -338,14 +311,6 @@ void GameModule::loadSceneExits(Common::SeekableReadStream &s) {
_sceneExits[i].rect = readRect(s);
_sceneExits[i].newModuleNum = s.readUint32LE();
}
-
-#ifdef DEBUG_DUMP
- for (int i = 0; i < _sceneExitsCount; ++i) {
- debug(0, "SceneExit(%d) (%d, %d, %d, %d) %d", i, _sceneExits[i].rect.left, _sceneExits[i].rect.top,
- _sceneExits[i].rect.right, _sceneExits[i].rect.bottom, _sceneExits[i].newModuleNum);
- }
-#endif
-
}
void GameModule::loadBgObjects(Common::SeekableReadStream &s) {
@@ -360,14 +325,6 @@ void GameModule::loadBgObjects(Common::SeekableReadStream &s) {
s.read(_bgObjects[i].name, 20);
_bgObjects[i].rect = readRect(s);
}
-
-#ifdef DEBUG_DUMP
- for (int i = 0; i < _bgObjectsCount; ++i) {
- debug(0, "BgObject(%d) [%s] (%d, %d, %d, %d)", i, _bgObjects[i].name, _bgObjects[i].rect.left,
- _bgObjects[i].rect.top, _bgObjects[i].rect.right, _bgObjects[i].rect.bottom);
- }
-#endif
-
}
void GameModule::loadAnimations(Common::SeekableReadStream &s) {
@@ -402,21 +359,6 @@ void GameModule::loadAnimations(Common::SeekableReadStream &s) {
for (int j = 0; j < anim.frameCount; ++j)
anim.frameRects2[j] = readRect(s);
}
-
-#ifdef DEBUG_DUMP
- for (int i = 0; i < _animationsCount; ++i) {
- Animation &anim = _animations[i];
- debug(0, "Animation(%d) frameCount: %d", i, anim.frameCount);
- for (int j = 0; j < anim.frameCount; ++j) {
- debug(0, "Frame %d: %04X %d (%d, %d, %d, %d) (%d, %d, %d, %d) ",
- j, anim.frameSpriteIndices[j], anim.frameTicks[j],
- anim.frameRects1[j].left, anim.frameRects1[j].top, anim.frameRects1[j].right,
- anim.frameRects1[j].bottom, anim.frameRects2[j].left, anim.frameRects2[j].top,
- anim.frameRects2[j].right, anim.frameRects2[j].bottom);
- }
- }
-#endif
-
}
void GameModule::loadSceneObjectDefs(Common::SeekableReadStream &s) {
@@ -433,16 +375,6 @@ void GameModule::loadSceneObjectDefs(Common::SeekableReadStream &s) {
for (int j = 0; j < 16; ++j)
_sceneObjectDefs[i].animIndices[j] = s.readUint32LE();
}
-
-#ifdef DEBUG_DUMP
- for (int i = 0; i < _sceneObjectDefsCount; ++i) {
- debugN(0, "SceneObjectDef(%d) [%s] %d ", i, _sceneObjectDefs[i].name, _sceneObjectDefs[i].walkSpeed);
- for (int j = 0; j < 16; ++j)
- debugN(0, " %d", _sceneObjectDefs[i].animIndices[j]);
- debug(0, ".");
- }
-#endif
-
}
void GameModule::loadSceneObjectInits(Common::SeekableReadStream &s) {
@@ -460,17 +392,6 @@ void GameModule::loadSceneObjectInits(Common::SeekableReadStream &s) {
_sceneObjectInits[i].x = s.readUint16LE();
_sceneObjectInits[i].y = s.readUint16LE();
}
-
-#ifdef DEBUG_DUMP
- for (int i = 0; i < _sceneObjectInitsCount; ++i) {
- debug(0, "SceneObjectInit(%d) %d %d (%d, %d)", i, _sceneObjectInits[i].sceneObjectIndex,
- _sceneObjectInits[i].animIndex, _sceneObjectInits[i].x, _sceneObjectInits[i].y);
- for (int j = 0; j < 8; ++j)
- debug(0, " condition(%d) %d %d %d", j, _sceneObjectInits[i].conditions.conditions[j].cond,
- _sceneObjectInits[i].conditions.conditions[j].value1, _sceneObjectInits[i].conditions.conditions[j].value2);
- }
-#endif
-
}
void GameModule::loadActions(Common::SeekableReadStream &s) {
@@ -502,25 +423,6 @@ void GameModule::loadActions(Common::SeekableReadStream &s) {
_actions[i].actionCommands.push_back(actionCommand);
}
}
-
-#ifdef DEBUG_DUMP
- for (int i = 0; i < _actionsCount; ++i) {
- debug(0, "Action(%d)", i);
- for (int j = 0; j < 8; ++j)
- debug(0, " condition(%d) %d %d %d", j, _actions[i].conditions.conditions[j].cond,
- _actions[i].conditions.conditions[j].value1, _actions[i].conditions.conditions[j].value2);
- for (int j = 0; j < 8; ++j)
- debug(0, " result(%d) %d %d %d", j, _actions[i].results.actionResults[j].kind,
- _actions[i].results.actionResults[j].value1, _actions[i].results.actionResults[j].value2);
- for (uint j = 0; j < _actions[i].actionCommands.size(); ++j) {
- ActionCommand &actionCommand = _actions[i].actionCommands[j];
- debug(0, " entry(%d) cmd: %d sceneObjectIndex: %d timeStamp: %d walkDest: (%d, %d) param: %d", j, actionCommand.cmd, actionCommand.sceneObjectIndex,
- actionCommand.timeStamp, actionCommand.walkDest.x, actionCommand.walkDest.y,
- actionCommand.param);
- }
- }
-#endif
-
}
void GameModule::loadGuiSpriteIndices(Common::SeekableReadStream &s) {
@@ -531,10 +433,6 @@ void GameModule::loadGuiSpriteIndices(Common::SeekableReadStream &s) {
s.seek(offs);
for (int i = 0; i < kGuiSpriteCount; ++i)
_guiSpriteIndices[i] = s.readUint32LE();
-
-#ifdef DEBUG_DUMP
-#endif
-
}
void GameModule::loadInventoryItemSpriteIndices(Common::SeekableReadStream &s) {
@@ -545,10 +443,6 @@ void GameModule::loadInventoryItemSpriteIndices(Common::SeekableReadStream &s) {
s.seek(offs);
for (int i = 0; i < kInventoryItemSpriteCount; ++i)
_inventoryItemSpriteIndices[i] = s.readUint32LE();
-
-#ifdef DEBUG_DUMP
-#endif
-
}
void GameModule::loadInventoryItemInfos(Common::SeekableReadStream &s) {
@@ -564,10 +458,6 @@ void GameModule::loadInventoryItemInfos(Common::SeekableReadStream &s) {
_inventoryItemInfos[i].height = s.readUint16LE();
s.skip(8); // Unused
}
-
-#ifdef DEBUG_DUMP
-#endif
-
}
void GameModule::loadDialogItemSpriteIndices(Common::SeekableReadStream &s) {
@@ -579,10 +469,6 @@ void GameModule::loadDialogItemSpriteIndices(Common::SeekableReadStream &s) {
for (int i = 0; i < kDialogItemSpriteCount; ++i) {
_dialogItemSpriteIndices[i] = s.readUint32LE();
}
-
-#ifdef DEBUG_DUMP
-#endif
-
}
void GameModule::loadSceneSounds(Common::SeekableReadStream &s) {
@@ -597,14 +483,6 @@ void GameModule::loadSceneSounds(Common::SeekableReadStream &s) {
_sceneSounds[i].conditions = readConditions(s);
_sceneSounds[i].soundNum = s.readUint32LE();
}
-
-#ifdef DEBUG_DUMP
- debug("_sceneSoundsCount: %d", _sceneSoundsCount);
- for (int i = 0; i < _sceneSoundsCount; ++i) {
- debug("sound(%d) soundNum: %d", i, _sceneSounds[i].soundNum);
- }
-#endif
-
}
void GameModule::loadPreloadSounds(Common::SeekableReadStream &s) {
@@ -617,14 +495,6 @@ void GameModule::loadPreloadSounds(Common::SeekableReadStream &s) {
s.seek(offs);
for (uint i = 0; i < _preloadSoundsCount; ++i)
_preloadSounds[i] = s.readUint32LE();
-
-#ifdef DEBUG_DUMP
- debug("_preloadSoundsCount: %d", _preloadSoundsCount);
- for (uint i = 0; i < _preloadSoundsCount; ++i) {
- debug("preloadSound(%d) soundNum: %d", i, _preloadSounds[i]);
- }
-#endif
-
}
} // End of namespace Bbvs
Commit: 5c93ecb130158da0f35ca70f8e251775ad4dc80e
https://github.com/scummvm/scummvm/commit/5c93ecb130158da0f35ca70f8e251775ad4dc80e
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-02T03:14:38-08:00
Commit Message:
BBVS: Set the best video mode when playing a video instead of a hardcoded one
Changed paths:
engines/bbvs/videoplayer.cpp
diff --git a/engines/bbvs/videoplayer.cpp b/engines/bbvs/videoplayer.cpp
index 0b6f011..85cc5ed 100644
--- a/engines/bbvs/videoplayer.cpp
+++ b/engines/bbvs/videoplayer.cpp
@@ -37,13 +37,11 @@ void BbvsEngine::playVideo(int videoNum) {
videoFilename = Common::String::format("vid/video%03d.avi", videoNum - 1);
// Set the correct video mode
- Common::List<Graphics::PixelFormat> formats;
- // RGB565 16bit
- Graphics::PixelFormat pixelFormat(2, 5, 6, 5, 0, 11, 5, 0, 0);
- formats.push_back(pixelFormat);
- initGraphics(320, 240, false, formats);
- if (_system->getScreenFormat().bytesPerPixel != pixelFormat.bytesPerPixel)
- error("Could not switch screen format for the video");
+ initGraphics(320, 240, false, 0);
+ if (_system->getScreenFormat().bytesPerPixel == 1) {
+ warning("Couldn't switch to a RGB color video mode to play a video.");
+ return;
+ }
Video::VideoDecoder *videoDecoder = new Video::AVIDecoder();
videoDecoder->loadFile(videoFilename);
Commit: 3471c0c24db691bc0f0ea4609629bac945e34bff
https://github.com/scummvm/scummvm/commit/3471c0c24db691bc0f0ea4609629bac945e34bff
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-07T00:37:14-08:00
Commit Message:
BBVS: Fix compilation in MSVC10 as suggested by dreammaster
Changed paths:
engines/bbvs/bbvs.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 5f433e0..27dc974 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -1751,7 +1751,7 @@ void BbvsEngine::updateWalkObject(SceneObject *sceneObject) {
void BbvsEngine::walkObject(SceneObject *sceneObject, const Common::Point &destPt, int walkSpeed) {
int deltaX = destPt.x - (sceneObject->x >> 16);
int deltaY = destPt.y - (sceneObject->y >> 16);
- float distance = sqrt(deltaX * deltaX + deltaY * deltaY);
+ float distance = sqrt((double)(deltaX * deltaX + deltaY * deltaY));
// NOTE The original doesn't have this check but without it the whole pathfinding breaks
if (distance > 0.0) {
sceneObject->walkCount = distance / ((((float)ABS(deltaX) / distance) + 1.0) * ((float)walkSpeed / 120));
Commit: 62e7b4bbba3c56aa037e586a698268cc3708e3bb
https://github.com/scummvm/scummvm/commit/62e7b4bbba3c56aa037e586a698268cc3708e3bb
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-07T08:11:42-08:00
Commit Message:
BBVS: Fix GCC warning (signed/unsigned comparison)
Changed paths:
engines/bbvs/bbvs.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 27dc974..5775835 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -1492,7 +1492,7 @@ bool BbvsEngine::processCurrAction() {
if (sceneObject->walkDestPt.x != -1) {
debug(5, "waiting for walk to finish");
actionsFinished = false;
- } else if ((sceneObject->x >> 16) != soAction->walkDest.x || (sceneObject->y >> 16) != soAction->walkDest.y) {
+ } else if ((int16)(sceneObject->x >> 16) != soAction->walkDest.x || (int16)(sceneObject->y >> 16) != soAction->walkDest.y) {
debug(5, "starting to walk");
sceneObject->walkDestPt = soAction->walkDest;
actionsFinished = false;
Commit: 86b5192d1b271033afa213891dbafa9ec5d60b3c
https://github.com/scummvm/scummvm/commit/86b5192d1b271033afa213891dbafa9ec5d60b3c
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T14:39:05-08:00
Commit Message:
BBVS: Use spaces instead of tabs for formatting
Changed paths:
engines/bbvs/bbvs.cpp
engines/bbvs/bbvs.h
engines/bbvs/dialogs.h
engines/bbvs/minigames/bbtennis.h
engines/bbvs/minigames/minigame.h
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 5775835..6b261be 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -99,7 +99,7 @@ static const int kAfterVideoSceneNum[] = {
};
const int kMainMenu = 44;
-const int kCredits = 45;
+const int kCredits = 45;
bool WalkArea::contains(const Common::Point &pt) const {
return Common::Rect(x, y, x + width, y + height).contains(pt);
diff --git a/engines/bbvs/bbvs.h b/engines/bbvs/bbvs.h
index a896e9d..8bfe648 100644
--- a/engines/bbvs/bbvs.h
+++ b/engines/bbvs/bbvs.h
@@ -63,84 +63,84 @@ class SoundMan;
#define BBVS_SAVEGAME_VERSION 0
enum {
- kVerbLook = 0,
- kVerbUse = 1,
- kVerbTalk = 2,
- kVerbWalk = 3,
- kVerbInvItem = 4,
- kVerbShowInv = 5
+ kVerbLook = 0,
+ kVerbUse = 1,
+ kVerbTalk = 2,
+ kVerbWalk = 3,
+ kVerbInvItem = 4,
+ kVerbShowInv = 5
};
enum {
- kITNone = 0,
- kITEmpty = 1,
- KITSceneObject = 2,
- kITBgObject = 3,
- kITDialog = 4,
- kITScroll = 5,
- kITSceneExit = 6,
- kITInvItem = 7
+ kITNone = 0,
+ kITEmpty = 1,
+ KITSceneObject = 2,
+ kITBgObject = 3,
+ kITDialog = 4,
+ kITScroll = 5,
+ kITSceneExit = 6,
+ kITInvItem = 7
};
enum {
- kGSScene = 0,
- kGSInventory = 1,
- kGSVerbs = 2,
- kGSWait = 3,
- kGSDialog = 4,
- kGSWaitDialog = 5
+ kGSScene = 0,
+ kGSInventory = 1,
+ kGSVerbs = 2,
+ kGSWait = 3,
+ kGSDialog = 4,
+ kGSWaitDialog = 5
};
enum {
- kActionCmdStop = 0,
- kActionCmdWalkObject = 3,
- kActionCmdMoveObject = 4,
- kActionCmdAnimObject = 5,
- kActionCmdSetCameraPos = 7,
- kActionCmdPlaySpeech = 8,
- kActionCmdPlaySound = 10,
- kActionCmdStartBackgroundSound = 11,
- kActionCmdStopBackgroundSound = 12
+ kActionCmdStop = 0,
+ kActionCmdWalkObject = 3,
+ kActionCmdMoveObject = 4,
+ kActionCmdAnimObject = 5,
+ kActionCmdSetCameraPos = 7,
+ kActionCmdPlaySpeech = 8,
+ kActionCmdPlaySound = 10,
+ kActionCmdStartBackgroundSound = 11,
+ kActionCmdStopBackgroundSound = 12
};
enum {
- kCondUnused = 1,
- kCondSceneObjectVerb = 2,
- kCondBgObjectVerb = 3,
- kCondSceneObjectInventory = 4,
- kCondBgObjectInventory = 5,
- kCondHasInventoryItem = 6,
- kCondHasNotInventoryItem = 7,
- kCondIsGameVar = 8,
- kCondIsNotGameVar = 9,
- kCondIsPrevSceneNum = 10,
- kCondIsCurrTalkObject = 11,
- kCondIsDialogItem = 12,
- kCondIsCameraNum = 13,
- kCondIsNotPrevSceneNum = 14,
- kCondDialogItem0 = 15,
- kCondIsButtheadAtBgObject = 16,
- kCondIsNotSceneVisited = 17,
- kCondIsSceneVisited = 18,
- kCondIsCameraNumTransition = 19
+ kCondUnused = 1,
+ kCondSceneObjectVerb = 2,
+ kCondBgObjectVerb = 3,
+ kCondSceneObjectInventory = 4,
+ kCondBgObjectInventory = 5,
+ kCondHasInventoryItem = 6,
+ kCondHasNotInventoryItem = 7,
+ kCondIsGameVar = 8,
+ kCondIsNotGameVar = 9,
+ kCondIsPrevSceneNum = 10,
+ kCondIsCurrTalkObject = 11,
+ kCondIsDialogItem = 12,
+ kCondIsCameraNum = 13,
+ kCondIsNotPrevSceneNum = 14,
+ kCondDialogItem0 = 15,
+ kCondIsButtheadAtBgObject = 16,
+ kCondIsNotSceneVisited = 17,
+ kCondIsSceneVisited = 18,
+ kCondIsCameraNumTransition = 19
};
enum {
- kActResAddInventoryItem = 1,
- kActResRemoveInventoryItem = 2,
- kActResSetGameVar = 3,
- kActResUnsetGameVar = 4,
- kActResStartDialog = 5,
- kActResChangeScene = 6
+ kActResAddInventoryItem = 1,
+ kActResRemoveInventoryItem = 2,
+ kActResSetGameVar = 3,
+ kActResUnsetGameVar = 4,
+ kActResStartDialog = 5,
+ kActResChangeScene = 6
};
enum {
- kLeftButtonClicked = 1,
- kRightButtonClicked = 2,
- kLeftButtonDown = 4,
- kRightButtonDown = 8,
- kAnyButtonClicked = kLeftButtonClicked | kRightButtonClicked,
- kAnyButtonDown = kLeftButtonDown | kRightButtonDown
+ kLeftButtonClicked = 1,
+ kRightButtonClicked = 2,
+ kLeftButtonDown = 4,
+ kRightButtonDown = 8,
+ kAnyButtonClicked = kLeftButtonClicked | kRightButtonClicked,
+ kAnyButtonDown = kLeftButtonDown | kRightButtonDown
};
struct BBPoint {
diff --git a/engines/bbvs/dialogs.h b/engines/bbvs/dialogs.h
index 9ecc33a..2dce2a1 100644
--- a/engines/bbvs/dialogs.h
+++ b/engines/bbvs/dialogs.h
@@ -50,9 +50,9 @@ enum {
};
enum {
- kMainMenuScr = 0,
- kOptionsMenuScr = 1,
- kMiniGamesMenuScr = 2
+ kMainMenuScr = 0,
+ kOptionsMenuScr = 1,
+ kMiniGamesMenuScr = 2
};
class MainMenu : public GUI::Dialog {
diff --git a/engines/bbvs/minigames/bbtennis.h b/engines/bbvs/minigames/bbtennis.h
index 644eec7..fb6355f 100644
--- a/engines/bbvs/minigames/bbtennis.h
+++ b/engines/bbvs/minigames/bbtennis.h
@@ -57,10 +57,10 @@ public:
};
enum {
- kGSTitleScreen = 0, // Title screen
- kGSMainGame = 1, // Game when called as part of the main game
- kGSStandaloneGame = 2, // Game when called as standalone game
- kGSScoreCountUp = 3 // Score countup and next level text
+ kGSTitleScreen = 0, // Title screen
+ kGSMainGame = 1, // Game when called as part of the main game
+ kGSStandaloneGame = 2, // Game when called as standalone game
+ kGSScoreCountUp = 3 // Score countup and next level text
};
Obj _objects[kMaxObjectsCount];
diff --git a/engines/bbvs/minigames/minigame.h b/engines/bbvs/minigames/minigame.h
index 1e1a469..1bba25f 100644
--- a/engines/bbvs/minigames/minigame.h
+++ b/engines/bbvs/minigames/minigame.h
@@ -31,10 +31,10 @@
namespace Bbvs {
enum {
- kMinigameBbLoogie = 0,
- kMinigameBbTennis = 1,
- kMinigameBbAnt = 2,
- kMinigameBbAirGuitar = 3,
+ kMinigameBbLoogie = 0,
+ kMinigameBbTennis = 1,
+ kMinigameBbAnt = 2,
+ kMinigameBbAirGuitar = 3,
kMinigameCount
};
Commit: 9263bb9eb32d877491be7f2177b49d06608954a6
https://github.com/scummvm/scummvm/commit/9263bb9eb32d877491be7f2177b49d06608954a6
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T14:43:22-08:00
Commit Message:
BBVS: Fix formatting (use tab instead of spaces)
Changed paths:
engines/bbvs/minigames/bbairguitar.cpp
diff --git a/engines/bbvs/minigames/bbairguitar.cpp b/engines/bbvs/minigames/bbairguitar.cpp
index 0453ec5..26434d3 100644
--- a/engines/bbvs/minigames/bbairguitar.cpp
+++ b/engines/bbvs/minigames/bbairguitar.cpp
@@ -736,7 +736,7 @@ int MinigameBbAirGuitar::run(bool fromMainGame) {
memset(_objects, 0, sizeof(_objects));
- _modified = false;
+ _modified = false;
_currPatchNum = -1;
_btn3KindToggle = 0;
_currButtonNum = 27;
Commit: 3847654bcd28285a4b598d246d91e5bbf26e5820
https://github.com/scummvm/scummvm/commit/3847654bcd28285a4b598d246d91e5bbf26e5820
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T14:48:08-08:00
Commit Message:
BBVS: Fix include guard and include guard name comments for endifs
Changed paths:
engines/bbvs/bbvs.h
engines/bbvs/gamemodule.h
engines/bbvs/graphics.h
engines/bbvs/minigames/bbairguitar.h
engines/bbvs/minigames/bbant.h
engines/bbvs/minigames/bbloogie.h
engines/bbvs/minigames/bbtennis.h
engines/bbvs/minigames/minigame.h
engines/bbvs/sound.h
engines/bbvs/spritemodule.h
diff --git a/engines/bbvs/bbvs.h b/engines/bbvs/bbvs.h
index 8bfe648..4a13403 100644
--- a/engines/bbvs/bbvs.h
+++ b/engines/bbvs/bbvs.h
@@ -20,8 +20,8 @@
*
*/
-#ifndef BBVS_H
-#define BBVS_H
+#ifndef BBVS_BBVS_H
+#define BBVS_BBVS_H
#include "audio/mixer.h"
#include "audio/decoders/aiff.h"
@@ -413,4 +413,4 @@ public:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_BBVS_H
diff --git a/engines/bbvs/gamemodule.h b/engines/bbvs/gamemodule.h
index ffd2488..4d4f5b9 100644
--- a/engines/bbvs/gamemodule.h
+++ b/engines/bbvs/gamemodule.h
@@ -248,4 +248,4 @@ protected:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_GAMEMODULE_H
diff --git a/engines/bbvs/graphics.h b/engines/bbvs/graphics.h
index 277cf45..acb8eb9 100644
--- a/engines/bbvs/graphics.h
+++ b/engines/bbvs/graphics.h
@@ -58,4 +58,4 @@ public:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_GRAPHICS_H
diff --git a/engines/bbvs/minigames/bbairguitar.h b/engines/bbvs/minigames/bbairguitar.h
index 5c1eb00..eba3016 100644
--- a/engines/bbvs/minigames/bbairguitar.h
+++ b/engines/bbvs/minigames/bbairguitar.h
@@ -145,4 +145,4 @@ public:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_MINIGAMES_BBAIRGUITAR_H
diff --git a/engines/bbvs/minigames/bbant.h b/engines/bbvs/minigames/bbant.h
index a133d66..8600a45 100644
--- a/engines/bbvs/minigames/bbant.h
+++ b/engines/bbvs/minigames/bbant.h
@@ -170,4 +170,4 @@ public:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_MINIGAMES_BBANT_H
diff --git a/engines/bbvs/minigames/bbloogie.h b/engines/bbvs/minigames/bbloogie.h
index fb745c1..6c4ece3 100644
--- a/engines/bbvs/minigames/bbloogie.h
+++ b/engines/bbvs/minigames/bbloogie.h
@@ -138,4 +138,4 @@ public:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_MINIGAMES_BBLOOGIE_H
diff --git a/engines/bbvs/minigames/bbtennis.h b/engines/bbvs/minigames/bbtennis.h
index fb6355f..72ee719 100644
--- a/engines/bbvs/minigames/bbtennis.h
+++ b/engines/bbvs/minigames/bbtennis.h
@@ -131,4 +131,4 @@ public:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_MINIGAMES_BBTENNIS_H
diff --git a/engines/bbvs/minigames/minigame.h b/engines/bbvs/minigames/minigame.h
index 1bba25f..cc5a96e 100644
--- a/engines/bbvs/minigames/minigame.h
+++ b/engines/bbvs/minigames/minigame.h
@@ -79,4 +79,4 @@ protected:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_MINIGAMES_MINIGAME_H
diff --git a/engines/bbvs/sound.h b/engines/bbvs/sound.h
index 24f14fc..4e44c2b 100644
--- a/engines/bbvs/sound.h
+++ b/engines/bbvs/sound.h
@@ -60,4 +60,4 @@ protected:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_SOUND_H
diff --git a/engines/bbvs/spritemodule.h b/engines/bbvs/spritemodule.h
index 13469f7..c287815 100644
--- a/engines/bbvs/spritemodule.h
+++ b/engines/bbvs/spritemodule.h
@@ -65,4 +65,4 @@ protected:
} // End of namespace Bbvs
-#endif // BBVS_H
+#endif // BBVS_SPRITEMODULE_H
Commit: 82bb55aa892365b1f5e9835d20e2487f0faf3232
https://github.com/scummvm/scummvm/commit/82bb55aa892365b1f5e9835d20e2487f0faf3232
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T14:53:09-08:00
Commit Message:
BBVS: Remove obsolete debug comments
Changed paths:
engines/bbvs/bbvs.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 6b261be..d3af885 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -166,13 +166,6 @@ Common::Error BbvsEngine::run() {
_currSceneNum = 0;
_newSceneNum = 31;
- // DEBUG Jump directly to rooms
- //_newSceneNum = 23; // Class room
- //_newSceneNum = kMainMenu;
- //_newSceneNum = 25;// Tank and crash
- //_newSceneNum = 7;
- //_newSceneNum = 12;
-
if (ConfMan.hasKey("save_slot"))
_bootSaveSlot = ConfMan.getInt("save_slot");
Commit: 6078bf7eba1a10bfd737a874744a11870f485f75
https://github.com/scummvm/scummvm/commit/6078bf7eba1a10bfd737a874744a11870f485f75
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T15:12:26-08:00
Commit Message:
BBVS: Remove rectIntersection and use Rect::findIntersectingRect instead
Changed paths:
engines/bbvs/bbvs.cpp
engines/bbvs/bbvs.h
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index d3af885..77288b5 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -1780,18 +1780,10 @@ void BbvsEngine::turnObject(SceneObject *sceneObject) {
}
}
-bool BbvsEngine::rectIntersection(const Common::Rect &rect1, const Common::Rect &rect2, Common::Rect &outRect) {
- outRect.left = MAX(rect1.left, rect2.left);
- outRect.top = MAX(rect1.top, rect2.top);
- outRect.right = MIN(rect1.right, rect2.right);
- outRect.bottom = MIN(rect1.bottom, rect2.bottom);
- return !outRect.isEmpty();
-}
-
int BbvsEngine::rectSubtract(const Common::Rect &rect1, const Common::Rect &rect2, Common::Rect *outRects) {
int count = 0;
- Common::Rect workRect;
- if (rectIntersection(rect1, rect2, workRect)) {
+ Common::Rect workRect = rect1.findIntersectingRect(rect2);
+ if (!workRect.isEmpty()) {
count = 0;
outRects[count] = Common::Rect(rect2.width(), workRect.top - rect2.top);
if (!outRects[count].isEmpty()) {
diff --git a/engines/bbvs/bbvs.h b/engines/bbvs/bbvs.h
index 4a13403..5853b80 100644
--- a/engines/bbvs/bbvs.h
+++ b/engines/bbvs/bbvs.h
@@ -341,7 +341,6 @@ public:
void walkObject(SceneObject *sceneObject, const Common::Point &destPt, int walkSpeed);
void turnObject(SceneObject *sceneObject);
- bool rectIntersection(const Common::Rect &rect1, const Common::Rect &rect2, Common::Rect &outRect);
int rectSubtract(const Common::Rect &rect1, const Common::Rect &rect2, Common::Rect *outRects);
WalkInfo *addWalkInfo(int16 x, int16 y, int delta, int direction, int16 midPtX, int16 midPtY, int walkAreaIndex);
Commit: 2f22673945f69268c031ebbb7b0d1cd3f01c6e39
https://github.com/scummvm/scummvm/commit/2f22673945f69268c031ebbb7b0d1cd3f01c6e39
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T15:19:11-08:00
Commit Message:
BBVS: Remove unneccessary makeLoopingAudioStream in playSpeech and use the audiostream directly
Changed paths:
engines/bbvs/bbvs.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index 77288b5..c886ed9 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -2127,7 +2127,7 @@ void BbvsEngine::playSpeech(int soundNum) {
Common::String sndFilename = Common::String::format("snd/snd%05d.aif", soundNum);
Common::File *fd = new Common::File();
fd->open(sndFilename);
- Audio::AudioStream *audioStream = Audio::makeLoopingAudioStream(Audio::makeAIFFStream(fd, DisposeAfterUse::YES), 1);
+ Audio::AudioStream *audioStream = Audio::makeAIFFStream(fd, DisposeAfterUse::YES);
_mixer->playStream(Audio::Mixer::kSpeechSoundType, &_speechSoundHandle, audioStream);
}
Commit: f0acfd4645b19592812acd45b6765303238c1cfe
https://github.com/scummvm/scummvm/commit/f0acfd4645b19592812acd45b6765303238c1cfe
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T15:21:32-08:00
Commit Message:
BBVS: Use int16 instead of int in Rect struct
Changed paths:
engines/bbvs/bbvs.h
diff --git a/engines/bbvs/bbvs.h b/engines/bbvs/bbvs.h
index 5853b80..b429c31 100644
--- a/engines/bbvs/bbvs.h
+++ b/engines/bbvs/bbvs.h
@@ -157,7 +157,7 @@ struct BBPolygon {
};
struct Rect {
- int left, top, right, bottom;
+ int16 left, top, right, bottom;
};
struct SceneObject {
Commit: 882cf2f5ba1f51263d3458f413ba1addaf235db5
https://github.com/scummvm/scummvm/commit/882cf2f5ba1f51263d3458f413ba1addaf235db5
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T15:27:00-08:00
Commit Message:
BBVS: Fix const char string arrays
Changed paths:
engines/bbvs/bbvs.cpp
engines/bbvs/minigames/bbairguitar.cpp
engines/bbvs/minigames/bbant.cpp
engines/bbvs/minigames/bbloogie.cpp
engines/bbvs/minigames/bbtennis.cpp
diff --git a/engines/bbvs/bbvs.cpp b/engines/bbvs/bbvs.cpp
index c886ed9..eefeea0 100644
--- a/engines/bbvs/bbvs.cpp
+++ b/engines/bbvs/bbvs.cpp
@@ -2209,7 +2209,7 @@ void BbvsEngine::runMainMenu() {
void BbvsEngine::checkEasterEgg(char key) {
- static const char *kEasterEggStrings[] = {
+ static const char * const kEasterEggStrings[] = {
"BOIDUTS",
"YNNIF",
"SKCUS",
diff --git a/engines/bbvs/minigames/bbairguitar.cpp b/engines/bbvs/minigames/bbairguitar.cpp
index 26434d3..2c97bcd 100644
--- a/engines/bbvs/minigames/bbairguitar.cpp
+++ b/engines/bbvs/minigames/bbairguitar.cpp
@@ -24,7 +24,7 @@
namespace Bbvs {
-static const char *kNoteSoundFilenames[] = {
+static const char * const kNoteSoundFilenames[] = {
"a.aif", "a#.aif", "b.aif", "c.aif", "c#.aif",
"d.aif", "d#.aif", "e.aif", "f.aif", "f#.aif",
"g.aif", "g#.aif", "a_oct.aif"
@@ -32,7 +32,7 @@ static const char *kNoteSoundFilenames[] = {
static const uint kNoteSoundFilenamesCount = ARRAYSIZE(kNoteSoundFilenames);
-static const char *kPatchDirectories[] = {
+static const char * const kPatchDirectories[] = {
"rock", "burp", "fart"
};
diff --git a/engines/bbvs/minigames/bbant.cpp b/engines/bbvs/minigames/bbant.cpp
index a51a9d8..1b9293a 100644
--- a/engines/bbvs/minigames/bbant.cpp
+++ b/engines/bbvs/minigames/bbant.cpp
@@ -42,7 +42,7 @@ static const int kScoreTbl[] = {
0, 1, 1, 3, 2, 4
};
-static const char *kSoundFilenames[] = {
+static const char * const kSoundFilenames[] = {
"ant1.aif", "ant2.aif", "ant3.aif", "ant4.aif", "ant5.aif",
"ant6.aif", "ant7.aif", "ant8.aif", "ant9.aif", "ant10.aif",
"ant11.aif", "antmus1.aif", "fryant.aif", "stomp.aif", "bing.aif",
diff --git a/engines/bbvs/minigames/bbloogie.cpp b/engines/bbvs/minigames/bbloogie.cpp
index 70e7e7d..df7fec3 100644
--- a/engines/bbvs/minigames/bbloogie.cpp
+++ b/engines/bbvs/minigames/bbloogie.cpp
@@ -75,7 +75,7 @@ static const uint kPrincipalSounds[] = {
3, 4, 5, 7
};
-static const char *kSoundFilenames[] = {
+static const char * const kSoundFilenames[] = {
"loog1.aif", "loog2.aif", "loog3.aif", "loog4.aif", "loog5.aif",
"loog6.aif", "loog7.aif", "loog8.aif", "loog9.aif", "loog10.aif",
"loog11.aif", "loog12.aif", "loog13.aif", "loog14.aif", "loog15.aif",
diff --git a/engines/bbvs/minigames/bbtennis.cpp b/engines/bbvs/minigames/bbtennis.cpp
index 82c9037..aa9e2c2 100644
--- a/engines/bbvs/minigames/bbtennis.cpp
+++ b/engines/bbvs/minigames/bbtennis.cpp
@@ -35,7 +35,7 @@ static const int kLeftPlayerOffY[] = {
-18, -18, -14, -11, -11, -11, -11
};
-static const char *kSoundFilenames[] = {
+static const char * const kSoundFilenames[] = {
"tenis9.aif", "tenis10.aif", "tenis11.aif", "tenis12.aif", "tenis13.aif",
"tenis14.aif", "tenis15.aif", "tenis16.aif", "tenis17.aif", "tenis18.aif",
"tenis19.aif", "tenis20.aif", "tenis21.aif", "1ahh.aif", "1dammit.aif",
Commit: 3aba8da16b2385fb257034d6d45013b3e1b44af8
https://github.com/scummvm/scummvm/commit/3aba8da16b2385fb257034d6d45013b3e1b44af8
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T15:28:43-08:00
Commit Message:
BBVS: Remove Point type and use BBPoint instead in BBAnt minigame
Changed paths:
engines/bbvs/minigames/bbant.cpp
diff --git a/engines/bbvs/minigames/bbant.cpp b/engines/bbvs/minigames/bbant.cpp
index 1b9293a..03d507e 100644
--- a/engines/bbvs/minigames/bbant.cpp
+++ b/engines/bbvs/minigames/bbant.cpp
@@ -24,16 +24,12 @@
namespace Bbvs {
-struct Point {
- int x, y;
-};
-
-static const Point kPosIncrTbl1[] = {
+static const BBPoint kPosIncrTbl1[] = {
{0, -1}, {-1, -1}, {-1, 0}, {-1, 1},
{ 0, 1}, { 1, 1}, { 1, 0}, { 1, -1}
};
-static const Point kPosIncrTbl2[] = {
+static const BBPoint kPosIncrTbl2[] = {
{0, -2}, {-2, -2}, {-2, 0}, {-2, 2},
{ 0, 2}, { 2, 2}, { 2, 0}, { 2, -2}
};
Commit: 608485729b52e401865c7f189af2aa2e39021597
https://github.com/scummvm/scummvm/commit/608485729b52e401865c7f189af2aa2e39021597
Author: johndoe123 (john_doe at techie.com)
Date: 2014-02-15T15:37:14-08:00
Commit Message:
BBVS: Make kAnimationsTbl and kObjKindAnimTables const in BBAnt minigame
Changed paths:
engines/bbvs/minigames/bbant.cpp
engines/bbvs/minigames/bbant.h
engines/bbvs/minigames/bbant_anims.cpp
diff --git a/engines/bbvs/minigames/bbant.cpp b/engines/bbvs/minigames/bbant.cpp
index 03d507e..abecf22 100644
--- a/engines/bbvs/minigames/bbant.cpp
+++ b/engines/bbvs/minigames/bbant.cpp
@@ -644,7 +644,7 @@ void MinigameBbAnt::removeStompObj(Obj *obj) {
void MinigameBbAnt::insertBugObj(int kind, int animIndexIncr, int always0, int x, int y, int field30, int always1) {
Obj *obj = getFreeObject();
if (obj) {
- const ObjAnimation **objKindAnimTable = getObjKindAnimTable(kind);
+ const ObjAnimation * const *objKindAnimTable = getObjKindAnimTable(kind);
obj->field30 = field30;
obj->animIndexIncr = animIndexIncr;
obj->kind = kind;
@@ -691,7 +691,7 @@ void MinigameBbAnt::updateBugObjAnim(int objIndex) {
obj->animIndexIncr = 6;
break;
}
- const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ const ObjAnimation * const *objKindAnimTable = getObjKindAnimTable(obj->kind);
obj->xIncr = kPosIncrTbl1[obj->animIndexIncr].x << 16;
obj->yIncr = kPosIncrTbl1[obj->animIndexIncr].y << 16;
obj->anim = objKindAnimTable[obj->animIndexIncr];
@@ -710,7 +710,7 @@ void MinigameBbAnt::updateObjAnim2(int objIndex) {
obj->animIndexIncr += 4;
if (obj->animIndexIncr >= 8)
obj->animIndexIncr %= 8;
- const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ const ObjAnimation * const *objKindAnimTable = getObjKindAnimTable(obj->kind);
obj->xIncr = kPosIncrTbl1[obj->animIndex + obj->animIndexIncr].x << 16;
obj->yIncr = kPosIncrTbl1[obj->animIndex + obj->animIndexIncr].y << 16;
obj->anim = objKindAnimTable[obj->animIndex + obj->animIndexIncr];
@@ -742,7 +742,7 @@ void MinigameBbAnt::updateObjAnim3(int objIndex) {
obj->animIndexIncr = 7;
if (obj->animIndexIncr > 7)
obj->animIndexIncr = 0;
- const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ const ObjAnimation * const *objKindAnimTable = getObjKindAnimTable(obj->kind);
obj->xIncr = kPosIncrTbl1[obj->animIndexIncr].x << 16;
obj->yIncr = kPosIncrTbl1[obj->animIndexIncr].y << 16;
obj->anim = objKindAnimTable[obj->animIndexIncr];
@@ -786,7 +786,7 @@ void MinigameBbAnt::updateBugObj1(int objIndex) {
playSound(kSoundTbl2[_vm->getRandom(3)]);
}
flag1 = false;
- const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ const ObjAnimation * const *objKindAnimTable = getObjKindAnimTable(obj->kind);
obj->hasSmoke = false;
obj->status = 4;
obj->xIncr = 0;
@@ -833,7 +833,7 @@ void MinigameBbAnt::updateBugObj1(int objIndex) {
case 4:
if (flag1) {
- const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ const ObjAnimation * const *objKindAnimTable = getObjKindAnimTable(obj->kind);
obj->status = 6;
obj->xIncr = 0;
obj->yIncr = 0;
@@ -845,7 +845,7 @@ void MinigameBbAnt::updateBugObj1(int objIndex) {
case 6:
if (flag1) {
- const ObjAnimation **objKindAnimTable = getObjKindAnimTable(obj->kind);
+ const ObjAnimation * const *objKindAnimTable = getObjKindAnimTable(obj->kind);
obj->status = 7;
obj->xIncr = kPosIncrTbl2[obj->animIndexIncr].x << 16;
obj->yIncr = kPosIncrTbl2[obj->animIndexIncr].y << 16;
@@ -976,7 +976,7 @@ void MinigameBbAnt::updateFootObj(int objIndex) {
Obj *bugObj = &_objects[i];
if (bugObj->kind >= 1 && bugObj->kind <= 5) {
bugObj->counter = _vm->getRandom(200) + 360;
- const ObjAnimation **objKindAnimTable = getObjKindAnimTable(bugObj->kind);
+ const ObjAnimation * const *objKindAnimTable = getObjKindAnimTable(bugObj->kind);
if (bugObj->status == 8) {
bugObj->hasSmoke = false;
bugObj->xIncr = 0;
diff --git a/engines/bbvs/minigames/bbant.h b/engines/bbvs/minigames/bbant.h
index 8600a45..b9ead3a 100644
--- a/engines/bbvs/minigames/bbant.h
+++ b/engines/bbvs/minigames/bbant.h
@@ -101,7 +101,7 @@ public:
const ObjAnimation *getAnimation(int animIndex);
const ObjInit *getObjInit(int index);
- const ObjAnimation **getObjKindAnimTable(int kind);
+ const ObjAnimation * const *getObjKindAnimTable(int kind);
const ObjAnimation *getObjAnim(int index);
void buildDrawList0(DrawList &drawList);
diff --git a/engines/bbvs/minigames/bbant_anims.cpp b/engines/bbvs/minigames/bbant_anims.cpp
index 9527b7a..c9223ad 100644
--- a/engines/bbvs/minigames/bbant_anims.cpp
+++ b/engines/bbvs/minigames/bbant_anims.cpp
@@ -730,9 +730,9 @@ static const MinigameBbAnt::ObjInit kObjInits[] = {
{&kAnimations[152], &kAnimations[153], &kAnimations[154], 145, 165},
{&kAnimations[155], &kAnimations[156], &kAnimations[157], 110, 175}
};
-static const ObjAnimation *kAnimationsTbl[] = {&kAnimations[0], &kAnimations[1], &kAnimations[2], &kAnimations[3], &kAnimations[4], &kAnimations[5], &kAnimations[6], &kAnimations[7], &kAnimations[16], &kAnimations[17], &kAnimations[18], &kAnimations[19], &kAnimations[20], &kAnimations[21], &kAnimations[22], &kAnimations[23], &kAnimations[24], &kAnimations[25], &kAnimations[26], &kAnimations[27], &kAnimations[28], &kAnimations[29], &kAnimations[30], &kAnimations[31], &kAnimations[32], &kAnimations[33], &kAnimations[42], &kAnimations[43], &kAnimations[44], &kAnimations[45], &kAnimations[46], &kAnimations[47], &kAnimations[48], &kAnimations[49], &kAnimations[50], &kAnimations[51], &kAnimations[52], &kAnimations[53], &kAnimations[54], &kAnimations[55], &kAnimations[56], &kAnimations[57], &kAnimations[58], &kAnimations[59], &kAnimations[68], &kAnimations[69], &kAnimations[70], &kAnimations[71], &kAnimations[72], &kAnimations[73], &kAnimations[74], &kAnimations[75], &kAnimations[7
6], &kAnimations[77], &kAnimations[78], &kAnimations[79], &kAnimations[80], &kAnimations[81], &kAnimations[82], &kAnimations[83], &kAnimations[84], &kAnimations[85], &kAnimations[94], &kAnimations[95], &kAnimations[96], &kAnimations[97], &kAnimations[98], &kAnimations[99], &kAnimations[100], &kAnimations[101], &kAnimations[102], &kAnimations[103], &kAnimations[104], &kAnimations[105], &kAnimations[106], &kAnimations[107], &kAnimations[108], &kAnimations[109], &kAnimations[110], &kAnimations[111], &kAnimations[120], &kAnimations[121], &kAnimations[122], &kAnimations[123], &kAnimations[124], &kAnimations[125], &kAnimations[126], &kAnimations[127], &kAnimations[128], &kAnimations[129]};
+static const ObjAnimation * const kAnimationsTbl[] = {&kAnimations[0], &kAnimations[1], &kAnimations[2], &kAnimations[3], &kAnimations[4], &kAnimations[5], &kAnimations[6], &kAnimations[7], &kAnimations[16], &kAnimations[17], &kAnimations[18], &kAnimations[19], &kAnimations[20], &kAnimations[21], &kAnimations[22], &kAnimations[23], &kAnimations[24], &kAnimations[25], &kAnimations[26], &kAnimations[27], &kAnimations[28], &kAnimations[29], &kAnimations[30], &kAnimations[31], &kAnimations[32], &kAnimations[33], &kAnimations[42], &kAnimations[43], &kAnimations[44], &kAnimations[45], &kAnimations[46], &kAnimations[47], &kAnimations[48], &kAnimations[49], &kAnimations[50], &kAnimations[51], &kAnimations[52], &kAnimations[53], &kAnimations[54], &kAnimations[55], &kAnimations[56], &kAnimations[57], &kAnimations[58], &kAnimations[59], &kAnimations[68], &kAnimations[69], &kAnimations[70], &kAnimations[71], &kAnimations[72], &kAnimations[73], &kAnimations[74], &kAnimations[75], &kAnima
tions[76], &kAnimations[77], &kAnimations[78], &kAnimations[79], &kAnimations[80], &kAnimations[81], &kAnimations[82], &kAnimations[83], &kAnimations[84], &kAnimations[85], &kAnimations[94], &kAnimations[95], &kAnimations[96], &kAnimations[97], &kAnimations[98], &kAnimations[99], &kAnimations[100], &kAnimations[101], &kAnimations[102], &kAnimations[103], &kAnimations[104], &kAnimations[105], &kAnimations[106], &kAnimations[107], &kAnimations[108], &kAnimations[109], &kAnimations[110], &kAnimations[111], &kAnimations[120], &kAnimations[121], &kAnimations[122], &kAnimations[123], &kAnimations[124], &kAnimations[125], &kAnimations[126], &kAnimations[127], &kAnimations[128], &kAnimations[129]};
-static const ObjAnimation **kObjKindAnimTables[] = {
+static const ObjAnimation * const * const kObjKindAnimTables[] = {
0, &kAnimationsTbl[0],
&kAnimationsTbl[18], &kAnimationsTbl[36],
&kAnimationsTbl[54], &kAnimationsTbl[72]
@@ -746,7 +746,7 @@ const MinigameBbAnt::ObjInit *MinigameBbAnt::getObjInit(int index) {
return &kObjInits[index];
}
-const ObjAnimation **MinigameBbAnt::getObjKindAnimTable(int kind) {
+const ObjAnimation * const *MinigameBbAnt::getObjKindAnimTable(int kind) {
return kObjKindAnimTables[kind];
}
Commit: c2e9f38d79a577e54c5baefbcf9601c00e145e98
https://github.com/scummvm/scummvm/commit/c2e9f38d79a577e54c5baefbcf9601c00e145e98
Author: Eugene Sandulenko (sev at scummvm.org)
Date: 2014-02-21T11:14:29-08:00
Commit Message:
Merge pull request #435 from johndoe123/bbvs
BBVS: New engine: Beavis and Butthead In Virtual Stupidity
Changed paths:
A engines/bbvs/bbvs.cpp
A engines/bbvs/bbvs.h
A engines/bbvs/configure.engine
A engines/bbvs/detection.cpp
A engines/bbvs/dialogs.cpp
A engines/bbvs/dialogs.h
A engines/bbvs/gamemodule.cpp
A engines/bbvs/gamemodule.h
A engines/bbvs/graphics.cpp
A engines/bbvs/graphics.h
A engines/bbvs/minigames/bbairguitar.cpp
A engines/bbvs/minigames/bbairguitar.h
A engines/bbvs/minigames/bbairguitar_anims.cpp
A engines/bbvs/minigames/bbant.cpp
A engines/bbvs/minigames/bbant.h
A engines/bbvs/minigames/bbant_anims.cpp
A engines/bbvs/minigames/bbloogie.cpp
A engines/bbvs/minigames/bbloogie.h
A engines/bbvs/minigames/bbloogie_anims.cpp
A engines/bbvs/minigames/bbtennis.cpp
A engines/bbvs/minigames/bbtennis.h
A engines/bbvs/minigames/bbtennis_anims.cpp
A engines/bbvs/minigames/minigame.cpp
A engines/bbvs/minigames/minigame.h
A engines/bbvs/module.mk
A engines/bbvs/saveload.cpp
A engines/bbvs/sound.cpp
A engines/bbvs/sound.h
A engines/bbvs/spritemodule.cpp
A engines/bbvs/spritemodule.h
A engines/bbvs/videoplayer.cpp
More information about the Scummvm-git-logs
mailing list