mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-16 14:50:17 +00:00
1393 lines
38 KiB
C++
1393 lines
38 KiB
C++
/* 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/minigame.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 byte kTurnTbl[] = {
|
|
2, 6, 4, 0, 2, 6, 4, 0,
|
|
3, 1, 5, 7, 0, 0, 0, 0
|
|
};
|
|
|
|
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");
|
|
_currActionCommandIndex = -1;
|
|
_buttheadObject = nullptr;
|
|
_beavisObject = nullptr;
|
|
_currCameraNum = 0;
|
|
_walkAreasCount = 0;
|
|
_walkInfosCount = 0;
|
|
_walkableRectsCount = 0;
|
|
_sourceWalkArea = nullptr;
|
|
_destWalkArea = nullptr;
|
|
_currWalkDistance = kMaxDistance;
|
|
_walkReachedDestArea = false;
|
|
_hasSnapshot = false;
|
|
_snapshot = nullptr;
|
|
_snapshotStream = nullptr;
|
|
_isSaveAllowed = false;
|
|
|
|
for (int i = 0; i < 80; i++) {
|
|
_walkAreas[i].x = 0;
|
|
_walkAreas[i].y = 0;
|
|
_walkAreas[i].width = 0;
|
|
_walkAreas[i].height = 0;
|
|
_walkAreas[i].checked = false;
|
|
_walkAreas[i].linksCount = 0;
|
|
for (int j = 0; j < 16; j++)
|
|
_walkAreas[i].links[j] = nullptr;
|
|
for (int j = 0; j < 32; j++) {
|
|
_walkAreas[i].linksD1[j] = nullptr;
|
|
_walkAreas[i].linksD2[j] = nullptr;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 256; i++) {
|
|
_walkInfoPtrs[i] = nullptr;
|
|
}
|
|
|
|
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();
|
|
memset(_easterEggInput, 0, sizeof(_easterEggInput));
|
|
|
|
_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;
|
|
|
|
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();
|
|
else if (_currSceneNum == kCredits &&
|
|
(_mouseButtons & kAnyButtonClicked)) {
|
|
_mouseButtons &= ~kAnyButtonClicked;
|
|
_newSceneNum = kMainMenu;
|
|
}
|
|
if (_playVideoNumber > 0) {
|
|
playVideo(_playVideoNumber);
|
|
_playVideoNumber = 0;
|
|
}
|
|
}
|
|
|
|
writeContinueSavegame();
|
|
|
|
freeSnapshot();
|
|
|
|
delete _sound;
|
|
delete _spriteModule;
|
|
delete _gameModule;
|
|
delete _screen;
|
|
|
|
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:
|
|
checkEasterEgg(event.kbd.ascii);
|
|
_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 inputTicks;
|
|
|
|
if (_gameTicks > 0) {
|
|
int 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();
|
|
}
|
|
|
|
_system->delayMillis(10);
|
|
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
|
|
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 ((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;
|
|
} 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::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::makeAIFFStream(fd, DisposeAfterUse::YES);
|
|
_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(0, "BbvsEngine::runMinigame() minigameNum: %d", minigameNum);
|
|
|
|
bool fromMainGame = _currSceneNum != kMainMenu;
|
|
|
|
_sound->unloadSounds();
|
|
|
|
Minigame *minigame = 0;
|
|
|
|
switch (minigameNum) {
|
|
case kMinigameBbLoogie:
|
|
minigame = new MinigameBbLoogie(this);
|
|
break;
|
|
case kMinigameBbTennis:
|
|
minigame = new MinigameBbTennis(this);
|
|
break;
|
|
case kMinigameBbAnt:
|
|
minigame = new MinigameBbAnt(this);
|
|
break;
|
|
case kMinigameBbAirGuitar:
|
|
minigame = new MinigameBbAirGuitar(this);
|
|
break;
|
|
default:
|
|
error("Incorrect minigame number %d", minigameNum);
|
|
break;
|
|
}
|
|
|
|
bool minigameResult = minigame->run(fromMainGame);
|
|
|
|
delete minigame;
|
|
|
|
// Check if the principal was hit with a megaloogie in the loogie minigame
|
|
if (minigameNum == 0 && minigameResult)
|
|
_gameVars[42] = 1;
|
|
|
|
#if 0
|
|
//DEBUG Fake it :)
|
|
if (minigameNum == 0)
|
|
_gameVars[42] = 1;
|
|
#endif
|
|
|
|
return true;
|
|
}
|
|
|
|
void BbvsEngine::runMainMenu() {
|
|
MainMenu *mainMenu = new MainMenu(this);
|
|
mainMenu->runModal();
|
|
delete mainMenu;
|
|
}
|
|
|
|
void BbvsEngine::checkEasterEgg(char key) {
|
|
|
|
static const char * const 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
|