libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-14 21:59:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
6841227241
scummvm/engines/asylum/puzzles/hivecontrol.cpp

484 lines
20 KiB
C++
Raw Blame History

/* 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 3 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, see <http://www.gnu.org/licenses/>.
*
*/
#include "asylum/puzzles/hivecontrol.h"
#include "asylum/resources/worldstats.h"
#include "asylum/system/cursor.h"
#include "asylum/system/graphics.h"
#include "asylum/system/screen.h"
#include "asylum/views/scene.h"
#include "asylum/asylum.h"
namespace Asylum {
const Control puzzleHiveControlIntToControl[] = {
kControlWingsButton1,
kControlWingsButton2,
kControlWingsButton3,
kControlReset,
kControlWheelLeft,
kControlWheelRight,
kControlButtonRight,
kControlButtonLeft,
kControlGlyph1,
kControlGlyph2,
kControlGlyph3,
kControlGlyph4,
kControlGlyph5,
kControlGlyph6
};
PuzzleHiveControl::PuzzleHiveControl(AsylumEngine *engine) : Puzzle(engine) {
_rectIndex = 0;
_soundVolume = 0;
_counter = 0;
_data_457260 = 0;
_data_457264 = 0;
_prevLeverPosition = 3;
_resetFlag = false;
memset(&_frameIndexes, 0, sizeof(_frameIndexes));
reset();
}
PuzzleHiveControl::~PuzzleHiveControl() {
}
void PuzzleHiveControl::saveLoadWithSerializer(Common::Serializer &s) {
// TODO
s.skip(6 * 4 * 2);
debugC(kDebugLevelSavegame, "[PuzzleHiveControl::saveLoadWithSerializer] Not implemented");
s.syncAsSint32LE(_soundVolume);
}
void PuzzleHiveControl::reset() {
_leverPosition = 3;
_leverDelta = 0;
_currentControl = kControlNone;
_colorL = _colorR = 0;
_frameIndexOffset = 0;
memset(&_glyphFlags, false, sizeof(_glyphFlags));
memset(&_wingsState, false, sizeof(_wingsState));
_frameIndexes[kElementSwirlRim] = 0;
if (_leverPosition != _prevLeverPosition) {
_leverDelta = (uint32)abs((double)_leverPosition - (double)_prevLeverPosition) * 16 / 5;
_currentControl = kControlGlyph4;
}
}
//////////////////////////////////////////////////////////////////////////
// Event Handling
//////////////////////////////////////////////////////////////////////////
bool PuzzleHiveControl::init(const AsylumEvent &) {
_controlPoints[kControlWingsButton1] = Common::Point(338, 139);
_controlPoints[kControlWingsButton2] = Common::Point(376, 151);
_controlPoints[kControlWingsButton3] = Common::Point(403, 162);
_controlPoints[kControlReset] = Common::Point(219, 86);
_controlPoints[kControlWheelRight] = Common::Point(204, 263);
_controlPoints[kControlWheelLeft] = Common::Point(164, 310);
_controlPoints[kControlButtonLeft] = Common::Point(320, 375);
_controlPoints[kControlButtonRight] = Common::Point(363, 337);
_controlPoints[kControlGlyph1] = Common::Point(102, 201);
_controlPoints[kControlGlyph2] = Common::Point(101, 171);
_controlPoints[kControlGlyph3] = Common::Point(108, 140);
_controlPoints[kControlGlyph4] = Common::Point(126, 111);
_controlPoints[kControlGlyph5] = Common::Point(140, 85);
_controlPoints[kControlGlyph6] = Common::Point(161, 54);
_rectIndex = -2;
_frameIndexes[kElementLever] = (5 - _leverPosition) * (GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementLever]) - 1) / 5;
getScreen()->setPalette(getWorld()->graphicResourceIds[29]);
getScreen()->setGammaLevel(getWorld()->graphicResourceIds[29]);
getCursor()->show();
getScreen()->setupTransTables(1, getWorld()->graphicResourceIds[70]);
getScreen()->selectTransTable(0);
getSound()->playSound(getWorld()->graphicResourceIds[73], true, _soundVolume);
getSound()->playSound(getWorld()->graphicResourceIds[74], true, Config.ambientVolume);
return true;
}
bool PuzzleHiveControl::mouseLeftDown(const AsylumEvent &) {
if (_currentControl != kControlNone)
return true;
_currentControl = findControl();
switch (_currentControl) {
case kControlNone:
break;
case kControlWingsButton1:
getCursor()->hide();
getSound()->playSound(getWorld()->graphicResourceIds[81], false, Config.sfxVolume - 10);
if (_wingsState[1] != _wingsState[2]) {
if (_wingsState[0])
--_frameIndexOffset;
else
++_frameIndexOffset;
}
_frameIndexOffset += _wingsState[0] ? -1 : 1;
_wingsState[0] = !_wingsState[0];
_frameIndexes[kElementLensLeft] = _colorL * 8 + _frameIndexOffset;
_frameIndexes[kElementLensRight] = _colorR * 8 + _frameIndexOffset;
break;
case kControlWingsButton2:
getCursor()->hide();
getSound()->playSound(getWorld()->graphicResourceIds[81], false, Config.sfxVolume - 10);
if (_wingsState[0] != _wingsState[2]) {
if (_wingsState[1])
--_frameIndexOffset;
else
++_frameIndexOffset;
}
_frameIndexOffset += _wingsState[1] ? -2 : 2;
_wingsState[1] = !_wingsState[1];
_frameIndexes[kElementLensLeft] = _colorL * 8 + _frameIndexOffset;
_frameIndexes[kElementLensRight] = _colorR * 8 + _frameIndexOffset;
break;
case kControlWingsButton3:
getCursor()->hide();
getSound()->playSound(getWorld()->graphicResourceIds[81], false, Config.sfxVolume - 10);
if (_wingsState[0] != _wingsState[1]) {
if (_wingsState[2])
--_frameIndexOffset;
else
++_frameIndexOffset;
}
_frameIndexOffset += (_wingsState[2] ? -3 : 3);
_wingsState[2] = !_wingsState[2];
_frameIndexes[kElementLensLeft] = _colorL * 8 + _frameIndexOffset;
_frameIndexes[kElementLensRight] = _colorR * 8 + _frameIndexOffset;
break;
case kControlReset:
getCursor()->hide();
getSound()->playSound(getWorld()->graphicResourceIds[78], false, Config.sfxVolume - 10);
getSound()->playSound(getWorld()->graphicResourceIds[79], false, Config.sfxVolume - 10);
_resetFlag = true;
reset();
break;
case kControlWheelLeft:
getCursor()->hide();
getSound()->playSound(getWorld()->graphicResourceIds[80], false, Config.sfxVolume - 10);
_colorL = (_colorL + 1) % 3;
break;
case kControlWheelRight:
getCursor()->hide();
getSound()->playSound(getWorld()->graphicResourceIds[80], false, Config.sfxVolume - 10);
_colorR = (_colorR + 1) % 3;
break;
case kControlButtonLeft:
getCursor()->hide();
getSound()->playSound(getWorld()->graphicResourceIds[77], false, Config.sfxVolume - 10);
if (!_glyphFlags[0][_leverPosition]) {
_glyphFlags[0][_leverPosition] = puzzleHiveControlHieroglyphs[0][_leverPosition] == _frameIndexes[kElementLensLeft];
if (_glyphFlags[0][_leverPosition]) {
getSound()->playSound(getWorld()->graphicResourceIds[83], false, Config.sfxVolume - 10);
++_frameIndexes[kElementSwirlRim];
// Check for puzzle completion
if (_frameIndexes[kElementSwirlRim] == 12) {
getSound()->stop(getWorld()->graphicResourceIds[73]);
getSound()->stop(getWorld()->graphicResourceIds[74]);
getScreen()->clear();
getScreen()->setupTransTables(3, getWorld()->cellShadeMask1, getWorld()->cellShadeMask2, getWorld()->cellShadeMask3);
getScreen()->selectTransTable(1);
_vm->setGameFlag(kGameFlagSolveHiveControl);
_vm->switchEventHandler(getScene());
}
}
}
break;
case kControlButtonRight:
getCursor()->hide();
getSound()->playSound(getWorld()->graphicResourceIds[77], false, Config.sfxVolume - 10);
if (!_glyphFlags[1][_leverPosition]) {
_glyphFlags[1][_leverPosition] = puzzleHiveControlHieroglyphs[1][_leverPosition] == _frameIndexes[kElementLensRight];
if (_glyphFlags[1][_leverPosition]) {
getSound()->playSound(getWorld()->graphicResourceIds[83], false, Config.sfxVolume - 10);
++_frameIndexes[kElementSwirlRim];
// Check for puzzle completion
if (_frameIndexes[kElementSwirlRim] == 12) {
getSound()->stop(getWorld()->graphicResourceIds[73]);
getSound()->stop(getWorld()->graphicResourceIds[74]);
getScreen()->clear();
getScreen()->setupTransTables(3, getWorld()->cellShadeMask1, getWorld()->cellShadeMask2, getWorld()->cellShadeMask3);
getScreen()->selectTransTable(1);
_vm->setGameFlag(kGameFlagSolveHiveControl);
_vm->switchEventHandler(getScene());
}
}
}
break;
case kControlGlyph1:
case kControlGlyph2:
case kControlGlyph3:
case kControlGlyph4:
case kControlGlyph5:
case kControlGlyph6:
_leverPosition = _currentControl - 49;
_leverDelta = (uint32)abs((double)_leverPosition - (double)_prevLeverPosition) * (GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementLever]) - 1) / 5;
if (_leverDelta)
getSound()->playSound(getWorld()->graphicResourceIds[76], false, Config.sfxVolume - 10);
}
return true;
}
bool PuzzleHiveControl::mouseRightDown(const AsylumEvent &) {
if (_leverDelta) {
_leverDelta = 0;
_prevLeverPosition = _leverPosition;
_currentControl = kControlNone;
}
getSound()->stop(getWorld()->graphicResourceIds[73]);
getSound()->stop(getWorld()->graphicResourceIds[74]);
getScreen()->clear();
getScreen()->setupTransTables(3, getWorld()->cellShadeMask1, getWorld()->cellShadeMask2, getWorld()->cellShadeMask3);
getScreen()->selectTransTable(1);
_vm->switchEventHandler(getScene());
return true;
}
//////////////////////////////////////////////////////////////////////////
// Helpers
//////////////////////////////////////////////////////////////////////////
void PuzzleHiveControl::updateCursor() {
int32 index = findControl();
if (_rectIndex == index)
return;
_rectIndex = index;
if (index == -1)
getCursor()->set(getWorld()->graphicResourceIds[30], -1, kCursorAnimationNone);
else
getCursor()->set(getWorld()->graphicResourceIds[30], -1);
}
Control PuzzleHiveControl::findControl() {
for (uint32 i = 0; i < ARRAYSIZE(puzzleHiveControlIntToControl); ++i)
if (hitTest1(puzzleHiveControlIntToControl[i], getCursor()->position(), _controlPoints[puzzleHiveControlIntToControl[i]]))
return puzzleHiveControlIntToControl[i];
return kControlNone;
}
void PuzzleHiveControl::updateScreen() {
getScreen()->clearGraphicsInQueue();
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[28], 0, Common::Point(0, 0), kDrawFlagNone, 0, 3);
switch (_currentControl) {
case kControlNone:
break;
case kControlGlyph1:
case kControlGlyph2:
case kControlGlyph3:
case kControlGlyph4:
case kControlGlyph5:
case kControlGlyph6:
if (_leverDelta) {
if (_leverPosition > _prevLeverPosition)
--_frameIndexes[kElementLever];
else
++_frameIndexes[kElementLever];
--_leverDelta;
if (_leverDelta == 0) {
_prevLeverPosition = _leverPosition;
_currentControl = kControlNone;
}
} else
_currentControl = kControlNone;
break;
default:
_frameIndexes[_currentControl] = (_frameIndexes[_currentControl] + 1) % GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[_currentControl]);
if (_frameIndexes[_currentControl] == 0) {
getCursor()->show();
if (_currentControl == kControlWheelLeft || _currentControl == kControlWheelRight) {
getSound()->playSound(getWorld()->graphicResourceIds[75], false, Config.sfxVolume - 10);
if (_currentControl == kControlWheelLeft)
_frameIndexes[kElementLensLeft] = (_frameIndexes[kElementLensLeft] + 8) % GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementLensLeft]);
else
_frameIndexes[kElementLensRight] = (_frameIndexes[kElementLensRight] + 8) % GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementLensRight]);
}
_currentControl = kControlNone;
}
}
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementSwirl], _frameIndexes[kElementSwirl], Common::Point(486, 291), kDrawFlagNone, 0, 2);
_frameIndexes[kElementSwirl] = (_frameIndexes[kElementSwirl] + 1) % GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementSwirl]);
if (_resetFlag) {
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementResetDynamic], _frameIndexes[kElementResetDynamic], Common::Point(211, 77), kDrawFlagNone, 0, 2);
_frameIndexes[kElementResetDynamic] = (_frameIndexes[kElementResetDynamic] + 1) % GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementResetDynamic]);
if (_frameIndexes[kElementResetDynamic] == 0) {
_resetFlag = false;
getCursor()->show();
if (!(_wingsState[0] || _wingsState[1] || _wingsState[2])) {
_frameIndexes[kElementLensLeft] = 0;
_frameIndexes[kElementLensRight] = 0;
}
}
} else {
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementFlyHead], _frameIndexes[kElementFlyHead], Common::Point(258, 86), kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementResetStatic], _frameIndexes[kElementResetStatic], Common::Point(232, 77), kDrawFlagNone, 0, 2);
_frameIndexes[kElementFlyHead] = (_frameIndexes[kElementFlyHead] + 1) % GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementFlyHead]);
}
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlWingsButton1], _frameIndexes[kControlWingsButton1], _controlPoints[kControlWingsButton1], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlWingsButton2], _frameIndexes[kControlWingsButton2], _controlPoints[kControlWingsButton2], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlWingsButton3], _frameIndexes[kControlWingsButton3], _controlPoints[kControlWingsButton3], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementLever], _frameIndexes[kElementLever], Common::Point(9, 40), kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlReset], _frameIndexes[kControlReset], _controlPoints[kControlReset], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlWheelRight], _frameIndexes[kControlWheelRight], _controlPoints[kControlWheelRight], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlWheelLeft], _frameIndexes[kControlWheelLeft], _controlPoints[kControlWheelLeft], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlButtonLeft], _frameIndexes[kControlButtonLeft], _controlPoints[kControlButtonLeft], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlButtonRight], _frameIndexes[kControlButtonRight], _controlPoints[kControlButtonRight], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementWingLeft1], _frameIndexes[kElementWingLeft1], Common::Point(326, 162), kDrawFlagNone, 1, 1);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementWingRight1], _frameIndexes[kElementWingRight1], Common::Point(374, 86), kDrawFlagNone, 1, 1);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementWingLeft2], _frameIndexes[kElementWingLeft2], Common::Point(275, 186), kDrawFlagNone, 1, 1);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementWingRight2], _frameIndexes[kElementWingRight2], Common::Point(419, 59), kDrawFlagNone, 1, 1);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementWingLeft3], _frameIndexes[kElementWingLeft3], Common::Point(386, 196), kDrawFlagNone, 1, 1);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementWingRight3], _frameIndexes[kElementWingRight3], Common::Point(433, 111), kDrawFlagNone, 1, 1);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlGlyph1], _frameIndexes[kControlGlyph1], _controlPoints[kControlGlyph1], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlGlyph2], _frameIndexes[kControlGlyph2], _controlPoints[kControlGlyph2], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlGlyph3], _frameIndexes[kControlGlyph3], _controlPoints[kControlGlyph3], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlGlyph4], _frameIndexes[kControlGlyph4], _controlPoints[kControlGlyph4], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlGlyph5], _frameIndexes[kControlGlyph5], _controlPoints[kControlGlyph5], kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kControlGlyph6], _frameIndexes[kControlGlyph6], _controlPoints[kControlGlyph6], kDrawFlagNone, 0, 2);
bool reseted = false;
for (uint32 i = 0; i < 3; ++i) {
if (_wingsState[i]) {
if (_frameIndexes[kElementWingLeft1 + 2*i] != GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementWingLeft1 + 2*i]) - 1)
_frameIndexes[kElementWingLeft1 + 2*i] = (_frameIndexes[kElementWingLeft1 + 2*i] + 1) % GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementWingLeft1 + 2*i]);
if (_frameIndexes[kElementWingRight1 + 2*i] != GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementWingRight1 + 2*i]) - 1)
_frameIndexes[kElementWingRight1 + 2*i] = (_frameIndexes[kElementWingRight1 + 2*i] + 1) % GraphicResource::getFrameCount(_vm, getWorld()->graphicResourceIds[kElementWingRight1 + 2*i]);
} else {
if (_frameIndexes[kElementWingLeft1 + 2*i] > 0) {
--_frameIndexes[kElementWingLeft1 + 2*i];
if (_resetFlag && _frameIndexes[kElementWingLeft1 + 2*i] == 0 && !reseted) {
_frameIndexes[kElementLensLeft] = 0;
reseted = true;
}
}
if (_frameIndexes[kElementWingRight1 + 2*i ] > 0) {
--_frameIndexes[kElementWingRight1 + 2*i];
if (_resetFlag && _frameIndexes[kElementWingRight1 + 2*i] == 0 && !reseted) {
_frameIndexes[kElementLensRight] = 0;
reseted = true;
}
}
}
}
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementLensLeft], _frameIndexes[kElementLensLeft], Common::Point(305, 216), kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementLensRight], _frameIndexes[kElementLensRight], Common::Point(411, 65), kDrawFlagNone, 0, 2);
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementIndicator], _frameIndexes[kElementSwirlRim], Common::Point(158, 148), kDrawFlagNone, 0, 2);
for (uint32 i = 0; i < 6; ++i) {
if (_glyphFlags[0][i])
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[58 + i], 0, Common::Point(104, 58), kDrawFlagNone, 0, 1);
if (_glyphFlags[1][i])
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[64 + i], 0, Common::Point(133, 70), kDrawFlagNone, 0, 1);
}
getScreen()->addGraphicToQueue(getWorld()->graphicResourceIds[kElementSwirlRim], _frameIndexes[kElementSwirlRim], Common::Point(458, 278), kDrawFlagNone, 0, 2);
if (!_data_457260 && !_data_457264)
playSound();
if (_counter) {
if (_counter < 30 || getSound()->isPlaying(getWorld()->graphicResourceIds[83])) {
++_counter;
} else {
AsylumEvent evt;
mouseRightDown(evt);
getCursor()->show();
}
}
}
void PuzzleHiveControl::playSound() {
// TODO
}
bool PuzzleHiveControl::hitTest1(Control control, const Common::Point &point, const Common::Point &location) {
if (control == kControlNone)
error("[PuzzleHiveControl::hitTest1] Invalid control");
GraphicResource resource(_vm);
resource.load(getWorld()->graphicResourceIds[control]);
GraphicFrame *frame = resource.getFrame(0);
Common::Point point1(point.x - location.x, point.y - location.y);
if (!frame->getRect().contains(point1)) {
return false;
} else {
point1.x -= frame->x;
point1.y -= frame->y;
return *((byte *)frame->surface.getPixels() + point1.x + frame->surface.pitch * point1.y) != 0;
}
}
} // End of namespace Asylum
Reference in New Issue View Git Blame Copy Permalink