libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-18 07:39:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
bc85ff1868
scummvm/engines/access/amazon/amazon_logic.cpp

2229 lines
53 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 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 "common/scummsys.h"
#include "access/access.h"
#include "access/resources.h"
#include "access/screen.h"
#include "access/amazon/amazon_game.h"
#include "access/amazon/amazon_logic.h"
#include "access/amazon/amazon_resources.h"
namespace Access {
namespace Amazon {
PannedScene::PannedScene(AmazonEngine *vm) : AmazonManager(vm) {
for (int i = 0; i < PAN_SIZE; ++i) {
_pan[i]._pObject = nullptr;
_pan[i]._pImgNum = 0;
_pan[i]._pObjX = _pan[i]._pObjY = _pan[i]._pObjZ = 0;
_pan[i]._pObjXl = _pan[i]._pObjYl = 0;
}
_xCount = 0;
_xTrack = _yTrack = _zTrack = 0;
_xCam = _yCam = _zCam = 0;
_pNumObj = 0;
}
void PannedScene::pan() {
_zCam += _zTrack;
_xCam += _xTrack;
int tx = (_xTrack << 8) / _zCam;
_yCam += _yTrack;
int ty = (_yTrack << 8) / _zCam;
if (_vm->_timers[24]._flag != 1) {
++_vm->_timers[24]._flag;
for (int i = 0; i < _pNumObj; i++) {
_pan[i]._pObjZ += _zTrack;
_pan[i]._pObjXl += (_pan[i]._pObjZ * tx) & 0xff;
_pan[i]._pObjX += ((_pan[i]._pObjZ * tx) >> 8) + (_pan[i]._pObjXl >> 8);
_pan[i]._pObjXl &= 0xff;
_pan[i]._pObjYl += (_pan[i]._pObjZ * ty) & 0xff;
_pan[i]._pObjY += ((_pan[i]._pObjZ * ty) >> 8) + (_pan[i]._pObjYl >> 8);
_pan[i]._pObjYl &= 0xff;
}
}
for (int i = 0; i < _pNumObj; i++) {
ImageEntry ie;
ie._flags = IMGFLAG_UNSCALED;
ie._position = Common::Point(_pan[i]._pObjX, _pan[i]._pObjY);
ie._offsetY = 255;
ie._spritesPtr = _pan[i]._pObject;
ie._frameNumber = _pan[i]._pImgNum;
_vm->_images.addToList(ie);
}
}
/*------------------------------------------------------------------------*/
CampScene::CampScene(AmazonEngine *vm) : PannedScene(vm) {
_skipStart = false;
}
void CampScene::mWhileDoOpen() {
Screen &screen = *_vm->_screen;
EventsManager &events = *_vm->_events;
screen.setDisplayScan();
events.hideCursor();
screen.forceFadeOut();
_skipStart = false;
if (_vm->_conversation != 2) {
// Cutscene at start of chapter 1
screen.setPanel(3);
_vm->startChapter(1);
_vm->establishCenter(0, 1);
}
Resource *data = _vm->_files->loadFile(1, 0);
_vm->_objectsTable[1] = new SpriteResource(_vm, data);
delete data;
_vm->_files->_setPaletteFlag = false;
_vm->_files->loadScreen(1, 2);
_vm->_buffer2.blitFrom(*_vm->_screen);
_vm->_buffer1.blitFrom(*_vm->_screen);
// Load animation data
_vm->_animation->freeAnimationData();
Resource *animResource = _vm->_files->loadFile(1, 1);
_vm->_animation->loadAnimations(animResource);
delete animResource;
_xTrack = 8;
_yTrack = -3;
_zTrack = 0;
_xCam = _yCam = 0;
_zCam = 270;
_vm->_timers[24]._timer = _vm->_timers[24]._initTm = 1;
++_vm->_timers[24]._flag;
_vm->_timers.updateTimers();
_pNumObj = 10;
for (int i = 0; i < _pNumObj; i++) {
_pan[i]._pObject = _vm->_objectsTable[1];
_pan[i]._pImgNum = OPENING_OBJS[i][0];
_pan[i]._pObjX = OPENING_OBJS[i][1];
_pan[i]._pObjY = OPENING_OBJS[i][2];
_pan[i]._pObjZ = OPENING_OBJS[i][3];
_pan[i]._pObjXl = _pan[i]._pObjYl = 0;
}
_vm->_oldRects.clear();
_vm->_newRects.clear();
Animation *anim = _vm->_animation->setAnimation(0);
_vm->_animation->setAnimTimer(anim);
anim = _vm->_animation->setAnimation(1);
_vm->_animation->setAnimTimer(anim);
_vm->_midi->newMusic(10, 0);
bool startFl = false;
while (!_vm->shouldQuit()) {
_vm->_images.clear();
_vm->_animation->animate(0);
_vm->_animation->animate(1);
pan();
_vm->_buffer2.copyFrom(_vm->_buffer1);
_vm->_newRects.clear();
_vm->plotList();
_vm->copyBlocks();
if (!startFl) {
startFl = true;
screen.forceFadeIn();
}
events.pollEventsAndWait();
if (_vm->_events->isKeyMousePressed()) {
_skipStart = true;
_vm->_midi->newMusic(10, 1);
break;
}
if (_xCam > 680) {
events._vbCount = 125;
while (!_vm->shouldQuit() && !events.isKeyMousePressed() && events._vbCount > 0) {
events.pollEventsAndWait();
}
break;
}
}
events.showCursor();
_vm->_buffer2.copyFrom(*_vm->_screen);
_vm->_buffer1.copyFrom(*_vm->_screen);
_vm->freeCells();
_vm->_oldRects.clear();
_vm->_newRects.clear();
_vm->_numAnimTimers = 0;
_vm->_images.clear();
if (_vm->isCD()) {
if (_vm->_conversation == 2) {
// Cutscene at end of Chapter 6
Resource *spriteData = _vm->_files->loadFile(28, 37);
_vm->_objectsTable[28] = new SpriteResource(_vm, spriteData);
delete spriteData;
_vm->_animation->freeAnimationData();
animResource = _vm->_files->loadFile(28, 38);
_vm->_animation->loadAnimations(animResource);
delete animResource;
}
} else {
_vm->freeCells();
_vm->_oldRects.clear();
_vm->_newRects.clear();
_vm->_numAnimTimers = 0;
_vm->_images.clear();
}
}
/*------------------------------------------------------------------------*/
Opening::Opening(AmazonEngine *vm) : CampScene(vm) {
_pCount = 0;
}
void Opening::doIntroduction() {
Screen &screen = *_vm->_screen;
screen.setInitialPalettte();
_vm->_events->setCursor(CURSOR_ARROW);
_vm->_events->showCursor();
screen.setPanel(0);
screen.setPalette();
_vm->_events->setCursor(CURSOR_ARROW);
_vm->_events->showCursor();
screen.setPanel(3);
doTitle();
if (_vm->shouldQuit() || _skipStart || _vm->isDemo())
return;
screen.setPanel(3);
mWhileDoOpen();
if (_vm->shouldQuit() || _skipStart)
return;
doTent();
}
void Opening::doCredit() {
if (_pCount < 15)
return;
if (_pCount <= 75)
_vm->_buffer2.plotImage(_vm->_objectsTable[0], _vm->isDemo()? 24 : 0, Common::Point(90, 35));
else if (_pCount <= 210)
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 1, Common::Point(65, 35));
else if (_pCount <= 272)
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 2, Common::Point(96, 45));
else if (_pCount <= 334)
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 3, Common::Point(68, 54));
else if (_pCount <= 396)
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 4, Common::Point(103, 54));
else if (_pCount <= 458) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 5, Common::Point(8, 5));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 12, Common::Point(88, 55));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 6, Common::Point(194, 98));
} else if (_pCount <= 520) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 7, Common::Point(32, 13));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 8, Common::Point(162, 80));
} else if (_pCount <= 580) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 9, Common::Point(18, 15));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 10, Common::Point(164, 81));
} else
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 11, Common::Point(106, 55));
}
void Opening::doCreditDemo() {
if (_pCount < 15)
return;
if (_pCount <= 75)
_vm->_buffer2.plotImage(_vm->_objectsTable[0], _vm->isDemo()? 24 : 0, Common::Point(90, 35));
else if (_pCount <= 210)
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 25, Common::Point(82, 35));
else if (_pCount <= 272) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 23, Common::Point(77, 20));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 4, Common::Point(50, 35));
} else if (_pCount <= 334) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 16, Common::Point(200, 70));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 4, Common::Point(170, 85));
} else if (_pCount <= 396) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 15, Common::Point(65, 15));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 2, Common::Point(30, 30));
} else if (_pCount <= 458) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 19, Common::Point(123, 40));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 10, Common::Point(115, 55));
} else if (_pCount <= 520) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 18, Common::Point(50, 15));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 9, Common::Point(40, 30));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 0, Common::Point(40, 55));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 20, Common::Point(198, 95));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 3, Common::Point(160, 110));
} else if (_pCount <= 580) {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 21, Common::Point(40, 10));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 6, Common::Point(20, 25));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 22, Common::Point(145, 50));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 7, Common::Point(125, 65));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 12, Common::Point(207, 90));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 5, Common::Point(200, 105));
} else {
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 11, Common::Point(125, 30));
_vm->_buffer2.plotImage(_vm->_objectsTable[0], 4, Common::Point(115, 45));
}
}
void Opening::scrollTitle() {
_vm->copyBF1BF2();
_vm->_newRects.clear();
if (_vm->isDemo())
doCreditDemo();
else
doCredit();
_vm->copyRects();
_vm->copyBF2Vid();
}
void Opening::doTitle() {
Screen &screen = *_vm->_screen;
screen.setDisplayScan();
screen.forceFadeOut();
_vm->_events->hideCursor();
if (!_vm->isDemo()) {
_vm->_sound->loadSoundTable(0, 98, 30);
_vm->_sound->loadSoundTable(1, 98, 8);
_vm->_files->_setPaletteFlag = false;
_vm->_files->loadScreen(0, 3);
_vm->_buffer2.copyFrom(*_vm->_screen);
_vm->_buffer1.copyFrom(*_vm->_screen);
screen.forceFadeIn();
_vm->_sound->playSound(1, true);
Resource *spriteData = _vm->_files->loadFile(0, 2);
_vm->_objectsTable[0] = new SpriteResource(_vm, spriteData);
delete spriteData;
_vm->_files->_setPaletteFlag = false;
_vm->_files->loadScreen(0, 4);
_vm->_buffer2.copyFrom(*_vm->_screen);
_vm->_buffer1.copyFrom(*_vm->_screen);
const int COUNTDOWN[6] = { 2, 0x80, 1, 0x7d, 0, 0x87 };
for (_pCount = 0; _pCount < 3 && !_vm->shouldQuit(); ++_pCount) {
_vm->_buffer2.blitFrom(_vm->_buffer1);
int id = COUNTDOWN[_pCount * 2];
int xp = COUNTDOWN[_pCount * 2 + 1];
_vm->_buffer2.plotImage(_vm->_objectsTable[0], id, Common::Point(xp, 71));
_vm->_buffer2.copyTo(_vm->_screen);
_vm->_events->_vbCount = 70;
while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0 && !_skipStart) {
_vm->_events->pollEventsAndWait();
if (_vm->_events->_rightButton)
_skipStart = true;
}
}
if (_vm->shouldQuit())
return;
_vm->_sound->stopSound();
_vm->_sound->checkSoundQueue(); // HACK: Clear sound 1 from the queue
_vm->_sound->playSound(0);
screen.forceFadeOut();
_vm->_events->_vbCount = 100;
while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0)
_vm->_events->pollEventsAndWait();
if (_vm->shouldQuit())
return;
_vm->_sound->freeSounds();
delete _vm->_objectsTable[0];
_vm->_objectsTable[0] = nullptr;
_vm->_files->_setPaletteFlag = false;
_vm->_files->loadScreen(0, 5);
_vm->_buffer2.blitFrom(*_vm->_screen);
_vm->_buffer1.blitFrom(*_vm->_screen);
screen.forceFadeIn();
_vm->_midi->newMusic(1, 0);
_vm->_events->_vbCount = 950;
while (!_vm->shouldQuit() && (_vm->_events->_vbCount > 0) && !_vm->_events->isKeyMousePressed()) {
_vm->_events->pollEventsAndWait();
}
if (_vm->_events->_rightButton) {
_skipStart = true;
_vm->_room->clearRoom();
_vm->_events->showCursor();
return;
}
_vm->_midi->newMusic(1, 1);
_vm->_midi->setLoop(false);
_vm->_events->zeroKeys();
}
_vm->_buffer1.create(_vm->_screen->w + TILE_WIDTH, _vm->_screen->h);
_vm->_room->loadRoom(0);
screen.clearScreen();
screen.setBufferScan();
_vm->_scrollRow = _vm->_scrollCol = 0;
_vm->_scrollX = _vm->_scrollY = 0;
_vm->_player->_rawPlayer = Common::Point(0, 0);
screen.forceFadeOut();
_vm->_room->buildScreen();
_vm->copyBF2Vid();
screen.forceFadeIn();
_vm->_oldRects.clear();
_vm->_newRects.clear();
_vm->_events->clearEvents();
_vm->_player->_scrollAmount = 1;
_pCount = 0;
while (!_vm->shouldQuit()) {
if (_vm->_events->isKeyMousePressed()) {
if (_vm->_events->_rightButton)
_skipStart = true;
_vm->_room->clearRoom();
_vm->_events->showCursor();
return;
}
_vm->_events->_vbCount = 4;
if (_vm->_scrollCol + screen._vWindowWidth != _vm->_room->_playFieldWidth) {
_vm->_scrollX += _vm->_player->_scrollAmount;
while (_vm->_scrollX >= TILE_WIDTH) {
_vm->_scrollX -= TILE_WIDTH;
++_vm->_scrollCol;
_vm->_buffer1.moveBufferLeft();
_vm->_room->buildColumn(_vm->_scrollCol + screen._vWindowWidth, screen._vWindowBytesWide);
}
scrollTitle();
++_pCount;
while (!_vm->shouldQuit() && (_vm->_events->_vbCount > 0)) {
_vm->_events->pollEventsAndWait();
}
continue;
}
_vm->_events->_vbCount = 120;
while (!_vm->shouldQuit() && (_vm->_events->_vbCount > 0))
_vm->_events->pollEventsAndWait();
while (!_vm->shouldQuit()) {
_pCount = 0;
_vm->_events->_vbCount = 3;
if (_vm->_scrollRow + screen._vWindowHeight >= _vm->_room->_playFieldHeight) {
_vm->_room->clearRoom();
_vm->_events->showCursor();
return;
}
_vm->_scrollY = _vm->_scrollY + _vm->_player->_scrollAmount;
while (_vm->_scrollY >= TILE_HEIGHT && !_vm->shouldQuit()) {
_vm->_scrollY -= TILE_HEIGHT;
++_vm->_scrollRow;
_vm->_buffer1.moveBufferUp();
// WORKAROUND: the original was using screen._vWindowBytesWide * screen._vWindowLinesTall
_vm->_room->buildRow(_vm->_scrollRow + screen._vWindowHeight, screen._vWindowLinesTall);
if (_vm->_scrollRow + screen._vWindowHeight >= _vm->_room->_playFieldHeight) {
_vm->_room->clearRoom();
_vm->_events->showCursor();
return;
}
}
scrollTitle();
while (!_vm->shouldQuit() && (_vm->_events->_vbCount > 0))
_vm->_events->pollEventsAndWait();
}
}
}
void Opening::doTent() {
int step = 0;
_vm->_screen->setDisplayScan();
_vm->_screen->forceFadeOut();
_vm->_events->hideCursor();
_vm->_sound->loadSoundTable(0, 98, 39);
_vm->_sound->loadSoundTable(1, 98, 14);
_vm->_sound->loadSoundTable(2, 98, 15);
_vm->_sound->loadSoundTable(3, 98, 16);
_vm->_sound->loadSoundTable(4, 98, 31, 2);
_vm->_sound->loadSoundTable(5, 98, 52, 2);
_vm->_sound->playSound(0);
_vm->_files->_setPaletteFlag = false;
_vm->_files->loadScreen(2, 0);
_vm->_buffer2.blitFrom(*_vm->_screen);
_vm->_buffer1.blitFrom(*_vm->_screen);
_vm->_screen->forceFadeIn();
_vm->_video->setVideo(_vm->_screen, Common::Point(126, 73), FileIdent(2, 1), 10);
int previousFrame = -1;
while (!_vm->shouldQuit() && !_vm->_video->_videoEnd) {
_vm->_video->playVideo();
if (previousFrame != _vm->_video->_videoFrame) {
previousFrame = _vm->_video->_videoFrame;
if ((_vm->_video->_videoFrame == 32) || (_vm->_video->_videoFrame == 34))
_vm->_sound->playSound(4);
else if (_vm->_video->_videoFrame == 36) {
if (step != 2) {
_vm->_sound->playSound(2);
step = 2;
}
} else if (_vm->_video->_videoFrame == 18) {
if (step != 1) {
_vm->_midi->newMusic(73, 1);
_vm->_midi->newMusic(11, 0);
step = 1;
_vm->_sound->playSound(1);
}
}
}
_vm->_events->pollEventsAndWait();
}
_vm->_sound->playSound(5);
_vm->_video->setVideo(_vm->_screen, Common::Point(43, 11), FileIdent(2, 2), 10);
previousFrame = -1;
while (!_vm->shouldQuit() && !_vm->_video->_videoEnd) {
_vm->_video->playVideo();
if (previousFrame != _vm->_video->_videoFrame) {
previousFrame = _vm->_video->_videoFrame;
if (_vm->_video->_videoFrame == 26) {
_vm->_sound->playSound(5);
} else if (_vm->_video->_videoFrame == 15) {
if (step !=3) {
_vm->_sound->playSound(3);
step = 3;
}
}
}
_vm->_events->pollEventsAndWait();
}
_vm->_events->_vbCount = 200;
while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0)
_vm->_events->pollEventsAndWait();
_vm->_events->showCursor();
_vm->_midi->newMusic(11, 1);
_vm->_sound->_soundTable.clear();
_vm->establishCenter(0, 4);
}
/*------------------------------------------------------------------------*/
Plane::Plane(AmazonEngine *vm) : PannedScene(vm) {
_pCount = 0;
_planeCount = 0;
_propCount = 0;
}
void Plane::doFlyCell() {
SpriteResource *sprites = _vm->_objectsTable[15];
if (_pCount <= 40) {
_vm->_buffer2.plotImage(sprites, 3, Common::Point(70, 74));
} else if (_pCount <= 80) {
_vm->_buffer2.plotImage(sprites, 6, Common::Point(70, 74));
} else if (_pCount <= 120) {
_vm->_buffer2.plotImage(sprites, 2, Common::Point(50, 76));
} else if (_pCount <= 160) {
_vm->_buffer2.plotImage(sprites, 14, Common::Point(63, 78));
} else if (_pCount <= 200) {
_vm->_buffer2.plotImage(sprites, 5, Common::Point(86, 74));
} else if (_pCount <= 240) {
_vm->_buffer2.plotImage(sprites, 0, Common::Point(103, 76));
} else if (_pCount <= 280) {
_vm->_buffer2.plotImage(sprites, 4, Common::Point(119, 77));
} else {
_vm->_buffer2.plotImage(sprites, 1, Common::Point(111, 77));
}
if (_planeCount == 11 || _planeCount == 12)
++_position.y;
else if (_planeCount >= 28)
--_position.y;
_vm->_buffer2.plotImage(sprites, 7, _position);
_vm->_buffer2.plotImage(sprites, 8 + _propCount, Common::Point(
_position.x + 99, _position.y + 10));
_vm->_buffer2.plotImage(sprites, 11 + _propCount, Common::Point(
_position.x + 104, _position.y + 18));
if (++_planeCount >= 30)
_planeCount = 0;
if (++_propCount >= 3)
_propCount = 0;
++_xCount;
if (_xCount == 1)
++_position.x;
else
_xCount = 0;
}
void Plane::doFallCell() {
if (_vm->_scaleI <= 20)
return;
SpriteFrame *frame = _vm->_objectsTable[20]->getFrame(_planeCount / 6);
Common::Rect r(115, 11, 115 + _vm->_screen->_scaleTable1[frame->w],
11 + _vm->_screen->_scaleTable1[frame->h]);
_vm->_buffer2.sPlotF(frame, r);
_vm->_scaleI -= 3;
_vm->_scale = _vm->_scaleI;
_vm->_screen->setScaleTable(_vm->_scale);
++_xCount;
if (_xCount == 5)
return;
_xCount = 0;
if (_planeCount == 18)
_planeCount = 0;
else
_planeCount += 6;
}
void Plane::scrollFly() {
_vm->copyBF1BF2();
_vm->_newRects.clear();
doFlyCell();
_vm->copyRects();
_vm->copyBF2Vid();
}
void Plane::scrollFall() {
_vm->copyBF1BF2();
_vm->_newRects.clear();
doFallCell();
_vm->copyRects();
_vm->copyBF2Vid();
}
void Plane::mWhileFly() {
Screen &screen = *_vm->_screen;
Player &player = *_vm->_player;
EventsManager &events = *_vm->_events;
events.hideCursor();
screen.clearScreen();
screen.setBufferScan();
screen.fadeOut();
_vm->_scrollX = 0;
_vm->_room->buildScreen();
_vm->copyBF2Vid();
screen.fadeIn();
_vm->_oldRects.clear();
_vm->_newRects.clear();
_vm->_events->clearEvents();
_vm->_scrollRow = _vm->_scrollCol = 0;
_vm->_scrollX = _vm->_scrollY = 0;
player._rawPlayer = Common::Point(0, 0);
player._scrollAmount = 1;
_pCount = 0;
_planeCount = 0;
_propCount = 0;
_xCount = 0;
_position = Common::Point(20, 29);
while (!_vm->shouldQuit() && !events.isKeyMousePressed() &&
((_vm->_scrollCol + screen._vWindowWidth) != _vm->_room->_playFieldWidth)) {
events._vbCount = 4;
_vm->_scrollX += player._scrollAmount;
while (_vm->_scrollX >= TILE_WIDTH) {
_vm->_scrollX -= TILE_WIDTH;
++_vm->_scrollCol;
_vm->_buffer1.moveBufferLeft();
_vm->_room->buildColumn(_vm->_scrollCol + screen._vWindowWidth, screen._vWindowBytesWide);
}
scrollFly();
++_pCount;
while (!_vm->shouldQuit() && events._vbCount > 0) {
_vm->_sound->playSound(0);
events.pollEventsAndWait();
}
}
events.showCursor();
}
void Plane::mWhileFall() {
Screen &screen = *_vm->_screen;
EventsManager &events = *_vm->_events;
events.hideCursor();
screen.clearScreen();
screen.setBufferScan();
screen.fadeOut();
_vm->_scrollX = 0;
_vm->_room->buildScreen();
_vm->copyBF2Vid();
screen.fadeIn();
_vm->_oldRects.clear();
_vm->_newRects.clear();
_vm->_events->clearEvents();
_vm->_scrollRow = _vm->_scrollCol = 0;
_vm->_scrollX = _vm->_scrollY = 0;
_vm->_player->_scrollAmount = 3;
_vm->_scaleI = 255;
_xCount = 0;
_planeCount = 0;
while (!_vm->shouldQuit() && !events.isKeyMousePressed() &&
(_vm->_scrollCol + screen._vWindowWidth != _vm->_room->_playFieldWidth)) {
events._vbCount = 4;
_vm->_scrollX += _vm->_player->_scrollAmount;
while (_vm->_scrollX >= TILE_WIDTH) {
_vm->_scrollX -= TILE_WIDTH;
++_vm->_scrollCol;
_vm->_buffer1.moveBufferLeft();
_vm->_room->buildColumn(_vm->_scrollCol + screen._vWindowWidth, screen._vWindowBytesWide);
}
scrollFall();
while (!_vm->shouldQuit() && events._vbCount > 0) {
events.pollEventsAndWait();
}
}
events.showCursor();
}
/*------------------------------------------------------------------------*/
Jungle::Jungle(AmazonEngine *vm) : CampScene(vm) {
for (int i = 0; i < JUNGLE_SIZE; ++i) {
_jCnt[i] = _jungleX[i] = -1;
}
}
void Jungle::jungleMove() {
const static int jungleY[3] = { 27, 30, 29 };
int count = 1;
int frameOffset = 0;
if (!_vm->_timers[0]._flag) {
++_vm->_timers[0]._flag;
_vm->_scrollX += _vm->_player->_scrollAmount;
for (int i = 0; i < 3; ++i) {
int newJCnt = (_jCnt[i] + 1) % 8;
_jCnt[i] = newJCnt;
_jungleX[i] += 5;
}
frameOffset = 4;
count = (_vm->_allenFlag != 1) ? 2 : 3;
}
for (int i = 0; i < count; ++i) {
ImageEntry ie;
ie._flags = IMGFLAG_UNSCALED;
ie._spritesPtr = _vm->_objectsTable[24];
ie._frameNumber = _jCnt[i] + frameOffset;
ie._position = Common::Point(_jungleX[i], jungleY[i]);
ie._offsetY = jungleY[i];
_vm->_images.addToList(ie);
frameOffset += 8;
}
}
void Jungle::initJWalk2() {
const int JUNGLE1OBJ[7][4] = {
{ 2, 470, 0, 20 },
{ 0, 290, 0, 50 },
{ 1, 210, 0, 40 },
{ 0, 500, 0, 30 },
{ 1, 550, 0, 20 },
{ 0, 580, 0, 60 },
{ 1, 650, 0, 30 }
};
Screen &screen = *_vm->_screen;
screen.fadeOut();
_vm->_events->hideCursor();
screen.clearScreen();
_vm->_buffer2.clearBuffer();
screen.setBufferScan();
_vm->_scrollX = _vm->_scrollY;
_vm->_scrollCol = _vm->_scrollRow;
_vm->_room->buildScreen();
_vm->copyBF2Vid();
screen.fadeIn();
_vm->_events->clearEvents();
_xCount = 2;
_vm->_player->_scrollAmount = 5;
_xTrack = -10;
_yTrack = _zTrack = 0;
_xCam = 480;
_yCam = 0;
_zCam = 80;
_vm->_timers[24]._timer = 1;
_vm->_timers[24]._initTm = 1;
++_vm->_timers[24]._flag;
_pNumObj = 7;
for (int i = 0; i < _pNumObj; i++) {
_pan[i]._pObject = _vm->_objectsTable[24];
_pan[i]._pImgNum = JUNGLE1OBJ[i][0];
_pan[i]._pObjX = JUNGLE1OBJ[i][1];
_pan[i]._pObjY = JUNGLE1OBJ[i][2];
_pan[i]._pObjZ = JUNGLE1OBJ[i][3];
_pan[i]._pObjXl = _pan[i]._pObjYl = 0;
}
_jCnt[0] = 0;
_jCnt[1] = 3;
_jCnt[2] = 5;
_jungleX[0] = 50;
_jungleX[1] = 16;
_jungleX[2] = 93;
}
void Jungle::mWhileJWalk() {
Screen &screen = *_vm->_screen;
EventsManager &events = *_vm->_events;
Player &player = *_vm->_player;
static const int JUNGLE_OBJ[7][4] = {
{ 2, 77, 0, 40 },
{ 0, 290, 0, 50 },
{ 1, 210, 0, 70 },
{ 0, 50, 0, 30 },
{ 1, 70, 0, 20 },
{ 0, -280, 0, 60 },
{ 1, -150, 0, 30 },
};
screen.fadeOut();
events.hideCursor();
screen.clearScreen();
_vm->_buffer2.clearBuffer();
screen.setBufferScan();
_vm->_scrollX = 0;
// Build the initial jungle scene and fade it in
_vm->_room->buildScreen();
_vm->copyBF2Vid();
screen.fadeIn();
// Set up the player to walk horizontally
player._xFlag = 1;
player._yFlag = 0;
player._moveTo.x = 160;
player._playerMove = true;
_xCount = 2;
_xTrack = 10;
_yTrack = _zTrack = 0;
_xCam = 480;
_yCam = 0;
_zCam = 80;
TimerEntry *te = &_vm->_timers[24];
te->_initTm = te->_timer = 1;
te->_flag++;
_pNumObj = 7;
for (int i = 0; i < _pNumObj; i++) {
_pan[i]._pObject = _vm->_objectsTable[24];
_pan[i]._pImgNum = JUNGLE_OBJ[i][0];
_pan[i]._pObjX = JUNGLE_OBJ[i][1];
_pan[i]._pObjY = JUNGLE_OBJ[i][2];
_pan[i]._pObjZ = JUNGLE_OBJ[i][3];
_pan[i]._pObjXl = _pan[i]._pObjYl = 0;
}
while (!_vm->shouldQuit() && !events.isKeyMousePressed() && (player._xFlag != 2)) {
_vm->_images.clear();
events._vbCount = 6;
_pan[0]._pImgNum = _xCount;
if (_xCount == 2)
++_xCount;
else
--_xCount;
player.checkMove();
player.checkScroll();
pan();
scrollJWalk();
while (!_vm->shouldQuit() && events._vbCount > 0) {
events.pollEventsAndWait();
}
}
_vm->_images.clear();
events.showCursor();
}
void Jungle::mWhileJWalk2() {
Screen &screen = *_vm->_screen;
initJWalk2();
while (!_vm->shouldQuit() && !_vm->_events->isKeyMousePressed() &&
(_vm->_scrollCol + screen._vWindowWidth) != _vm->_room->_playFieldWidth) {
_vm->_images.clear();
_vm->_events->_vbCount = 6;
_pan[0]._pImgNum = _xCount;
jungleMove();
while (_vm->_scrollX >= TILE_WIDTH) {
_vm->_scrollX -= TILE_WIDTH;
++_vm->_scrollCol;
_vm->_buffer1.moveBufferLeft();
_vm->_room->buildColumn(_vm->_scrollCol + screen._vWindowWidth, screen._vWindowBytesWide);
}
if (_xCount == 2)
++_xCount;
else
--_xCount;
pan();
scrollJWalk();
while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0) {
_vm->_events->pollEventsAndWait();
}
}
_vm->_events->showCursor();
}
void Jungle::scrollJWalk() {
_vm->copyBF1BF2();
_vm->_newRects.clear();
_vm->plotList();
_vm->copyRects();
_vm->copyBF2Vid();
}
/*------------------------------------------------------------------------*/
Guard::Guard(AmazonEngine *vm) : PannedScene(vm) {
_guardCel = 0;
_gCode1 = _gCode2 = 0;
_xMid = _yMid = 0;
}
void Guard::setVerticalCode() {
Screen &screen = *_vm->_screen;
_gCode1 = 0;
_gCode2 = 0;
if (_topLeft.x < screen._orgX1)
_gCode1 |= 8;
else if (_topLeft.x == screen._orgX1) {
_gCode1 |= 8;
_gCode1 |= 2;
} else
_gCode1 |= 2;
if (_bottomRight.x < screen._orgX1)
_gCode2 |= 8;
else if (_bottomRight.x == screen._orgX1) {
_gCode2 |= 8;
_gCode2 |= 2;
} else
_gCode2 |= 2;
if (_topLeft.y < screen._orgY1)
_gCode1 |= 4;
else if (_topLeft.y > screen._orgY2)
_gCode1 |= 1;
if (_bottomRight.y < screen._orgY1)
_gCode2 |= 4;
else if (_bottomRight.y > screen._orgY2)
_gCode2 |= 1;
}
void Guard::setHorizontalCode() {
Screen &screen = *_vm->_screen;
_gCode1 = 0;
_gCode2 = 0;
if (_topLeft.y < screen._orgY1)
_gCode1 |= 4;
else if (_topLeft.x == screen._orgX1) {
_gCode1 |= 4;
_gCode1 |= 1;
} else
_gCode1 |= 1;
if (_bottomRight.y < screen._orgY1)
_gCode2 |= 4;
else if (_bottomRight.x == screen._orgX1) {
_gCode2 |= 4;
_gCode2 |= 1;
} else
_gCode2 |= 1;
if (_topLeft.x < screen._orgX1)
_gCode1 |= 8;
else if (_topLeft.x > screen._orgX2)
_gCode1 |= 2;
if (_bottomRight.x < screen._orgX1)
_gCode2 |= 8;
else if (_bottomRight.x > screen._orgX2)
_gCode2 |= 2;
}
void Guard::chkVLine() {
if (_position.x > _vm->_player->_rawPlayer.x) {
_topLeft = _vm->_player->_rawPlayer;
_bottomRight = _position;
} else {
_topLeft = _position;
_bottomRight = _vm->_player->_rawPlayer;
}
if (_vm->_screen->_orgY1 > _vm->_screen->_orgY2)
SWAP(_vm->_screen->_orgY1, _vm->_screen->_orgY2);
for (;;) {
setVerticalCode();
int code = _gCode1 | _gCode2;
if (code == 10) {
_vm->_guardFind = 0;
return;
}
int code2 = _gCode1 & _gCode2;
code2 &= 5;
if (((code & 10) == 8) || ((code & 10) == 2) || (code2 != 0))
return;
int midX = (_topLeft.x + _bottomRight.x) / 2;
int midY = (_topLeft.y + _bottomRight.y) / 2;
if (midX < _vm->_screen->_orgX1) {
if ((midX == _topLeft.x) && (midY == _topLeft.y))
return;
_topLeft.x = midX;
_topLeft.y = midY;
} else {
if ((midX == _bottomRight.x) && (midY == _bottomRight.y))
return;
_bottomRight.x = midX;
_bottomRight.y = midY;
}
}
}
void Guard::chkHLine() {
if (_position.y > _vm->_player->_rawPlayer.y) {
_topLeft = _vm->_player->_rawPlayer;
_bottomRight = _position;
} else {
_topLeft = _position;
_bottomRight = _vm->_player->_rawPlayer;
}
if (_vm->_screen->_orgX1 > _vm->_screen->_orgX2)
SWAP(_vm->_screen->_orgX1, _vm->_screen->_orgX2);
while (true) {
setHorizontalCode();
int code = _gCode1 | _gCode2;
if (code == 5) {
_vm->_guardFind = 0;
return;
}
int code2 = _gCode1 & _gCode2;
code2 &= 10;
if (((code & 5) == 4) || ((code & 5) == 1) || (code2 != 0))
return;
int midX = (_topLeft.x + _bottomRight.x) / 2;
int midY = (_topLeft.y + _bottomRight.y) / 2;
if (midY < _vm->_screen->_orgY1) {
if ((midX == _topLeft.x) && (midY == _topLeft.y))
return;
_topLeft.x = midX;
_topLeft.y = midY;
} else {
if ((midX == _bottomRight.x) && (midY == _bottomRight.y))
return;
_bottomRight.x = midX;
_bottomRight.y = midY;
}
}
}
void Guard::guardSee() {
Screen &screen = *_vm->_screen;
int tmpY = (_vm->_scrollRow << 4) + _vm->_scrollY;
_vm->_flags[140] = 0;
if (tmpY > _position.y)
return;
tmpY += screen._vWindowLinesTall;
tmpY -= 11;
if (tmpY < _position.y)
return;
_vm->_guardFind = 1;
_vm->_flags[140] = 1;
for (uint16 idx = 0; idx < _vm->_room->_plotter._walls.size(); idx++) {
screen._orgX1 = _vm->_room->_plotter._walls[idx].left;
screen._orgY1 = _vm->_room->_plotter._walls[idx].top;
screen._orgX2 = _vm->_room->_plotter._walls[idx].right;
screen._orgY2 = _vm->_room->_plotter._walls[idx].bottom;
if (screen._orgX1 == screen._orgX2) {
chkVLine();
if (_vm->_guardFind == 0)
return;
} else if (screen._orgY1 == screen._orgY2) {
chkHLine();
if (_vm->_guardFind == 0)
return;
}
}
}
void Guard::setGuardFrame() {
ImageEntry ie;
ie._flags = IMGFLAG_UNSCALED;
if (_vm->_guardLocation == 4)
ie._flags |= IMGFLAG_BACKWARDS;
ie._spritesPtr = _vm->_objectsTable[37];
ie._frameNumber = _guardCel;
ie._position = _position;
ie._offsetY = 10;
_vm->_images.addToList(ie);
}
void Guard::doGuard() {
// Skip the code dealing with the guard on the boat (chapter 8)
// if the cheat mode is activated
if (_vm->_cheatFl)
return;
if (_vm->_timers[8]._flag) {
setGuardFrame();
return;
}
++_vm->_timers[8]._flag;
++_guardCel;
int curCel = _guardCel;
switch (_vm->_guardLocation) {
case 1:
// Guard walking down
if (curCel <= 8 || curCel > 13)
_guardCel = curCel = 8;
_position.y += _vm->_player->_walkOffDown[curCel - 8];
guardSee();
if (_position.y >= 272) {
_position.y = 272;
_vm->_guardLocation = 2;
}
break;
case 2:
// Guard walking left
if (curCel <= 43 || curCel > 48)
_guardCel = curCel = 43;
_position.x -= _vm->_player->_walkOffLeft[curCel - 43];
guardSee();
if (_position.x <= 56) {
_position.x = 56;
_vm->_guardLocation = 3;
}
break;
case 3:
// Guard walking up
if (curCel <= 0 || curCel > 5)
_guardCel = curCel = 0;
_position.y -= _vm->_player->_walkOffUp[curCel];
guardSee();
if (_position.y <= 89) {
_position.y = 89;
_vm->_guardLocation = 4;
if (_vm->_flags[121] == 1)
_vm->_guardLocation = 5;
}
break;
default:
// Guard walking right
if (curCel <= 43 || curCel > 48)
_guardCel = curCel = 43;
_position.x += _vm->_player->_walkOffRight[curCel - 43];
guardSee();
if (_position.x >= 127) {
_position.x = 127;
_vm->_guardLocation = 1;
}
break;
}
setGuardFrame();
}
void Guard::setPosition(const Common::Point &pt) {
_position = pt;
}
/*------------------------------------------------------------------------*/
Cast::Cast(AmazonEngine *vm) : PannedScene(vm) {
}
void Cast::doCast(int param1) {
Screen &screen = *_vm->_screen;
_vm->_buffer1.create(_vm->_screen->w, _vm->_screen->h);
_vm->_buffer2.create(_vm->_screen->w, _vm->_screen->h);
screen.setDisplayScan();
_vm->_events->hideCursor();
screen.forceFadeOut();
screen._clipHeight = 173;
screen.clearScreen();
_vm->_chapter = 16;
_vm->tileScreen();
_vm->updateSummary(param1);
screen.setPanel(3);
_vm->_chapter = 14;
Resource *spriteData = _vm->_files->loadFile(91, 0);
_vm->_objectsTable[0] = new SpriteResource(_vm, spriteData);
delete spriteData;
spriteData = _vm->_files->loadFile(91, 1);
_vm->_objectsTable[1] = new SpriteResource(_vm, spriteData);
delete spriteData;
_vm->_files->_setPaletteFlag = false;
_vm->_files->loadScreen(58, 1);
_vm->_buffer2.blitFrom(*_vm->_screen);
_vm->_buffer1.blitFrom(*_vm->_screen);
_xTrack = 0;
_yTrack = -6;
_zTrack = 0;
_xCam = _yCam = 0;
_zCam = 60;
_vm->_timers[24]._timer = 1;
_vm->_timers[24]._initTm = 1;
++_vm->_timers[24]._flag;
_pNumObj = 26;
for (int i = 0; i < _pNumObj; i++) {
_pan[i]._pObject = _vm->_objectsTable[0];
_pan[i]._pImgNum = CAST_END_OBJ[i][0];
_pan[i]._pObjX = CAST_END_OBJ[i][1];
_pan[i]._pObjY = CAST_END_OBJ[i][2];
_pan[i]._pObjZ = CAST_END_OBJ[i][3];
_pan[i]._pObjXl = _pan[i]._pObjYl = 0;
}
_pNumObj += 4;
for (int i = 0; i < 4; i++) {
_pan[26 + i]._pObject = _vm->_objectsTable[1];
_pan[26 + i]._pImgNum = CAST_END_OBJ1[i][0];
_pan[26 + i]._pObjX = CAST_END_OBJ1[i][1];
_pan[26 + i]._pObjY = CAST_END_OBJ1[i][2];
_pan[26 + i]._pObjZ = CAST_END_OBJ1[i][3];
_pan[26 + i]._pObjXl = _pan[26 + i]._pObjYl = 0;
}
_vm->_oldRects.clear();
_vm->_newRects.clear();
_vm->_numAnimTimers = 0;
_vm->_midi->newMusic(58, 0);
screen.forceFadeIn();
while (!_vm->shouldQuit()) {
_vm->_images.clear();
pan();
_vm->_buffer2.blitFrom(_vm->_buffer1);
_vm->_newRects.clear();
_vm->plotList();
_vm->copyBlocks();
for (int idx = 0; idx < 5 && !_vm->shouldQuit() &&
!_vm->_events->isKeyMousePressed(); ++idx)
_vm->_events->pollEventsAndWait();
if (_vm->_events->isKeyMousePressed())
break;
if (_yCam < -7550) {
while (!_vm->shouldQuit() && !_vm->_midi->checkMidiDone())
_vm->_events->pollEventsAndWait();
break;
}
}
_vm->_midi->newMusic(58, 1);
_vm->_events->showCursor();
_vm->freeCells();
_vm->_oldRects.clear();
_vm->_newRects.clear();
_vm->_numAnimTimers = 0;
_vm->_images.clear();
screen.forceFadeOut();
_vm->quitGame();
_vm->_events->pollEvents();
}
/*------------------------------------------------------------------------*/
River::River(AmazonEngine *vm) : PannedScene(vm) {
_chickenOutFl = false;
_rScrollRow = 0;
_rScrollCol = 0;
_rScrollX = 0;
_rScrollY = 0;
_mapOffset = 0;
_screenVertX = 0;
_saveRiver = false;
_deathFlag = false;
_deathCount = 0;
_oldScrollCol = 0;
_maxHits = 0;
_mapPtr = nullptr;
_canoeMoveCount = 0;
_canoeVXPos = 0;
_canoeFrame = 0;
_canoeDir = 0;
_canoeLane = 0;
_canoeYPos = 0;
_hitCount = 0;
_riverIndex = 0;
_topList = _botList = nullptr;
_deathType = 0;
_hitSafe = 0;
}
void River::setRiverPan() {
int delta = (_vm->_scrollCol * 16) + _vm->_scrollX;
_xTrack = 9;
_yTrack = _zTrack = 0;
_xCam = 160;
_yCam = 0;
_zCam = 80;
_vm->_timers[24]._timer = 1;
_vm->_timers[24]._initTm = 1;
++_vm->_timers[24]._flag;
_pNumObj = 23;
for (int i = 0; i < _pNumObj; i++) {
_pan[i]._pObject = _vm->_objectsTable[45];
_pan[i]._pImgNum = RIVER1OBJ[i][0];
_pan[i]._pObjX = RIVER1OBJ[i][1] + delta;
_pan[i]._pObjY = RIVER1OBJ[i][2];
_pan[i]._pObjZ = RIVER1OBJ[i][3];
_pan[i]._pObjXl = _pan[i]._pObjYl = 0;
}
}
void River::initRiver() {
static const int RIVERVXTBL[3] = { 6719, 7039, 8319 };
Screen &screen = *_vm->_screen;
_vm->_events->centerMousePos();
_vm->_events->restrictMouse();
screen.setDisplayScan();
screen.clearScreen();
screen.savePalette();
screen.forceFadeOut();
_vm->_files->_setPaletteFlag = false;
_vm->_files->loadScreen(95, 4);
_vm->_buffer2.blitFrom(*_vm->_screen);
screen.restorePalette();
screen.setBufferScan();
_vm->_destIn = &_vm->_buffer2;
_vm->_room->roomMenu();
if (_saveRiver) {
// Restoring a savegame, so set properties from saved fields
_vm->_scrollRow = _rScrollRow;
_vm->_scrollCol = _rScrollCol;
_vm->_scrollX = _rScrollX;
_vm->_scrollY = _rScrollY;
} else {
// Set initial scene state
_vm->_scrollRow = 0;
_vm->_scrollCol = 140;
_vm->_scrollX = 0;
_vm->_scrollY = 0;
}
_vm->_room->buildScreen();
_vm->copyBF2Vid();
screen.forceFadeIn();
if (!_saveRiver) {
// Reset draw rects
_vm->_oldRects.clear();
_vm->_newRects.clear();
_vm->_events->clearEvents();
}
_vm->_player->_scrollAmount = 2;
setRiverPan();
_vm->_timers[3]._timer = 1;
_vm->_timers[3]._initTm = 1;
++_vm->_timers[3]._flag;
_canoeFrame = 0;
_mapPtr = (const byte *)MAPTBL[_vm->_riverFlag] + 1;
if (_saveRiver) {
_mapPtr--;
_mapPtr += _mapOffset;
} else {
_screenVertX = RIVERVXTBL[_vm->_riverFlag] - 320;
_canoeLane = 3;
_hitCount = 0;
_hitSafe = 0;
_canoeYPos = 71;
}
_riverIndex = _vm->_riverFlag;
_topList = RIVER_OBJECTS[_riverIndex][RIVER_START];
updateObstacles();
riverSetPhysX();
_canoeDir = 0;
_deathFlag = false;
_deathCount = 0;
_vm->_timers[11]._timer = 1200;
_vm->_timers[11]._initTm = 1200;
++_vm->_timers[11]._flag;
_vm->_timers[12]._timer = 1500;
_vm->_timers[12]._initTm = 1500;
++_vm->_timers[12]._flag;
_maxHits = 2 - _vm->_riverFlag;
_saveRiver = false;
// Set font colors for drawing using font2
Font::_fontColors[0] = 0;
Font::_fontColors[1] = 33;
Font::_fontColors[2] = 34;
Font::_fontColors[3] = 35;
}
void River::resetPositions() {
riverSetPhysX();
int val = (_vm->_scrollCol + 1 - _oldScrollCol) * 16;
if (val < 0) {
val |= 0x80;
}
for (int i = 0; i < _pNumObj; i++)
_pan[i]._pObjX += val;
}
void River::checkRiverPan() {
int val = _vm->_scrollCol * 16 + 320;
for (int i = 0; i < _pNumObj; i++) {
if (_pan[i]._pObjX < val)
return;
}
setRiverPan();
}
bool River::riverJumpTest() {
if (_vm->_scrollCol == 120 || _vm->_scrollCol == 60 || _vm->_scrollCol == 0) {
int val = *++_mapPtr;
if (val == 0xFF)
return true;
_oldScrollCol = _vm->_scrollCol;
if (val == 0) {
_vm->_scrollCol = 139;
_vm->_scrollX = 14;
_vm->_room->buildScreen();
resetPositions();
return false;
}
} else if (_vm->_scrollCol == 105) {
int val1 = _mapPtr[1];
int val2 = _mapPtr[2];
_mapPtr += 3;
if (_canoeLane < 3) {
if (val1 != 0) {
_deathFlag = true;
_deathCount = 300;
_deathType = val2;
}
} else {
if (val1 != 1) {
_deathFlag = true;
_deathCount = 300;
_deathType = val2;
}
_oldScrollCol = _vm->_scrollCol;
_vm->_scrollCol = 44;
_vm->_scrollX = 14;
_vm->_room->buildScreen();
resetPositions();
return false;
}
}
_vm->_scrollX = 14;
--_vm->_scrollCol;
_vm->_buffer1.moveBufferRight();
_vm->_room->buildColumn(_vm->_scrollCol, 0);
checkRiverPan();
return false;
}
void River::riverSound() {
if (_vm->_timers[11]._flag == 0) {
++_vm->_timers[11]._flag;
_vm->_sound->playSound(2);
}
if (_vm->_timers[12]._flag == 0) {
++_vm->_timers[12]._flag;
_vm->_sound->playSound(3);
}
if ((_xCam >= 1300) && (_xCam <= 1320))
_vm->_sound->playSound(1);
}
void River::moveCanoe() {
EventsManager &events = *_vm->_events;
Common::Point pt = events.calcRawMouse();
Common::Point mousePos = events.getMousePos();
// Do an event polling
_vm->_canSaveLoad = true;
events.pollEvents();
_vm->_canSaveLoad = false;
if (_vm->_room->_function == FN_CLEAR1)
return;
if (_canoeDir) {
// Canoe movement in progress
moveCanoe2();
} else {
if (events._leftButton && pt.y >= 140) {
if (pt.x < _vm->_room->_rMouse[8][0]) {
// Disk icon wasn't clicked
_vm->_scripts->printString(AMRES.BAR_MESSAGE);
} else {
// Clicked on the Disc icon. Show the ScummVM menu
_vm->_room->handleCommand(9);
if (_vm->_room->_function != FN_CLEAR1) {
_vm->_room->buildScreen();
_vm->copyBF2Vid();
}
}
} else if (events._leftButton && mousePos.x < 35 && mousePos.y < 12) {
// Clicked on the Skip button. So chicken out
_chickenOutFl = true;
} else if ((events._leftButton && pt.y <= _canoeYPos) ||
(!events._leftButton && _vm->_player->_move == UP)) {
// Move canoe up
if (_canoeLane > 0) {
_canoeDir = -1;
_canoeMoveCount = 0;
moveCanoe2();
}
} else if (events._leftButton || _vm->_player->_move == DOWN) {
// Move canoe down
if (_canoeLane < 7) {
_canoeDir = 1;
_canoeMoveCount = 0;
moveCanoe2();
}
}
}
}
void River::moveCanoe2() {
_canoeYPos += _canoeDir;
if (++_canoeMoveCount == 5) {
_canoeLane += _canoeDir;
_canoeDir = 0;
}
}
void River::updateObstacles() {
RiverStruct *cur;
for (cur = _topList; cur < RIVER_OBJECTS[_riverIndex][RIVER_END]; ++cur) {
int val = cur->_riverX + cur->_width - 1;
if (val < _screenVertX)
// Obstacle is not yet on-screen
break;
if (cur->_riverX < (_screenVertX + 319)) {
// Object is now on-screen. So set _topList/_botList to the range
// of river obstacles that are currently visible
_topList = cur;
_botList = cur;
while (cur < RIVER_OBJECTS[_riverIndex][RIVER_END]) {
++cur;
val = cur->_riverX + cur->_width - 1;
if (val < _screenVertX || (cur->_riverX >= (_screenVertX + 319)))
break;
_botList = cur;
}
return;
}
}
cur = _topList;
cur--;
_botList = cur;
}
void River::riverSetPhysX() {
int xAmt = (_vm->_scrollCol * 16) + _vm->_scrollX;
for (RiverStruct *cur = _topList; cur <= _botList; ++cur) {
cur->_xp = xAmt - (_screenVertX - cur->_riverX);
}
}
bool River::checkRiverCollide() {
if (_hitSafe)
return false;
_canoeVXPos = _screenVertX + 170;
for (RiverStruct *cur = _topList; cur <= _botList; ++cur) {
if (cur->_lane < _canoeLane)
continue;
if ((cur->_lane == _canoeLane) || (cur->_lane == _canoeLane + 1)) {
if ((cur->_riverX + cur->_width - 1) >= _canoeVXPos &&
cur->_riverX < (_canoeVXPos + 124)) {
_vm->_sound->playSound(4);
return true;
}
}
}
return false;
}
void River::plotRiver() {
// Handle cycling through the canoe rowing frames
if (_vm->_timers[3]._flag == 0) {
++_vm->_timers[3]._flag;
if (_canoeFrame++ == 12)
_canoeFrame = 0;
}
// Draw the canoe
ImageEntry ie;
ie._flags = IMGFLAG_UNSCALED;
ie._spritesPtr = _vm->_objectsTable[45];
ie._frameNumber = _canoeFrame;
ie._position.x = (_vm->_scrollCol * 16) + _vm->_scrollX + 160;
ie._position.y = _canoeYPos - 41;
ie._offsetY = 41;
_vm->_images.addToList(ie);
// Draw any on-screen obstacles
for (RiverStruct *cur = _topList; cur <= _botList; ++cur) {
if (cur->_id != -1) {
ie._flags = IMGFLAG_UNSCALED;
ie._spritesPtr = _vm->_objectsTable[45];
ie._frameNumber = cur->_id;
ie._position.x = cur->_xp;
ie._position.y = (cur->_lane * 5) + 56 - cur->_offsetY;
ie._offsetY = cur->_offsetY;
_vm->_images.addToList(ie);
}
}
// Draw the text for skipping the river
Font &font2 = *_vm->_fonts._font2;
font2.drawString(_vm->_screen, "SKIP", Common::Point(5, 5));
}
void River::mWhileDownRiver() {
Screen &screen = *_vm->_screen;
_vm->_events->hideCursor();
screen.setDisplayScan();
screen.clearScreen();
screen.savePalette();
if (!_vm->isDemo())
_vm->_files->loadScreen(95, 4);
_vm->_buffer2.blitFrom(*_vm->_screen);
screen.restorePalette();
screen.setPalette();
screen.setBufferScan();
_vm->_scrollX = 0;
_vm->_room->buildScreen();
_vm->copyBF2Vid();
_vm->_player->_scrollAmount = 2;
_vm->_destIn = &_vm->_buffer2;
_xTrack = -7;
_yTrack = _zTrack = 0;
_xCam = _yCam = 0;
_zCam = 80;
_vm->_timers[24]._timer = 1;
_vm->_timers[24]._initTm = 1;
++_vm->_timers[24]._flag;
_pNumObj = 14;
for (int i = 0; i <_pNumObj; i++) {
_pan[i]._pObject = _vm->_objectsTable[33];
_pan[i]._pImgNum = DOWNRIVEROBJ[i][0];
_pan[i]._pObjX = DOWNRIVEROBJ[i][1];
_pan[i]._pObjY = DOWNRIVEROBJ[i][2];
_pan[i]._pObjZ = DOWNRIVEROBJ[i][3];
_pan[i]._pObjXl = _pan[i]._pObjYl = 0;
}
_vm->_timers[3]._timer = 200;
_vm->_timers[3]._initTm = 200;
++_vm->_timers[3]._flag;
_vm->_timers[4]._timer = 350;
_vm->_timers[4]._initTm = 350;
++_vm->_timers[4]._flag;
while (!_vm->shouldQuit() && !_vm->_events->isKeyMousePressed() &&
(_vm->_scrollCol + screen._vWindowWidth != _vm->_room->_playFieldWidth)) {
_vm->_images.clear();
_vm->_events->_vbCount = 6;
_vm->_scrollX += _vm->_player->_scrollAmount;
while (_vm->_scrollX >= TILE_WIDTH) {
_vm->_scrollX -= TILE_WIDTH;
++_vm->_scrollCol;
_vm->_buffer1.moveBufferLeft();
_vm->_room->buildColumn(_vm->_scrollCol + screen._vWindowWidth, screen._vWindowBytesWide);
}
pan();
scrollRiver();
if (!_vm->_timers[3]._flag) {
++_vm->_timers[3]._flag;
_vm->_sound->playSound(1);
} else if (!_vm->_timers[4]._flag) {
++_vm->_timers[4]._flag;
_vm->_sound->playSound(0);
}
while (!_vm->shouldQuit() && _vm->_events->_vbCount > 0) {
_vm->_events->pollEventsAndWait();
}
}
_vm->_events->showCursor();
}
void River::scrollRiver() {
_vm->copyBF1BF2();
_vm->_newRects.clear();
_vm->_buffer2.plotImage(_vm->_objectsTable[33], 0, Common::Point(66, 30));
_vm->plotList();
_vm->copyRects();
_vm->copyBF2Vid();
}
void River::scrollRiver1() {
_vm->copyBF1BF2();
_vm->_newRects.clear();
plotRiver();
_vm->plotList();
_vm->copyRects();
_vm->copyBF2Vid();
}
void River::doRiver() {
static const int RIVERDEATH[5] = { 22, 23, 24, 25, 26 };
initRiver();
_vm->_events->showCursor();
while (!_vm->shouldQuit()) {
_vm->_events->_vbCount = 4;
// Move the river position
_screenVertX -= _vm->_player->_scrollAmount;
if (_vm->_scrollX == 0) {
_vm->_midi->midiRepeat();
if (riverJumpTest()) {
_chickenOutFl = false;
return;
}
} else {
_vm->_scrollX -= _vm->_player->_scrollAmount;
}
if (_chickenOutFl) {
_chickenOutFl = false;
return;
}
_vm->_images.clear();
_vm->_animation->animate(0);
riverSound();
pan();
moveCanoe();
if (_vm->_room->_function != FN_CLEAR1) {
updateObstacles();
riverSetPhysX();
bool checkCollide = checkRiverCollide();
if (_hitSafe != 0)
_hitSafe -= 2;
if (checkCollide) {
_vm->dead(RIVERDEATH[0]);
return;
}
if (_deathFlag) {
if (--_deathCount == 0) {
_vm->dead(RIVERDEATH[_deathType]);
return;
}
}
// Scroll the river
scrollRiver1();
// Allow time for new scrolled river position to be shown
_vm->_canSaveLoad = true;
while (!_vm->shouldQuit() && _vm->_room->_function == FN_NONE &&
_vm->_events->_vbCount > 0) {
_vm->_events->pollEventsAndWait();
}
_vm->_canSaveLoad = false;
}
if (_vm->_room->_function == FN_CLEAR1) {
_vm->_scripts->_endFlag = true;
_vm->_scripts->_returnCode = 0;
_chickenOutFl = false;
break;
}
}
}
void River::synchronize(Common::Serializer &s) {
if (_vm->_player->_roomNumber == 45) {
if (s.isSaving()) {
// Set river properties to be saved out
_rScrollRow = _vm->_scrollRow;
_rScrollCol = _vm->_scrollCol;
_rScrollX = _vm->_scrollX;
_rScrollY = _vm->_scrollY;
_mapOffset = _mapPtr - MAPTBL[_vm->_riverFlag];
}
s.syncAsSint16LE(_canoeLane);
s.syncAsSint16LE(_canoeYPos);
s.syncAsSint16LE(_hitCount);
s.syncAsSint16LE(_riverIndex);
s.syncAsSint16LE(_hitSafe);
s.syncAsUint16LE(_rScrollRow);
s.syncAsUint16LE(_rScrollCol);
s.syncAsSint16LE(_rScrollX);
s.syncAsSint16LE(_rScrollY);
s.syncAsUint16LE(_mapOffset);
s.syncAsUint16LE(_screenVertX);
_saveRiver = s.isLoading();
}
}
/*------------------------------------------------------------------------*/
Ant::Ant(AmazonEngine *vm) : AmazonManager(vm) {
_antDirection = ANT_RIGHT;
_pitDirection = ANT_RIGHT;
_antCel = 0;
_torchCel = 0;
_pitCel = 0;
_stabCel = 0;
_antPos = Common::Point(0, 0);
_antDieFl = _antEatFl = false;
_stabFl = false;
_pitPos = Common::Point(0, 0);
}
void Ant::plotTorchSpear(int indx, const int *&buf) {
int idx = indx;
ImageEntry ie;
ie._flags = IMGFLAG_UNSCALED;
ie._spritesPtr = _vm->_objectsTable[62];
ie._frameNumber = buf[(idx / 2)];
ie._position = Common::Point(_pitPos.x + buf[(idx / 2) + 1], _pitPos.y + buf[(idx / 2) + 2]);
ie._offsetY = 255;
_vm->_images.addToList(ie);
}
void Ant::plotPit(int indx, const int *&buf) {
int idx = indx;
ImageEntry ie;
ie._flags = IMGFLAG_UNSCALED;
ie._spritesPtr = _vm->_objectsTable[62];
ie._frameNumber = buf[(idx / 2)];
ie._position = Common::Point(_pitPos.x, _pitPos.y);
ie._offsetY = _pitPos.y;
_vm->_images.addToList(ie);
_vm->_player->_rawPlayer = _pitPos;
if (_vm->_inventory->_inv[INV_TORCH]._value == ITEM_IN_INVENTORY) {
// Player has torch
idx = _torchCel;
buf = Amazon::TORCH;
_vm->_timers[14]._flag = 1;
idx += 6;
if (buf[idx / 2] == -1)
idx = 0;
_torchCel = idx;
plotTorchSpear(idx, buf);
} else if (!_stabFl && (_vm->_inventory->_inv[INV_KNIFE_SPEAR]._value == ITEM_IN_INVENTORY)) {
// Player has spear
idx = 0;
buf = Amazon::SPEAR;
plotTorchSpear(idx, buf);
}
}
int Ant::antHandleRight(int indx, const int *&buf) {
int retval = indx;
if (_pitDirection == ANT_RIGHT) {
_pitDirection = ANT_LEFT;
_pitPos.y = 127;
}
retval = _pitCel;
buf = Amazon::PITWALK;
if (_pitPos.x < 230) {
if (retval == 0) {
retval = 48;
_pitPos.y = 127;
}
retval -= 6;
_pitPos.x -= buf[(retval / 2) + 1];
_pitPos.y -= buf[(retval / 2) + 2];
_pitCel = retval;
}
return retval;
}
int Ant::antHandleLeft(int indx, const int *&buf) {
int retval = indx;
if (_pitDirection == ANT_LEFT) {
_pitDirection = ANT_RIGHT;
_pitPos.y = 127;
}
retval = _pitCel;
buf = Amazon::PITWALK;
retval += 6;
if (buf[retval / 2] == -1) {
retval = 0;
_pitPos.y = 127;
}
_pitPos.x += buf[(retval / 2) + 1];
_pitPos.y += buf[(retval / 2) + 2];
_pitCel = retval;
return retval;
}
int Ant::antHandleStab(int indx, const int *&buf) {
int retval = indx;
if (_vm->_inventory->_inv[INV_KNIFE_SPEAR]._value == ITEM_IN_INVENTORY) {
if (_stabFl) {
buf = Amazon::PITSTAB;
retval = _stabCel;
if (_vm->_timers[13]._flag == 0) {
_vm->_timers[13]._flag = 1;
retval += 6;
_stabCel = retval;
if (buf[retval] == -1) {
_stabFl = false;
_pitCel = 0;
_pitPos.y = 127;
retval = 0;
buf = Amazon::PITWALK;
} else {
_pitPos.x += buf[(retval / 2) + 1];
_pitPos.y += buf[(retval / 2) + 2];
_pitCel = retval;
}
}
} else {
_stabFl = true;
_pitCel = 0;
retval = 0;
_stabCel = 0;
int dist = _pitPos.x - _antPos.x;
if (_antEatFl && !_antDieFl && (dist <= 80)) {
_antDieFl = true;
_antCel = 0;
_antPos.y = 123;
_vm->_sound->playSound(1);
}
}
}
return retval;
}
void Ant::doAnt() {
_antDirection = ANT_RIGHT;
if (_vm->_aniFlag != 1) {
_vm->_aniFlag = 1;
_antCel = 0;
_torchCel = 0;
_pitCel = 0;
_vm->_timers[15]._timer = 16;
_vm->_timers[15]._initTm = 16;
_vm->_timers[15]._flag = 1;
_vm->_timers[13]._timer = 5;
_vm->_timers[13]._initTm = 5;
_vm->_timers[13]._flag = 1;
_vm->_timers[14]._timer = 10;
_vm->_timers[14]._initTm = 10;
_vm->_timers[14]._flag = 1;
_antPos = Common::Point(-40, 123);
_antDieFl = _antEatFl = false;
_stabFl = false;
_pitPos = Common::Point(_vm->_player->_rawPlayer.x, 127);
}
const int *buf = nullptr;
if (_antDieFl) {
buf = Amazon::ANTDIE;
} else if (_antEatFl) {
buf = Amazon::ANTEAT;
} else if (_antPos.x > 120 && _vm->_flags[198] == 1) {
_antEatFl = true;
_vm->_flags[235] = 1;
_antCel = 0;
buf = Amazon::ANTEAT;
} else {
buf = Amazon::ANTWALK;
if (_vm->_inventory->_inv[INV_TORCH]._value == ITEM_IN_INVENTORY)
// Player has burning torch, which scares the Ant
_antDirection = ANT_LEFT;
}
int idx = _antCel;
if (_vm->_timers[15]._flag == 0) {
_vm->_timers[15]._flag = 1;
if (_antDirection == ANT_LEFT) {
if (_antPos.x > 10) {
if (idx == 0)
idx = 36;
else
idx -= 6;
_antPos -= Common::Point(buf[(idx / 2) + 1], buf[(idx / 2) + 2]);
_antCel = idx;
}
} else {
idx += 6;
if (buf[(idx / 2)] != -1) {
_antPos += Common::Point(buf[(idx / 2) + 1], buf[(idx / 2) + 2]);
_antCel = idx;
} else if (!_antDieFl) {
idx = 0;
_antPos += Common::Point(buf[(idx / 2) + 1], buf[(idx / 2) + 2]);
_antCel = idx;
} else {
idx -= 6;
if (_vm->_flags[200] == 0)
_vm->_flags[200] = 1;
}
}
}
ImageEntry ie;
ie._flags = IMGFLAG_UNSCALED;
ie._spritesPtr = _vm->_objectsTable[61];
ie._frameNumber = buf[(idx / 2)];
ie._position = Common::Point(_antPos.x, _antPos.y);
ie._offsetY = _antPos.y - 70;
_vm->_images.addToList(ie);
_antCel = idx;
if (_vm->_flags[196] != 1) {
idx = _pitCel;
if (_stabFl) {
idx = antHandleStab(idx, buf);
} else {
buf = Amazon::PITWALK;
if (_vm->_timers[13]._flag == 0) {
_vm->_timers[13]._flag = 1;
_vm->_events->pollEvents();
if (_vm->_events->_leftButton) {
// Handle moving the player whilst the mouse button is held down
Common::Point pt = _vm->_events->calcRawMouse();
if (pt.x < _pitPos.x)
idx = antHandleLeft(idx, buf);
else if (pt.x > _pitPos.x)
idx = antHandleRight(idx, buf);
} else {
// Handle movement based on keyboard keys
buf = Amazon::PITWALK;
if (_vm->_player->_move == UP)
idx = antHandleStab(idx, buf);
else if (_vm->_player->_move == LEFT)
idx = antHandleLeft(idx, buf);
else if (_vm->_player->_move == RIGHT)
idx = antHandleRight(idx, buf);
}
}
}
plotPit(idx, buf);
}
if (!_antDieFl) {
int dist = _pitPos.x - _antPos.x;
if ((_antEatFl && (dist <= 45)) || (!_antEatFl && (dist <= 80))) {
_vm->_flags[199] = 1;
_vm->_aniFlag = 0;
}
}
}
void Ant::synchronize(Common::Serializer &s) {
if (_vm->_player->_roomNumber == 61) {
s.syncAsByte(_antDirection);
s.syncAsByte(_pitDirection);
s.syncAsSint16LE(_antCel);
s.syncAsSint16LE(_torchCel);
s.syncAsSint16LE(_pitCel);
s.syncAsSint16LE(_stabCel);
s.syncAsSint16LE(_antPos.x);
s.syncAsSint16LE(_antPos.y);
s.syncAsSint16LE(_pitPos.x);
s.syncAsSint16LE(_pitPos.y);
s.syncAsByte(_antDieFl);
s.syncAsByte(_antEatFl);
s.syncAsByte(_stabFl);
}
}
} // End of namespace Amazon
} // End of namespace Access
Reference in New Issue View Git Blame Copy Permalink