2013-05-18 03:13:48 +00:00
|
|
|
/* ScummVM - Graphic Adventure Engine
|
|
|
|
*
|
|
|
|
* ScummVM is the legal property of its developers, whose names
|
|
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
|
|
* file distributed with this source distribution.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "voyeur/events.h"
|
2013-05-25 13:58:03 +00:00
|
|
|
#include "voyeur/voyeur.h"
|
2013-12-25 03:08:37 +00:00
|
|
|
#include "voyeur/staticres.h"
|
2013-12-06 02:49:12 +00:00
|
|
|
#include "common/events.h"
|
2013-06-21 04:18:19 +00:00
|
|
|
#include "graphics/cursorman.h"
|
2013-06-06 01:28:51 +00:00
|
|
|
#include "graphics/palette.h"
|
2013-05-18 03:13:48 +00:00
|
|
|
|
|
|
|
namespace Voyeur {
|
|
|
|
|
2013-06-08 14:31:37 +00:00
|
|
|
IntNode::IntNode() {
|
|
|
|
_intFunc = NULL;
|
|
|
|
_curTime = 0;
|
|
|
|
_timeReset = 0;
|
|
|
|
_flags = 0;
|
|
|
|
}
|
|
|
|
|
2013-06-08 19:41:22 +00:00
|
|
|
IntNode::IntNode(uint16 curTime, uint16 timeReset, uint16 flags) {
|
|
|
|
_intFunc = NULL;
|
|
|
|
_curTime = curTime;
|
|
|
|
_timeReset = timeReset;
|
|
|
|
_flags = flags;
|
|
|
|
}
|
|
|
|
|
2013-06-08 14:31:37 +00:00
|
|
|
/*------------------------------------------------------------------------*/
|
|
|
|
|
2013-12-06 02:49:12 +00:00
|
|
|
IntData::IntData() {
|
|
|
|
_field9 = false;
|
|
|
|
_flipWait = false;
|
|
|
|
_hasPalette = false;
|
|
|
|
field16 = 0;
|
|
|
|
field1A = 0;
|
|
|
|
field1E = 0;
|
|
|
|
field22 = 0;
|
|
|
|
field24 = 0;
|
|
|
|
field26 = 0;
|
|
|
|
field2A = 0;
|
2014-01-06 23:06:16 +00:00
|
|
|
field38 = false;
|
2014-01-07 06:26:53 +00:00
|
|
|
field3B = false;
|
|
|
|
field3D = false;
|
2013-12-06 02:49:12 +00:00
|
|
|
_palStartIndex = 0;
|
|
|
|
_palEndIndex = 0;
|
|
|
|
_palette = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------*/
|
2014-01-06 01:56:14 +00:00
|
|
|
|
2013-06-08 19:41:22 +00:00
|
|
|
EventsManager::EventsManager(): _intPtr(_gameData),
|
|
|
|
_fadeIntNode(0, 0, 3), _cycleIntNode(0, 0, 3) {
|
2013-05-28 03:01:15 +00:00
|
|
|
_cycleStatus = 0;
|
2013-06-02 02:14:59 +00:00
|
|
|
_mouseButton = 0;
|
2013-06-08 14:31:37 +00:00
|
|
|
_fadeStatus = 0;
|
2013-06-02 02:14:59 +00:00
|
|
|
_priorFrameTime = g_system->getMillis();
|
2013-12-10 03:22:32 +00:00
|
|
|
_joe = 0;
|
2013-06-02 02:14:59 +00:00
|
|
|
Common::fill(&_keyState[0], &_keyState[256], false);
|
2013-12-29 23:25:46 +00:00
|
|
|
Common::fill(&_cycleTime[0], &_cycleTime[4], 0);
|
2013-12-30 05:52:50 +00:00
|
|
|
Common::fill(&_cycleNext[0], &_cycleNext[4], (byte *)nullptr);
|
2013-12-29 23:25:46 +00:00
|
|
|
_cyclePtr = NULL;
|
2013-12-28 22:58:43 +00:00
|
|
|
|
|
|
|
_leftClick = _rightClick = false;
|
|
|
|
_mouseClicked = _mouseUnk = false;
|
|
|
|
_newLeftClick = _newRightClick = false;;
|
|
|
|
_newMouseClicked = _newMouseUnk = false;
|
2013-12-06 03:36:59 +00:00
|
|
|
|
|
|
|
_videoDead = 0;
|
2013-05-28 03:01:15 +00:00
|
|
|
}
|
|
|
|
|
2013-05-25 13:58:03 +00:00
|
|
|
void EventsManager::resetMouse() {
|
|
|
|
// No implementation
|
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::startMainClockInt() {
|
2013-06-08 14:31:37 +00:00
|
|
|
_mainIntNode._intFunc = &EventsManager::mainVoyeurIntFunc;
|
2013-05-25 13:58:03 +00:00
|
|
|
_mainIntNode._flags = 0;
|
|
|
|
_mainIntNode._curTime = 0;
|
|
|
|
_mainIntNode._timeReset = _vm->_graphicsManager._palFlag ? 50 : 60;
|
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::mainVoyeurIntFunc() {
|
2013-12-23 20:38:39 +00:00
|
|
|
if (!(_vm->_voy._field478 & 1)) {
|
|
|
|
++_vm->_voy._switchBGNum;
|
2014-01-04 06:11:00 +00:00
|
|
|
|
|
|
|
if (_vm->_debugger._isTimeActive) {
|
|
|
|
// Increase camera discharge
|
|
|
|
++_vm->_voy._RTVNum;
|
|
|
|
|
|
|
|
if (_vm->_voy._RTVNum >= _vm->_voy._field4F2)
|
|
|
|
_vm->_voy._field4F0 = 1;
|
|
|
|
}
|
2013-12-23 20:38:39 +00:00
|
|
|
}
|
2013-05-18 03:13:48 +00:00
|
|
|
}
|
|
|
|
|
2013-06-01 02:13:28 +00:00
|
|
|
void EventsManager::sWaitFlip() {
|
2013-06-06 01:28:51 +00:00
|
|
|
Common::Array<ViewPortResource *> &viewPorts = _vm->_graphicsManager._viewPortListPtr->_entries;
|
2013-06-01 02:13:28 +00:00
|
|
|
for (uint idx = 0; idx < viewPorts.size(); ++idx) {
|
|
|
|
ViewPortResource &viewPort = *viewPorts[idx];
|
|
|
|
|
2013-06-18 02:41:58 +00:00
|
|
|
if (_vm->_graphicsManager._saveBack && (viewPort._flags & DISPFLAG_40)) {
|
2013-06-01 02:13:28 +00:00
|
|
|
Common::Rect *clipPtr = _vm->_graphicsManager._clipPtr;
|
|
|
|
_vm->_graphicsManager._clipPtr = &viewPort._clipRect;
|
|
|
|
|
|
|
|
if (viewPort._restoreFn)
|
|
|
|
(_vm->_graphicsManager.*viewPort._restoreFn)(&viewPort);
|
|
|
|
|
|
|
|
_vm->_graphicsManager._clipPtr = clipPtr;
|
2013-06-01 16:35:50 +00:00
|
|
|
viewPort._rectListCount[viewPort._pageIndex] = 0;
|
2013-06-17 01:20:42 +00:00
|
|
|
viewPort._rectListPtr[viewPort._pageIndex]->clear();
|
2013-06-18 02:41:58 +00:00
|
|
|
viewPort._flags &= ~DISPFLAG_40;
|
2013-06-01 02:13:28 +00:00
|
|
|
}
|
|
|
|
}
|
2013-12-28 22:58:43 +00:00
|
|
|
|
|
|
|
while (_gameData._flipWait && !_vm->shouldQuit()) {
|
|
|
|
pollEvents();
|
|
|
|
g_system->delayMillis(10);
|
|
|
|
}
|
2013-06-01 02:13:28 +00:00
|
|
|
}
|
|
|
|
|
2013-06-02 02:14:59 +00:00
|
|
|
void EventsManager::checkForNextFrameCounter() {
|
|
|
|
// Check for next game frame
|
|
|
|
uint32 milli = g_system->getMillis();
|
|
|
|
if ((milli - _priorFrameTime) >= GAME_FRAME_TIME) {
|
|
|
|
++_gameCounter;
|
|
|
|
_priorFrameTime = milli;
|
|
|
|
|
2013-06-06 01:28:51 +00:00
|
|
|
// Run the timer-based updates
|
2013-06-08 19:41:22 +00:00
|
|
|
voyeurTimer();
|
2013-06-06 01:28:51 +00:00
|
|
|
|
2013-12-23 20:38:39 +00:00
|
|
|
if ((_gameCounter % GAME_FRAME_RATE) == 0)
|
|
|
|
mainVoyeurIntFunc();
|
|
|
|
|
2014-01-04 06:11:00 +00:00
|
|
|
// Give time to the debugger
|
|
|
|
_vm->_debugger.onFrame();
|
|
|
|
|
2013-06-03 02:33:47 +00:00
|
|
|
// Display the frame
|
2013-12-01 01:44:23 +00:00
|
|
|
g_system->copyRectToScreen((byte *)_vm->_graphicsManager._screenSurface.getPixels(),
|
2013-06-03 02:33:47 +00:00
|
|
|
SCREEN_WIDTH, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
|
|
|
|
g_system->updateScreen();
|
|
|
|
|
2013-06-02 02:14:59 +00:00
|
|
|
// Signal the ScummVM debugger
|
|
|
|
_vm->_debugger.onFrame();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-08 19:41:22 +00:00
|
|
|
void EventsManager::voyeurTimer() {
|
|
|
|
_gameData.field22 += _gameData.field24;
|
|
|
|
_gameData.field1A += _gameData.field1E;
|
|
|
|
// _gameData.field1C += _gameData._timerFn; *** WHY INC field by a function pointer?!
|
|
|
|
|
|
|
|
_gameData.field16 = 0;
|
2014-01-07 06:26:53 +00:00
|
|
|
_gameData.field3D = true;
|
2013-06-08 19:41:22 +00:00
|
|
|
|
|
|
|
if (--_gameData.field26 <= 0) {
|
|
|
|
if (_gameData._flipWait) {
|
2014-01-06 23:06:16 +00:00
|
|
|
_gameData.field38 = true;
|
2013-06-08 19:41:22 +00:00
|
|
|
_gameData._flipWait = false;
|
2014-01-07 06:26:53 +00:00
|
|
|
_gameData.field3B = false;
|
2013-06-08 19:41:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
_gameData.field26 >>= 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
videoTimer();
|
|
|
|
|
|
|
|
// Iterate through the list of registered nodes
|
|
|
|
Common::List<IntNode *>::iterator i;
|
|
|
|
for (i = _intNodes.begin(); i != _intNodes.end(); ++i) {
|
|
|
|
IntNode &node = **i;
|
|
|
|
|
|
|
|
if (node._flags & 1)
|
|
|
|
continue;
|
|
|
|
if (!(node._flags & 2)) {
|
|
|
|
if (--node._curTime != 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
node._curTime = node._timeReset;
|
|
|
|
}
|
|
|
|
|
|
|
|
(this->*node._intFunc)();
|
|
|
|
}
|
2013-12-23 20:38:39 +00:00
|
|
|
|
2013-06-08 19:41:22 +00:00
|
|
|
}
|
|
|
|
|
2013-06-06 01:28:51 +00:00
|
|
|
void EventsManager::videoTimer() {
|
2013-06-08 19:41:22 +00:00
|
|
|
if (_gameData._hasPalette) {
|
|
|
|
_gameData._hasPalette = false;
|
2013-06-06 01:28:51 +00:00
|
|
|
|
2013-12-18 13:53:44 +00:00
|
|
|
g_system->getPaletteManager()->setPalette(_gameData._palette +
|
|
|
|
_gameData._palStartIndex * 3, _gameData._palStartIndex,
|
2013-06-08 19:41:22 +00:00
|
|
|
_gameData._palEndIndex - _gameData._palStartIndex + 1);
|
2013-06-06 01:28:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::delay(int cycles) {
|
|
|
|
uint32 totalMilli = cycles * 1000 / GAME_FRAME_RATE;
|
2013-06-02 02:14:59 +00:00
|
|
|
uint32 delayEnd = g_system->getMillis() + totalMilli;
|
|
|
|
|
|
|
|
while (!_vm->shouldQuit() && g_system->getMillis() < delayEnd) {
|
|
|
|
g_system->delayMillis(10);
|
2013-06-03 02:33:47 +00:00
|
|
|
|
|
|
|
pollEvents();
|
2013-06-02 02:14:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-28 07:37:37 +00:00
|
|
|
void EventsManager::delayClick(int cycles) {
|
|
|
|
uint32 totalMilli = cycles * 1000 / GAME_FRAME_RATE;
|
|
|
|
uint32 delayEnd = g_system->getMillis() + totalMilli;
|
|
|
|
|
2013-12-28 09:32:17 +00:00
|
|
|
do {
|
2013-12-28 07:37:37 +00:00
|
|
|
g_system->delayMillis(10);
|
2013-12-28 09:32:17 +00:00
|
|
|
getMouseInfo();
|
|
|
|
} while (!_vm->shouldQuit() && g_system->getMillis() < delayEnd
|
2013-12-28 22:58:43 +00:00
|
|
|
&& !_vm->_eventsManager._mouseClicked);
|
2013-12-28 07:37:37 +00:00
|
|
|
}
|
|
|
|
|
2013-06-02 02:14:59 +00:00
|
|
|
void EventsManager::pollEvents() {
|
|
|
|
checkForNextFrameCounter();
|
|
|
|
|
|
|
|
Common::Event event;
|
|
|
|
while (g_system->getEventManager()->pollEvent(event)) {
|
|
|
|
// Handle keypress
|
|
|
|
switch (event.type) {
|
|
|
|
case Common::EVENT_QUIT:
|
|
|
|
case Common::EVENT_RTL:
|
|
|
|
return;
|
|
|
|
|
|
|
|
case Common::EVENT_KEYDOWN:
|
2014-01-04 06:11:00 +00:00
|
|
|
// Check for debugger
|
|
|
|
if (event.kbd.keycode == Common::KEYCODE_d && (event.kbd.flags & Common::KBD_CTRL)) {
|
|
|
|
// Attach to the debugger
|
|
|
|
_vm->_debugger.attach();
|
|
|
|
_vm->_debugger.onFrame();
|
|
|
|
} else {
|
|
|
|
_keyState[(byte)toupper(event.kbd.ascii)] = true;
|
|
|
|
}
|
2013-06-02 02:14:59 +00:00
|
|
|
return;
|
|
|
|
case Common::EVENT_KEYUP:
|
|
|
|
_keyState[(byte)toupper(event.kbd.ascii)] = false;
|
|
|
|
return;
|
|
|
|
case Common::EVENT_LBUTTONDOWN:
|
|
|
|
_mouseButton = 1;
|
2013-12-28 22:58:43 +00:00
|
|
|
_vm->_eventsManager._newLeftClick = true;
|
|
|
|
_vm->_eventsManager._newMouseClicked = true;
|
2013-06-02 02:14:59 +00:00
|
|
|
return;
|
|
|
|
case Common::EVENT_RBUTTONDOWN:
|
|
|
|
_mouseButton = 2;
|
2013-12-28 22:58:43 +00:00
|
|
|
_vm->_eventsManager._newRightClick = true;
|
|
|
|
_vm->_eventsManager._newMouseClicked = true;
|
2013-06-02 02:14:59 +00:00
|
|
|
return;
|
|
|
|
case Common::EVENT_LBUTTONUP:
|
|
|
|
case Common::EVENT_RBUTTONUP:
|
2013-12-28 22:58:43 +00:00
|
|
|
_vm->_eventsManager._newMouseClicked = false;
|
|
|
|
_vm->_eventsManager._newLeftClick = false;
|
|
|
|
_vm->_eventsManager._newRightClick = false;
|
2013-06-02 02:14:59 +00:00
|
|
|
_mouseButton = 0;
|
|
|
|
return;
|
2013-06-13 02:13:52 +00:00
|
|
|
case Common::EVENT_MOUSEMOVE:
|
|
|
|
_mousePos = event.mouse;
|
|
|
|
break;
|
2013-06-02 02:14:59 +00:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-06 01:28:51 +00:00
|
|
|
void EventsManager::startFade(CMapResource *cMap) {
|
|
|
|
_fadeIntNode._flags |= 1;
|
|
|
|
if (_cycleStatus & 1)
|
|
|
|
_cycleIntNode._flags |= 1;
|
|
|
|
|
|
|
|
_fadeFirstCol = cMap->_start;
|
|
|
|
_fadeLastCol = cMap->_end;
|
|
|
|
_fadeCount = cMap->_steps + 1;
|
|
|
|
|
|
|
|
if (cMap->_steps > 0) {
|
2013-06-11 03:24:02 +00:00
|
|
|
_fadeStatus = cMap->_fadeStatus | 1;
|
2013-06-06 01:28:51 +00:00
|
|
|
byte *vgaP = &_vm->_graphicsManager._VGAColors[_fadeFirstCol * 3];
|
|
|
|
int mapIndex = 0;
|
|
|
|
|
2013-06-11 03:24:02 +00:00
|
|
|
for (int idx = _fadeFirstCol; idx <= _fadeLastCol; ++idx, vgaP += 3) {
|
2013-06-08 02:07:57 +00:00
|
|
|
ViewPortPalEntry &palEntry = _vm->_graphicsManager._viewPortListPtr->_palette[idx];
|
|
|
|
palEntry._rEntry = vgaP[0] << 8;
|
2013-06-11 03:24:02 +00:00
|
|
|
int rDiff = (cMap->_entries[mapIndex * 3] << 8) - palEntry._rEntry;
|
|
|
|
palEntry._rChange = rDiff / cMap->_steps;
|
2013-06-08 02:07:57 +00:00
|
|
|
|
|
|
|
palEntry._gEntry = vgaP[1] << 8;
|
2013-06-11 03:24:02 +00:00
|
|
|
int gDiff = (cMap->_entries[mapIndex * 3 + 1] << 8) - palEntry._gEntry;
|
|
|
|
palEntry._gChange = gDiff / cMap->_steps;
|
2013-06-08 02:07:57 +00:00
|
|
|
|
|
|
|
palEntry._bEntry = vgaP[2] << 8;
|
2013-06-11 03:24:02 +00:00
|
|
|
int bDiff = (cMap->_entries[mapIndex * 3 + 2] << 8) - palEntry._bEntry;
|
|
|
|
palEntry._bChange = bDiff / cMap->_steps;
|
|
|
|
|
|
|
|
palEntry._palIndex = idx;
|
2013-06-06 01:28:51 +00:00
|
|
|
if (!(cMap->_fadeStatus & 1))
|
|
|
|
++mapIndex;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cMap->_fadeStatus & 2)
|
2014-01-07 06:26:53 +00:00
|
|
|
_intPtr.field3B = true;
|
2013-06-06 01:28:51 +00:00
|
|
|
_fadeIntNode._flags &= ~1;
|
|
|
|
} else {
|
|
|
|
byte *vgaP = &_vm->_graphicsManager._VGAColors[_fadeFirstCol * 3];
|
|
|
|
int mapIndex = 0;
|
|
|
|
|
|
|
|
for (int idx = _fadeFirstCol; idx <= _fadeLastCol; ++idx, vgaP += 3) {
|
2013-06-18 02:59:26 +00:00
|
|
|
Common::copy(&cMap->_entries[mapIndex], &cMap->_entries[mapIndex + 3], vgaP);
|
2013-06-06 01:28:51 +00:00
|
|
|
|
|
|
|
if (!(cMap->_fadeStatus & 1))
|
|
|
|
mapIndex += 3;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_intPtr._palStartIndex > _fadeFirstCol)
|
|
|
|
_intPtr._palStartIndex = _fadeFirstCol;
|
|
|
|
if (_intPtr._palEndIndex < _fadeLastCol)
|
|
|
|
_intPtr._palEndIndex = _fadeLastCol;
|
|
|
|
|
|
|
|
_intPtr._hasPalette = true;
|
|
|
|
if (!(cMap->_fadeStatus & 2))
|
2014-01-06 23:06:16 +00:00
|
|
|
_intPtr.field38 = true;
|
2013-06-06 01:28:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (_cycleStatus & 1)
|
|
|
|
_cycleIntNode._flags &= ~1;
|
|
|
|
}
|
|
|
|
|
2013-06-08 14:31:37 +00:00
|
|
|
void EventsManager::addIntNode(IntNode *node) {
|
|
|
|
_intNodes.push_back(node);
|
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::addFadeInt() {
|
2013-06-08 19:41:22 +00:00
|
|
|
IntNode &node = _fade2IntNode;
|
2013-06-08 14:31:37 +00:00
|
|
|
node._intFunc = &EventsManager::fadeIntFunc;
|
|
|
|
node._flags = 0;
|
|
|
|
node._curTime = 0;
|
|
|
|
node._timeReset = 1;
|
|
|
|
|
|
|
|
addIntNode(&node);
|
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::vDoFadeInt() {
|
2014-01-07 06:26:53 +00:00
|
|
|
if (_intPtr.field3B)
|
2013-06-08 14:31:37 +00:00
|
|
|
return;
|
|
|
|
if (--_fadeCount == 0) {
|
|
|
|
_fadeIntNode._flags |= 1;
|
|
|
|
_fadeStatus &= ~1;
|
2013-12-18 14:03:18 +00:00
|
|
|
return;
|
2013-06-08 14:31:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
for (int i = _fadeFirstCol; i <= _fadeLastCol; ++i) {
|
|
|
|
ViewPortPalEntry &palEntry = _vm->_graphicsManager._viewPortListPtr->_palette[i];
|
|
|
|
byte *vgaP = &_vm->_graphicsManager._VGAColors[palEntry._palIndex * 3];
|
|
|
|
|
|
|
|
palEntry._rEntry += palEntry._rChange;
|
|
|
|
palEntry._gEntry += palEntry._gChange;
|
|
|
|
palEntry._bEntry += palEntry._bChange;
|
|
|
|
|
|
|
|
vgaP[0] = palEntry._rEntry >> 8;
|
|
|
|
vgaP[1] = palEntry._gEntry >> 8;
|
|
|
|
vgaP[2] = palEntry._bEntry >> 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (_intPtr._palStartIndex > _fadeFirstCol)
|
|
|
|
_intPtr._palStartIndex = _fadeFirstCol;
|
|
|
|
if (_intPtr._palEndIndex < _fadeLastCol)
|
|
|
|
_intPtr._palEndIndex = _fadeLastCol;
|
|
|
|
|
|
|
|
_intPtr._hasPalette = true;
|
2014-01-06 23:06:16 +00:00
|
|
|
_intPtr.field38 = true;
|
2013-06-08 14:31:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::vDoCycleInt() {
|
2013-12-30 05:52:50 +00:00
|
|
|
for (int idx = 3; idx >= 0; --idx) {
|
2013-12-30 11:00:15 +00:00
|
|
|
if (_cyclePtr->_type[idx] && --_cycleTime[idx] <= 0) {
|
2013-12-30 05:52:50 +00:00
|
|
|
byte *pSrc = _cycleNext[idx];
|
|
|
|
byte *pPal = _vm->_graphicsManager._VGAColors;
|
|
|
|
|
2013-12-30 11:00:15 +00:00
|
|
|
if (_cyclePtr->_type[idx] != 1) {
|
|
|
|
// New palette data being specified - loop to set entries
|
2013-12-30 05:52:50 +00:00
|
|
|
do {
|
|
|
|
int palIndex = READ_LE_UINT16(pSrc);
|
|
|
|
pPal[palIndex * 3] = pSrc[3];
|
|
|
|
pPal[palIndex * 3 + 1] = pSrc[4];
|
|
|
|
pPal[palIndex * 3 + 1] = pSrc[5];
|
|
|
|
pSrc += 6;
|
|
|
|
|
|
|
|
if ((int16)READ_LE_UINT16(pSrc) >= 0) {
|
|
|
|
// Resetting back to start of cycle data
|
|
|
|
pSrc = _cycleNext[idx];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (*(pSrc + 2) == 0);
|
|
|
|
|
|
|
|
_cycleNext[idx] = pSrc;
|
|
|
|
_cycleTime[idx] = pSrc[2];
|
|
|
|
} else {
|
2013-12-30 11:00:15 +00:00
|
|
|
// Palette rotation to be done
|
2013-12-30 05:52:50 +00:00
|
|
|
_cycleTime[idx] = pSrc[4];
|
|
|
|
|
|
|
|
if (pSrc[5] == 1) {
|
|
|
|
// Move palette entry to end of range
|
|
|
|
int start = READ_LE_UINT16(pSrc);
|
|
|
|
int end = READ_LE_UINT16(&pSrc[2]);
|
2013-12-31 07:39:38 +00:00
|
|
|
assert(start < 0x100 && end < 0x100);
|
2013-12-30 05:52:50 +00:00
|
|
|
|
|
|
|
// Store the RGB of the first entry to be moved
|
2013-12-30 11:00:15 +00:00
|
|
|
byte r = pPal[start * 3];
|
|
|
|
byte g = pPal[start * 3 + 1];
|
|
|
|
byte b = pPal[start * 3 + 2];
|
2013-12-30 05:52:50 +00:00
|
|
|
|
|
|
|
// Move the remainder of the range backwards one entry
|
|
|
|
// TODO: Is this allowing for overlap properly?
|
2013-12-30 11:00:15 +00:00
|
|
|
Common::copy(&pPal[start * 3 + 3], &pPal[end * 3 + 3], &pPal[start * 3]);
|
2013-12-30 05:52:50 +00:00
|
|
|
|
|
|
|
// Place the original saved entry at the end of the range
|
2013-12-30 11:00:15 +00:00
|
|
|
pPal[end * 3] = r;
|
|
|
|
pPal[end * 3 + 1] = g;
|
|
|
|
pPal[end * 3 + 2] = b;
|
2013-12-30 05:52:50 +00:00
|
|
|
|
|
|
|
if (_fadeStatus & 1) {
|
|
|
|
//dx = start, di = end
|
|
|
|
warning("TODO: Adjustment of ViewPortListResource");
|
|
|
|
}
|
|
|
|
} else {
|
2013-12-30 11:00:15 +00:00
|
|
|
// Move palette entry to start of range
|
2013-12-30 05:52:50 +00:00
|
|
|
int start = READ_LE_UINT16(pSrc);
|
|
|
|
int end = READ_LE_UINT16(&pSrc[2]);
|
2013-12-31 07:39:38 +00:00
|
|
|
assert(start < 0x100 && end < 0x100);
|
2013-12-30 05:52:50 +00:00
|
|
|
|
|
|
|
// Store the RGB of the entry to be moved
|
2013-12-30 11:00:15 +00:00
|
|
|
byte r = pPal[end * 3];
|
|
|
|
byte g = pPal[end * 3 + 1];
|
|
|
|
byte b = pPal[end * 3 + 2];
|
2013-12-30 05:52:50 +00:00
|
|
|
|
|
|
|
// Move the remainder of the range forwards one entry
|
|
|
|
// TODO: Does this allow for overlap range correctly?
|
2013-12-30 11:00:15 +00:00
|
|
|
Common::copy_backward(&pPal[start * 3], &pPal[end * 3], &pPal[end * 3 + 3]);
|
2013-12-30 05:52:50 +00:00
|
|
|
|
|
|
|
// Place the original saved entry at the end of the range
|
2013-12-30 11:00:15 +00:00
|
|
|
pPal[start * 3] = r;
|
|
|
|
pPal[start * 3 + 1] = g;
|
|
|
|
pPal[start * 3 + 2] = b;
|
2013-12-30 05:52:50 +00:00
|
|
|
|
|
|
|
if (_fadeStatus & 1) {
|
|
|
|
//dx = start, di = end
|
|
|
|
warning("TODO: Adjustment of ViewPortListResource");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-12-30 11:00:15 +00:00
|
|
|
|
|
|
|
_intPtr._hasPalette = true;
|
|
|
|
_intPtr.field38 = true;
|
2013-12-30 05:52:50 +00:00
|
|
|
}
|
|
|
|
}
|
2013-06-08 14:31:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void EventsManager::fadeIntFunc() {
|
2013-12-25 03:08:37 +00:00
|
|
|
warning("TODO");
|
2013-06-08 14:31:37 +00:00
|
|
|
}
|
|
|
|
|
2013-12-28 07:37:37 +00:00
|
|
|
void EventsManager::deleteIntNode(IntNode *node) {
|
|
|
|
_intNodes.remove(node);
|
|
|
|
}
|
|
|
|
|
2013-06-08 14:31:37 +00:00
|
|
|
void EventsManager::vInitColor() {
|
|
|
|
_fadeIntNode._intFunc = &EventsManager::vDoFadeInt;
|
|
|
|
_cycleIntNode._intFunc = &EventsManager::vDoCycleInt;
|
2013-06-08 19:41:22 +00:00
|
|
|
|
|
|
|
addIntNode(&_fadeIntNode);
|
|
|
|
addIntNode(&_cycleIntNode);
|
2013-06-08 14:31:37 +00:00
|
|
|
}
|
|
|
|
|
2013-06-21 04:18:19 +00:00
|
|
|
void EventsManager::setCursor(PictureResource *pic) {
|
|
|
|
PictureResource cursor;
|
|
|
|
cursor._bounds = pic->_bounds;
|
|
|
|
cursor._flags = DISPFLAG_CURSOR;
|
|
|
|
|
|
|
|
_vm->_graphicsManager.sDrawPic(pic, &cursor, Common::Point());
|
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::setCursor(byte *cursorData, int width, int height) {
|
2014-01-03 19:20:53 +00:00
|
|
|
CursorMan.replaceCursor(cursorData, width, height, width / 2, height / 2, 0);
|
2013-06-21 04:18:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::setCursorColor(int idx, int mode) {
|
2013-06-21 01:24:30 +00:00
|
|
|
switch (mode) {
|
2013-06-17 01:50:31 +00:00
|
|
|
case 0:
|
|
|
|
_vm->_graphicsManager.setColor(idx, 90, 90, 232);
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
_vm->_graphicsManager.setColor(idx, 232, 90, 90);
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
_vm->_graphicsManager.setColor(idx, 90, 232, 90);
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
_vm->_graphicsManager.setColor(idx, 90, 232, 232);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2013-06-13 02:13:52 +00:00
|
|
|
}
|
|
|
|
|
2013-12-28 09:53:33 +00:00
|
|
|
void EventsManager::showCursor() {
|
2013-06-21 04:18:19 +00:00
|
|
|
CursorMan.showMouse(true);
|
|
|
|
}
|
|
|
|
|
2013-12-21 03:51:31 +00:00
|
|
|
void EventsManager::hideCursor() {
|
2013-12-28 09:53:33 +00:00
|
|
|
CursorMan.showMouse(false);
|
2013-12-21 03:51:31 +00:00
|
|
|
}
|
|
|
|
|
2013-12-10 03:22:32 +00:00
|
|
|
void EventsManager::getMouseInfo() {
|
2013-12-23 20:38:39 +00:00
|
|
|
pollEvents();
|
|
|
|
|
2013-12-10 14:19:54 +00:00
|
|
|
if (_vm->_voy._field478 & 0x10) {
|
2013-12-10 03:22:32 +00:00
|
|
|
if ((_gameCounter - _joe) > 8) {
|
|
|
|
_joe = _gameCounter;
|
|
|
|
|
|
|
|
if (_vm->_bob) {
|
|
|
|
_vm->_bob = false;
|
2013-12-18 13:53:44 +00:00
|
|
|
_vm->_graphicsManager.setOneColor(128, 55, 5, 5);
|
2013-12-10 03:22:32 +00:00
|
|
|
_vm->_graphicsManager.setColor(128, 220, 20, 20);
|
|
|
|
} else {
|
|
|
|
_vm->_bob = true;
|
2013-12-18 13:53:44 +00:00
|
|
|
_vm->_graphicsManager.setOneColor(128, 55, 55, 55);
|
2013-12-10 03:22:32 +00:00
|
|
|
_vm->_graphicsManager.setColor(128, 220, 20, 20);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-28 22:58:43 +00:00
|
|
|
_vm->_eventsManager._mouseClicked = _vm->_eventsManager._newMouseClicked;
|
|
|
|
_vm->_eventsManager._leftClick = _vm->_eventsManager._newLeftClick;
|
|
|
|
_vm->_eventsManager._rightClick = _vm->_eventsManager._newRightClick;
|
|
|
|
_vm->_eventsManager._mouseUnk = _vm->_eventsManager._newMouseUnk;
|
2013-12-28 09:32:17 +00:00
|
|
|
|
2013-12-28 22:58:43 +00:00
|
|
|
_vm->_eventsManager._newMouseClicked = false;
|
|
|
|
_vm->_eventsManager._newLeftClick = false;
|
|
|
|
_vm->_eventsManager._newRightClick = false;
|
|
|
|
_vm->_eventsManager._mouseUnk = false;
|
2013-12-10 03:22:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void EventsManager::checkForKey() {
|
|
|
|
warning("TODO: checkForKey");
|
|
|
|
}
|
|
|
|
|
2013-12-10 14:19:54 +00:00
|
|
|
void EventsManager::startCursorBlink() {
|
2013-12-28 03:01:06 +00:00
|
|
|
if (_vm->_voy._field478 & 0x10) {
|
|
|
|
_vm->_graphicsManager.setOneColor(128, 55, 5, 5);
|
|
|
|
_vm->_graphicsManager.setColor(128, 220, 20, 20);
|
|
|
|
_intPtr.field38 = true;
|
|
|
|
_intPtr._hasPalette = true;
|
|
|
|
|
|
|
|
_vm->_graphicsManager.drawDot();
|
|
|
|
//copySection();
|
|
|
|
}
|
2013-12-10 14:19:54 +00:00
|
|
|
}
|
|
|
|
|
2013-12-11 01:47:05 +00:00
|
|
|
void EventsManager::incrementTime(int amt) {
|
2013-12-23 20:38:39 +00:00
|
|
|
for (int i = 0; i < amt; ++i)
|
|
|
|
mainVoyeurIntFunc();
|
2013-12-11 01:47:05 +00:00
|
|
|
}
|
|
|
|
|
2013-12-28 07:37:37 +00:00
|
|
|
void EventsManager::stopEvidDim() {
|
|
|
|
deleteIntNode(&_evIntNode);
|
|
|
|
}
|
|
|
|
|
2013-12-25 03:08:37 +00:00
|
|
|
Common::String EventsManager::getEvidString(int eventIndex) {
|
|
|
|
assert(eventIndex <= _vm->_voy._eventCount);
|
|
|
|
VoyeurEvent &e = _vm->_voy._events[eventIndex];
|
|
|
|
return Common::String::format("%03d %.2d:%.2d %s %s", eventIndex + 1,
|
|
|
|
e._hour, e._minute, e._isAM ? AM : PM, EVENT_TYPE_STRINGS[e._type - 1]);
|
|
|
|
}
|
|
|
|
|
2013-05-18 03:13:48 +00:00
|
|
|
} // End of namespace Voyeur
|