731 lines
17 KiB
C++
731 lines
17 KiB
C++
/* 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.
|
|
*
|
|
* $URL$
|
|
* $Id$
|
|
*
|
|
*/
|
|
|
|
#include "agi/preagi_winnie.h"
|
|
#include "agi/graphics.h"
|
|
|
|
#include "common/events.h"
|
|
|
|
namespace Agi {
|
|
|
|
// default attributes
|
|
#define IDA_DEFAULT 0x0F
|
|
#define IDA_DEFAULT_REV 0xF0
|
|
|
|
void Winnie::initEngine() {
|
|
//SetScreenPar(320, 200, (char*)ibm_fontdata);
|
|
//SetMenuPars(21, 21, IDS_WTP_SELECTION);
|
|
}
|
|
|
|
void Winnie::initVars() {
|
|
memset(&game, 0, sizeof(game));
|
|
game.fSound = 1;
|
|
game.nObjMiss = IDI_WTP_MAX_OBJ_MISSING;
|
|
game.nObjRet = 0;
|
|
game.fGame[0] = 1;
|
|
game.fGame[1] = 1;
|
|
room = IDI_WTP_ROOM_HOME;
|
|
|
|
mist = -1;
|
|
wind = false;
|
|
event = false;
|
|
}
|
|
|
|
void Winnie::readRoom(int iRoom, uint8 *buffer, int buflen) {
|
|
char szFile[256] = {0};
|
|
sprintf(szFile, IDS_WTP_PATH_ROOM, iRoom);
|
|
Common::File file;
|
|
if (!file.open(szFile))
|
|
return;
|
|
uint32 filelen = file.size();
|
|
memset(buffer, 0, sizeof(buffer));
|
|
file.read(buffer, filelen);
|
|
file.close();
|
|
}
|
|
|
|
void Winnie::randomize() {
|
|
int iObj = 0;
|
|
int iRoom = 0;
|
|
bool done;
|
|
|
|
for (int i = 0; i < IDI_WTP_MAX_OBJ_MISSING; i++) {
|
|
done = false;
|
|
while (!done) {
|
|
iObj = _vm->rnd(IDI_WTP_MAX_OBJ - 1) + 2;
|
|
done = true;
|
|
for (int j = 0; j < IDI_WTP_MAX_OBJ_MISSING; j++) {
|
|
if (game.iUsedObj[j] == iObj) {
|
|
done = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
game.iUsedObj[i] = iObj;
|
|
|
|
done = false;
|
|
while (!done) {
|
|
iRoom = _vm->rnd(IDI_WTP_MAX_ROOM_NORMAL) + 1;
|
|
done = true;
|
|
for (int j = 0; j < IDI_WTP_MAX_ROOM_OBJ; j++) {
|
|
if (game.iObjRoom[j] == iRoom) {
|
|
done = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
game.iObjRoom[iObj] = iRoom;
|
|
}
|
|
}
|
|
|
|
void Winnie::intro() {
|
|
intro_DrawLogo();
|
|
intro_DrawTitle();
|
|
intro_PlayTheme();
|
|
}
|
|
|
|
void Winnie::intro_DrawLogo() {
|
|
drawPic(IDS_WTP_FILE_LOGO);
|
|
_vm->printStr(IDS_WTP_INTRO_0);
|
|
_vm->waitAnyKeyChoice();
|
|
}
|
|
|
|
void Winnie::intro_DrawTitle() {
|
|
drawPic(IDS_WTP_FILE_TITLE);
|
|
_vm->printStr(IDS_WTP_INTRO_1);
|
|
_vm->waitAnyKeyChoice();
|
|
}
|
|
|
|
void Winnie::intro_PlayTheme() {
|
|
//if (!Winnie_PlaySound(IDI_WTP_SND_POOH_0)) return;
|
|
//if (!Winnie_PlaySound(IDI_WTP_SND_POOH_1)) return;
|
|
//if (!Winnie_PlaySound(IDI_WTP_SND_POOH_2)) return;
|
|
}
|
|
|
|
int Winnie::getObjInRoom(int iRoom) {
|
|
for (int iObj = 1; iObj < IDI_WTP_MAX_ROOM_OBJ; iObj++)
|
|
if (game.iObjRoom[iObj] == iRoom)
|
|
return iObj;
|
|
return 0;
|
|
}
|
|
|
|
#define setTakeDrop() {\
|
|
if (getObjInRoom(room))\
|
|
fCanSel[IDI_WTP_SEL_TAKE] = true;\
|
|
else\
|
|
fCanSel[IDI_WTP_SEL_TAKE] = false;\
|
|
if (game.iObjHave)\
|
|
fCanSel[IDI_WTP_SEL_DROP] = true;\
|
|
else\
|
|
fCanSel[IDI_WTP_SEL_DROP] = false;\
|
|
}
|
|
|
|
int Winnie::parser(int pc, int index, uint8 *buffer) {
|
|
WTP_ROOM_HDR hdr;
|
|
int startpc = pc;
|
|
int8 opcode;
|
|
int iNewRoom = 0;
|
|
|
|
int iSel, iDir, iBlock;
|
|
int fCanSel[IDI_WTP_SEL_LAST + 1];
|
|
char szMenu[121] = {0};
|
|
bool done;
|
|
int fBlock;
|
|
|
|
// extract header from buffer
|
|
memcpy(&hdr, buffer, sizeof(WTP_ROOM_HDR));
|
|
|
|
for (;;) {
|
|
pc = startpc;
|
|
|
|
// check if block is to be run
|
|
|
|
iBlock = *(buffer + pc++);
|
|
if (iBlock == 0)
|
|
return IDI_WTP_PAR_OK;
|
|
|
|
fBlock = *(buffer + pc++);
|
|
if (game.fGame[iBlock] != fBlock)
|
|
return IDI_WTP_PAR_OK;
|
|
|
|
// extract text from block
|
|
|
|
opcode = *(buffer + pc);
|
|
switch(opcode) {
|
|
case 0:
|
|
case IDO_WTP_OPTION_0:
|
|
case IDO_WTP_OPTION_1:
|
|
case IDO_WTP_OPTION_2:
|
|
// clear fCanSel block
|
|
memset(fCanSel, 0, sizeof(fCanSel));
|
|
|
|
// check if NSEW directions should be displayed
|
|
if (hdr.roomNew[0])
|
|
fCanSel[IDI_WTP_SEL_NORTH] = fCanSel[IDI_WTP_SEL_SOUTH] =
|
|
fCanSel[IDI_WTP_SEL_EAST] = fCanSel[IDI_WTP_SEL_WEST] = true;
|
|
|
|
// check if object in room or player carrying one
|
|
setTakeDrop();
|
|
|
|
// check which rows have a menu option
|
|
for (iSel = 0; iSel < IDI_WTP_MAX_OPTION; iSel++) {
|
|
opcode = *(buffer + pc++);
|
|
if (opcode) {
|
|
fCanSel[opcode - IDO_WTP_OPTION_0] = true;
|
|
fCanSel[iSel + IDI_WTP_SEL_REAL_OPT_1] = opcode - 0x14;
|
|
}
|
|
}
|
|
|
|
// extract menu string
|
|
strcpy(szMenu, (char *)(buffer + pc));
|
|
_vm->XOR80(szMenu);
|
|
break;
|
|
default:
|
|
// print description
|
|
_vm->printStrXOR((char *)(buffer + pc));
|
|
if (getSelOkBack())
|
|
return IDI_WTP_PAR_OK;
|
|
else
|
|
return IDI_WTP_PAR_BACK;
|
|
}
|
|
|
|
// input handler
|
|
|
|
done = false;
|
|
while (!done) {
|
|
// run wind if it's time
|
|
//if (wind)
|
|
// Winnie_Wind();
|
|
|
|
// get menu selection
|
|
getMenuSel(szMenu, &iSel, fCanSel);
|
|
|
|
if (++game.nMoves == IDI_WTP_MAX_MOVES_UNTIL_WIND)
|
|
wind = true;
|
|
|
|
if (event && (room <= IDI_WTP_MAX_ROOM_TELEPORT)) {
|
|
if (!tigger_mist) {
|
|
tigger_mist = 1;
|
|
//Winnie_Tigger();
|
|
} else {
|
|
tigger_mist = 0;
|
|
//Winnie_Mist();
|
|
}
|
|
event = false;
|
|
return IDI_WTP_PAR_GOTO;
|
|
}
|
|
|
|
// process selection
|
|
switch(iSel) {
|
|
case IDI_WTP_SEL_HOME:
|
|
switch(room) {
|
|
case IDI_WTP_ROOM_HOME:
|
|
case IDI_WTP_ROOM_MIST:
|
|
case IDI_WTP_ROOM_TIGGER:
|
|
break;
|
|
default:
|
|
room = IDI_WTP_ROOM_HOME;
|
|
return IDI_WTP_PAR_GOTO;
|
|
}
|
|
break;
|
|
case IDI_WTP_SEL_BACK:
|
|
return IDI_WTP_PAR_BACK;
|
|
case IDI_WTP_SEL_OPT_1:
|
|
case IDI_WTP_SEL_OPT_2:
|
|
case IDI_WTP_SEL_OPT_3:
|
|
done = true;
|
|
break;
|
|
case IDI_WTP_SEL_NORTH:
|
|
case IDI_WTP_SEL_SOUTH:
|
|
case IDI_WTP_SEL_EAST:
|
|
case IDI_WTP_SEL_WEST:
|
|
iDir = iSel - IDI_WTP_SEL_NORTH;
|
|
if (hdr.roomNew[iDir] == IDI_WTP_ROOM_NONE) {
|
|
_vm->printStr(IDS_WTP_CANT_GO);
|
|
_vm->waitAnyKeyChoice();
|
|
} else {
|
|
room = hdr.roomNew[iDir];
|
|
return IDI_WTP_PAR_GOTO;
|
|
}
|
|
break;
|
|
case IDI_WTP_SEL_TAKE:
|
|
//Winnie_TakeObj(room);
|
|
setTakeDrop();
|
|
break;
|
|
case IDI_WTP_SEL_DROP:
|
|
//Winnie_DropObj(room);
|
|
setTakeDrop();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// jump to the script block of the selected option
|
|
pc = hdr.opt[index].ofsOpt[iSel] - IDI_WTP_OFS_ROOM;
|
|
opcode = *(buffer + pc);
|
|
if (!opcode) pc++;
|
|
|
|
// process script
|
|
do {
|
|
opcode = *(buffer + pc++);
|
|
switch(opcode) {
|
|
case IDO_WTP_GOTO_ROOM:
|
|
opcode = *(buffer + pc++);
|
|
iNewRoom = opcode;
|
|
break;
|
|
case IDO_WTP_PRINT_MSG:
|
|
opcode = *(buffer + pc++);
|
|
printRoomStr(room, opcode);
|
|
_vm->waitAnyKeyChoice();
|
|
break;
|
|
case IDO_WTP_PRINT_STR:
|
|
opcode = *(buffer + pc++);
|
|
printRoomStr(room, opcode);
|
|
break;
|
|
case IDO_WTP_DROP_OBJ:
|
|
opcode = *(buffer + pc++);
|
|
opcode = -1;
|
|
//Winnie_DropObjRnd();
|
|
break;
|
|
case IDO_WTP_FLAG_CLEAR:
|
|
opcode = *(buffer + pc++);
|
|
//Winnie_ClearFlag(opcode);
|
|
break;
|
|
case IDO_WTP_FLAG_SET:
|
|
opcode = *(buffer + pc++);
|
|
//Winnie_SetFlag(opcode);
|
|
break;
|
|
case IDO_WTP_GAME_OVER:
|
|
//Winnie_GameOver();
|
|
break;
|
|
case IDO_WTP_WALK_MIST:
|
|
mist--;
|
|
if (!mist) {
|
|
room = _vm->rnd(IDI_WTP_MAX_ROOM_TELEPORT) + 1;
|
|
return IDI_WTP_PAR_GOTO;
|
|
}
|
|
break;
|
|
case IDO_WTP_PLAY_SOUND:
|
|
opcode = *(buffer + pc++);
|
|
//Winnie_PlaySound((ENUM_WTP_SOUND)opcode);
|
|
break;
|
|
case IDO_WTP_SAVE_GAME:
|
|
//Winnie_SaveGame();
|
|
room = IDI_WTP_ROOM_HOME;
|
|
return IDI_WTP_PAR_GOTO;
|
|
case IDO_WTP_LOAD_GAME:
|
|
//Winnie_LoadGame();
|
|
room = IDI_WTP_ROOM_HOME;
|
|
return IDI_WTP_PAR_GOTO;
|
|
case IDO_WTP_OWL_HELP:
|
|
opcode = *(buffer + pc++);
|
|
//Winnie_ShowOwlHelp();
|
|
break;
|
|
case IDO_WTP_GOTO_RND:
|
|
room = _vm->rnd(IDI_WTP_MAX_ROOM_TELEPORT) + 1;
|
|
return IDI_WTP_PAR_GOTO;
|
|
default:
|
|
opcode = 0;
|
|
break;
|
|
}
|
|
} while (opcode);
|
|
|
|
if (iNewRoom) {
|
|
room = iNewRoom;
|
|
return IDI_WTP_PAR_GOTO;
|
|
}
|
|
|
|
if (iBlock == 1)
|
|
return IDI_WTP_PAR_OK;
|
|
}
|
|
}
|
|
|
|
void Winnie::drawMenu(char *szMenu, int iSel, int fCanSel[]) {
|
|
int iRow = 0, iCol = 0;
|
|
|
|
_vm->clearTextArea();
|
|
_vm->drawStr(IDI_WTP_ROW_MENU, IDI_WTP_COL_MENU, IDA_DEFAULT, szMenu);
|
|
|
|
if (fCanSel[IDI_WTP_SEL_NORTH])
|
|
_vm->drawStr(IDI_WTP_ROW_OPTION_4, IDI_WTP_COL_NSEW, IDA_DEFAULT, IDS_WTP_NSEW);
|
|
if (fCanSel[IDI_WTP_SEL_TAKE])
|
|
_vm->drawStr(IDI_WTP_ROW_OPTION_4, IDI_WTP_COL_TAKE, IDA_DEFAULT, IDS_WTP_TAKE);
|
|
if (fCanSel[IDI_WTP_SEL_DROP])
|
|
_vm->drawStr(IDI_WTP_ROW_OPTION_4, IDI_WTP_COL_DROP, IDA_DEFAULT, IDS_WTP_DROP);
|
|
|
|
switch(iSel) {
|
|
case IDI_WTP_SEL_OPT_1:
|
|
iRow = IDI_WTP_ROW_OPTION_1;
|
|
iCol = IDI_WTP_COL_OPTION;
|
|
break;
|
|
case IDI_WTP_SEL_OPT_2:
|
|
iRow = IDI_WTP_ROW_OPTION_2;
|
|
iCol = IDI_WTP_COL_OPTION;
|
|
break;
|
|
case IDI_WTP_SEL_OPT_3:
|
|
iRow = IDI_WTP_ROW_OPTION_3;
|
|
iCol = IDI_WTP_COL_OPTION;
|
|
break;
|
|
case IDI_WTP_SEL_NORTH:
|
|
iRow = IDI_WTP_ROW_OPTION_4;
|
|
iCol = IDI_WTP_COL_NORTH;
|
|
break;
|
|
case IDI_WTP_SEL_SOUTH:
|
|
iRow = IDI_WTP_ROW_OPTION_4;
|
|
iCol = IDI_WTP_COL_SOUTH;
|
|
break;
|
|
case IDI_WTP_SEL_EAST:
|
|
iRow = IDI_WTP_ROW_OPTION_4;
|
|
iCol = IDI_WTP_COL_EAST;
|
|
break;
|
|
case IDI_WTP_SEL_WEST:
|
|
iRow = IDI_WTP_ROW_OPTION_4;
|
|
iCol = IDI_WTP_COL_WEST;
|
|
break;
|
|
case IDI_WTP_SEL_TAKE:
|
|
iRow = IDI_WTP_ROW_OPTION_4;
|
|
iCol = IDI_WTP_COL_TAKE;
|
|
break;
|
|
case IDI_WTP_SEL_DROP:
|
|
iRow = IDI_WTP_ROW_OPTION_4;
|
|
iCol = IDI_WTP_COL_DROP;
|
|
break;
|
|
}
|
|
_vm->drawStr(iRow, iCol - 1, IDA_DEFAULT, IDS_WTP_SELECTION);
|
|
_vm->_gfx->doUpdate();
|
|
_vm->_system->updateScreen(); // TODO: this should go in the game's main loop
|
|
}
|
|
|
|
void Winnie::incMenuSel(int *iSel, int fCanSel[]) {
|
|
do {
|
|
*iSel += 1;
|
|
if (*iSel > IDI_WTP_SEL_DROP) *iSel = IDI_WTP_SEL_OPT_1;
|
|
} while(!fCanSel[*iSel]);
|
|
}
|
|
|
|
void Winnie::decMenuSel(int *iSel, int fCanSel[]) {
|
|
do {
|
|
*iSel -= 1;
|
|
if (*iSel < IDI_WTP_SEL_OPT_1) *iSel = IDI_WTP_SEL_DROP;
|
|
} while(!fCanSel[*iSel]);
|
|
}
|
|
|
|
#define makeSel() {\
|
|
if (fCanSel[*iSel]) {\
|
|
return;\
|
|
} else {\
|
|
keyHelp();\
|
|
clrMenuSel(iSel, fCanSel);\
|
|
}\
|
|
}
|
|
|
|
void Winnie::getMenuSel(char *szMenu, int *iSel, int fCanSel[]) {
|
|
Common::Event event_;
|
|
int x, y;
|
|
|
|
clrMenuSel(iSel, fCanSel);
|
|
drawMenu(szMenu, *iSel, fCanSel);
|
|
|
|
for (;;) {
|
|
// check if tigger/mist is to be triggered
|
|
// if (something)
|
|
// event = true;
|
|
|
|
while (_vm->_system->getEventManager()->pollEvent(event_)) {
|
|
switch(event_.type) {
|
|
case Common::EVENT_QUIT:
|
|
_vm->_system->quit();
|
|
break;
|
|
case Common::EVENT_MOUSEMOVE:
|
|
x = event_.mouse.x;
|
|
y = event_.mouse.y;
|
|
//Winnie_GetMenuMouseSel(iSel, fCanSel, x, y);
|
|
break;
|
|
case Common::EVENT_LBUTTONUP:
|
|
switch(*iSel) {
|
|
case IDI_WTP_SEL_OPT_1:
|
|
case IDI_WTP_SEL_OPT_2:
|
|
case IDI_WTP_SEL_OPT_3:
|
|
for (int iSel2 = 0; iSel2 < IDI_WTP_MAX_OPTION; iSel2++) {
|
|
if (*iSel == (fCanSel[iSel2 + IDI_WTP_SEL_REAL_OPT_1] - 1)) {
|
|
*iSel = iSel2;
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
if (fCanSel[*iSel]) {
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
case Common::EVENT_RBUTTONUP:
|
|
*iSel = IDI_WTP_SEL_BACK;
|
|
return;
|
|
//FIXME: ScummVM does not support the middle mouse button
|
|
//case Common::EVENT_MBUTTONUP:
|
|
// Winnie_Inventory();
|
|
// break;
|
|
case Common::EVENT_WHEELUP:
|
|
decMenuSel(iSel, fCanSel);
|
|
break;
|
|
case Common::EVENT_WHEELDOWN:
|
|
incMenuSel(iSel, fCanSel);
|
|
break;
|
|
case Common::EVENT_KEYDOWN:
|
|
switch (event_.kbd.keycode) {
|
|
case Common::KEYCODE_ESCAPE:
|
|
*iSel = IDI_WTP_SEL_HOME;
|
|
return;
|
|
case Common::KEYCODE_BACKSPACE:
|
|
*iSel = IDI_WTP_SEL_BACK;
|
|
return;
|
|
case Common::KEYCODE_c:
|
|
//Winnie_Inventory();
|
|
break;
|
|
case Common::KEYCODE_SPACE:
|
|
case Common::KEYCODE_RIGHT:
|
|
case Common::KEYCODE_DOWN:
|
|
incMenuSel(iSel, fCanSel);
|
|
break;
|
|
case Common::KEYCODE_LEFT:
|
|
case Common::KEYCODE_UP:
|
|
decMenuSel(iSel, fCanSel);
|
|
break;
|
|
case Common::KEYCODE_1:
|
|
case Common::KEYCODE_2:
|
|
case Common::KEYCODE_3:
|
|
*iSel = event_.kbd.keycode - Common::KEYCODE_1;
|
|
if (fCanSel[*iSel + IDI_WTP_SEL_REAL_OPT_1]) {
|
|
return;
|
|
} else {
|
|
//Winnie_KeyHelp();
|
|
clrMenuSel(iSel, fCanSel);
|
|
}
|
|
break;
|
|
case Common::KEYCODE_n:
|
|
*iSel = IDI_WTP_SEL_NORTH;
|
|
makeSel();
|
|
break;
|
|
case Common::KEYCODE_s:
|
|
if (event_.kbd.flags & Common::KBD_CTRL) {
|
|
//FlipSound();
|
|
} else {
|
|
*iSel = IDI_WTP_SEL_SOUTH;
|
|
makeSel();
|
|
}
|
|
break;
|
|
case Common::KEYCODE_e:
|
|
*iSel = IDI_WTP_SEL_EAST;
|
|
makeSel();
|
|
break;
|
|
case Common::KEYCODE_w:
|
|
*iSel = IDI_WTP_SEL_WEST;
|
|
makeSel();
|
|
break;
|
|
case Common::KEYCODE_t:
|
|
*iSel = IDI_WTP_SEL_TAKE;
|
|
makeSel();
|
|
break;
|
|
case Common::KEYCODE_d:
|
|
*iSel = IDI_WTP_SEL_DROP;
|
|
makeSel();
|
|
break;
|
|
case Common::KEYCODE_RETURN:
|
|
switch(*iSel) {
|
|
case IDI_WTP_SEL_OPT_1:
|
|
case IDI_WTP_SEL_OPT_2:
|
|
case IDI_WTP_SEL_OPT_3:
|
|
for (int iSel2 = 0; iSel2 < IDI_WTP_MAX_OPTION; iSel2++) {
|
|
if (*iSel == (fCanSel[iSel2 + IDI_WTP_SEL_REAL_OPT_1] - 1)) {
|
|
*iSel = iSel2;
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
if (fCanSel[*iSel]) {
|
|
return;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
//Winnie_KeyHelp();
|
|
clrMenuSel(iSel, fCanSel);
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
drawMenu(szMenu, *iSel, fCanSel);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Winnie::gameLoop() {
|
|
WTP_ROOM_HDR hdr;
|
|
uint8 *roomdata = new uint8[4096];
|
|
int iBlock;
|
|
|
|
phase0:
|
|
if (!game.nObjMiss && (room == IDI_WTP_ROOM_PICNIC))
|
|
room = IDI_WTP_ROOM_PARTY;
|
|
readRoom(room, roomdata, 4096);
|
|
memcpy(&hdr, roomdata, sizeof(WTP_ROOM_HDR));
|
|
drawRoomPic();
|
|
phase1:
|
|
if (getObjInRoom(room)) {
|
|
// Winnie_PrintObjStr(Winnie_GetObjInRoom(room), IDI_WTP_OBJ_DESC);
|
|
// _vm->waitAnyKeyChoice();
|
|
}
|
|
phase2:
|
|
for (iBlock = 0; iBlock < IDI_WTP_MAX_BLOCK; iBlock++) {
|
|
if (parser(hdr.ofsDesc[iBlock] - IDI_WTP_OFS_ROOM, iBlock, roomdata) == IDI_WTP_PAR_BACK) {
|
|
goto phase1;
|
|
}
|
|
}
|
|
for (;;) {
|
|
for (iBlock = 0; iBlock < IDI_WTP_MAX_BLOCK; iBlock++) {
|
|
switch(parser(hdr.ofsBlock[iBlock] - IDI_WTP_OFS_ROOM, iBlock, roomdata)) {
|
|
case IDI_WTP_PAR_GOTO:
|
|
goto phase0;
|
|
break;
|
|
case IDI_WTP_PAR_BACK:
|
|
goto phase2;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete [] roomdata;
|
|
}
|
|
|
|
void Winnie::drawPic(const char *szName) {
|
|
char szFile[256] = {0};
|
|
uint8 *buffer = new uint8[4096];
|
|
|
|
// construct filename
|
|
sprintf(szFile, IDS_WTP_PATH, szName);
|
|
|
|
_vm->preAgiLoadResource(rPICTURE, szName);
|
|
_vm->_picture->decodePicture(0, true, false, IDI_WTP_PIC_WIDTH, IDI_WTP_PIC_HEIGHT);
|
|
_vm->_picture->showPic(IDI_WTP_PIC_X0, IDI_WTP_PIC_Y0, IDI_WTP_PIC_WIDTH, IDI_WTP_PIC_HEIGHT);
|
|
_vm->_gfx->doUpdate();
|
|
_vm->_system->updateScreen(); // TODO: this should go in the game's main loop
|
|
_vm->preAgiUnloadResource(rPICTURE, 0);
|
|
|
|
delete [] buffer;
|
|
}
|
|
|
|
void Winnie::drawRoomPic() {
|
|
WTP_ROOM_HDR roomhdr;
|
|
uint8 *buffer = new uint8[4096];
|
|
//int iObj = Winnie_GetObjInRoom(room);
|
|
|
|
// clear gfx screen
|
|
_vm->_gfx->clearScreen(0);
|
|
_vm->_gfx->doUpdate();
|
|
_vm->_system->updateScreen(); // TODO: this should go in the game's main loop
|
|
|
|
// read room picture
|
|
readRoom(room, buffer, 4096);
|
|
memcpy(&roomhdr, buffer, sizeof(WTP_ROOM_HDR));
|
|
|
|
// draw room picture
|
|
_vm->preAgiLoadResource(rPICTURE, buffer + roomhdr.ofsPic - IDI_WTP_OFS_ROOM);
|
|
_vm->_picture->decodePicture(0, true, false, IDI_WTP_PIC_WIDTH, IDI_WTP_PIC_HEIGHT);
|
|
_vm->_picture->showPic(IDI_WTP_PIC_X0, IDI_WTP_PIC_Y0, IDI_WTP_PIC_WIDTH, IDI_WTP_PIC_HEIGHT);
|
|
_vm->_gfx->doUpdate();
|
|
_vm->_system->updateScreen(); // TODO: this should go in the game's main loop
|
|
|
|
// draw object picture
|
|
//Winnie_DrawObjPic(iObj, IDI_WTP_PIC_X0 + roomhdr.objX, IDI_WTP_PIC_Y0 + roomhdr.objY);
|
|
|
|
delete [] buffer;
|
|
}
|
|
|
|
bool Winnie::getSelOkBack() {
|
|
Common::Event event_;
|
|
|
|
for (;;) {
|
|
while (_vm->_system->getEventManager()->pollEvent(event_)) {
|
|
switch (event_.type) {
|
|
case Common::EVENT_QUIT:
|
|
_vm->_system->quit();
|
|
break;
|
|
case Common::EVENT_LBUTTONUP:
|
|
return true;
|
|
case Common::EVENT_RBUTTONUP:
|
|
return false;
|
|
case Common::EVENT_KEYDOWN:
|
|
switch (event_.kbd.keycode) {
|
|
case Common::KEYCODE_BACKSPACE:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void Winnie::clrMenuSel(int *iSel, int fCanSel[]) {
|
|
*iSel = IDI_WTP_SEL_OPT_1;
|
|
while(!fCanSel[*iSel]) {
|
|
*iSel += 1;
|
|
}
|
|
}
|
|
|
|
void Winnie::printRoomStr(int iRoom, int iStr) {
|
|
WTP_ROOM_HDR hdr;
|
|
uint8 *buffer = (uint8 *)malloc(4096);
|
|
|
|
readRoom(iRoom, buffer, 4096);
|
|
memcpy(&hdr, buffer, sizeof(hdr));
|
|
_vm->printStrXOR((char *)(buffer + hdr.ofsStr[iStr - 1] - IDI_WTP_OFS_ROOM));
|
|
|
|
free(buffer);
|
|
}
|
|
|
|
Winnie::Winnie(PreAgiEngine* vm) : _vm(vm) {
|
|
|
|
}
|
|
|
|
void Winnie::init() {
|
|
initEngine();
|
|
initVars();
|
|
}
|
|
|
|
void Winnie::run() {
|
|
randomize();
|
|
intro();
|
|
gameLoop();
|
|
}
|
|
|
|
}
|