libretro/scummvm
1
0
Fork 0
mirror of https://github.com/libretro/scummvm.git synced 2024-12-21 09:21:08 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
0d50c67a3e
scummvm/engines/cge/snail.cpp
Eugene Sandulenko eb3d556e15 CGE: Plug memory leak. CID 1003914
2013-04-26 07:59:53 +03:00

1269 lines
35 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.
*
*/
/*
* This code is based on original Soltys source code
* Copyright (c) 1994-1995 Janus B. Wisniewski and L.K. Avalon
*/
#include "cge/general.h"
#include "cge/sound.h"
#include "cge/snail.h"
#include "cge/vga13h.h"
#include "cge/text.h"
#include "cge/cge_main.h"
#include "cge/events.h"
#include "cge/walk.h"
namespace CGE {
const char *CommandHandler::_commandText[] = {
"LABEL", "PAUSE", "WAIT", "LEVEL", "HIDE",
"SAY", "INF", "TIME", "CAVE", "KILL",
"RSEQ", "SEQ", "SEND", "SWAP", "KEEP",
"GIVE", "IF", "GAME", "SETX0", "SETY0",
"SLAVE", "SETXY", "RELX", "RELY", "RELZ",
"SETX", "SETY", "SETZ", "TRANS", "PORT",
"NEXT", "NNEXT", "TNEXT", "RNNEXT", "RTNEXT",
"RMNEAR", "RMTAKE", "FLAG", "SETREF", "BACKPT",
"FLASH", "LIGHT", "SETHB", "SETVB", "WALK",
"REACH", "COVER", "UNCOVER", "CLEAR", "TALK",
"MOUSE", "SOUND", "COUNT", NULL
};
CommandHandler::CommandHandler(CGEEngine *vm, bool turbo)
: _turbo(turbo), _busy(false), _textDelay(false),
_timerExpiry(0), _talkEnable(true),
_head(0), _tail(0), _commandList((Command *)malloc(sizeof(Command) * 256)), _vm(vm) {
}
CommandHandler::~CommandHandler() {
free(_commandList);
}
/**
* Add a Command on the head of _commandList
* @param com Command
* @param ref Reference
* @param val Value
* @param ptr Sprite pointer
*/
void CommandHandler::addCommand(CommandType com, int ref, int val, void *ptr) {
Command *headCmd = &_commandList[_head++];
headCmd->_commandType = com;
headCmd->_ref = ref;
headCmd->_val = val;
headCmd->_spritePtr = ptr;
headCmd->_cbType = kNullCB;
if (headCmd->_commandType == kCmdClear) {
_tail = _head;
_vm->killText();
_timerExpiry = 0;
}
}
/**
* Add a Callback on the head of _commandList
* @param com Command
* @param ref Reference
* @param val Value
* @param CallbackType Callback type
*/
void CommandHandler::addCallback(CommandType com, int ref, int val, CallbackType cbType) {
Command *headCmd = &_commandList[_head++];
headCmd->_commandType = com;
headCmd->_ref = ref;
headCmd->_val = val;
headCmd->_spritePtr = NULL;
headCmd->_cbType = cbType;
if (headCmd->_commandType == kCmdClear) {
_tail = _head;
_vm->killText();
_timerExpiry = 0;
}
}
/**
* Add a Command on the tail of _commandList
* @param com Command
* @param ref Reference
* @param val Value
* @param ptr Sprite pointer
*/
void CommandHandler::insertCommand(CommandType com, int ref, int val, void *ptr) {
Command *tailCmd;
if (_busy) {
_commandList[(_tail - 1) & 0xFF] = _commandList[_tail];
tailCmd = &_commandList[_tail];
} else
tailCmd = &_commandList[(_tail - 1) & 0xFF];
_tail--;
tailCmd->_commandType = com;
tailCmd->_ref = ref;
tailCmd->_val = val;
tailCmd->_spritePtr = ptr;
tailCmd->_cbType = kNullCB;
if (tailCmd->_commandType == kCmdClear) {
_tail = _head;
_vm->killText();
_timerExpiry = 0;
}
}
void CommandHandler::runCommand() {
if (_busy)
return;
_busy = true;
uint8 tmpHead = _head;
while (_tail != tmpHead) {
Command *tailCmd = &_commandList[_tail];
if (!_turbo) { // only for the slower one
if (_timerExpiry) {
// Delay in progress
if (_timerExpiry > g_system->getMillis())
// Delay not yet ended
break;
// Delay is finished
_timerExpiry = 0;
} else {
if (_textDelay) {
_vm->killText();
_textDelay = false;
}
}
if (_vm->_talk && tailCmd->_commandType != kCmdPause)
break;
}
Sprite *spr = ((tailCmd->_ref >= 0) ? _vm->locate(tailCmd->_ref) : ((Sprite *) tailCmd->_spritePtr));
switch (tailCmd->_commandType) {
case kCmdLabel:
break;
case kCmdPause:
_timerExpiry = g_system->getMillis() + tailCmd->_val * kCommandFrameDelay;
if (_vm->_talk)
_textDelay = true;
break;
case kCmdWait:
if (spr) {
if (spr->seqTest(tailCmd->_val) &&
(tailCmd->_val >= 0 || spr != _vm->_hero || _vm->_hero->_tracePtr < 0)) {
_timerExpiry = g_system->getMillis() + spr->_time * kCommandFrameDelay;
} else {
_busy = false;
return;
}
}
break;
case kCmdLevel:
_vm->snLevel(spr, tailCmd->_val);
break;
case kCmdHide:
_vm->snHide(spr, tailCmd->_val);
break;
case kCmdSay:
if (spr && _talkEnable) {
if (spr == _vm->_hero && spr->seqTest(-1))
spr->step(kSeqHTalk);
_vm->_text->say(_vm->_text->getText(tailCmd->_val), spr);
_vm->_sys->_funDel = kHeroFun0;
}
break;
case kCmdInf:
if (_talkEnable) {
_vm->inf(_vm->_text->getText(tailCmd->_val), true);
_vm->_sys->_funDel = kHeroFun0;
}
break;
case kCmdTime:
if (spr && _talkEnable) {
if (spr == _vm->_hero && spr->seqTest(-1))
spr->step(kSeqHTalk);
_vm->_text->sayTime(spr);
}
break;
case kCmdCave:
_vm->switchScene(tailCmd->_val);
break;
case kCmdKill:
_vm->snKill(spr);
break;
case kCmdSeq:
_vm->snSeq(spr, tailCmd->_val);
break;
case kCmdRSeq:
_vm->snRSeq(spr, tailCmd->_val);
break;
case kCmdSend:
_vm->snSend(spr, tailCmd->_val);
break;
case kCmdSwap:
_vm->snSwap(spr, tailCmd->_val);
break;
case kCmdCover:
_vm->snCover(spr, tailCmd->_val);
break;
case kCmdUncover:
_vm->snUncover(spr, (tailCmd->_val >= 0) ? _vm->locate(tailCmd->_val) : ((Sprite *) tailCmd->_spritePtr));
break;
case kCmdKeep:
_vm->snKeep(spr, tailCmd->_val);
break;
case kCmdGive:
_vm->snGive(spr, tailCmd->_val);
break;
case kCmdGame:
_vm->snGame(spr, tailCmd->_val);
break;
case kCmdSetX0:
_vm->snSetX0(tailCmd->_ref, tailCmd->_val);
break;
case kCmdSetY0:
_vm->snSetY0(tailCmd->_ref, tailCmd->_val);
break;
case kCmdSetXY:
_vm->snSetXY(spr, tailCmd->_val);
break;
case kCmdRelX:
_vm->snRelX(spr, tailCmd->_val);
break;
case kCmdRelY:
_vm->snRelY(spr, tailCmd->_val);
break;
case kCmdRelZ:
_vm->snRelZ(spr, tailCmd->_val);
break;
case kCmdSetX:
_vm->snSetX(spr, tailCmd->_val);
break;
case kCmdSetY:
_vm->snSetY(spr, tailCmd->_val);
break;
case kCmdSetZ:
_vm->snSetZ(spr, tailCmd->_val);
break;
case kCmdSlave:
_vm->snSlave(spr, tailCmd->_val);
break;
case kCmdTrans:
_vm->snTrans(spr, tailCmd->_val);
break;
case kCmdPort:
_vm->snPort(spr, tailCmd->_val);
break;
case kCmdNext:
case kCmdIf:
case kCmdTalk:
break;
case kCmdMouse:
_vm->snMouse(tailCmd->_val != 0);
break;
case kCmdNNext:
_vm->snNNext(spr, tailCmd->_val);
break;
case kCmdTNext:
_vm->snTNext(spr, tailCmd->_val);
break;
case kCmdRNNext:
_vm->snRNNext(spr, tailCmd->_val);
break;
case kCmdRTNext:
_vm->snRTNext(spr, tailCmd->_val);
break;
case kCmdRMNear:
_vm->snRmNear(spr);
break;
case kCmdRmTake:
_vm->snRmTake(spr);
break;
case kCmdFlag:
_vm->snFlag(tailCmd->_ref & 3, tailCmd->_val != 0);
break;
case kCmdSetRef:
_vm->snSetRef(spr, tailCmd->_val);
break;
case kCmdBackPt:
_vm->snBackPt(spr, tailCmd->_val);
break;
case kCmdFlash:
_vm->snFlash(tailCmd->_val != 0);
break;
case kCmdLight:
_vm->snLight(tailCmd->_val != 0);
break;
case kCmdSetHBarrier:
_vm->snHBarrier(tailCmd->_ref, tailCmd->_val);
break;
case kCmdSetVBarrier:
_vm->snVBarrier(tailCmd->_ref, tailCmd->_val);
break;
case kCmdWalk:
_vm->snWalk(spr, tailCmd->_ref, tailCmd->_val);
break;
case kCmdReach:
_vm->snReach(spr, tailCmd->_val);
break;
case kCmdSound:
_vm->snSound(spr, tailCmd->_val);
break;
case kCmdCount:
_vm->_sound->setRepeat(tailCmd->_val);
break;
case kCmdExec:
switch (tailCmd->_cbType) {
case kQGame:
_vm->qGame();
break;
case kMiniStep:
_vm->miniStep(tailCmd->_val);
break;
case kXScene:
_vm->xScene();
break;
case kSoundSetVolume:
_vm->sndSetVolume();
break;
default:
error("Unknown Callback Type in SNEXEC");
}
break;
case kCmdStep:
spr->step();
break;
case kCmdZTrim:
_vm->snZTrim(spr);
break;
case kCmdGhost:
_vm->snGhost((Bitmap *) tailCmd->_spritePtr);
break;
default:
warning("Unhandled snc->_com in SNMouse(bool)");
break;
}
_tail++;
if (!_turbo)
break;
}
_busy = false;
}
bool CommandHandler::idle() {
return (_head == _tail);
}
void CommandHandler::reset() {
_tail = _head;
}
/**
* Handles mini-Games logic
* @param com Command
* @param num mini game number
*/
void CGEEngine::snGame(Sprite *spr, int num) {
debugC(1, kCGEDebugEngine, "CGEEngine::snGame(spr, %d)", num);
switch (num) {
case 1: {
static Sprite *dup[3] = { NULL, NULL, NULL };
int buref = 0;
int Stage = 0;
for (dup[0] = _vga->_showQ->first(); dup[0]; dup[0] = dup[0]->_next) {
buref = dup[0]->_ref;
if (buref / 1000 == 16 && buref % 100 == 6) {
Stage = (buref / 100) % 10;
break;
}
}
if (dup[1] == NULL) {
dup[1] = _vga->_showQ->locate(16003); // pan
dup[2] = _vga->_showQ->locate(16004); // pani
}
if (_game) { // continue game
int i = newRandom(3), hand = (dup[0]->_shpCnt == 6);
Stage++;
if (hand && Stage > kDressed)
++hand;
if (i >= 0 && (dup[i] == spr && newRandom(3) == 0)) {
_commandHandler->addCommand(kCmdSeq, -1, 3, dup[0]); // Yes
_commandHandler->addCommand(kCmdSeq, -1, 3, dup[1]); // Yes
_commandHandler->addCommand(kCmdSeq, -1, 3, dup[2]); // Yes
_commandHandler->addCommand(kCmdTNext, -1, 0, dup[0]); // Reset Take
_commandHandler->addCommand(kCmdTNext, -1, 0, dup[1]); // Reset Take
_commandHandler->addCommand(kCmdTNext, -1, 0, dup[2]); // Reset Take
_commandHandler->addCommand(kCmdNNext, -1, 0, dup[0]); // Reset Near
_commandHandler->addCommand(kCmdPause, -1, 72, NULL); // Pause the game for 72/80 second
_commandHandler->addCommand(kCmdSay, 1, 16009, NULL); // Say "I win.."
_commandHandler->addCommand(kCmdSay, buref, 16010, NULL); // Say "Go Sit..."
_commandHandler->addCommand(kCmdSay, 1, 16011, NULL); // Say "I prefer not"
if (hand) {
_commandHandler->addCommand(kCmdSend, 16060 + hand, 16, NULL); // Give hand
_commandHandler->addCommand(kCmdSeq, buref, 4, NULL); // Take off
_commandHandler->addCommand(kCmdSeq, 16060 + hand, 1, NULL); // start one of the Bartender animations
_commandHandler->addCommand(kCmdSound, 16060 + hand, 16002, NULL); // Play tear sound
_commandHandler->addCommand(kCmdWait, 16060 + hand, 3, NULL); // Take up
_commandHandler->addCommand(kCmdSwap, buref, buref + 100, NULL); // Open hand
_commandHandler->addCommand(kCmdSeq, 16016, Stage, NULL); // Start Belongings animation
_commandHandler->addCommand(kCmdSend, 16060 + hand, -1, NULL); // Hide hand
_commandHandler->addCommand(kCmdWait, 16060 + hand, -1, NULL); // Stop moving hand
} else {
_commandHandler->addCommand(kCmdSeq, buref, 4, NULL); // Take off
_commandHandler->addCommand(kCmdSound, 16060 + hand, 16002, NULL); // Play tear sound
_commandHandler->addCommand(kCmdWait, buref, -1, NULL); // Will take off
_commandHandler->addCommand(kCmdSwap, buref, buref + 100, NULL); // Open hand
_commandHandler->addCommand(kCmdSeq, 16016, Stage, NULL); // Start Belongings animation
}
_commandHandler->addCommand(kCmdPause, -1, 72, NULL); // Pause the game for 72/80 second
_commandHandler->addCommand(kCmdSeq, -1, 0, dup[1]); // Get away (Him)
_commandHandler->addCommand(kCmdSetXY, -1, 203 + kScrWidth * 49, dup[1]);
_commandHandler->addCommand(kCmdSetZ, -1, 7, dup[1]);
_commandHandler->addCommand(kCmdSeq, -1, 0, dup[2]); // Get Away (Her)
_commandHandler->addCommand(kCmdSetXY, -1, 182 + kScrWidth * 62, dup[2]);
_commandHandler->addCommand(kCmdSetZ, -1, 9, dup[2]);
_game = false;
return;
} else {
_commandHandler->addCommand(kCmdSeq, -1, 2, dup[0]); // reset animation sequence
_commandHandler->addCommand(kCmdSeq, -1, 2, dup[1]); // reset animation sequence
_commandHandler->addCommand(kCmdSeq, -1, 2, dup[2]); // reset animation sequence
_commandHandler->addCommand(kCmdPause, -1, 72, NULL); // Pause the game for 72/80 second
}
}
_commandHandler->addCommand(kCmdWalk, 198, 134, NULL); // Go to place
_commandHandler->addCommand(kCmdWait, 1, -1, NULL); // Stop moving
_commandHandler->addCommand(kCmdCover, 1, 16101, NULL); // Man to beat
_commandHandler->addCommand(kCmdSeq, 16101, 1, NULL); // Start Chief animation (16dupnia)
_commandHandler->addCommand(kCmdWait, 16101, 5, NULL); // wait
_commandHandler->addCommand(kCmdPause, 16101, 24, NULL); // Pause the game for 24/80 second
_commandHandler->addCommand(kCmdSeq, 16040, 1, NULL); // Start Slap animation (16plask)
_commandHandler->addCommand(kCmdSound, 16101, 16001, NULL); // Play "Slap" sound
_commandHandler->addCommand(kCmdPause, 16101, 24, NULL); // Pause the game for 24/80 second
_commandHandler->addCommand(kCmdSeq, 16040, 0, NULL); // Reset animation sequence
_commandHandler->addCommand(kCmdWait, 16101, -1, NULL); // stay
_commandHandler->addCommand(kCmdUncover, 1, 16101, NULL); // SDS
if (!_game) {
_commandHandler->addCommand(kCmdSay, buref, 16008, NULL); // say "Guess!"
_game = true;
}
}
break;
case 2:
if (_sprTv == NULL) {
_sprTv = _vga->_showQ->locate(20700);
_sprK1 = _vga->_showQ->locate(20701);
_sprK2 = _vga->_showQ->locate(20702);
_sprK3 = _vga->_showQ->locate(20703);
}
if (!_game) { // init
_commandHandler->addCommand(kCmdGame, 20002, 2, NULL);
_game = true;
break;
}
// cont
_sprK1->step(newRandom(6));
_sprK2->step(newRandom(6));
_sprK3->step(newRandom(6));
// check the ALT key as it's the solution of the puzzle
// the test has been restricted to some specific OSes
// in order to avoid some obvious issues (like Android, iOS, NDS, N64...)
// Not perfect, but at least better than nothing.
#if defined(WIN32) || defined(UNIX) || defined(MACOSX) || defined(MOTOEZX) || defined(LINUPY) || defined(LINUXMOTO_SDL)
if (spr->_ref == 1 && _keyboard->_keyAlt) {
#else
if (spr->_ref == 1 && _gameCase2Cpt > 1) {
#endif
_sprK1->step(5);
_sprK2->step(5);
_sprK3->step(5);
}
_commandHandler->addCommand(kCmdSetZ, 20700, 0, NULL);
bool hit = (_sprK1->_seqPtr + _sprK2->_seqPtr + _sprK3->_seqPtr == 15);
if (hit) {
if (spr->_ref == 1) {
_commandHandler->addCommand(kCmdSay, 1, 20003, NULL); // hurray!
_commandHandler->addCommand(kCmdSeq, 20011, 2, NULL); // Camera away
_commandHandler->addCommand(kCmdSend, 20701, -1, NULL); // move dice1 to scene -1
_commandHandler->addCommand(kCmdSend, 20702, -1, NULL); // move dice2 to scene -1
_commandHandler->addCommand(kCmdSend, 20703, -1, NULL); // move dice3 to scene -1
_commandHandler->addCommand(kCmdSend, 20700, -1, NULL); // move TV to scene -1
_commandHandler->addCommand(kCmdKeep, 20007, 0, NULL); // to pocket
_commandHandler->addCommand(kCmdSend, 20006, 20, NULL); // Move Coin to scene 20
_commandHandler->addCommand(kCmdSound, 20006, 20002, NULL); // Play Coin sound
_commandHandler->addCommand(kCmdSay, 20002, 20004, NULL); // Say "Luck guy..."
_commandHandler->addCommand(kCmdSend, 20010, 20, NULL); // Move Paper to scene 20
_commandHandler->addCommand(kCmdSound, 20010, 20003, NULL); // Play "ksh" sound! (fx20003.wav)
_commandHandler->addCommand(kCmdSay, 20001, 20005, NULL); // Say "Congratulations"
_game = false;
return;
} else
_sprK3->step(newRandom(5));
}
if (_gameCase2Cpt < 100) {
switch (_gameCase2Cpt) {
case 15:
// Give hint about ALTered dice
_commandHandler->addCommand(kCmdSay, 20003, 20021, NULL);
break;
case 30:
case 45:
case 60:
case 75:
// Tell to use ALT key
_commandHandler->addCommand(kCmdSay, 20003, 20022, NULL);
break;
}
_gameCase2Cpt++;
}
switch (spr->_ref) {
case 1:
_commandHandler->addCommand(kCmdSay, 20001, 20011, NULL); // Say "It'a my turn"
_commandHandler->addCommand(kCmdSeq, 20001, 1, NULL); // Throw dice<63>
_commandHandler->addCommand(kCmdWait, 20001, 1, NULL); // wait
_commandHandler->addCommand(kCmdSetZ, 20700, 2, NULL); // hide dice
_commandHandler->addCommand(kCmdHide, 20007, 1, NULL); // hide dice
_commandHandler->addCommand(kCmdWait, 20001, 16, NULL); // wait
_commandHandler->addCommand(kCmdSeq, 20007, 1, NULL); // Start dice animation (20kosci)
_commandHandler->addCommand(kCmdHide, 20007, 0, NULL); // unhide
_commandHandler->addCommand(kCmdSound, 20007, 20001, NULL); // Play Dice sound
_commandHandler->addCommand(kCmdWait, 20007, -1, NULL); // the end
_commandHandler->addCommand(kCmdGame, 20001, 2, NULL); // again!
break;
case 20001:
_commandHandler->addCommand(kCmdSay, 20002, 20012, NULL); // Say "Now it's mine"
_commandHandler->addCommand(kCmdSeq, 20002, 1, NULL); // Throw dice<63>
_commandHandler->addCommand(kCmdWait, 20002, 3, NULL); // wait
_commandHandler->addCommand(kCmdSetZ, 20700, 2, NULL); // hide dice
_commandHandler->addCommand(kCmdHide, 20007, 1, NULL); // hide dice
_commandHandler->addCommand(kCmdWait, 20002, 10, NULL); // wait
_commandHandler->addCommand(kCmdSeq, 20007, 2, NULL); // Start dice animation (20kosci)
_commandHandler->addCommand(kCmdHide, 20007, 0, NULL); // unhide
_commandHandler->addCommand(kCmdSound, 20007, 20001, NULL); // Play Dice sound
_commandHandler->addCommand(kCmdWait, 20007, -1, NULL); // the end
_commandHandler->addCommand(kCmdGame, 20002, 2, NULL); // again!
break;
case 20002:
_commandHandler->addCommand(kCmdSay, 20002, 20010, NULL); // "Roll the bones!"
_commandHandler->addCommand(kCmdWalk, 20005, -1, NULL); // Walk to table
_commandHandler->addCommand(kCmdWait, 1, -1, NULL); // Wait
_commandHandler->addCommand(kCmdCover, 1, 20101, NULL); // grasol ??
_commandHandler->addCommand(kCmdSeq, 20101, 1, NULL); // Start Chief animation (20solgra)<29>
_commandHandler->addCommand(kCmdWait, 20101, 5, NULL); // Wait
_commandHandler->addCommand(kCmdSetZ, 20700, 2, NULL); // Hide dice
_commandHandler->addCommand(kCmdHide, 20007, 1, NULL); // Hide dice
_commandHandler->addCommand(kCmdWait, 20101, 15, NULL); // wait
_commandHandler->addCommand(kCmdSeq, 20007, 1, NULL); // Start dice animation (20kosci)
_commandHandler->addCommand(kCmdHide, 20007, 0, NULL); // Unhide
_commandHandler->addCommand(kCmdSound, 20007, 20001, NULL); // Play Dice sound
_commandHandler->addCommand(kCmdWait, 20101, -1, NULL); // the end
_commandHandler->addCommand(kCmdUncover, 1, 20101, NULL); // SDS ??
_commandHandler->addCommand(kCmdGame, 1, 2, NULL); // again!
break;
}
}
}
void CGEEngine::expandSprite(Sprite *spr) {
debugC(5, kCGEDebugEngine, "CGEEngine::expandSprite(spr)");
if (spr)
_vga->_showQ->insert(_vga->_spareQ->remove(spr));
}
void CGEEngine::contractSprite(Sprite *spr) {
debugC(1, kCGEDebugEngine, "CGEEngine::contractSprite(spr)");
if (spr)
_vga->_spareQ->append(_vga->_showQ->remove(spr));
}
/**
* Check if an item is in the inventory, and returns its position
* @param spr Sprite pointer
* @return -1 if not found, else index.
*/
int CGEEngine::findPocket(Sprite *spr) {
debugC(1, kCGEDebugEngine, "CGEEngine::findPocket(spr)");
for (int i = 0; i < kPocketNX; i++)
if (_pocket[i] == spr)
return i;
return -1;
}
/**
* Check if an item is in the inventory, and returns its position
* @param Inventory slot number Sprite pointer
*/
void CGEEngine::selectPocket(int n) {
debugC(1, kCGEDebugEngine, "CGEEngine::selectPocket(%d)", n);
if (n < 0 || (_pocLight->_seqPtr && _pocPtr == n)) {
// If no slot specified, or another slot already selected
// stop the blinking animation
_pocLight->step(0);
n = findPocket(NULL);
if (n >= 0)
_pocPtr = n;
} else {
// If slot specified, check if the slot if used.
// Is so, start the blinking animation
if (_pocket[n] != NULL) {
_pocPtr = n;
_pocLight->step(1);
}
}
_pocLight->gotoxy(kPocketX + _pocPtr * kPocketDX + kPocketSX, kPocketY + kPocketSY);
}
/**
* Logic used when all the inventory slots are full and the user tries to pick
* another object.
* @param Inventory slot number Sprite pointer
*/
void CGEEngine::pocFul() {
debugC(1, kCGEDebugEngine, "CGEEngine::pocFul()");
_hero->park();
_commandHandler->addCommand(kCmdWait, -1, -1, _hero);
_commandHandler->addCommand(kCmdSeq, -1, kSeqPocketFull, _hero);
_commandHandler->addCommand(kCmdSound, -1, 2, _hero); // Play the 'hum-hum" sound (fx00002)
_commandHandler->addCommand(kCmdWait, -1, -1, _hero);
_commandHandler->addCommand(kCmdSay, 1, kPocketFull, _hero);
}
void CGEEngine::hide1(Sprite *spr) {
debugC(1, kCGEDebugEngine, "CGEEngine::hide1(spr)");
_commandHandlerTurbo->addCommand(kCmdGhost, -1, 0, spr->ghost());
}
void CGEEngine::snGhost(Bitmap *bmp) {
debugC(1, kCGEDebugEngine, "CGEEngine::snGhost(bmp)");
bmp->hide(bmp->_map & 0xFFFF, bmp->_map >> 16);
bmp->_m = NULL;
bmp->_map = 0;
delete bmp;
}
void CGEEngine::feedSnail(Sprite *spr, SnList snq) {
debugC(1, kCGEDebugEngine, "CGEEngine::feedSnail(spr, snq)");
if (!spr || !spr->active())
return;
uint8 ptr = (snq == kTake) ? spr->_takePtr : spr->_nearPtr;
if (ptr == kNoPtr)
return;
CommandHandler::Command *comtab = spr->snList(snq);
CommandHandler::Command *c = comtab + ptr;
if (findPocket(NULL) < 0) { // no empty pockets?
CommandHandler::Command *p;
for (p = c; p->_commandType != kCmdNext; p++) { // find KEEP command
if (p->_commandType == kCmdKeep) {
pocFul();
return;
}
if (p->_spritePtr)
break;
}
}
while (true) {
if (c->_commandType == kCmdTalk) {
if ((_commandHandler->_talkEnable = (c->_val != 0)) == false)
killText();
}
if (c->_commandType == kCmdNext) {
Sprite *s = (c->_ref < 0) ? spr : locate(c->_ref);
if (s) {
uint8 *idx = (snq == kTake) ? &s->_takePtr : &s->_nearPtr;
if (*idx != kNoPtr) {
int v;
switch (c->_val) {
case -1 :
v = c - comtab + 1;
break;
case -2 :
v = c - comtab;
break;
case -3 :
v = -1;
break;
default :
v = c->_val;
break;
}
if (v >= 0)
*idx = v;
}
}
if (s == spr)
break;
}
if (c->_commandType == kCmdIf) {
Sprite *s = (c->_ref < 0) ? spr : locate(c->_ref);
if (s) { // sprite extsts
if (! s->seqTest(-1))
c = comtab + c->_val; // not parked
else
++c;
} else
++c;
} else {
_commandHandler->addCommand(c->_commandType, c->_ref, c->_val, spr);
if (c->_spritePtr)
break;
else
c++;
}
}
}
void CGEEngine::snNNext(Sprite *spr, int p) {
debugC(1, kCGEDebugEngine, "CGEEngine::snNNext(spr, %d)", p);
if (spr)
if (spr->_nearPtr != kNoPtr)
spr->_nearPtr = p;
}
void CGEEngine::snTNext(Sprite *spr, int p) {
debugC(1, kCGEDebugEngine, "CGEEngine::snTNext(spr, %d)", p);
if (spr)
if (spr->_takePtr != kNoPtr)
spr->_takePtr = p;
}
void CGEEngine::snRNNext(Sprite *spr, int p) {
debugC(1, kCGEDebugEngine, "CGEEngine::snRNNext(spr, %d)", p);
if (spr)
if (spr->_nearPtr != kNoPtr)
spr->_nearPtr += p;
}
void CGEEngine::snRTNext(Sprite *spr, int p) {
debugC(1, kCGEDebugEngine, "CGEEngine::snRTNext(spr, %d)", p);
if (spr)
if (spr->_takePtr != kNoPtr)
spr->_takePtr += p;
}
void CGEEngine::snZTrim(Sprite *spr) {
debugC(4, kCGEDebugEngine, "CGEEngine::snZTrim(spr)");
if (!spr || !spr->active())
return;
Sprite *s = (spr->_flags._shad) ? spr->_prev : NULL;
_vga->_showQ->insert(_vga->_showQ->remove(spr));
if (s) {
s->_z = spr->_z;
_vga->_showQ->insert(_vga->_showQ->remove(s), spr);
}
}
void CGEEngine::snHide(Sprite *spr, int val) {
debugC(1, kCGEDebugEngine, "CGEEngine::snHide(spr, %d)", val);
if (spr) {
spr->_flags._hide = (val >= 0) ? (val != 0) : (!spr->_flags._hide);
if (spr->_flags._shad)
spr->_prev->_flags._hide = spr->_flags._hide;
}
}
void CGEEngine::snRmNear(Sprite *spr) {
debugC(1, kCGEDebugEngine, "CGEEngine::snRmNear(spr)");
if (spr)
spr->_nearPtr = kNoPtr;
}
void CGEEngine::snRmTake(Sprite *spr) {
debugC(1, kCGEDebugEngine, "CGEEngine::snRmTake(spr)");
if (spr)
spr->_takePtr = kNoPtr;
}
void CGEEngine::snSeq(Sprite *spr, int val) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSeq(spr, %d)", val);
if (spr) {
if (spr == _hero && val == 0)
_hero->park();
else
spr->step(val);
}
}
void CGEEngine::snRSeq(Sprite *spr, int val) {
debugC(1, kCGEDebugEngine, "CGEEngine::snRSeq(spr, %d)", val);
if (spr)
snSeq(spr, spr->_seqPtr + val);
}
void CGEEngine::snSend(Sprite *spr, int val) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSend(spr, %d)", val);
if (!spr)
return;
int was = spr->_scene;
bool was1 = (was == 0 || was == _now);
bool val1 = (val == 0 || val == _now);
spr->_scene = val;
if (val1 != was1) {
if (was1) {
if (spr->_flags._kept) {
int n = findPocket(spr);
if (n >= 0)
_pocket[n] = NULL;
}
hide1(spr);
contractSprite(spr);
spr->_flags._slav = false;
} else {
if (spr->_ref % 1000 == 0)
_bitmapPalette = _vga->_sysPal;
if (spr->_flags._back)
spr->backShow(true);
else
expandSprite(spr);
_bitmapPalette = NULL;
}
}
}
void CGEEngine::snSwap(Sprite *spr, int xref) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSwap(spr, %d)", xref);
Sprite *xspr = locate(xref);
if (!spr || !xspr)
return;
int was = spr->_scene;
int xwas = xspr->_scene;
bool was1 = (was == 0 || was == _now);
bool xwas1 = (xwas == 0 || xwas == _now);
SWAP(spr->_scene, xspr->_scene);
SWAP(spr->_x, xspr->_x);
SWAP(spr->_y, xspr->_y);
SWAP(spr->_z, xspr->_z);
if (spr->_flags._kept) {
int n = findPocket(spr);
if (n >= 0)
_pocket[n] = xspr;
xspr->_flags._kept = true;
xspr->_flags._port = false;
}
if (xwas1 != was1) {
if (was1) {
hide1(spr);
contractSprite(spr);
} else
expandSprite(spr);
if (xwas1) {
hide1(xspr);
contractSprite(xspr);
} else
expandSprite(xspr);
}
}
void CGEEngine::snCover(Sprite *spr, int xref) {
debugC(1, kCGEDebugEngine, "CGEEngine::snCover(spr, %d)", xref);
Sprite *xspr = locate(xref);
if (!spr || !xspr)
return;
spr->_flags._hide = true;
xspr->_z = spr->_z;
xspr->_scene = spr->_scene;
xspr->gotoxy(spr->_x, spr->_y);
expandSprite(xspr);
if ((xspr->_flags._shad = spr->_flags._shad) == 1) {
_vga->_showQ->insert(_vga->_showQ->remove(spr->_prev), xspr);
spr->_flags._shad = false;
}
feedSnail(xspr, kNear);
}
void CGEEngine::snUncover(Sprite *spr, Sprite *xspr) {
debugC(1, kCGEDebugEngine, "CGEEngine::snUncover(spr, xspr)");
if (!spr || !xspr)
return;
spr->_flags._hide = false;
spr->_scene = xspr->_scene;
spr->gotoxy(xspr->_x, xspr->_y);
if ((spr->_flags._shad = xspr->_flags._shad) == 1) {
_vga->_showQ->insert(_vga->_showQ->remove(xspr->_prev), spr);
xspr->_flags._shad = false;
}
spr->_z = xspr->_z;
snSend(xspr, -1);
if (spr->_time == 0)
spr->_time++;
}
void CGEEngine::snSetX0(int scene, int x0) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSetX0(%d, %d)", scene, x0);
_heroXY[scene - 1].x = x0;
}
void CGEEngine::snSetY0(int scene, int y0) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSetY0(%d, %d)", scene, y0);
_heroXY[scene - 1].y = y0;
}
void CGEEngine::snSetXY(Sprite *spr, uint16 xy) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSetXY(spr, %d)", xy);
if (spr)
spr->gotoxy(xy % kScrWidth, xy / kScrWidth);
}
void CGEEngine::snRelX(Sprite *spr, int x) {
debugC(1, kCGEDebugEngine, "CGEEngine::snRelX(spr, %d)", x);
if (spr && _hero)
spr->gotoxy(_hero->_x + x, spr->_y);
}
void CGEEngine::snRelY(Sprite *spr, int y) {
debugC(1, kCGEDebugEngine, "CGEEngine::snRelY(spr, %d)", y);
if (spr && _hero)
spr->gotoxy(spr->_x, _hero->_y + y);
}
void CGEEngine::snRelZ(Sprite *spr, int z) {
debugC(1, kCGEDebugEngine, "CGEEngine::snRelZ(spr, %d)", z);
if (spr && _hero) {
spr->_z = _hero->_z + z;
snZTrim(spr);
}
}
void CGEEngine::snSetX(Sprite *spr, int x) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSetX(spr, %d)", x);
if (spr)
spr->gotoxy(x, spr->_y);
}
void CGEEngine::snSetY(Sprite *spr, int y) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSetY(spr, %d)", y);
if (spr)
spr->gotoxy(spr->_x, y);
}
void CGEEngine::snSetZ(Sprite *spr, int z) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSetZ(spr, %d)", z);
if (spr) {
spr->_z = z;
snZTrim(spr);
}
}
void CGEEngine::snSlave(Sprite *spr, int ref) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSlave(spr, %d)", ref);
Sprite *slv = locate(ref);
if (spr && slv) {
if (spr->active()) {
snSend(slv, spr->_scene);
slv->_flags._slav = true;
slv->_z = spr->_z;
_vga->_showQ->insert(_vga->_showQ->remove(slv), spr->_next);
}
}
}
void CGEEngine::snTrans(Sprite *spr, int trans) {
debugC(1, kCGEDebugEngine, "CGEEngine::snTrans(spr, %d)", trans);
if (spr)
spr->_flags._tran = (trans < 0) ? !spr->_flags._tran : (trans != 0);
}
void CGEEngine::snPort(Sprite *spr, int port) {
debugC(1, kCGEDebugEngine, "CGEEngine::snPort(spr, %d)", port);
if (spr)
spr->_flags._port = (port < 0) ? !spr->_flags._port : (port != 0);
}
void CGEEngine::snKill(Sprite *spr) {
debugC(1, kCGEDebugEngine, "CGEEngine::snKill(spr)");
if (!spr)
return;
if (spr->_flags._kept) {
int n = findPocket(spr);
if (n >= 0)
_pocket[n] = NULL;
}
Sprite *nx = spr->_next;
hide1(spr);
_vga->_showQ->remove(spr);
_eventManager->clearEvent(spr);
if (spr->_flags._kill) {
delete spr;
} else {
spr->_scene = -1;
_vga->_spareQ->append(spr);
}
if (nx) {
if (nx->_flags._slav)
snKill(nx);
}
}
/**
* Play a FX sound
* @param spr Sprite pointer
* @param wav FX index
*/
void CGEEngine::snSound(Sprite *spr, int wav) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSound(spr, %d)", wav);
if (wav == -1)
_sound->stop();
else
_sound->play((*_fx)[wav], (spr) ? ((spr->_x + spr->_w / 2) / (kScrWidth / 16)) : 8);
_sound->setRepeat(1);
}
void CGEEngine::snKeep(Sprite *spr, int stp) {
debugC(1, kCGEDebugEngine, "CGEEngine::snKeep(spr, %d)", stp);
selectPocket(-1);
if (spr && ! spr->_flags._kept && _pocket[_pocPtr] == NULL) {
int16 oldRepeat = _sound->getRepeat();
_sound->setRepeat(1);
snSound(spr, 3);
_sound->setRepeat(oldRepeat);
_pocket[_pocPtr] = spr;
spr->_scene = 0;
spr->_flags._kept = true;
spr->gotoxy(kPocketX + kPocketDX * _pocPtr + kPocketDX / 2 - spr->_w / 2,
kPocketY + kPocketDY / 2 - spr->_h / 2);
if (stp >= 0)
spr->step(stp);
}
selectPocket(-1);
}
/**
* Remove an object from the inventory and (if specified) trigger an animation
* @param spr Inventory item
* @param stp Animation
*/
void CGEEngine::snGive(Sprite *spr, int stp) {
debugC(1, kCGEDebugEngine, "CGEEngine::snGive(spr, %d)", stp);
if (spr) {
int p = findPocket(spr);
if (p >= 0) {
_pocket[p] = NULL;
spr->_scene = _now;
spr->_flags._kept = false;
if (stp >= 0)
spr->step(stp);
}
}
selectPocket(-1);
}
void CGEEngine::snBackPt(Sprite *spr, int stp) {
debugC(1, kCGEDebugEngine, "CGEEngine::snBackPt(spr, %d)", stp);
if (spr) {
if (stp >= 0)
spr->step(stp);
spr->backShow(true);
}
}
void CGEEngine::snLevel(Sprite *spr, int lev) {
debugC(1, kCGEDebugEngine, "CGEEngine::snLevel(spr, %d)", lev);
assert((lev >= 0) && (lev < 5));
for (int i = 0; i < 5; i++) {
spr = _vga->_spareQ->locate(100 + i);
if (spr) {
if (i <= lev) {
spr->backShow(true);
spr->_scene = 0;
spr->_flags._hide = false;
} else {
spr->_flags._hide = true;
spr->_scene = -1;
}
} else {
warning("SPR not found! ref: %d", 100 + i);
}
}
_lev = lev;
_maxScene = _maxSceneArr[_lev];
}
/**
* Set a flag to a value
* @param indx Flag index
* @param val Flag value
*/
void CGEEngine::snFlag(int indx, bool val) {
_flag[indx] = val;
}
void CGEEngine::snSetRef(Sprite *spr, int nr) {
debugC(1, kCGEDebugEngine, "CGEEngine::snSetRef(spr, %d)", nr);
if (spr)
spr->_ref = nr;
}
void CGEEngine::snFlash(bool on) {
debugC(1, kCGEDebugEngine, "CGEEngine::snFlash(%s)", on ? "true" : "false");
if (on) {
Dac *pal = (Dac *)malloc(sizeof(Dac) * kPalCount);
if (pal) {
memcpy(pal, _vga->_sysPal, kPalSize);
for (int i = 0; i < kPalCount; i++) {
register int c;
c = pal[i]._r << 1;
pal[i]._r = (c < 64) ? c : 63;
c = pal[i]._g << 1;
pal[i]._g = (c < 64) ? c : 63;
c = pal[i]._b << 1;
pal[i]._b = (c < 64) ? c : 63;
}
_vga->setColors(pal, 64);
}
free(pal);
} else
_vga->setColors(_vga->_sysPal, 64);
_dark = false;
}
void CGEEngine::snLight(bool in) {
debugC(1, kCGEDebugEngine, "CGEEngine::snLight(%s)", in ? "true" : "false");
if (in)
_vga->sunrise(_vga->_sysPal);
else
_vga->sunset();
_dark = !in;
}
/**
* Set an horizontal boundary
* @param scene Scene number
* @param barX Horizontal boundary value
*/
void CGEEngine::snHBarrier(const int scene, const int barX) {
debugC(1, kCGEDebugEngine, "CGEEngine::snHBarrier(%d, %d)", scene, barX);
_barriers[(scene > 0) ? scene : _now]._horz = barX;
}
/**
* Set a vertical boundary
* @param scene Scene number
* @param barY Vertical boundary value
*/
void CGEEngine::snVBarrier(const int scene, const int barY) {
debugC(1, kCGEDebugEngine, "CGEEngine::snVBarrier(%d, %d)", scene, barY);
_barriers[(scene > 0) ? scene : _now]._vert = barY;
}
void CGEEngine::snWalk(Sprite *spr, int x, int y) {
debugC(1, kCGEDebugEngine, "CGEEngine::snWalk(spr, %d, %d)", x, y);
if (_hero) {
if (spr && y < 0)
_hero->findWay(spr);
else
_hero->findWay(XZ(x, y));
}
}
void CGEEngine::snReach(Sprite *spr, int mode) {
debugC(1, kCGEDebugEngine, "CGEEngine::snReach(spr, %d)", mode);
if (_hero)
_hero->reach(spr, mode);
}
void CGEEngine::snMouse(bool on) {
debugC(1, kCGEDebugEngine, "CGEEngine::snMouse(%s)", on ? "true" : "false");
if (on)
_mouse->on();
else
_mouse->off();
}
} // End of namespace CGE
Reference in New Issue View Git Blame Copy Permalink