libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-21 01:08:25 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
08db6ea515
scummvm/engines/hopkins/anim.cpp
Strangerke 08db6ea515 HOPKINS: Rename a fading variable
2013-03-27 08:10:40 +01:00

930 lines
27 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 "hopkins/anim.h"
#include "hopkins/files.h"
#include "hopkins/globals.h"
#include "hopkins/graphics.h"
#include "hopkins/hopkins.h"
#include "common/system.h"
#include "graphics/palette.h"
#include "common/file.h"
#include "common/rect.h"
#include "engines/util.h"
namespace Hopkins {
AnimationManager::AnimationManager(HopkinsEngine *vm) {
_vm = vm;
_clearAnimationFl = false;
for (int i = 0; i < 8; ++i)
Common::fill((byte *)&Bank[i], (byte *)&Bank[i] + sizeof(BankItem), 0);
for (int i = 0; i < 35; ++i)
Common::fill((byte *)&_animBqe[i], (byte *)&_animBqe[i] + sizeof(BqeAnimItem), 0);
}
void AnimationManager::clearAll() {
initAnimBqe();
}
/**
* Play Animation
* @param filename Filename of animation to play
* @param rate1 Delay amount before starting animation
* @param rate2 Delay amount between animation frames
* @param rate3 Delay amount after animation finishes
*/
void AnimationManager::playAnim(const Common::String &filename, uint32 rate1, uint32 rate2, uint32 rate3, bool skipSeqFl) {
byte *screenCopy = NULL;
Common::File f;
if (_vm->shouldQuit())
return;
_vm->_eventsManager->mouseOff();
bool hasScreenCopy = false;
byte *screenP = _vm->_graphicsManager->_vesaScreen;
Common::String tmpStr;
// The Windows 95 demo only contains the interlaced version of the BOMBE1 and BOMBE2 videos
if (_vm->getPlatform() == Common::kPlatformWindows && _vm->getIsDemo() && filename == "BOMBE1A.ANM")
tmpStr = "BOMBE1.ANM";
else if (_vm->getPlatform() == Common::kPlatformWindows && _vm->getIsDemo() && filename == "BOMBE2A.ANM")
tmpStr = "BOMBE2.ANM";
else
tmpStr = filename;
if (!f.open(tmpStr))
error("File not found - %s", tmpStr.c_str());
f.skip(6);
f.read(_vm->_graphicsManager->_palette, 800);
f.skip(4);
size_t nbytes = f.readUint32LE();
f.skip(14);
f.read(screenP, nbytes);
if (_clearAnimationFl) {
_vm->_graphicsManager->lockScreen();
_vm->_graphicsManager->clearScreen();
_vm->_graphicsManager->unlockScreen();
}
if (_vm->_graphicsManager->WinScan / 2 > SCREEN_WIDTH) {
hasScreenCopy = true;
screenCopy = _vm->_globals->allocMemory(307200);
memcpy(screenCopy, screenP, 307200);
}
if (skipSeqFl) {
if (hasScreenCopy)
memcpy(screenCopy, _vm->_graphicsManager->_vesaBuffer, 307200);
_vm->_graphicsManager->setPaletteVGA256(_vm->_graphicsManager->_palette);
} else {
_vm->_graphicsManager->setPaletteVGA256(_vm->_graphicsManager->_palette);
_vm->_graphicsManager->lockScreen();
if (hasScreenCopy)
_vm->_graphicsManager->m_scroll16A(screenCopy, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
else
_vm->_graphicsManager->m_scroll16(screenP, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->updateScreen();
}
_vm->_eventsManager->_rateCounter = 0;
_vm->_eventsManager->_escKeyFl = false;
_vm->_soundManager->loadAnimSound();
if (_vm->_globals->iRegul == 1) {
// Do pre-animation delay
do {
if (_vm->_eventsManager->_escKeyFl)
break;
_vm->_eventsManager->refreshEvents();
} while (!_vm->shouldQuit() && _vm->_eventsManager->_rateCounter < rate1);
}
if (!_vm->_eventsManager->_escKeyFl) {
_vm->_eventsManager->_rateCounter = 0;
int frameNumber = 0;
while (!_vm->shouldQuit()) {
++frameNumber;
_vm->_soundManager->playAnimSound(frameNumber);
byte imageStr[17];
// Read frame header
if (f.read(imageStr, 16) != 16)
break;
imageStr[16] = 0;
if (strncmp((const char *)imageStr, "IMAGE=", 6))
break;
f.read(screenP, READ_LE_UINT32(imageStr + 8));
if (_vm->_globals->iRegul == 1) {
do {
if (_vm->_eventsManager->_escKeyFl)
break;
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
} while (!_vm->shouldQuit() && _vm->_eventsManager->_rateCounter < rate2);
}
if (!_vm->_eventsManager->_escKeyFl) {
_vm->_eventsManager->_rateCounter = 0;
_vm->_graphicsManager->lockScreen();
if (hasScreenCopy) {
if (*screenP != kByteStop) {
_vm->_graphicsManager->copyWinscanVbe3(screenP, screenCopy);
_vm->_graphicsManager->m_scroll16A(screenCopy, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
}
} else if (*screenP != kByteStop) {
_vm->_graphicsManager->copyVideoVbe16(screenP);
}
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->updateScreen();
_vm->_soundManager->checkSoundEnd();
}
}
}
if (_vm->_globals->iRegul == 1 && !_vm->_eventsManager->_escKeyFl) {
// Do post-animation delay
do {
if (_vm->_eventsManager->_escKeyFl)
break;
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
} while (_vm->_eventsManager->_rateCounter < rate3);
}
if (!_vm->_eventsManager->_escKeyFl) {
_vm->_eventsManager->_rateCounter = 0;
_vm->_soundManager->checkSoundEnd();
}
if (_vm->_graphicsManager->_fadingFl && !hasScreenCopy) {
screenCopy = _vm->_globals->allocMemory(307200);
f.seek(6);
f.read(_vm->_graphicsManager->_palette, 800);
f.skip(4);
nbytes = f.readUint32LE();
f.skip(14);
f.read(screenP, nbytes);
memcpy(screenCopy, screenP, 307200);
for (;;) {
byte imageStr[17];
if (f.read(imageStr, 16) != 16)
break;
imageStr[16] = 0;
if (strncmp((const char *)imageStr, "IMAGE=", 6))
break;
f.read(screenP, READ_LE_UINT32(imageStr + 8));
if (*screenP != kByteStop)
_vm->_graphicsManager->copyWinscanVbe3(screenP, screenCopy);
}
_vm->_graphicsManager->fadeOutDefaultLength(screenCopy);
screenCopy = _vm->_globals->freeMemory(screenCopy);
}
if (hasScreenCopy) {
if (_vm->_graphicsManager->_fadingFl)
_vm->_graphicsManager->fadeOutDefaultLength(screenCopy);
screenCopy = _vm->_globals->freeMemory(screenCopy);
}
_vm->_graphicsManager->_fadingFl = false;
f.close();
_vm->_graphicsManager->_skipVideoLockFl = false;
_vm->_eventsManager->mouseOn();
}
/**
* Play Animation, type 2
*/
void AnimationManager::playAnim2(const Common::String &filename, uint32 rate1, uint32 rate2, uint32 rate3) {
byte *screenCopy = NULL;
int oldScrollPosX = 0;
byte *screenP = NULL;
Common::File f;
if (_vm->shouldQuit())
return;
_vm->_eventsManager->mouseOff();
bool hasScreenCopy = false;
while (!_vm->shouldQuit()) {
memcpy(_vm->_graphicsManager->_oldPalette, _vm->_graphicsManager->_palette, 769);
if (_vm->_graphicsManager->_lineNbr == SCREEN_WIDTH)
_vm->_saveLoadManager->saveFile("TEMP.SCR", _vm->_graphicsManager->_vesaScreen, 307200);
else if (_vm->_graphicsManager->_lineNbr == (SCREEN_WIDTH * 2))
_vm->_saveLoadManager->saveFile("TEMP.SCR", _vm->_graphicsManager->_vesaScreen, 614400);
if (!_vm->_graphicsManager->_lineNbr)
_vm->_graphicsManager->_scrollOffset = 0;
screenP = _vm->_graphicsManager->_vesaScreen;
if (!f.open(filename))
error("Error opening file - %s", filename.c_str());
f.skip(6);
f.read(_vm->_graphicsManager->_palette, 800);
f.skip(4);
size_t nbytes = f.readUint32LE();
f.skip(14);
f.read(screenP, nbytes);
_vm->_graphicsManager->clearPalette();
oldScrollPosX = _vm->_graphicsManager->_scrollPosX;
_vm->_graphicsManager->setScreenWidth(SCREEN_WIDTH);
_vm->_graphicsManager->scrollScreen(0);
_vm->_graphicsManager->lockScreen();
_vm->_graphicsManager->clearScreen();
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->_maxX = SCREEN_WIDTH;
if (_vm->_graphicsManager->WinScan / 2 > SCREEN_WIDTH) {
hasScreenCopy = true;
screenCopy = _vm->_globals->allocMemory(307200);
memcpy(screenCopy, screenP, 307200);
}
_vm->_graphicsManager->setPaletteVGA256(_vm->_graphicsManager->_palette);
_vm->_graphicsManager->lockScreen();
if (hasScreenCopy)
_vm->_graphicsManager->m_scroll16A(screenCopy, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
else
_vm->_graphicsManager->m_scroll16(screenP, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->updateScreen();
_vm->_eventsManager->_rateCounter = 0;
_vm->_eventsManager->_escKeyFl = false;
_vm->_soundManager->loadAnimSound();
if (_vm->_globals->iRegul == 1) {
while (!_vm->_eventsManager->_escKeyFl && _vm->_eventsManager->_rateCounter < rate1) {
_vm->_eventsManager->refreshEvents();
}
}
break;
}
if (!_vm->_eventsManager->_escKeyFl) {
_vm->_eventsManager->_rateCounter = 0;
int frameNumber = 0;
for (;;) {
if (_vm->_eventsManager->_escKeyFl)
break;
++frameNumber;
_vm->_soundManager->playAnimSound(frameNumber);
byte imageStr[17];
if (f.read(imageStr, 16) != 16)
break;
imageStr[16] = 0;
if (strncmp((const char *)imageStr, "IMAGE=", 6))
break;
f.read(screenP, READ_LE_UINT32(imageStr + 8));
if (_vm->_globals->iRegul == 1) {
while (!_vm->_eventsManager->_escKeyFl && _vm->_eventsManager->_rateCounter < rate2) {
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
}
}
_vm->_eventsManager->_rateCounter = 0;
_vm->_graphicsManager->lockScreen();
if (*screenP != kByteStop) {
if (hasScreenCopy) {
_vm->_graphicsManager->copyWinscanVbe3(screenP, screenCopy);
_vm->_graphicsManager->m_scroll16A(screenCopy, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
} else {
_vm->_graphicsManager->copyVideoVbe16(screenP);
}
}
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->updateScreen();
_vm->_soundManager->checkSoundEnd();
}
if (_vm->_globals->iRegul == 1) {
while (!_vm->_eventsManager->_escKeyFl && _vm->_eventsManager->_rateCounter < rate3) {
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
}
}
}
_vm->_graphicsManager->_skipVideoLockFl = false;
f.close();
if (_vm->_graphicsManager->_fadingFl && !hasScreenCopy) {
f.seek(6);
f.read(_vm->_graphicsManager->_palette, 800);
f.skip(4);
size_t nbytes = f.readUint32LE();
f.skip(14);
f.read(screenP, nbytes);
byte *ptra = _vm->_globals->allocMemory(307200);
memcpy(ptra, screenP, 307200);
for (;;) {
byte imageStr[17];
if (f.read(imageStr, 16) != 16)
break;
imageStr[16] = 0;
if (strncmp((const char *)imageStr, "IMAGE=", 6))
break;
f.read(screenP, READ_LE_UINT32(imageStr + 8));
if (*screenP != kByteStop)
_vm->_graphicsManager->copyWinscanVbe3(screenP, ptra);
}
_vm->_graphicsManager->fadeOutDefaultLength(ptra);
ptra = _vm->_globals->freeMemory(ptra);
}
if (hasScreenCopy) {
if (_vm->_graphicsManager->_fadingFl)
_vm->_graphicsManager->fadeOutDefaultLength(screenCopy);
_vm->_globals->freeMemory(screenCopy);
}
_vm->_graphicsManager->_fadingFl = false;
_vm->_saveLoadManager->load("TEMP.SCR", _vm->_graphicsManager->_vesaScreen);
g_system->getSavefileManager()->removeSavefile("TEMP.SCR");
memcpy(_vm->_graphicsManager->_palette, _vm->_graphicsManager->_oldPalette, 769);
_vm->_graphicsManager->clearPalette();
_vm->_graphicsManager->lockScreen();
_vm->_graphicsManager->clearScreen();
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->_scrollPosX = oldScrollPosX;
_vm->_graphicsManager->scrollScreen(oldScrollPosX);
if (_vm->_graphicsManager->_largeScreenFl) {
_vm->_graphicsManager->setScreenWidth(2 * SCREEN_WIDTH);
_vm->_graphicsManager->_maxX = 2 * SCREEN_WIDTH;
_vm->_graphicsManager->lockScreen();
_vm->_graphicsManager->m_scroll16(_vm->_graphicsManager->_vesaBuffer, _vm->_eventsManager->_startPos.x, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
} else {
_vm->_graphicsManager->setScreenWidth(SCREEN_WIDTH);
_vm->_graphicsManager->_maxX = SCREEN_WIDTH;
_vm->_graphicsManager->lockScreen();
_vm->_graphicsManager->clearScreen();
_vm->_graphicsManager->m_scroll16(_vm->_graphicsManager->_vesaBuffer, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
}
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->fadeInShort();
_vm->_graphicsManager->updateScreen();
_vm->_eventsManager->mouseOn();
}
/**
* Load Animation
*/
void AnimationManager::loadAnim(const Common::String &animName) {
clearAnim();
Common::String filename = animName + ".ANI";
Common::File f;
if (!f.open(filename))
error("Failed to open %s", filename.c_str());
int filesize = f.size();
int nbytes = filesize - 115;
char header[10];
char dummyBuf[15];
char filename1[15];
char filename2[15];
char filename3[15];
char filename4[15];
char filename5[15];
char filename6[15];
f.read(header, 10);
f.read(dummyBuf, 15);
f.read(filename1, 15);
f.read(filename2, 15);
f.read(filename3, 15);
f.read(filename4, 15);
f.read(filename5, 15);
f.read(filename6, 15);
if (READ_BE_UINT32(header) != MKTAG('A', 'N', 'I', 'S'))
error("Invalid animation File: %s", filename.c_str());
const char *files[6] = { &filename1[0], &filename2[0], &filename3[0], &filename4[0],
&filename5[0], &filename6[0] };
for (int idx = 0; idx <= 5; ++idx) {
if (files[idx][0]) {
if (!f.exists(files[idx]))
error("Missing file %s in animation File: %s", files[idx], filename.c_str());
if (loadSpriteBank(idx + 1, files[idx]))
error("Invalid sprite bank in animation File: %s", filename.c_str());
}
}
byte *data = _vm->_globals->allocMemory(nbytes + 1);
f.read(data, nbytes);
f.close();
for (int idx = 1; idx <= 20; ++idx)
searchAnim(data, idx, nbytes);
_vm->_globals->freeMemory(data);
}
/**
* Clear animation
*/
void AnimationManager::clearAnim() {
for (int idx = 0; idx < 35; ++idx) {
_animBqe[idx]._data = _vm->_globals->freeMemory(_animBqe[idx]._data);
_animBqe[idx]._enabledFl = false;
}
for (int idx = 0; idx < 8; ++idx) {
Bank[idx]._data = _vm->_globals->freeMemory(Bank[idx]._data);
Bank[idx]._loadedFl = false;
Bank[idx]._filename = "";
Bank[idx]._fileHeader = 0;
}
}
/**
* Load Sprite Bank
*/
int AnimationManager::loadSpriteBank(int idx, const Common::String &filename) {
int result = 0;
Bank[idx]._loadedFl = true;
Bank[idx]._filename = filename;
byte *fileDataPtr = _vm->_fileManager->loadFile(filename);
Bank[idx]._fileHeader = 0;
if (fileDataPtr[1] == 'L' && fileDataPtr[2] == 'E')
Bank[idx]._fileHeader = 1;
else if (fileDataPtr[1] == 'O' && fileDataPtr[2] == 'R')
Bank[idx]._fileHeader = 2;
if (!Bank[idx]._fileHeader) {
_vm->_globals->freeMemory(fileDataPtr);
Bank[idx]._loadedFl = false;
result = -1;
}
Bank[idx]._data = fileDataPtr;
int objectDataIdx = 0;
for(objectDataIdx = 0; objectDataIdx <= 249; objectDataIdx++) {
int width = _vm->_objectsManager->getWidth(fileDataPtr, objectDataIdx);
int height = _vm->_objectsManager->getHeight(fileDataPtr, objectDataIdx);
if (!width && !height)
break;
}
if (objectDataIdx > 249) {
_vm->_globals->freeMemory(fileDataPtr);
Bank[idx]._loadedFl = false;
result = -2;
}
Bank[idx]._objDataIdx = objectDataIdx;
Common::String ofsFilename = Bank[idx]._filename;
char ch;
do {
ch = ofsFilename.lastChar();
ofsFilename.deleteLastChar();
} while (ch != '.');
ofsFilename += ".OFS";
Common::File f;
if (f.exists(ofsFilename)) {
byte *ofsData = _vm->_fileManager->loadFile(ofsFilename);
byte *curOfsData = ofsData;
for (int objIdx = 0; objIdx < Bank[idx]._objDataIdx; ++objIdx, curOfsData += 8) {
int x1 = READ_LE_INT16(curOfsData);
int y1 = READ_LE_INT16(curOfsData + 2);
int x2 = READ_LE_INT16(curOfsData + 4);
int y2 = READ_LE_INT16(curOfsData + 6);
_vm->_objectsManager->setOffsetXY(Bank[idx]._data, objIdx, x1, y1, 0);
if (Bank[idx]._fileHeader == 2)
_vm->_objectsManager->setOffsetXY(Bank[idx]._data, objIdx, x2, y2, 1);
}
_vm->_globals->freeMemory(ofsData);
result = 0;
}
return result;
}
/**
* Search Animation
*/
void AnimationManager::searchAnim(const byte *data, int animIndex, int bufSize) {
for (int dataIdx = 0; dataIdx <= bufSize; dataIdx++) {
if (READ_BE_UINT32(&data[dataIdx]) == MKTAG('A', 'N', 'I', 'M')) {
int entryIndex = data[dataIdx + 4];
if (animIndex == entryIndex) {
int curBufferPos = dataIdx + 5;
int count = 0;
bool innerLoopCond = false;
do {
if (READ_BE_UINT32(&data[curBufferPos]) == MKTAG('A', 'N', 'I', 'M') || READ_BE_UINT24(&data[curBufferPos]) == MKTAG24('F', 'I', 'N'))
innerLoopCond = true;
if (bufSize < curBufferPos) {
_animBqe[animIndex]._enabledFl = false;
_animBqe[animIndex]._data = g_PTRNUL;
return;
}
++curBufferPos;
++count;
} while (!innerLoopCond);
_animBqe[animIndex]._data = _vm->_globals->allocMemory(count + 50);
_animBqe[animIndex]._enabledFl = true;
memcpy(_animBqe[animIndex]._data, data + dataIdx + 5, 20);
byte *dataP = _animBqe[animIndex]._data;
int curDestDataIndx = 20;
int curSrcDataIndx = dataIdx + 25;
for (int i = 0; i <= 4999; i++) {
memcpy(dataP + curDestDataIndx, data + curSrcDataIndx, 10);
if (!READ_LE_UINT16(data + curSrcDataIndx + 4))
break;
curDestDataIndx += 10;
curSrcDataIndx += 10;
}
break;
}
}
if (READ_BE_UINT24(&data[dataIdx]) == MKTAG24('F', 'I', 'N'))
break;
}
}
/**
* Play sequence
*/
void AnimationManager::playSequence(const Common::String &file, uint32 rate1, uint32 rate2, uint32 rate3, bool skipEscFl, bool skipSeqFl, bool noColFl) {
if (_vm->shouldQuit())
return;
bool hasScreenCopy = false;
_vm->_eventsManager->_mouseFl = false;
if (!noColFl) {
_vm->_eventsManager->refreshScreenAndEvents();
if (_vm->_graphicsManager->_lineNbr == SCREEN_WIDTH)
_vm->_saveLoadManager->saveFile("TEMP.SCR", _vm->_graphicsManager->_vesaScreen, 307200);
else if (_vm->_graphicsManager->_lineNbr == (SCREEN_WIDTH * 2))
_vm->_saveLoadManager->saveFile("TEMP.SCR", _vm->_graphicsManager->_vesaScreen, 614400);
if (!_vm->_graphicsManager->_lineNbr)
_vm->_graphicsManager->_scrollOffset = 0;
}
byte *screenP = _vm->_graphicsManager->_vesaScreen;
Common::File f;
if (!f.open(file))
error("Error opening file - %s", file.c_str());
f.skip(6);
f.read(_vm->_graphicsManager->_palette, 800);
f.skip(4);
size_t nbytes = f.readUint32LE();
f.skip(14);
f.read(screenP, nbytes);
byte *screenCopy = NULL;
if (_vm->_graphicsManager->WinScan / 2 > SCREEN_WIDTH) {
hasScreenCopy = true;
screenCopy = _vm->_globals->allocMemory(307200);
memcpy(screenCopy, screenP, 307200);
}
if (skipSeqFl) {
if (hasScreenCopy)
memcpy(screenCopy, _vm->_graphicsManager->_vesaBuffer, 307200);
if (!_vm->getIsDemo()) {
_vm->_graphicsManager->SETCOLOR3(252, 100, 100, 100);
_vm->_graphicsManager->SETCOLOR3(253, 100, 100, 100);
_vm->_graphicsManager->SETCOLOR3(251, 100, 100, 100);
_vm->_graphicsManager->SETCOLOR3(254, 0, 0, 0);
}
_vm->_graphicsManager->setPaletteVGA256(_vm->_graphicsManager->_palette);
} else {
_vm->_graphicsManager->lockScreen();
if (hasScreenCopy)
_vm->_graphicsManager->m_scroll16A(screenCopy, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
else
_vm->_graphicsManager->m_scroll16(screenP, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->updateScreen();
}
bool skipFl = false;
if (noColFl)
_vm->_graphicsManager->fadeInDefaultLength(screenP);
_vm->_eventsManager->_rateCounter = 0;
_vm->_eventsManager->_escKeyFl = false;
_vm->_soundManager->loadAnimSound();
if (_vm->_globals->iRegul == 1) {
do {
if (_vm->shouldQuit() || (_vm->_eventsManager->_escKeyFl && !skipEscFl)) {
skipFl = true;
break;
}
_vm->_eventsManager->_escKeyFl = false;
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
} while (_vm->_eventsManager->_rateCounter < rate1);
}
_vm->_eventsManager->_rateCounter = 0;
if (!skipFl) {
int soundNumber = 0;
for (;;) {
++soundNumber;
_vm->_soundManager->playAnimSound(soundNumber);
byte imageStr[17];
if (f.read(imageStr, 16) != 16)
break;
imageStr[16] = 0;
if (strncmp((const char *)imageStr, "IMAGE=", 6))
break;
f.read(screenP, READ_LE_UINT32(imageStr + 8));
if (_vm->_globals->iRegul == 1) {
do {
if (_vm->shouldQuit() || (_vm->_eventsManager->_escKeyFl && !skipEscFl)) {
skipFl = true;
break;
}
_vm->_eventsManager->_escKeyFl = false;
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
} while (_vm->_eventsManager->_rateCounter < rate2);
}
if (skipFl)
break;
_vm->_eventsManager->_rateCounter = 0;
_vm->_graphicsManager->lockScreen();
if (hasScreenCopy) {
if (*screenP != kByteStop) {
_vm->_graphicsManager->copyWinscanVbe(screenP, screenCopy);
_vm->_graphicsManager->m_scroll16A(screenCopy, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
}
} else if (*screenP != kByteStop) {
_vm->_graphicsManager->copyVideoVbe16a(screenP);
}
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->updateScreen();
_vm->_soundManager->checkSoundEnd();
}
}
if (_vm->_globals->iRegul == 1 && !skipFl) {
do {
if (_vm->shouldQuit() || (_vm->_eventsManager->_escKeyFl && !skipEscFl)) {
skipFl = true;
break;
}
_vm->_eventsManager->_escKeyFl = false;
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
} while (_vm->_eventsManager->_rateCounter < rate3);
}
if (!skipFl)
_vm->_eventsManager->_rateCounter = 0;
_vm->_graphicsManager->_skipVideoLockFl = false;
f.close();
if (!noColFl) {
_vm->_saveLoadManager->load("TEMP.SCR", _vm->_graphicsManager->_vesaScreen);
g_system->getSavefileManager()->removeSavefile("TEMP.SCR");
_vm->_eventsManager->_mouseFl = true;
}
if (hasScreenCopy)
_vm->_globals->freeMemory(screenCopy);
}
/**
* Play Sequence type 2
*/
void AnimationManager::playSequence2(const Common::String &file, uint32 rate1, uint32 rate2, uint32 rate3, bool skipSeqFl) {
byte *screenCopy = NULL;
byte *screenP;
int frameNumber;
Common::File f;
bool multiScreenFl = false;
for (;;) {
if (_vm->shouldQuit())
return;
_vm->_eventsManager->_mouseFl = false;
screenP = _vm->_graphicsManager->_vesaScreen;
if (!f.open(file))
error("File not found - %s", file.c_str());
f.skip(6);
f.read(_vm->_graphicsManager->_palette, 800);
f.skip(4);
size_t nbytes = f.readUint32LE();
f.skip(14);
f.read(screenP, nbytes);
if (_vm->_graphicsManager->WinScan / 2 > SCREEN_WIDTH) {
multiScreenFl = true;
screenCopy = _vm->_globals->allocMemory(307200);
memcpy((void *)screenCopy, screenP, 307200);
}
if (skipSeqFl) {
if (multiScreenFl) {
assert(screenCopy != NULL);
memcpy((void *)screenCopy, _vm->_graphicsManager->_vesaBuffer, 307200);
}
_vm->_graphicsManager->setPaletteVGA256(_vm->_graphicsManager->_palette);
} else {
_vm->_graphicsManager->lockScreen();
_vm->_graphicsManager->setPaletteVGA256(_vm->_graphicsManager->_palette);
if (multiScreenFl)
_vm->_graphicsManager->m_scroll16A(screenCopy, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
else
_vm->_graphicsManager->m_scroll16(screenP, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->updateScreen();
}
_vm->_eventsManager->_rateCounter = 0;
_vm->_eventsManager->_escKeyFl = false;
_vm->_soundManager->loadAnimSound();
if (_vm->_globals->iRegul == 1) {
do {
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
} while (!_vm->shouldQuit() && !_vm->_eventsManager->_escKeyFl && _vm->_eventsManager->_rateCounter < rate1);
}
break;
}
if (!_vm->_eventsManager->_escKeyFl) {
_vm->_eventsManager->_rateCounter = 0;
frameNumber = 0;
while (!_vm->shouldQuit()) {
_vm->_soundManager->playAnimSound(frameNumber++);
byte imageStr[17];
if (f.read(imageStr, 16) != 16)
break;
imageStr[16] = 0;
if (strncmp((const char *)imageStr, "IMAGE=", 6))
break;
f.read(screenP, READ_LE_UINT32(imageStr + 8));
if (_vm->_globals->iRegul == 1) {
do {
_vm->_eventsManager->refreshEvents();
} while (!_vm->shouldQuit() && !_vm->_eventsManager->_escKeyFl && _vm->_eventsManager->_rateCounter < rate2);
}
_vm->_eventsManager->_rateCounter = 0;
_vm->_graphicsManager->lockScreen();
if (multiScreenFl) {
if (*screenP != kByteStop) {
_vm->_graphicsManager->copyWinscanVbe(screenP, screenCopy);
_vm->_graphicsManager->m_scroll16A(screenCopy, 0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
}
} else if (*screenP != kByteStop) {
_vm->_graphicsManager->copyVideoVbe16a(screenP);
}
_vm->_graphicsManager->unlockScreen();
_vm->_graphicsManager->addRefreshRect(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
_vm->_graphicsManager->updateScreen();
_vm->_soundManager->checkSoundEnd();
}
}
if (_vm->_globals->iRegul == 1) {
// Wait for third rate delay
do {
_vm->_eventsManager->refreshEvents();
_vm->_soundManager->checkSoundEnd();
} while (!_vm->shouldQuit() && !_vm->_eventsManager->_escKeyFl && _vm->_eventsManager->_rateCounter < rate3);
}
_vm->_eventsManager->_rateCounter = 0;
if (_vm->_graphicsManager->_fadingFl && !multiScreenFl) {
byte *ptra = _vm->_globals->allocMemory(307200);
f.seek(6);
f.read(_vm->_graphicsManager->_palette, 800);
f.skip(4);
size_t nbytes = f.readUint32LE();
f.skip(14);
f.read(screenP, nbytes);
memcpy(ptra, screenP, 307200);
for (;;) {
byte imageStr[17];
if (f.read(imageStr, 16) != 16)
break;
imageStr[16] = 0;
if (strncmp((const char *)imageStr, "IMAGE=", 6))
break;
f.read(screenP, READ_LE_UINT32(imageStr + 8));
if (*screenP != kByteStop)
_vm->_graphicsManager->copyWinscanVbe(screenP, ptra);
}
_vm->_graphicsManager->fadeOutDefaultLength(ptra);
ptra = _vm->_globals->freeMemory(ptra);
}
if (multiScreenFl) {
if (_vm->_graphicsManager->_fadingFl)
_vm->_graphicsManager->fadeOutDefaultLength(screenCopy);
_vm->_globals->freeMemory(screenCopy);
}
_vm->_graphicsManager->_fadingFl = false;
f.close();
_vm->_eventsManager->_mouseFl = true;
}
void AnimationManager::initAnimBqe() {
for (int idx = 0; idx < 35; ++idx) {
_animBqe[idx]._data = g_PTRNUL;
_animBqe[idx]._enabledFl = false;
}
for (int idx = 0; idx < 8; ++idx) {
Bank[idx]._data = g_PTRNUL;
Bank[idx]._loadedFl = false;
Bank[idx]._filename = "";
Bank[idx]._fileHeader = 0;
}
}
} // End of namespace Hopkins
Reference in New Issue View Git Blame Copy Permalink