[Scummvm-cvs-logs] CVS: scummvm/kyra kyra.cpp,1.62,1.63 kyra.h,1.28,1.29 screen.cpp,1.17,1.18 screen.h,1.12,1.13 script.cpp,1.18,1.19 script.h,1.11,1.12 script_v1.cpp,1.15,1.16 sprites.cpp,1.4,1.5 sprites.h,1.3,1.4 staticres.cpp,1.12,1.13
Johannes Schickel
lordhoto at users.sourceforge.net
Sat Oct 29 11:38:47 CEST 2005
Update of /cvsroot/scummvm/scummvm/kyra
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv14547
Modified Files:
kyra.cpp kyra.h screen.cpp screen.h script.cpp script.h
script_v1.cpp sprites.cpp sprites.h staticres.cpp
Log Message:
Implemented some basic opcodes, and basic character drawing, also
started to change a bit of the sprite code (thanks to vinterstum for his work)
It is still WIP code and breaks CD version, since all the used tables have to
be located in one cd version binary.
Index: kyra.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/kyra.cpp,v
retrieving revision 1.62
retrieving revision 1.63
diff -u -d -r1.62 -r1.63
--- kyra.cpp 22 Oct 2005 21:04:07 -0000 1.62
+++ kyra.cpp 29 Oct 2005 18:37:40 -0000 1.63
@@ -45,8 +45,6 @@
#include "kyra/sprites.h"
#include "kyra/wsamovie.h"
-#define TEST_SPRITES 1
-
using namespace Kyra;
enum {
@@ -269,6 +267,44 @@
assert(_sprites);
_seq = new SeqPlayer(this, _system);
[...1574 lines suppressed...]
+ AnimObject *cur = queue;
+ AnimObject *prev = queue;
+ while (add->drawY > cur->drawY) {
+ AnimObject *temp = cur->nextAnimObject;
+ if (!temp)
+ break;
+ prev = cur;
+ cur = temp;
+ }
+
+ if (add->drawY <= cur->drawY) {
+ prev->nextAnimObject = add;
+ add->nextAnimObject = cur;
+ } else {
+ cur->nextAnimObject = add;
+ add->nextAnimObject = 0;
+ }
+ return 0;
+}
} // End of namespace Kyra
Index: kyra.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/kyra.h,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -d -r1.28 -r1.29
--- kyra.h 22 Oct 2005 00:24:07 -0000 1.28
+++ kyra.h 29 Oct 2005 18:37:40 -0000 1.29
@@ -31,8 +31,6 @@
namespace Kyra {
-#define MAX_NUM_ROOMS 12
-
enum {
GF_FLOPPY = 1 << 0,
GF_TALKIE = 1 << 1,
@@ -58,39 +56,80 @@
uint32 unk6;
uint8 inventoryItems[10];
int16 x1, y1, x2, y2;
+ uint16 field_20;
+ uint16 field_23;
};
struct Shape {
- uint8 unk0;
- uint8 unk1;
- uint8 imageNum;
+ uint8 imageIndex;
+ int8 xOffset, yOffset;
uint8 x, y, w, h;
};
struct Room {
-// uint8 id;
+ uint8 nameIndex;
uint16 northExit;
uint16 eastExit;
uint16 southExit;
uint16 westExit;
uint8 itemsTable[12];
- const char *filename;
+ uint16 itemsXPos[12];
+ uint8 itemsYPos[12];
+ uint32 unkField3[12]; // maybe pointer to shape of the item
};
-struct Cursor {
+struct AnimObject {
+ uint8 index;
+ uint32 active;
+ uint32 refreshFlag;
+ uint32 bkgdChangeFlag;
+ uint32 flags;
+ int16 drawY;
+ uint8 *sceneAnimPtr;
+ uint16 animFrameNumber;
+ uint8 *background;
+ uint16 rectSize;
+ int16 x1, y1;
+ int16 x2, y2;
+ uint16 width;
+ uint16 height;
+ uint16 width2;
+ uint16 height2;
+ AnimObject *nextAnimObject;
+};
+
+struct Rect {
int x, y;
- int w, h;
+ int x2, y2;
};
struct TalkCoords {
uint16 y, x, w;
};
+struct Item {
+ uint8 unk1;
+ uint8 height;
+ uint8 unk2;
+ uint8 unk3;
+};
+
struct SeqLoop {
const uint8 *ptr;
uint16 count;
};
+struct SceneExits {
+ int16 NorthXPos;
+ int8 NorthYPos;
+ int16 EastXPos;
+ int8 EastYPos;
+ int16 SouthXPos;
+ int8 SouthYPos;
+ int16 WestXPos;
+ int8 WestYPos;
+};
+
struct WSAMovieV1;
class MusicPlayer;
@@ -99,6 +138,9 @@
class PAKFile;
class Screen;
class Sprites;
+struct ScriptState;
+struct ScriptData;
+class ScriptHelper;
class KyraEngine : public Engine {
friend class MusicPlayer;
@@ -124,10 +166,15 @@
uint8 game() const { return _game; }
uint32 features() const { return _features; }
+ SceneExits sceneExits() const { return _sceneExits; }
+ // ugly hack used by the dat loader
+ SceneExits &sceneExits() { return _sceneExits; }
Common::RandomSource _rnd;
+ int16 _northExitHeight;
typedef void (KyraEngine::*IntroProc)();
+ typedef int (KyraEngine::*OpcodeProc)(ScriptState *script);
const char **seqWSATable() { return (const char **)_seq_WSATable; }
const char **seqCPSTable() { return (const char **)_seq_CPSTable; }
@@ -155,6 +202,163 @@
int mouseX() { return _mouseX; }
int mouseY() { return _mouseY; }
+
+ // all opcode procs (maybe that is somehow useless atm)
+ int cmd_magicInMouseItem(ScriptState *script);
+ int cmd_characterSays(ScriptState *script);
+ int cmd_pauseTicks(ScriptState *script);
+ int cmd_drawSceneAnimShape(ScriptState *script);
+ int cmd_queryGameFlag(ScriptState *script);
+ int cmd_setGameFlag(ScriptState *script);
+ int cmd_resetGameFlag(ScriptState *script);
+ int cmd_runNPCScript(ScriptState *script);
+ int cmd_setSpecialExitList(ScriptState *script);
+ int cmd_blockInWalkableRegion(ScriptState *script);
+ int cmd_blockOutWalkableRegion(ScriptState *script);
+ int cmd_walkPlayerToPoint(ScriptState *script);
+ int cmd_dropItemInScene(ScriptState *script);
+ int cmd_drawAnimShapeIntoScene(ScriptState *script);
+ int cmd_createMouseItem(ScriptState *script);
+ int cmd_savePageToDisk(ScriptState *script);
+ int cmd_sceneAnimOn(ScriptState *script);
+ int cmd_sceneAnimOff(ScriptState *script);
+ int cmd_getElapsedSeconds(ScriptState *script);
+ int cmd_mouseIsPointer(ScriptState *script);
+ int cmd_destroyMouseItem(ScriptState *script);
+ int cmd_runSceneAnimUntilDone(ScriptState *script);
+ int cmd_fadeSpecialPalette(ScriptState *script);
+ int cmd_playAdlibSound(ScriptState *script);
+ int cmd_playAdlibScore(ScriptState *script);
+ int cmd_phaseInSameScene(ScriptState *script);
+ int cmd_setScenePhasingFlag(ScriptState *script);
+ int cmd_resetScenePhasingFlag(ScriptState *script);
+ int cmd_queryScenePhasingFlag(ScriptState *script);
+ int cmd_sceneToDirection(ScriptState *script);
+ int cmd_setBirthstoneGem(ScriptState *script);
+ int cmd_placeItemInGenericMapScene(ScriptState *script);
+ int cmd_setBrandonStatusBit(ScriptState *script);
+ int cmd_pauseSeconds(ScriptState *script);
+ int cmd_getCharactersLocation(ScriptState *script);
+ int cmd_runNPCSubscript(ScriptState *script);
+ int cmd_magicOutMouseItem(ScriptState *script);
+ int cmd_internalAnimOn(ScriptState *script);
+ int cmd_forceBrandonToNormal(ScriptState *script);
+ int cmd_poisonDeathNow(ScriptState *script);
+ int cmd_setScaleMode(ScriptState *script);
+ int cmd_openWSAFile(ScriptState *script);
+ int cmd_closeWSAFile(ScriptState *script);
+ int cmd_runWSAFromBeginningToEnd(ScriptState *script);
+ int cmd_displayWSAFrame(ScriptState *script);
+ int cmd_enterNewScene(ScriptState *script);
+ int cmd_setSpecialEnterXAndY(ScriptState *script);
+ int cmd_runWSAFrames(ScriptState *script);
+ int cmd_popBrandonIntoScene(ScriptState *script);
+ int cmd_restoreAllObjectBackgrounds(ScriptState *script);
+ int cmd_setCustomPaletteRange(ScriptState *script);
+ int cmd_loadPageFromDisk(ScriptState *script);
+ int cmd_customPrintTalkString(ScriptState *script);
+ int cmd_restoreCustomPrintBackground(ScriptState *script);
+ int cmd_hideMouse(ScriptState *script);
+ int cmd_showMouse(ScriptState *script);
+ int cmd_getCharacterX(ScriptState *script);
+ int cmd_getCharacterY(ScriptState *script);
+ int cmd_changeCharactersFacing(ScriptState *script);
+ int cmd_CopyWSARegion(ScriptState *script);
+ int cmd_printText(ScriptState *script);
+ int cmd_random(ScriptState *script);
+ int cmd_loadSoundFile(ScriptState *script);
+ int cmd_displayWSAFrameOnHidPage(ScriptState *script);
+ int cmd_displayWSASequentialFrames(ScriptState *script);
+ int cmd_drawCharacterStanding(ScriptState *script);
+ int cmd_internalAnimOff(ScriptState *script);
+ int cmd_changeCharactersXAndY(ScriptState *script);
+ int cmd_clearSceneAnimatorBeacon(ScriptState *script);
+ int cmd_querySceneAnimatorBeacon(ScriptState *script);
+ int cmd_refreshSceneAnimator(ScriptState *script);
+ int cmd_placeItemInOffScene(ScriptState *script);
+ int cmd_wipeDownMouseItem(ScriptState *script);
+ int cmd_placeCharacterInOtherScene(ScriptState *script);
+ int cmd_getKey(ScriptState *script);
+ int cmd_specificItemInInventory(ScriptState *script);
+ int cmd_popMobileNPCIntoScene(ScriptState *script);
+ int cmd_mobileCharacterInScene(ScriptState *script);
+ int cmd_hideMobileCharacter(ScriptState *script);
+ int cmd_unhideMobileCharacter(ScriptState *script);
+ int cmd_setCharactersLocation(ScriptState *script);
+ int cmd_walkCharacterToPoint(ScriptState *script);
+ int cmd_specialEventDisplayBrynnsNote(ScriptState *script);
+ int cmd_specialEventRemoveBrynnsNote(ScriptState *script);
+ int cmd_setLogicPage(ScriptState *script);
+ int cmd_fatPrint(ScriptState *script);
+ int cmd_preserveAllObjectBackgrounds(ScriptState *script);
+ int cmd_updateSceneAnimations(ScriptState *script);
+ int cmd_sceneAnimationActive(ScriptState *script);
+ int cmd_setCharactersMovementDelay(ScriptState *script);
+ int cmd_getCharactersFacing(ScriptState *script);
+ int cmd_bkgdScrollSceneAndMasksRight(ScriptState *script);
+ int cmd_dispelMagicAnimation(ScriptState *script);
+ int cmd_findBrightestFireberry(ScriptState *script);
+ int cmd_setFireberryGlowPalette(ScriptState *script);
+ int cmd_setDeathHandlerFlag(ScriptState *script);
+ int cmd_drinkPotionAnimation(ScriptState *script);
+ int cmd_makeAmuletAppear(ScriptState *script);
+ int cmd_drawItemShapeIntoScene(ScriptState *script);
+ int cmd_setCharactersCurrentFrame(ScriptState *script);
+ int cmd_waitForConfirmationMouseClick(ScriptState *script);
+ int cmd_pageFlip(ScriptState *script);
+ int cmd_setSceneFile(ScriptState *script);
+ int cmd_getItemInMarbleVase(ScriptState *script);
+ int cmd_setItemInMarbleVase(ScriptState *script);
+ int cmd_addItemToInventory(ScriptState *script);
+ int cmd_intPrint(ScriptState *script);
+ int cmd_shakeScreen(ScriptState *script);
+ int cmd_createAmuletJewel(ScriptState *script);
+ int cmd_setSceneAnimCurrXY(ScriptState *script);
+ int cmd_Poison_Brandon_And_Remaps(ScriptState *script);
+ int cmd_fillFlaskWithWater(ScriptState *script);
+ int cmd_getCharactersMovementDelay(ScriptState *script);
+ int cmd_getBirthstoneGem(ScriptState *script);
+ int cmd_queryBrandonStatusBit(ScriptState *script);
+ int cmd_playFluteAnimation(ScriptState *script);
+ int cmd_playWinterScrollSequence(ScriptState *script);
+ int cmd_getIdolGem(ScriptState *script);
+ int cmd_setIdolGem(ScriptState *script);
+ int cmd_totalItemsInScene(ScriptState *script);
+ int cmd_restoreBrandonsMovementDelay(ScriptState *script);
+ int cmd_setMousePos(ScriptState *script);
+ int cmd_getMouseState(ScriptState *script);
+ int cmd_setEntranceMouseCursorTrack(ScriptState *script);
+ int cmd_itemAppearsOnGround(ScriptState *script);
+ int cmd_setNoDrawShapesFlag(ScriptState *script);
+ int cmd_fadeEntirePalette(ScriptState *script);
+ int cmd_itemOnGroundHere(ScriptState *script);
+ int cmd_queryCauldronState(ScriptState *script);
+ int cmd_setCauldronState(ScriptState *script);
+ int cmd_queryCrystalState(ScriptState *script);
+ int cmd_setCrystalState(ScriptState *script);
+ int cmd_setPaletteRange(ScriptState *script);
+ int cmd_shrinkBrandonDown(ScriptState *script);
+ int cmd_growBrandonUp(ScriptState *script);
+ int cmd_setBrandonScaleXAndY(ScriptState *script);
+ int cmd_resetScaleMode(ScriptState *script);
+ int cmd_getScaleDepthTableValue(ScriptState *script);
+ int cmd_setScaleDepthTableValue(ScriptState *script);
+ int cmd_message(ScriptState *script);
+ int cmd_checkClickOnNPC(ScriptState *script);
+ int cmd_getFoyerItem(ScriptState *script);
+ int cmd_setFoyerItem(ScriptState *script);
+ int cmd_setNoItemDropRegion(ScriptState *script);
+ int cmd_walkMalcolmOn(ScriptState *script);
+ int cmd_passiveProtection(ScriptState *script);
+ int cmd_setPlayingLoop(ScriptState *script);
+ int cmd_brandonToStoneSequence(ScriptState *script);
+ int cmd_brandonHealingSequence(ScriptState *script);
+ int cmd_protectCommandLine(ScriptState *script);
+ int cmd_pauseMusicSeconds(ScriptState *script);
+ int cmd_resetMaskRegion(ScriptState *script);
+ int cmd_setPaletteChangeFlag(ScriptState *script);
+ int cmd_fillRect(ScriptState *script);
+ int cmd_dummy(ScriptState *script);
protected:
@@ -172,6 +376,42 @@
int getWidestLineWidth(int linesCount);
void calcWidestLineBounds(int &x1, int &x2, int w, int cx);
void printText(const char *str, int x, int y, uint8 c0, uint8 c1, uint8 c2);
+ void setCharacterDefaultFrame(int character);
+ void setCharactersPositions(int character);
+ void setCharactersHeight();
+ int setGameFlag(int flag);
+ int queryGameFlag(int flag);
+ int resetGameFlag(int flag);
+
+ void enterNewScene(int sceneId, int facing, int unk1, int unk2, int brandonAlive);
+ void moveCharacterToPos(int character, int facing, int xpos, int ypos);
+ void setCharacterPositionWithUpdate(int character);
+ int setCharacterPosition(int character, uint8 *unk1);
+ void setCharacterPositionHelper(int character, uint8 *unk1);
+ int getOppositeFacingDirection(int dir);
+ void loadSceneMSC();
+ void blockInRegion(int x, int y, int width, int height);
+ void blockOutRegion(int x, int y, int width, int height);
+ void startSceneScript(int brandonAlive);
+ void initSceneData(int facing, int unk1, int brandonAlive);
+ void clearNoDropRects();
+ void addToNoDropRects(int x, int y, int w, int h);
+ byte findFreeItemInScene(int scene);
+ byte findItemAtPos(int x, int y);
+ void placeItemInGenericMapScene(int item, int index);
+ void initSceneObjectList(int brandonAlive);
+ void restoreAllObjectBackgrounds();
+ void preserveAnyChangedBackgrounds();
+ void preserveOrRestoreBackground(AnimObject *obj, bool restore);
+ void prepDrawAllObjects();
+ void copyChangedObjectsForward(int refreshFlag);
+ void updateAllObjectShapes();
+ void animRefreshNPC(int character);
+ int findDuplicateItemShape(int shape);
+
+ AnimObject *objectRemoveQueue(AnimObject *queue, AnimObject *rem);
+ AnimObject *objectAddHead(AnimObject *queue, AnimObject *head);
+ AnimObject *objectQueue(AnimObject *queue, AnimObject *add);
void seq_demo();
void seq_intro();
@@ -188,22 +428,32 @@
void snd_setSoundEffectFile(int file);
void snd_playSoundEffect(int track);
+ static OpcodeProc _opcodeTable[];
+ static const int _opcodeTableSize;
+
enum {
RES_ALL = 0,
- RES_INTRO = (1 << 0)
+ RES_INTRO = (1 << 0),
+ RES_INGAME = (1 << 1)
};
void res_loadResources(int type = RES_ALL);
void res_unloadResources(int type = RES_ALL);
void res_loadLangTable(const char *filename, PAKFile *res, byte ***loadTo, int *size, bool nativ);
void res_loadTable(const byte *src, byte ***loadTo, int *size);
-
- void loadRoom(uint16 roomID);
- void drawRoom();
+ void res_loadRoomTable(const byte *src, Room **loadTo, int *size);
+ void res_loadShapeTable(const byte *src, Shape **loadTo, int *size);
+
void delay(uint32 millis);
void loadPalette(const char *filename, uint8 *palData);
void loadMouseShapes();
- void setupRooms();
+ void loadCharacterShapes();
+ void loadSpecialEffectShapes();
+ void loadItems();
+ void loadMainScreen();
+ void setCharactersInDefaultScene();
+ void resetBrandonPosionFlags();
+ void initAnimStateList();
uint8 _game;
bool _fastMode;
@@ -216,14 +466,60 @@
uint16 _talkMessageY;
uint16 _talkMessageH;
bool _talkMessagePrinted;
- uint8 _flagsTable[51];
- uint8 *_itemShapes[377];
+ uint8 _flagsTable[53];
+ uint8 *_shapes[377];
uint16 _gameSpeed;
uint32 _features;
int _mouseX, _mouseY;
bool _needMouseUpdate;
-
+
+ WSAMovieV1 *_wsaObjects[10];
+ uint16 _entranceMouseCursorTracks[8];
+ uint16 _walkBlockNorth;
+ uint16 _walkBlockEast;
+ uint16 _walkBlockSouth;
+ uint16 _walkBlockWest;
+
+ int32 _scaleMode;
+ uint16 _scaleTable[145];
+
+ Rect _noDropRects[11];
+
+ uint16 _birthstoneGemTable[4];
+ uint8 _idolGemsTable[3];
+
+ uint16 _marbleVaseItem;
+
+ uint16 _brandonStatusBit;
+ uint8 _unkBrandonPoisonFlags[256]; // this seem not to be posion flags, it is used for drawing once
+ int _brandonPosX;
+ int _brandonPosY;
+ int16 _brandonScaleX;
+ int16 _brandonScaleY;
+ int _brandonDrawFrame;
+
+ int8 *_sceneAnimTable[50];
+
+ Item _itemTable[145];
+
+ uint16 *_exitListPtr;
+ uint16 _exitList[11];
+ SceneExits _sceneExits;
uint16 _currentRoom;
+ uint8 *_maskBuffer;
+
+ int _movUnkVar1;
+ int _lastFindWayRet;
+ int *_movFacingTable;
+
+ AnimObject *_objectQueue;
+ AnimObject *_animStates;
+ AnimObject *_charactersAnimState;
+ AnimObject *_animObjects;
+ AnimObject *_unkAnimsBuffer;
+
+ int _curMusicTheme;
+ int _newMusicTheme;
AudioStream *_currentVocFile;
Audio::SoundHandle _vocHandle;
@@ -232,7 +528,16 @@
MusicPlayer *_midi;
SeqPlayer *_seq;
Sprites *_sprites;
- Room _rooms[MAX_NUM_ROOMS];
+ ScriptHelper *_scriptInterpreter;
+
+ ScriptState *_scriptMain;
+ ScriptData *_npcScriptData;
+
+ ScriptState *_scriptClick; // TODO: rename to a better name
+ ScriptData *_scriptClickData;
+
+ Character *_characterList;
+ Character *_currentCharacter;
uint8 *_seq_Forest;
uint8 *_seq_KallakWriting;
@@ -255,8 +560,22 @@
int _seq_COLTable_Size;
int _seq_textsTable_Size;
+ char **_characterImageTable;
+ int _characterImageTableSize;
+
+ Shape *_defaultShapeTable;
+ int _defaultShapeTableSize;
+
+ Room *_roomTable;
+ int _roomTableSize;
+ char **_roomFilenameTable;
+ int _roomFilenameTableSize;
+
static const char *_xmidiFiles[];
static const int _xmidiFilesCount;
+
+ static const int8 _charXPosTable[];
+ static const int8 _charYPosTable[];
};
} // End of namespace Kyra
Index: screen.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/screen.cpp,v
retrieving revision 1.17
retrieving revision 1.18
diff -u -d -r1.17 -r1.18
--- screen.cpp 22 Oct 2005 21:04:07 -0000 1.17
+++ screen.cpp 29 Oct 2005 18:37:40 -0000 1.18
@@ -45,6 +45,12 @@
if (_screenPalette) {
memset(_screenPalette, 0, 768);
}
+ for (int i = 0; i < 3; ++i) {
+ _palettes[i] = (uint8 *)malloc(768);
+ if (_palettes[i]) {
+ memset(_palettes[i], 0, 768);
+ }
+ }
_curDim = &_screenDimTable[0];
_charWidth = 0;
_charOffset = 0;
@@ -78,6 +84,9 @@
free(_animBlockPtr);
free(_mouseShape);
free(_mouseRect);
+ for (int i = 0; i < 3; ++i) {
+ free(_palettes[i]);
+ }
}
void Screen::updateScreen() {
@@ -314,7 +323,7 @@
}
const uint8 *src = getPagePtr(_curPage) + y * SCREEN_W + x * 8;
while (h--) {
- memcpy(dst, src, w * 8);
+ memcpy(dst, src, w);
dst += SCREEN_W;
src += SCREEN_H;
}
@@ -559,47 +568,67 @@
// XXX
}
-void Screen::drawShapePlotPixelCallback1(uint8 *dst, uint8 color) {
- debug(9, "Screen::drawShapePlotPixelCallback1(0x%X, %d)", dst, color);
- *dst = color;
-}
-
-void Screen::drawShape(uint8 pageNum, const uint8 *shapeData, int x, int y, int sd, int flags, int *flagsTable, bool itemShape) {
- debug(9, "Screen::drawShape(%d, %d, %d, %d, %d, %d)", pageNum, x, y, sd, flags, itemShape);
+// TODO: implement the other callbacks and implement all of this function
+void Screen::drawShape(uint8 pageNum, const uint8 *shapeData, int x, int y, int sd, int flags, ...) {
+ debug(9, "Screen::drawShape(%d, %d, %d, %d, %d, ...)", pageNum, x, y, sd, flags);
assert(shapeData);
+ va_list args;
+ va_start(args, flags);
+
+ static int drawShapeVar1 = 0;
+ static int drawShapeVar2[] = {
+ 1, 3, 2, 5, 4, 3, 2, 1
+ };
+ static int drawShapeVar3 = 1;
+ static int drawShapeVar4 = 0;
+ static int drawShapeVar5 = 0;
+
+ uint8 *table = 0;
+ int tableLoopCount = 0;
+ int var_30 = 0;
+ uint8 *table2 = 0;
+ uint8 *table3 = 0;
+ uint8 *table4 = 0;
+
if (flags & 0x8000) {
- warning("unhandled (flags & 0x8000) in Screen::drawShape()");
+ table2 = va_arg(args, uint8*);
}
if (flags & 0x100) {
- warning("unhandled (flags & 0x100) in Screen::drawShape()");
+ table = va_arg(args, uint8*);
+ tableLoopCount = va_arg(args, int);
+ if (!tableLoopCount)
+ flags &= 0xFFFFFEFF;
}
if (flags & 0x1000) {
- warning("unhandled (flags & 0x1000) in Screen::drawShape()");
+ table3 = va_arg(args, uint8*);
+ table4 = va_arg(args, uint8*);
}
if (flags & 0x200) {
- warning("unhandled (flags & 0x200) in Screen::drawShape()");
+ drawShapeVar1 += 1;
+ drawShapeVar1 &= 7;
+ drawShapeVar3 = drawShapeVar2[drawShapeVar1];
+ drawShapeVar4 = 0;
+ drawShapeVar5 = 256;
}
if (flags & 0x4000) {
- warning("unhandled (flags & 0x4000) in Screen::drawShape()");
+ drawShapeVar5 = va_arg(args, int);
}
if (flags & 0x800) {
- warning("unhandled (flags & 0x800) in Screen::drawShape()");
+ var_30 = va_arg(args, int);
}
int scale_w, scale_h;
if (flags & DSF_SCALE) {
- scale_w = *flagsTable++;
- scale_h = *flagsTable++;
+ scale_w = va_arg(args, int);
+ scale_h = va_arg(args, int);
} else {
scale_w = 0x100;
scale_h = 0x100;
}
int ppc = (flags >> 8) & 0x3F;
- assert(ppc < _drawShapePlotPixelCount);
- DrawShapePlotPixelCallback plotPixel = _drawShapePlotPixelTable[ppc];
const uint8 *src = shapeData;
- if (_vm->features() & GF_TALKIE && !itemShape) {
+ if (_vm->features() & GF_TALKIE) {
src += 2;
}
uint16 shapeFlags = READ_LE_UINT16(src); src += 2;
@@ -607,12 +636,14 @@
int shapeHeight = *src++;
int scaledShapeHeight = (shapeHeight * scale_h) >> 8;
if (scaledShapeHeight == 0) {
+ va_end(args);
return;
}
int shapeWidth = READ_LE_UINT16(src); src += 2;
int scaledShapeWidth = (shapeWidth * scale_w) >> 8;
if (scaledShapeWidth == 0) {
+ va_end(args);
return;
}
@@ -640,6 +671,7 @@
}
if (!_decodeShapeBuffer) {
_decodeShapeBufferSize = 0;
+ va_end(args);
return;
}
memset(_decodeShapeBuffer, 0, _decodeShapeBufferSize);
@@ -650,7 +682,15 @@
while (count > 0) {
uint8 code = *src++;
if (code != 0) {
- *decodedShapeFrame++ = code;
+ // this is guessed
+ if (shapeFlags & 1) {
+ const uint8 *colorTable = shapeData + 10;
+ if (_vm->features() & GF_TALKIE)
+ colorTable += 2;
+ *decodedShapeFrame++ = colorTable[code];
+ } else {
+ *decodedShapeFrame++ = code;
+ }
--count;
} else {
code = *src++;
@@ -732,18 +772,294 @@
j = -j;
}
for (x = x1; x < x2; ++x) {
- int i = scaleXTable[x];
+ int xpos = scaleXTable[x];
if (flags & DSF_X_FLIPPED) {
- i = -i;
+ xpos = -xpos;
}
- uint8 color = shapeBuffer[j * shapeWidth + i];
+ uint8 color = shapeBuffer[j * shapeWidth + xpos];
if (color != 0) {
- (this->*plotPixel)(dst, color);
+ switch (ppc) {
+ case 0:
+ *dst = color;
+ break;
+
+ case 1:
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ break;
+
+ case 2: {
+ int temp = drawShapeVar4 + drawShapeVar5;
+ if (temp & 0xFF00) {
+ drawShapeVar4 = temp & 0xFF;
+ dst += drawShapeVar3;
+ color = *dst;
+ dst -= drawShapeVar3;
+ } else {
+ drawShapeVar4 = temp;
+ }
+ } break;
+
+ case 7:
+ case 3:
+ color = *dst;
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ break;
+
+ case 4:
+ color = table2[color];
+ break;
+
+ case 5:
+ color = table2[color];
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ break;
+
+ case 6: {
+ int temp = drawShapeVar4 + drawShapeVar5;
+ if (temp & 0xFF00) {
+ drawShapeVar4 = temp & 0xFF;
+ dst += drawShapeVar3;
+ color = *dst;
+ dst -= drawShapeVar3;
+ } else {
+ drawShapeVar4 = temp;
+ color = table2[color];
+ }
+ } break;
+
+ case 8: {
+ int offset = dst - shapeBuffer;
+ uint8 pixel = *(_shapePages[0] + offset);
+ pixel &= 0x7F;
+ pixel &= 0x87;
+ if (var_30 < pixel) {
+ color = *(_shapePages[1] + offset);
+ }
+ } break;
+
+ case 9: {
+ int offset = dst - shapeBuffer;
+ uint8 pixel = *(_shapePages[0] + offset);
+ pixel &= 0x7F;
+ pixel &= 0x87;
+ if (var_30 < pixel) {
+ color = *(_shapePages[1] + offset);
+ } else {
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ }
+ } break;
+
+ case 10: {
+ int offset = dst - shapeBuffer;
+ uint8 pixel = *(_shapePages[0] + offset);
+ pixel &= 0x7F;
+ pixel &= 0x87;
+ if (var_30 < pixel) {
+ color = *(_shapePages[1] + offset);
+ drawShapeVar4 = pixel;
+ } else {
+ int temp = drawShapeVar4 + drawShapeVar5;
+ if (temp & 0xFF00) {
+ dst += drawShapeVar3;
+ color = *dst;
+ dst -= drawShapeVar3;
+ }
+ drawShapeVar4 = temp & 0xFF;
+ }
+ } break;
+
+ case 15:
+ case 11: {
+ int offset = dst - shapeBuffer;
+ uint8 pixel = *(_shapePages[0] + offset);
+ pixel &= 0x7F;
+ pixel &= 0x87;
+ if (var_30 < pixel) {
+ color = *(_shapePages[1] + offset);
+ } else {
+ color = *dst;
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ }
+ } break;
+
+ case 12: {
+ int offset = dst - shapeBuffer;
+ uint8 pixel = *(_shapePages[0] + offset);
+ pixel &= 0x7F;
+ pixel &= 0x87;
+ if (var_30 < pixel) {
+ color = *(_shapePages[1] + offset);
+ } else {
+ color = table2[color];
+ }
+ } break;
+
+ case 13: {
+ int offset = dst - shapeBuffer;
+ uint8 pixel = *(_shapePages[0] + offset);
+ pixel &= 0x7F;
+ pixel &= 0x87;
+ if (var_30 < pixel) {
+ color = *(_shapePages[1] + offset);
+ } else {
+ color = table2[color];
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ }
+ } break;
+
+ case 14: {
+ int offset = dst - shapeBuffer;
+ uint8 pixel = *(_shapePages[0] + offset);
+ pixel &= 0x7F;
+ pixel &= 0x87;
+ if (var_30 < pixel) {
+ color = *(_shapePages[1] + offset);
+ drawShapeVar4 = pixel;
+ } else {
+ int temp = drawShapeVar4 + drawShapeVar5;
+ if (temp & 0xFF00) {
+ dst += drawShapeVar3;
+ color = *dst;
+ dst -= drawShapeVar3;
+ drawShapeVar4 = temp % 0xFF;
+ } else {
+ drawShapeVar4 = temp;
+ color = table2[color];
+ }
+ }
+ } break;
+
+ case 16: {
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ } break;
+
+ case 17: {
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ } break;
+
+ case 18: {
+ int temp = drawShapeVar4 + drawShapeVar5;
+ if (temp & 0xFF00) {
+ drawShapeVar4 = temp & 0xFF;
+ dst += drawShapeVar3;
+ color = *dst;
+ dst -= drawShapeVar3;
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ } else {
+ drawShapeVar4 = temp;
+ }
+ } break;
+
+ case 23:
+ case 19: {
+ color = *dst;
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ } break;
+
+ case 20: {
+ color = table2[color];
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ } break;
+
+ case 21: {
+ color = table2[color];
+ for (int i = 0; i < tableLoopCount; ++i) {
+ color = table[color];
+ }
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ } break;
+
+ case 22: {
+ int temp = drawShapeVar4 + drawShapeVar5;
+ if (temp & 0xFF00) {
+ drawShapeVar4 = temp & 0xFF;
+ dst += drawShapeVar3;
+ color = *dst;
+ dst -= drawShapeVar3;
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ } else {
+ drawShapeVar4 = temp;
+ color = table2[color];
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ }
+ } break;
+
+ case 24: {
+ int offset = dst - shapeBuffer;
+ uint8 pixel = *(_shapePages[0] + offset);
+ pixel &= 0x7F;
+ pixel &= 0x87;
+ if (var_30 < pixel) {
+ color = *(_shapePages[1] + offset);
+ }
+ uint8 newColor = table3[color];
+ if (!(newColor & 0x80)) {
+ color = *dst;
+ color = table4[color + (newColor << 8)];
+ }
+ } break;
+
+ default:
+ warning("unhandled ppc: %d", ppc);
+ break;
+ }
+ *dst = color;
}
++dst;
}
dst = dstNextLine;
}
+ va_end(args);
}
void Screen::decodeFrame3(const uint8 *src, uint8 *dst, uint32 size) {
@@ -994,10 +1310,17 @@
static uint8 table[274];
int tableIndex = 0;
- uint8 *newShape = (uint8*)malloc(shapeSize+16);
+ uint8 *newShape = NULL;
+ if (_vm->features() & GF_TALKIE) {
+ newShape = (uint8*)malloc(shapeSize+16);
+ } else {
+ newShape = (uint8*)malloc(shapeSize+18);
+ }
assert(newShape);
byte *dst = newShape;
+ if (_vm->features() & GF_TALKIE)
+ dst += 2;
WRITE_LE_UINT16(dst, (flags & 3)); dst += 2;
*dst = h; dst += 1;
WRITE_LE_UINT16(dst, w); dst += 2;
@@ -1026,6 +1349,7 @@
table[0x100+tableIndex] = value;
table[value] = tableIndex;
++tableIndex;
+ value = tableIndex;
}
} else {
value = table[value];
@@ -1063,11 +1387,15 @@
if (!(flags & 2)) {
if (shapeSize > _animBlockSize) {
dst = newShape;
+ if (_vm->features() & GF_TALKIE)
+ dst += 2;
flags = READ_LE_UINT16(dst);
flags |= 2;
WRITE_LE_UINT16(dst, flags);
} else {
src = newShape;
+ if (_vm->features() & GF_TALKIE)
+ src += 2;
if (flags & 1) {
src += 16;
}
@@ -1097,6 +1425,8 @@
if (flags & 1) {
dst = newShape + 10;
+ if (_vm->features() & GF_TALKIE)
+ dst += 2;
src = &table[0x100];
memcpy(dst, src, sizeof(uint8)*16);
}
@@ -1281,6 +1611,9 @@
restoreMouseRect();
+ if (_vm->features() & GF_TALKIE)
+ shape += 2;
+
int mouseRectSize = getRectSize((READ_LE_UINT16(shape + 3) >> 3) + 2, shape[5]);
if (_mouseRectSize < mouseRectSize) {
free(_mouseRect);
@@ -1302,6 +1635,8 @@
byte *dst = _mouseShape;
byte *src = shape;
+ if (_vm->features() & GF_TALKIE)
+ dst += 2;
if (!(READ_LE_UINT16(shape) & 2)) {
uint16 newFlags = 0;
@@ -1338,13 +1673,10 @@
// if disableMouse
// return
- // if mouseUnk == 0 {
- if (_mouseDrawWidth && _mouseRect) {
- copyScreenFromRect(_mouseDrawX, _mouseDrawY, _mouseDrawWidth, _mouseDrawHeight, _mouseRect);
- }
- _mouseDrawWidth = 0;
- // }
- // ++mouseUnk
+ if (_mouseDrawWidth && _mouseRect) {
+ copyScreenFromRect(_mouseDrawX, _mouseDrawY, _mouseDrawWidth, _mouseDrawHeight, _mouseRect);
+ }
+ _mouseDrawWidth = 0;
}
void Screen::copyMouseToScreen() {
@@ -1352,11 +1684,6 @@
// if disableMouse
// return
- // if mouseUnk == 0
- // return
- // --mouseUnk
- // if mouseUnk != 0
- // return
int width = _mouseWidth;
int height = _mouseHeight;
int xpos = _vm->mouseX() - _mouseXOffset;
@@ -1396,14 +1723,14 @@
copyScreenToRect(_mouseDrawX, _mouseDrawY, width, height, _mouseRect);
}
- drawShape(0, _mouseShape, xpos, ypos, 0, 0, 0, true);
+ drawShape(0, _mouseShape, xpos, ypos, 0, 0, 0);
}
void Screen::copyScreenFromRect(int x, int y, int w, int h, uint8 *ptr) {
debug(9, "copyScreenFromRect(%d, %d, %d, %d, 0x%X)", x, y, w, h, ptr);
x <<= 3; w <<= 3;
uint8 *src = ptr;
- uint8 *dst = &_pagePtrs[0][y * SCREEN_W + x];
+ uint8 *dst = &_pagePtrs[0][y * SCREEN_W + x];
for (int i = 0; i < h; ++i) {
memcpy(dst, src, w);
src += w;
@@ -1415,7 +1742,7 @@
debug(9, "copyScreenToRect(%d, %d, %d, %d, 0x%X)", x, y, w, h, ptr);
x <<= 3; w <<= 3;
uint8 *src = &_pagePtrs[0][y * SCREEN_W + x];
- uint8 *dst = ptr;
+ uint8 *dst = ptr;
for (int i = 0; i < h; ++i) {
memcpy(dst, src, w);
dst += w;
@@ -1423,4 +1750,14 @@
}
}
+uint8 *Screen::getPalette(int num) {
+ debug(9, "getPalette(%d)", num);
+ assert(num >= 0 && num < 4);
+ if (num == 0) {
+ return _screenPalette;
+ }
+
+ return _palettes[num-1];
+}
+
} // End of namespace Kyra
Index: screen.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/screen.h,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -d -r1.12 -r1.13
--- screen.h 22 Oct 2005 12:59:16 -0000 1.12
+++ screen.h 29 Oct 2005 18:37:40 -0000 1.13
@@ -23,6 +23,7 @@
#define KYRASCREEN_H
#include "common/util.h"
+#include <stdarg.h>
class OSystem;
@@ -110,26 +111,26 @@
void drawChar(uint8 c, int x, int y);
void setScreenDim(int dim);
void drawShapePlotPixelCallback1(uint8 *dst, uint8 color);
- void drawShape(uint8 pageNum, const uint8 *shapeData, int x, int y, int sd, int flags, int *flagsTable, bool itemShape=false);
+ void drawShape(uint8 pageNum, const uint8 *shapeData, int x, int y, int sd, int flags, ...);
static void decodeFrame3(const uint8 *src, uint8 *dst, uint32 size);
static void decodeFrame4(const uint8 *src, uint8 *dst, uint32 dstSize);
static void decodeFrameDelta(uint8 *dst, const uint8 *src);
static void decodeFrameDeltaPage(uint8 *dst, const uint8 *src, int pitch);
uint8 *encodeShape(int x, int y, int w, int h, int flags);
void copyRegionToBuffer(int pageNum, int x, int y, int w, int h, uint8 *dest);
-
+
int getRectSize(int x, int y);
void hideMouse();
void showMouse();
void setShapePages(int page1, int page2);
byte *setMouseCursor(int x, int y, byte *shape);
+ uint8 *getPalette(int num);
int _charWidth;
int _charOffset;
int _curPage;
uint8 *_currentPalette;
-
- typedef void (Screen::*DrawShapePlotPixelCallback)(uint8 *dst, uint8 c);
+ uint8 *_shapePages[2];
private:
int16 encodeShapeAndCalculateSize(uint8 *from, uint8 *to, int size);
@@ -139,8 +140,8 @@
void copyScreenToRect(int x, int y, int w, int h, uint8 *ptr);
uint8 *_pagePtrs[16];
- uint8 *_shapePages[2];
uint8 *_screenPalette;
+ uint8 *_palettes[3];
const ScreenDim *_curDim;
FontId _currentFont;
Font _fonts[FID_NUM];
@@ -164,8 +165,6 @@
static const ScreenDim _screenDimTable[];
static const int _screenDimTableCount;
- static const DrawShapePlotPixelCallback _drawShapePlotPixelTable[];
- static const int _drawShapePlotPixelCount;
};
} // End of namespace Kyra
Index: script.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/script.cpp,v
retrieving revision 1.18
retrieving revision 1.19
diff -u -d -r1.18 -r1.19
--- script.cpp 18 Oct 2005 01:30:18 -0000 1.18
+++ script.cpp 29 Oct 2005 18:37:40 -0000 1.19
@@ -69,7 +69,7 @@
ScriptHelper::~ScriptHelper() {
}
-bool ScriptHelper::loadScript(const char *filename, ScriptData *scriptData, byte *specialPtr) {
+bool ScriptHelper::loadScript(const char *filename, ScriptData *scriptData, KyraEngine::OpcodeProc *opcodes, int opcodeSize, byte *specialPtr) {
uint32 size = 0;
uint8 *data = _vm->resource()->fileData(filename, &size);
byte *curData = data;
@@ -147,6 +147,8 @@
return false;
}
scriptData->dataSize = chunkSize / 2;
+ scriptData->opcodes = opcodes;
+ scriptData->opcodeSize = opcodeSize;
delete [] data;
return true;
Index: script.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/script.h,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- script.h 18 Oct 2005 01:30:18 -0000 1.11
+++ script.h 29 Oct 2005 18:37:40 -0000 1.12
@@ -30,7 +30,8 @@
byte *data;
byte *ordr;
uint16 dataSize;
- /*command table ptr (uint32)*/
+ KyraEngine::OpcodeProc *opcodes;
+ int opcodeSize;
uint16 mustBeFreed;
};
@@ -53,10 +54,10 @@
ScriptHelper(KyraEngine *vm);
virtual ~ScriptHelper();
- bool loadScript(const char *filename, ScriptData *data, byte *specialPtr = 0);
+ bool loadScript(const char *filename, ScriptData *data, KyraEngine::OpcodeProc *opcodes, int opcodeSize, byte *specialPtr = 0);
void unloadScript(ScriptData *data);
- void initScript(ScriptState *scriptStat, ScriptData *data);
+ void initScript(ScriptState *scriptState, ScriptData *data);
bool startScript(ScriptState *script, int function);
bool validScript(ScriptState *script);
Index: script_v1.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/script_v1.cpp,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -d -r1.15 -r1.16
--- script_v1.cpp 18 Oct 2005 01:30:18 -0000 1.15
+++ script_v1.cpp 29 Oct 2005 18:37:40 -0000 1.16
@@ -22,6 +22,9 @@
#include "common/stdafx.h"
#include "kyra/kyra.h"
#include "kyra/script.h"
+#include "kyra/screen.h"
+#include "kyra/sprites.h"
+#include "common/system.h"
namespace Kyra {
@@ -112,9 +115,10 @@
}
void ScriptHelper::c1_execOpcode() {
- warning("c1_execOpcode STUB");
- // return 0 zero for now
- _curScript->retValue = 0;
+ assert((int)_parameter < _curScript->dataPtr->opcodeSize);
+ if (_curScript->dataPtr->opcodes[_parameter] == &KyraEngine::cmd_dummy)
+ debug("calling unimplemented opcode(0x%.02X)", _parameter);
+ _curScript->retValue = (_vm->*_curScript->dataPtr->opcodes[_parameter])(_curScript);
}
void ScriptHelper::c1_ifNotJmp() {
@@ -287,4 +291,949 @@
}
}
+#pragma mark -
+#pragma mark - Opcode implementations
+#pragma mark -
+
+#define stackPos(x) script->stack[script->sp+x]
+
+int KyraEngine::cmd_magicInMouseItem(ScriptState *script) {
+ warning("STUB: cmd_magicInMouseItem");
+ return 0;
+}
+
+int KyraEngine::cmd_characterSays(ScriptState *script) {
+ warning("STUB: cmd_characterSays");
+ return 0;
+}
+
+int KyraEngine::cmd_pauseTicks(ScriptState *script) {
+ warning("STUB: cmd_pauseTicks");
+ return 0;
+}
+
+int KyraEngine::cmd_drawSceneAnimShape(ScriptState *script) {
+ debug(9, "cmd_drawSceneAnimShape(0x%X)", script);
+ _screen->drawShape( stackPos(4), _sprites->getSceneShape(stackPos(0)), stackPos(1), stackPos(2), 0, stackPos(3) );
+ return 0;
+}
+
+int KyraEngine::cmd_queryGameFlag(ScriptState *script) {
+ debug(9, "cmd_queryGameFlag(0x%X)", script);
+ return queryGameFlag(stackPos(0));
+}
+
+int KyraEngine::cmd_setGameFlag(ScriptState *script) {
+ debug(9, "cmd_setGameFlag(0x%X)", script);
+ return setGameFlag(stackPos(0));
+}
+
+int KyraEngine::cmd_resetGameFlag(ScriptState *script) {
+ debug(9, "cmd_resetGameFlag(0x%X)", script);
+ return resetGameFlag(stackPos(0));
+}
+
+int KyraEngine::cmd_runNPCScript(ScriptState *script) {
+ warning("STUB: cmd_runNPCScript");
+ return 0;
+}
+
+int KyraEngine::cmd_setSpecialExitList(ScriptState *script) {
+ debug(9, "cmd_setSpecialExitList(0x%X)", script);
+
+ for (int i = 0; i < 10; ++i) {
+ _exitList[i] = stackPos(i);
+ }
+ _exitListPtr = _exitList;
+
+ return 0;
+}
+
+int KyraEngine::cmd_blockInWalkableRegion(ScriptState *script) {
+ debug(9, "cmd_blockInWalkableRegion(0x%X)", script);
+ blockOutRegion(stackPos(0), stackPos(1), stackPos(2)-stackPos(0)+1, stackPos(3)-stackPos(1)+1);
+ return 0;
+}
+
+int KyraEngine::cmd_blockOutWalkableRegion(ScriptState *script) {
+ debug(9, "cmd_blockOutWalkableRegion(0x%X)", script);
+ blockOutRegion(stackPos(0), stackPos(1), stackPos(2)-stackPos(0)+1, stackPos(3)-stackPos(1)+1);
+ return 0;
+}
+
+int KyraEngine::cmd_walkPlayerToPoint(ScriptState *script) {
+ warning("STUB: cmd_walkPlayerToPoint");
+ return 0;
+}
+
+int KyraEngine::cmd_dropItemInScene(ScriptState *script) {
+ debug(9, "cmd_dropItemInScene(0x%X)", script);
+ int item = stackPos(0);
+ int xpos = stackPos(1);
+ int ypos = stackPos(2);
+
+ byte freeItem = findFreeItemInScene(_currentCharacter->sceneId);
+ if (freeItem != 0xFF) {
+ int sceneId = _currentCharacter->sceneId;
+ Room *room = &_roomTable[sceneId];
+ room->itemsXPos[freeItem] = xpos;
+ room->itemsYPos[freeItem] = ypos;
+ room->itemsTable[freeItem] = item;
+
+ warning("PARTIALLY IMPLEMENTED: cmd_dropItemInScene");
+ // XXX animAddGameItem
+ // XXX updateAllObjectShapes
+ } else {
+ if (item == 43) {
+ placeItemInGenericMapScene(item, 0);
+ } else {
+ placeItemInGenericMapScene(item, 1);
+ }
+ }
+ return 0;
+}
+
+int KyraEngine::cmd_drawAnimShapeIntoScene(ScriptState *script) {
+ warning("STUB: cmd_drawAnimShapeIntoScene");
+ return 0;
+}
+
+int KyraEngine::cmd_createMouseItem(ScriptState *script) {
+ warning("STUB: cmd_createMouseItem");
+ return 0;
+}
+
+int KyraEngine::cmd_savePageToDisk(ScriptState *script) {
+ warning("STUB: cmd_savePageToDisk");
+ return 0;
+}
+
+int KyraEngine::cmd_sceneAnimOn(ScriptState *script) {
+ debug(9, "cmd_sceneAnimOn(0x%X)", script);
+ _sprites->enableAnim(stackPos(0));
+ return 0;
+}
+
+int KyraEngine::cmd_sceneAnimOff(ScriptState *script) {
+ debug(9, "cmd_sceneAnimOff(0x%X)", script);
+ _sprites->disableAnim(stackPos(0));
+ return 0;
+}
+
+int KyraEngine::cmd_getElapsedSeconds(ScriptState *script) {
+ warning("STUB: cmd_getElapsedSeconds");
+ return 0;
+}
+
+int KyraEngine::cmd_mouseIsPointer(ScriptState *script) {
+ warning("STUB: cmd_mouseIsPointer");
+ return 0;
+}
+
+int KyraEngine::cmd_destroyMouseItem(ScriptState *script) {
+ warning("STUB: cmd_destroyMouseItem");
+ return 0;
+}
+
+int KyraEngine::cmd_runSceneAnimUntilDone(ScriptState *script) {
+ warning("STUB: cmd_runSceneAnimUntilDone");
+ return 0;
+}
+
+int KyraEngine::cmd_fadeSpecialPalette(ScriptState *script) {
+ warning("STUB: cmd_fadeSpecialPalette");
+ return 0;
+}
+
+int KyraEngine::cmd_playAdlibSound(ScriptState *script) {
+ warning("STUB: cmd_playAdlibSound");
+ return 0;
+}
+
+int KyraEngine::cmd_playAdlibScore(ScriptState *script) {
+ warning("STUB: cmd_playAdlibScore");
+ return 0;
+}
+
+int KyraEngine::cmd_phaseInSameScene(ScriptState *script) {
+ warning("STUB: cmd_phaseInSameScene");
+ return 0;
+}
+
+int KyraEngine::cmd_setScenePhasingFlag(ScriptState *script) {
+ warning("STUB: cmd_setScenePhasingFlag");
+ return 0;
+}
+
+int KyraEngine::cmd_resetScenePhasingFlag(ScriptState *script) {
+ warning("STUB: cmd_resetScenePhasingFlag");
+ return 0;
+}
+
+int KyraEngine::cmd_queryScenePhasingFlag(ScriptState *script) {
+ warning("STUB: cmd_queryScenePhasingFlag");
+ return 0;
+}
+
+int KyraEngine::cmd_sceneToDirection(ScriptState *script) {
+ warning("STUB: cmd_sceneToDirection");
+ return 0;
+}
+
+int KyraEngine::cmd_setBirthstoneGem(ScriptState *script) {
+ debug(9, "cmd_setBirthstoneGem(0x%X)", script);
+ int index = stackPos(0);
+ if (index < 4 && index >= 0) {
+ _birthstoneGemTable[index] = stackPos(1);
+ return 1;
+ }
+ return 0;
+}
+
+int KyraEngine::cmd_placeItemInGenericMapScene(ScriptState *script) {
+ debug(9, "cmd_placeItemInGenericMapScene(0x%X)", script);
+ placeItemInGenericMapScene(stackPos(0), stackPos(1));
+ return 0;
+}
+
+int KyraEngine::cmd_setBrandonStatusBit(ScriptState *script) {
+ warning("STUB: cmd_setBrandonStatusBit");
+ return 0;
+}
+
+int KyraEngine::cmd_pauseSeconds(ScriptState *script) {
+ debug(9, "cmd_pauseSeconds(0x%X)", script);
+ _system->delayMillis(stackPos(0)*1000);
+ return 0;
+}
+
+int KyraEngine::cmd_getCharactersLocation(ScriptState *script) {
+ warning("STUB: cmd_getCharactersLocation");
+ return 0;
+}
+
+int KyraEngine::cmd_runNPCSubscript(ScriptState *script) {
+ warning("STUB: cmd_runNPCSubscript");
+ return 0;
+}
+
+int KyraEngine::cmd_magicOutMouseItem(ScriptState *script) {
+ warning("STUB: cmd_magicOutMouseItem");
+ return 0;
+}
+
+int KyraEngine::cmd_internalAnimOn(ScriptState *script) {
+ warning("STUB: cmd_internalAnimOn");
+ return 0;
+}
+
+int KyraEngine::cmd_forceBrandonToNormal(ScriptState *script) {
+ warning("STUB: cmd_forceBrandonToNormal");
+ return 0;
+}
+
+int KyraEngine::cmd_poisonDeathNow(ScriptState *script) {
+ warning("STUB: cmd_poisonDeathNow");
+ return 0;
+}
+
+int KyraEngine::cmd_setScaleMode(ScriptState *script) {
+ warning("STUB: cmd_setScaleMode");
+ return 0;
+}
+
+int KyraEngine::cmd_openWSAFile(ScriptState *script) {
+ debug(9, "cmd_openWSAFile(0x%X)", script);
+
+ int wsaIndex = stackPos(0);
+ uint16 offset = READ_BE_UINT16(&script->dataPtr->text[wsaIndex]);
+ char *filename = (char*)&script->dataPtr->text[offset];
+
+ wsaIndex = stackPos(1);
+ // stackPos(2) is NOT used whyever
+ int offscreenDecode = 0;
+ if (!stackPos(3)) {
+ offscreenDecode = 1;
+ } else {
+ offscreenDecode = 0;
+ }
+
+ _wsaObjects[wsaIndex] = wsa_open(filename, offscreenDecode, 0);
+ assert(_wsaObjects[wsaIndex]);
+
+ return 0;
+}
+
+int KyraEngine::cmd_closeWSAFile(ScriptState *script) {
+ debug(9, "cmd_closeWSAFile(0x%X)", script);
+
+ int wsaIndex = stackPos(0);
+ if (_wsaObjects[wsaIndex]) {
+ wsa_close(_wsaObjects[wsaIndex]);
+ _wsaObjects[wsaIndex] = 0;
+ }
+
+ return 0;
+}
+
+int KyraEngine::cmd_runWSAFromBeginningToEnd(ScriptState *script) {
+ debug(9, "cmd_runWSAFromBeginningToEnd(0x%X)", script);
+
+ _screen->hideMouse();
+
+ bool running = true;
+
+ int xpos = stackPos(0);
+ int ypos = stackPos(1);
+ int waitTime = stackPos(2);
+ int wsaIndex = stackPos(3);
+ int worldUpdate = stackPos(4);
+ int wsaFrame = 0;
+
+ while (running) {
+ wsa_play(_wsaObjects[wsaIndex], wsaFrame++, xpos, ypos, 0);
+ if (wsaFrame >= wsa_getNumFrames(_wsaObjects[wsaIndex]))
+ running = false;
+
+ waitTicks(waitTime);
+ _screen->updateScreen();
+ if (worldUpdate) {
+ updateAllObjectShapes();
+ // XXX
+ }
+ }
+
+ _screen->showMouse();
+
+ return 0;
+}
+
+int KyraEngine::cmd_displayWSAFrame(ScriptState *script) {
+ warning("STUB: cmd_displayWSAFrame");
+ return 0;
+}
+
+int KyraEngine::cmd_enterNewScene(ScriptState *script) {
+ debug(9, "cmd_enterNewScene(0x%X)", script);
+ enterNewScene(stackPos(0), stackPos(1), stackPos(2), stackPos(3), stackPos(4));
+ return 0;
+}
+
+int KyraEngine::cmd_setSpecialEnterXAndY(ScriptState *script) {
+ debug(9, "cmd_setSpecialEnterXAndY(0x%X)", script);
+ _brandonPosX = stackPos(0);
+ _brandonPosY = stackPos(1);
+ if (_brandonPosX + 1 == 0 && _brandonPosY + 1 == 0)
+ _currentCharacter->currentAnimFrame = 88;
+ return 0;
+}
+
+int KyraEngine::cmd_runWSAFrames(ScriptState *script) {
+ warning("STUB: cmd_runWSAFrames");
+ return 0;
+}
+
+int KyraEngine::cmd_popBrandonIntoScene(ScriptState *script) {
+ warning("STUB: cmd_popBrandonIntoScene");
+ return 0;
+}
+
+int KyraEngine::cmd_restoreAllObjectBackgrounds(ScriptState *script) {
+ warning("STUB: cmd_restoreAllObjectBackgrounds");
+ return 0;
+}
+
+int KyraEngine::cmd_setCustomPaletteRange(ScriptState *script) {
+ warning("STUB: cmd_setCustomPaletteRange");
+ return 0;
+}
+
+int KyraEngine::cmd_loadPageFromDisk(ScriptState *script) {
+ warning("STUB: cmd_loadPageFromDisk");
+ return 0;
+}
+
+int KyraEngine::cmd_customPrintTalkString(ScriptState *script) {
+ warning("STUB: cmd_customPrintTalkString");
+ return 0;
+}
+
+int KyraEngine::cmd_restoreCustomPrintBackground(ScriptState *script) {
+ warning("STUB: cmd_restoreCustomPrintBackground");
+ return 0;
+}
+
+int KyraEngine::cmd_hideMouse(ScriptState *script) {
+ debug(9, "cmd_hideMouse(0x%X)", script);
+ _screen->hideMouse();
+ return 0;
+}
+
+int KyraEngine::cmd_showMouse(ScriptState *script) {
+ debug(9, "cmd_showMouse(0x%X)", script);
+ _screen->showMouse();
+ return 0;
+}
+
+int KyraEngine::cmd_getCharacterX(ScriptState *script) {
+ debug(9, "cmd_getCharacterX(0x%X)", script);
+ return _characterList[stackPos(0)].x1;
+}
+
+int KyraEngine::cmd_getCharacterY(ScriptState *script) {
+ debug(9, "cmd_getCharacterY(0x%X)", script);
+ return _characterList[stackPos(0)].y1;
+}
+
+int KyraEngine::cmd_changeCharactersFacing(ScriptState *script) {
+ warning("STUB: cmd_changeCharactersFacing");
+ return 0;
+}
+
+int KyraEngine::cmd_CopyWSARegion(ScriptState *script) {
+ warning("STUB: cmd_CopyWSARegion");
+ return 0;
+}
+
+int KyraEngine::cmd_printText(ScriptState *script) {
+ warning("STUB: cmd_printText");
+ return 0;
+}
+
+int KyraEngine::cmd_random(ScriptState *script) {
+ debug(9, "cmd_random(0x%X)", script);
+ assert(stackPos(0) < stackPos(1));
+ return _rnd.getRandomNumberRng(stackPos(0), stackPos(1));
+}
+
+int KyraEngine::cmd_loadSoundFile(ScriptState *script) {
+ warning("STUB: cmd_loadSoundFile");
+ return 0;
+}
+
+int KyraEngine::cmd_displayWSAFrameOnHidPage(ScriptState *script) {
+ warning("STUB: cmd_displayWSAFrameOnHidPage");
+ return 0;
+}
+
+int KyraEngine::cmd_displayWSASequentialFrames(ScriptState *script) {
+ warning("STUB: cmd_displayWSASequentialFrames");
+ return 0;
+}
+
+int KyraEngine::cmd_drawCharacterStanding(ScriptState *script) {
+ debug(9, "cmd_drawCharacterStanding(0x%X)", script);
+ // XXX
+ int character = stackPos(0);
+ int animFrame = stackPos(1);
+ int newFacing = stackPos(2);
+ int updateShapes = stackPos(3);
+ _characterList[character].currentAnimFrame = animFrame;
+ if (newFacing != -1) {
+ _characterList[character].facing = newFacing;
+ }
+ animRefreshNPC(character);
+ if (updateShapes) {
+ updateAllObjectShapes();
+ }
+ return 0;
+}
+
+int KyraEngine::cmd_internalAnimOff(ScriptState *script) {
+ warning("STUB: cmd_internalAnimOff");
+ return 0;
+}
+
+int KyraEngine::cmd_changeCharactersXAndY(ScriptState *script) {
+ warning("STUB: cmd_changeCharactersXAndY");
+ return 0;
+}
+
+int KyraEngine::cmd_clearSceneAnimatorBeacon(ScriptState *script) {
+ warning("STUB: cmd_clearSceneAnimatorBeacon");
+ return 0;
+}
+
+int KyraEngine::cmd_querySceneAnimatorBeacon(ScriptState *script) {
+ warning("STUB: cmd_querySceneAnimatorBeacon");
+ return 0;
+}
+
+int KyraEngine::cmd_refreshSceneAnimator(ScriptState *script) {
+ warning("STUB: cmd_refreshSceneAnimator");
+ return 0;
+}
+
+int KyraEngine::cmd_placeItemInOffScene(ScriptState *script) {
+ debug(9, "cmd_placeItemInOffScene(0x%X)", script);
+ int item = stackPos(0);
+ int xpos = stackPos(1);
+ int ypos = stackPos(2);
+ int sceneId = stackPos(3);
+
+ byte freeItem = findFreeItemInScene(sceneId);
+ if (freeItem != 0xFF) {
+ assert(sceneId < _roomTableSize);
+ Room *room = &_roomTable[sceneId];
+
+ room->itemsTable[freeItem] = item;
+ room->itemsXPos[freeItem] = xpos;
+ room->itemsYPos[freeItem] = ypos;
+ }
+ return 0;
+}
+
+int KyraEngine::cmd_wipeDownMouseItem(ScriptState *script) {
+ warning("STUB: cmd_wipeDownMouseItem");
+ return 0;
+}
+
+int KyraEngine::cmd_placeCharacterInOtherScene(ScriptState *script) {
+ debug(9, "cmd_placeCharacterInOtherScene(0x%X)", script);
+ int id = stackPos(0);
+ int sceneId = stackPos(1);
+ int xpos = stackPos(2) & 0xFFFC;
+ int ypos = stackPos(3) & 0xFE;
+ int facing = stackPos(4);
+ int animFrame = stackPos(5);
+
+ _characterList[id].sceneId = sceneId;
+ _characterList[id].x1 = _characterList[id].x2 = xpos;
+ _characterList[id].y1 = _characterList[id].y2 = ypos;
+ _characterList[id].facing = facing;
+ _characterList[id].currentAnimFrame = animFrame;
+ return 0;
+}
+
+int KyraEngine::cmd_getKey(ScriptState *script) {
+ warning("STUB: cmd_getKey");
+ return 0;
+}
+
+int KyraEngine::cmd_specificItemInInventory(ScriptState *script) {
+ warning("STUB: cmd_specificItemInInventory");
+ return 0;
+}
+
+int KyraEngine::cmd_popMobileNPCIntoScene(ScriptState *script) {
+ warning("STUB: cmd_popMobileNPCIntoScene");
+ return 0;
+}
+
+int KyraEngine::cmd_mobileCharacterInScene(ScriptState *script) {
+ warning("STUB: cmd_mobileCharacterInScene");
+ return 0;
+}
+
+int KyraEngine::cmd_hideMobileCharacter(ScriptState *script) {
+ warning("STUB: cmd_hideMobileCharacter");
+ return 0;
+}
+
+int KyraEngine::cmd_unhideMobileCharacter(ScriptState *script) {
+ warning("STUB: cmd_unhideMobileCharacter");
+ return 0;
+}
+
+int KyraEngine::cmd_setCharactersLocation(ScriptState *script) {
+ warning("STUB: cmd_setCharactersLocation");
+ return 0;
+}
+
+int KyraEngine::cmd_walkCharacterToPoint(ScriptState *script) {
+ warning("STUB: cmd_walkCharacterToPoint");
+// debug(9, "cmd_walkCharacterToPoint(0x%X)", script);
+// int character = stackPos(0);
+// int toX = stackPos(1);
+// int toY = stackPos(2);
+// _movUnkVar1 = 1;
+// int findWayReturn = findWay(_characterList[character].x1, _characterList[character].y1, toX, toY, _movFacingTable, 150);
+// _movUnkVar1 = 0;
+// if (_lastFindWayRet < findWayReturn) {
+// _lastFindWayRet = findWayReturn;
+// }
+// if (findWayReturn == 0x7D00 || findWayReturn == 0) {
+// return 0;
+// }
+// int *curPos = _movFacingTable;
+// bool running = true;
+// while (running) {
+// // XXX
+// }
+ return 0;
+}
+
+int KyraEngine::cmd_specialEventDisplayBrynnsNote(ScriptState *script) {
+ warning("STUB: cmd_specialEventDisplayBrynnsNote");
+ return 0;
+}
+
+int KyraEngine::cmd_specialEventRemoveBrynnsNote(ScriptState *script) {
+ warning("STUB: cmd_specialEventRemoveBrynnsNote");
+ return 0;
+}
+
+int KyraEngine::cmd_setLogicPage(ScriptState *script) {
+ warning("STUB: cmd_setLogicPage");
+ return 0;
+}
+
+int KyraEngine::cmd_fatPrint(ScriptState *script) {
+ warning("STUB: cmd_fatPrint");
+ return 0;
+}
+
+int KyraEngine::cmd_preserveAllObjectBackgrounds(ScriptState *script) {
+ warning("STUB: cmd_preserveAllObjectBackgrounds");
+ return 0;
+}
+
+int KyraEngine::cmd_updateSceneAnimations(ScriptState *script) {
+ warning("STUB: cmd_updateSceneAnimations");
+ return 0;
+}
+
+int KyraEngine::cmd_sceneAnimationActive(ScriptState *script) {
+ warning("STUB: cmd_sceneAnimationActive");
+ return 0;
+}
+
+int KyraEngine::cmd_setCharactersMovementDelay(ScriptState *script) {
+ warning("STUB: cmd_setCharactersMovementDelay");
+ return 0;
+}
+
+int KyraEngine::cmd_getCharactersFacing(ScriptState *script) {
+ warning("STUB: cmd_getCharactersFacing");
+ return 0;
+}
+
+int KyraEngine::cmd_bkgdScrollSceneAndMasksRight(ScriptState *script) {
+ warning("STUB: cmd_bkgdScrollSceneAndMasksRight");
+ return 0;
+}
+
+int KyraEngine::cmd_dispelMagicAnimation(ScriptState *script) {
+ warning("STUB: cmd_dispelMagicAnimation");
+ return 0;
+}
+
+int KyraEngine::cmd_findBrightestFireberry(ScriptState *script) {
+ warning("STUB: cmd_findBrightestFireberry");
+ return 0;
+}
+
+int KyraEngine::cmd_setFireberryGlowPalette(ScriptState *script) {
+ warning("STUB: cmd_setFireberryGlowPalette");
+ return 0;
+}
+
+int KyraEngine::cmd_setDeathHandlerFlag(ScriptState *script) {
+ warning("STUB: cmd_setDeathHandlerFlag");
+ return 0;
+}
+
+int KyraEngine::cmd_drinkPotionAnimation(ScriptState *script) {
+ warning("STUB: cmd_drinkPotionAnimation");
+ return 0;
+}
+
+int KyraEngine::cmd_makeAmuletAppear(ScriptState *script) {
+ warning("STUB: cmd_makeAmuletAppear");
+ return 0;
+}
+
+int KyraEngine::cmd_drawItemShapeIntoScene(ScriptState *script) {
+ warning("STUB: cmd_drawItemShapeIntoScene");
+ return 0;
+}
+
+int KyraEngine::cmd_setCharactersCurrentFrame(ScriptState *script) {
+ warning("STUB: cmd_setCharactersCurrentFrame");
+ return 0;
+}
+
+int KyraEngine::cmd_waitForConfirmationMouseClick(ScriptState *script) {
+ warning("STUB: cmd_waitForConfirmationMouseClick");
+ return 0;
+}
+
+int KyraEngine::cmd_pageFlip(ScriptState *script) {
+ warning("STUB: cmd_pageFlip");
+ return 0;
+}
+
+int KyraEngine::cmd_setSceneFile(ScriptState *script) {
+ warning("STUB: cmd_setSceneFile");
+ return 0;
+}
+
+int KyraEngine::cmd_getItemInMarbleVase(ScriptState *script) {
+ warning("STUB: cmd_getItemInMarbleVase");
+ return 0;
+}
+
+int KyraEngine::cmd_setItemInMarbleVase(ScriptState *script) {
+ debug(9, "cmd_setItemInMarbleVase(0x%X)", script);
+ _marbleVaseItem = stackPos(0);
+ return 0;
+}
+
+int KyraEngine::cmd_addItemToInventory(ScriptState *script) {
+ warning("STUB: cmd_addItemToInventory");
+ return 0;
+}
+
+int KyraEngine::cmd_intPrint(ScriptState *script) {
+ warning("STUB: cmd_intPrint");
+ return 0;
+}
+
+int KyraEngine::cmd_shakeScreen(ScriptState *script) {
+ warning("STUB: cmd_shakeScreen");
+ return 0;
+}
+
+int KyraEngine::cmd_createAmuletJewel(ScriptState *script) {
+ warning("STUB: cmd_createAmuletJewel");
+ return 0;
+}
+
+int KyraEngine::cmd_setSceneAnimCurrXY(ScriptState *script) {
+ warning("STUB: cmd_setSceneAnimCurrXY");
+ return 0;
+}
+
+int KyraEngine::cmd_Poison_Brandon_And_Remaps(ScriptState *script) {
+ warning("STUB: cmd_Poison_Brandon_And_Remaps");
+ return 0;
+}
+
+int KyraEngine::cmd_fillFlaskWithWater(ScriptState *script) {
+ warning("STUB: cmd_fillFlaskWithWater");
+ return 0;
+}
+
+int KyraEngine::cmd_getCharactersMovementDelay(ScriptState *script) {
+ warning("STUB: cmd_getCharactersMovementDelay");
+ return 0;
+}
+
+int KyraEngine::cmd_getBirthstoneGem(ScriptState *script) {
+ warning("STUB: cmd_getBirthstoneGem");
+ return 0;
+}
+
+int KyraEngine::cmd_queryBrandonStatusBit(ScriptState *script) {
+ warning("STUB: cmd_queryBrandonStatusBit");
+ return 0;
+}
+
+int KyraEngine::cmd_playFluteAnimation(ScriptState *script) {
+ warning("STUB: cmd_playFluteAnimation");
+ return 0;
+}
+
+int KyraEngine::cmd_playWinterScrollSequence(ScriptState *script) {
+ warning("STUB: cmd_playWinterScrollSequence");
+ return 0;
+}
+
+int KyraEngine::cmd_getIdolGem(ScriptState *script) {
+ warning("STUB: cmd_getIdolGem");
+ return 0;
+}
+
+int KyraEngine::cmd_setIdolGem(ScriptState *script) {
+ debug(9, "cmd_setIdolGem(0x%X)", script);
+ _idolGemsTable[stackPos(0)] = stackPos(1);
+ return 0;
+}
+
+int KyraEngine::cmd_totalItemsInScene(ScriptState *script) {
+ warning("STUB: cmd_totalItemsInScene");
+ return 0;
+}
+
+int KyraEngine::cmd_restoreBrandonsMovementDelay(ScriptState *script) {
+ warning("STUB: cmd_restoreBrandonsMovementDelay");
+ return 0;
+}
+
+int KyraEngine::cmd_setMousePos(ScriptState *script) {
+ warning("STUB: cmd_setMousePos");
+ return 0;
+}
+
+int KyraEngine::cmd_getMouseState(ScriptState *script) {
+ warning("STUB: cmd_getMouseState");
+ return 0;
+}
+
+int KyraEngine::cmd_setEntranceMouseCursorTrack(ScriptState *script) {
+ debug(9, "cmd_setEntranceMouseCursorTrack(0x%X)", script);
+ _entranceMouseCursorTracks[0] = stackPos(0);
+ _entranceMouseCursorTracks[1] = stackPos(1);
+ _entranceMouseCursorTracks[2] = stackPos(0) + stackPos(2) - 1;
+ _entranceMouseCursorTracks[3] = stackPos(1) + stackPos(3) - 1;
+ _entranceMouseCursorTracks[4] = stackPos(3);
+ return 0;
+}
+
+int KyraEngine::cmd_itemAppearsOnGround(ScriptState *script) {
+ warning("STUB: cmd_itemAppearsOnGround");
+ return 0;
+}
+
+int KyraEngine::cmd_setNoDrawShapesFlag(ScriptState *script) {
+ warning("STUB: cmd_setNoDrawShapesFlag");
+ return 0;
+}
+
+int KyraEngine::cmd_fadeEntirePalette(ScriptState *script) {
+ warning("STUB: cmd_fadeEntirePalette");
+ return 0;
+}
+
+int KyraEngine::cmd_itemOnGroundHere(ScriptState *script) {
+ warning("STUB: cmd_itemOnGroundHere");
+ return 0;
+}
+
+int KyraEngine::cmd_queryCauldronState(ScriptState *script) {
+ warning("STUB: cmd_queryCauldronState");
+ return 0;
+}
+
+int KyraEngine::cmd_setCauldronState(ScriptState *script) {
+ warning("STUB: cmd_setCauldronState");
+ return 0;
+}
+
+int KyraEngine::cmd_queryCrystalState(ScriptState *script) {
+ warning("STUB: cmd_queryCrystalState");
+ return 0;
+}
+
+int KyraEngine::cmd_setCrystalState(ScriptState *script) {
+ warning("STUB: cmd_setCrystalState");
+ return 0;
+}
+
+int KyraEngine::cmd_setPaletteRange(ScriptState *script) {
+ warning("STUB: cmd_setPaletteRange");
+ return 0;
+}
+
+int KyraEngine::cmd_shrinkBrandonDown(ScriptState *script) {
+ warning("STUB: cmd_shrinkBrandonDown");
+ return 0;
+}
+
+int KyraEngine::cmd_growBrandonUp(ScriptState *script) {
+ warning("STUB: cmd_growBrandonUp");
+ return 0;
+}
+
+int KyraEngine::cmd_setBrandonScaleXAndY(ScriptState *script) {
+ warning("STUB: cmd_setBrandonScaleXAndY");
+ return 0;
+}
+
+int KyraEngine::cmd_resetScaleMode(ScriptState *script) {
+ warning("STUB: cmd_resetScaleMode");
+ return 0;
+}
+
+int KyraEngine::cmd_getScaleDepthTableValue(ScriptState *script) {
+ warning("STUB: cmd_getScaleDepthTableValue");
+ return 0;
+}
+
+int KyraEngine::cmd_setScaleDepthTableValue(ScriptState *script) {
+ warning("STUB: cmd_setScaleDepthTableValue");
+ return 0;
+}
+
+int KyraEngine::cmd_message(ScriptState *script) {
+ warning("STUB: cmd_message");
+ return 0;
+}
+
+int KyraEngine::cmd_checkClickOnNPC(ScriptState *script) {
+ warning("STUB: cmd_checkClickOnNPC");
+ return 0;
+}
+
+int KyraEngine::cmd_getFoyerItem(ScriptState *script) {
+ warning("STUB: cmd_getFoyerItem");
+ return 0;
+}
+
+int KyraEngine::cmd_setFoyerItem(ScriptState *script) {
+ warning("STUB: cmd_setFoyerItem");
+ return 0;
+}
+
+int KyraEngine::cmd_setNoItemDropRegion(ScriptState *script) {
+ debug(9, "cmd_setNoItemDropRegion(0x%X)", script);
+ addToNoDropRects(stackPos(0), stackPos(1), stackPos(2), stackPos(3));
+ return 0;
+}
+
+int KyraEngine::cmd_walkMalcolmOn(ScriptState *script) {
+ warning("STUB: cmd_walkMalcolmOn");
+ return 0;
+}
+
+int KyraEngine::cmd_passiveProtection(ScriptState *script) {
+ warning("STUB: cmd_passiveProtection");
+ return 0;
+}
+
+int KyraEngine::cmd_setPlayingLoop(ScriptState *script) {
+ warning("STUB: cmd_setPlayingLoop");
+ return 0;
+}
+
+int KyraEngine::cmd_brandonToStoneSequence(ScriptState *script) {
+ warning("STUB: cmd_brandonToStoneSequence");
+ return 0;
+}
+
+int KyraEngine::cmd_brandonHealingSequence(ScriptState *script) {
+ warning("STUB: cmd_brandonHealingSequence");
+ return 0;
+}
+
+int KyraEngine::cmd_protectCommandLine(ScriptState *script) {
+ warning("STUB: cmd_protectCommandLine");
+ return 0;
+}
+
+int KyraEngine::cmd_pauseMusicSeconds(ScriptState *script) {
+ warning("STUB: cmd_pauseMusicSeconds");
+ return 0;
+}
+
+int KyraEngine::cmd_resetMaskRegion(ScriptState *script) {
+ warning("STUB: cmd_resetMaskRegion");
+ return 0;
+}
+
+int KyraEngine::cmd_setPaletteChangeFlag(ScriptState *script) {
+ warning("STUB: cmd_setPaletteChangeFlag");
+ return 0;
+}
+
+int KyraEngine::cmd_fillRect(ScriptState *script) {
+ warning("STUB: cmd_fillRect");
+ return 0;
+}
+
+int KyraEngine::cmd_dummy(ScriptState *script) {
+ debug(9, "cmd_dummy(0x%X)", script);
+ return 0;
+}
+
} // end of namespace Kyra
Index: sprites.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/sprites.cpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- sprites.cpp 19 Oct 2005 07:16:17 -0000 1.4
+++ sprites.cpp 29 Oct 2005 18:37:40 -0000 1.5
@@ -37,16 +37,20 @@
_system = system;
_dat = 0;
memset(_anims, 0, sizeof(_anims));
+ memset( _sceneShapes, 0, sizeof(_sceneShapes));
_animDelay = 16;
+ _spriteDefStart = 0;
+
}
Sprites::~Sprites() {
delete[] _dat;
+ freeSceneShapes();
}
-Sprite Sprites::getSprite(uint8 spriteID) {
- assert( spriteID < MAX_NUM_SPRITES);
- return _sprites[spriteID];
+uint8 *Sprites::getSceneShape(uint8 sceneShapeID) {
+ assert( sceneShapeID < ARRAYSIZE(_sceneShapes));
+ return _sceneShapes[sceneShapeID];
}
void Sprites::drawSprites(uint8 srcPage, uint8 dstPage) {
@@ -56,21 +60,23 @@
if (_anims[i].script == 0 || !_anims[i].play)
break;
if (_anims[i].sprite >= 0) {
- assert( _anims[i].sprite < MAX_NUM_SPRITES);
- Sprite sprite = _sprites[_anims[i].sprite];
+ assert( _anims[i].sprite < ARRAYSIZE(_sceneShapes));
+ uint8 *sprite = _sceneShapes[_anims[i].sprite];
//debug(1, "Drawing from X %i, Y %i, to X %i, Y %i, width %i, height %i, srcPage %i, dstPage %i",
// sprite.x, sprite.y, _anims[i].x, _anims[i].y, sprite.width, sprite.height, srcPage, dstPage);
flags = Screen::CR_CLIPPED;
if (_anims[i].flipX)
flags |= Screen::CR_X_FLIPPED;
-
- _screen->copyRegion(sprite.x, sprite.y, _anims[i].x, _anims[i].y, sprite.width, sprite.height, srcPage, dstPage, flags);
+
+ //_screen->copyRegion(sprite.x, sprite.y, _anims[i].x, _anims[i].y, sprite.width, sprite.height, srcPage, dstPage, flags);
+ _screen->drawShape(0, sprite, _anims[i].x, _anims[i].y, 0, 0, 0);
}
}
}
void Sprites::doAnims() {
+ debug(9, "Sprites::doAnims()");
uint32 currTime = _system->getMillis();
for (int i = 0; i < MAX_NUM_ANIMS; i++) {
if (_anims[i].script == 0 || !_anims[i].play || _anims[i].nextRun != 0 && _anims[i].nextRun > currTime)
@@ -363,6 +369,10 @@
assert(fileSize > 0x6D);
+ _engine->_northExitHeight = READ_BE_UINT16(_dat + 0x15);
+ if (_engine->_northExitHeight & 1)
+ _engine->_northExitHeight += 1;
+ // XXX
memcpy(_screen->_currentPalette + 745 - 0x3D, _dat + 0x17, 0x3D);
_screen->setScreenPalette(_screen->_currentPalette);
uint8 *data = _dat + 0x6B;
@@ -398,27 +408,10 @@
break;
case 0xFF84:
data += 2;
+ _spriteDefStart = data;
while (READ_LE_UINT16(data) != 0xFF85) {
- uint16 spriteNum = READ_LE_UINT16(data);
- //debug(1, "Spritenum: %i", spriteNum);
- assert(spriteNum < MAX_NUM_SPRITES);
data += 2;
- _sprites[spriteNum].x = READ_LE_UINT16(data) * 8;
- data += 2;
- _sprites[spriteNum].y = READ_LE_UINT16(data);
- data += 2;
- _sprites[spriteNum].width = READ_LE_UINT16(data) * 8;
- data += 2;
- _sprites[spriteNum].height = READ_LE_UINT16(data);
- data += 2;
- spritesLoaded++;
- //debug(1, "Got sprite index: %i", spriteNum);
- //debug(1, "X: %i", _sprites[spriteNum].x);
- //debug(1, "Y: %i", _sprites[spriteNum].y);
- //debug(1, "Width: %i", _sprites[spriteNum].width);
- //debug(1, "Height: %i", _sprites[spriteNum].height);
}
- //debug(1, "End of sprite images.");
data += 2;
break;
case 0xFF86:
@@ -453,6 +446,48 @@
assert(fileSize - (data - _dat) == 0xC);
//TODO: Read in character entry coords here
+ SceneExits &exits = _engine->sceneExits();
+
+ exits.NorthXPos = READ_LE_UINT16(data) & 0xFFFC; data += 2;
+ exits.NorthYPos = *data++ & 0xFFFE;
+ exits.EastXPos = READ_LE_UINT16(data) & 0xFFFC; data += 2;
+ exits.EastYPos = *data++ & 0xFFFE;
+ exits.SouthXPos = READ_LE_UINT16(data) & 0xFFFC; data += 2;
+ exits.SouthYPos = *data++ & 0xFFFE;
+ exits.WestXPos = READ_LE_UINT16(data) & 0xFFFC; data += 2;
+ exits.WestYPos = *data++ & 0xFFFE;
+}
+
+void Sprites::freeSceneShapes() {
+ for (int i = 0; i < ARRAYSIZE(_sceneShapes); i++ )
+ free(_sceneShapes[i]);
+
+}
+
+void Sprites::loadSceneShapes() {
+ debug(9, "Sprites::loadSceneShapes()");
+ uint8 *data = _spriteDefStart;
+ int spriteNum, x, y, width, height;
+
+ assert(_spriteDefStart);
+
+ freeSceneShapes();
+ memset( _sceneShapes, 0, sizeof(_sceneShapes));
+
+ while (READ_LE_UINT16(data) != 0xFF85) {
+ spriteNum = READ_LE_UINT16(data);
+ assert(spriteNum < ARRAYSIZE(_sceneShapes));
+ data += 2;
+ x = READ_LE_UINT16(data) * 8;
+ data += 2;
+ y = READ_LE_UINT16(data);
+ data += 2;
+ width = READ_LE_UINT16(data) * 8;
+ data += 2;
+ height = READ_LE_UINT16(data);
+ data += 2;
+ _sceneShapes[spriteNum] = _screen->encodeShape(x, y, width, height, 0);
+ }
}
} // end of namespace Kyra
Index: sprites.h
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/sprites.h,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- sprites.h 18 Oct 2005 20:38:30 -0000 1.3
+++ sprites.h 29 Oct 2005 18:37:40 -0000 1.4
@@ -24,7 +24,6 @@
namespace Kyra {
-#define MAX_NUM_SPRITES 50
#define MAX_NUM_ANIMS 11
struct Sprite {
@@ -55,23 +54,27 @@
~Sprites();
void doAnims();
- void loadDAT(const char* filename);
- Sprite getSprite(uint8 spriteID);
+ void loadDAT(const char *filename);
+ uint8 *getSceneShape(uint8 sceneShapeID);
void drawSprites(uint8 srcPage, uint8 dstPage);
+ void loadSceneShapes();
void enableAnim(uint8 anim) { _anims[anim].play = true; }
void disableAnim(uint8 anim) { _anims[anim].play = false; }
protected:
+ void freeSceneShapes();
+
KyraEngine *_engine;
Resource *_res;
OSystem *_system;
Screen *_screen;
- Sprite _sprites[MAX_NUM_SPRITES];
+ uint8 *_sceneShapes[50];
uint8 *_dat;
Anim _anims[MAX_NUM_ANIMS];
Common::RandomSource _rnd;
uint8 _animDelay;
+ uint8 *_spriteDefStart;
};
} // End of namespace Kyra
Index: staticres.cpp
===================================================================
RCS file: /cvsroot/scummvm/scummvm/kyra/staticres.cpp,v
retrieving revision 1.12
retrieving revision 1.13
diff -u -d -r1.12 -r1.13
--- staticres.cpp 22 Oct 2005 00:24:07 -0000 1.12
+++ staticres.cpp 29 Oct 2005 18:37:40 -0000 1.13
@@ -26,7 +26,7 @@
namespace Kyra {
-#define RESFILE_VERSION 1
+#define RESFILE_VERSION 2
#define GAME_FLAGS (GF_FLOPPY | GF_TALKIE | GF_DEMO | GF_AUDIOCD)
#define LANGUAGE_FLAGS (GF_ENGLISH | GF_FRENCH | GF_GERMAN | GF_SPANISH | GF_LNGUNK)
@@ -129,31 +129,41 @@
loadNativeLanguage = false;
}
-#define loadRawFile(x, y, z) \
+#define getFileEx(x, y) \
if (_features & GF_TALKIE) { \
temp = getFile(x, y ".CD"); \
} else if (_features & GF_DEMO) { \
temp = getFile(x, y ".DEM"); \
} else { \
temp = getFile(x, y); \
- } \
+ }
+#define loadRawFile(x, y, z) \
+ getFileEx(x, y) \
if (temp) { \
z = temp; \
temp = 0; \
}
#define loadTable(x, y, z, a) \
- if (_features & GF_TALKIE) { \
- temp = getFile(x, y ".CD"); \
- } else if (_features & GF_DEMO) { \
- temp = getFile(x, y ".DEM"); \
- } else { \
- temp = getFile(x, y); \
- } \
+ getFileEx(x, y) \
if (temp) { \
res_loadTable(temp, z, a); \
delete [] temp; \
temp = 0; \
}
+#define loadRooms(x, y, z, a) \
+ getFileEx(x, y) \
+ if (temp) { \
+ res_loadRoomTable(temp, z, a); \
+ delete [] temp; \
+ temp = 0; \
+ }
+#define loadShapes(x, y, z, a) \
+ getFileEx(x, y) \
+ if (temp) { \
+ res_loadShapeTable(temp, z, a); \
+ delete [] temp; \
+ temp = 0; \
+ }
if ((type & RES_INTRO) || type == RES_ALL) {
loadRawFile(resFile, "FOREST.SEQ", _seq_Forest);
@@ -174,8 +184,19 @@
res_loadLangTable("INTRO-STRINGS.", &resFile, (byte***)&_seq_textsTable, &_seq_textsTable_Size, loadNativeLanguage);
}
+ if ((type & RES_INGAME) || type == RES_ALL) {
+ loadTable(resFile, "ROOM-FILENAMES.TXT", (byte***)&_roomFilenameTable, &_roomFilenameTableSize);
+ loadRooms(resFile, "ROOM-TABLE.ROOM", &_roomTable, &_roomTableSize);
+
+ loadTable(resFile, "CHAR-IMAGE.TXT", (byte***)&_characterImageTable, &_characterImageTableSize);
+
+ loadShapes(resFile, "SHAPES-DEFAULT.SHP", &_defaultShapeTable, &_defaultShapeTableSize);
+ }
+
+#undef loadRooms
#undef loadTable
#undef loadRawFile
+#undef getFileEx
}
void KyraEngine::res_unloadResources(int type) {
@@ -220,6 +241,27 @@
delete [] _seq_Demo3; _seq_Demo3 = 0;
delete [] _seq_Demo4; _seq_Demo4 = 0;
}
+
+ if ((type & RES_INGAME) || type == RES_ALL) {
+ for (int i = 0; i < _roomFilenameTableSize; ++i) {
+ delete [] _roomFilenameTable[i];
+ }
+ delete [] _roomFilenameTable;
+ _roomFilenameTableSize = 0;
+ _roomFilenameTable = 0;
+
+ delete [] _roomTable; _roomTable = 0;
+ _roomTableSize = 0;
+
+ for (int i = 0; i < _characterImageTableSize; ++i) {
+ delete [] _characterImageTable[i];
+ }
+ delete [] _characterImageTable;
+ _characterImageTableSize = 0;
+
+ delete [] _defaultShapeTable;
+ _defaultShapeTableSize = 0;
+ }
}
void KyraEngine::res_loadLangTable(const char *filename, PAKFile *res, byte ***loadTo, int *size, bool nativ) {
@@ -263,6 +305,41 @@
}
}
+void KyraEngine::res_loadRoomTable(const byte *src, Room **loadTo, int *size) {
+ uint32 count = READ_BE_UINT32(src); src += 4;
+ *size = count;
+ *loadTo = new Room[count];
+
+ for (uint32 i = 0; i < count; ++i) {
+ (*loadTo)[i].nameIndex = *src++;
+ (*loadTo)[i].northExit = READ_LE_UINT16(src); src += 2;
+ (*loadTo)[i].eastExit = READ_LE_UINT16(src); src += 2;
+ (*loadTo)[i].southExit = READ_LE_UINT16(src); src += 2;
+ (*loadTo)[i].westExit = READ_LE_UINT16(src); src += 2;
+ memset(&(*loadTo)[i].itemsTable[0], 0xFF, sizeof(byte)*6);
+ memset(&(*loadTo)[i].itemsTable[6], 0, sizeof(byte)*6);
+ memset((*loadTo)[i].itemsXPos, 0, sizeof(uint16)*12);
+ memset((*loadTo)[i].itemsYPos, 0, sizeof(uint8)*12);
+ memset((*loadTo)[i].unkField3, 0, sizeof((*loadTo)[i].unkField3));
+ }
+}
+
+void KyraEngine::res_loadShapeTable(const byte *src, Shape **loadTo, int *size) {
+ uint32 count = READ_BE_UINT32(src); src += 4;
+ *size = count;
+ *loadTo = new Shape[count];
+
+ for (uint32 i = 0; i < count; ++i) {
+ (*loadTo)[i].imageIndex = *src++;
+ (*loadTo)[i].x = *src++;
+ (*loadTo)[i].y = *src++;
+ (*loadTo)[i].w = *src++;
+ (*loadTo)[i].h = *src++;
+ (*loadTo)[i].xOffset = *src++;
+ (*loadTo)[i].yOffset = *src++;
+ }
+}
+
const ScreenDim Screen::_screenDimTable[] = {
{ 0x00, 0x00, 0x28, 0xC8, 0x0F, 0x0C, 0x00, 0x00 },
{ 0x08, 0x48, 0x18, 0x38, 0x0F, 0x0C, 0x00, 0x00 },
@@ -279,12 +356,207 @@
const int Screen::_screenDimTableCount = ARRAYSIZE(_screenDimTable);
-const Screen::DrawShapePlotPixelCallback Screen::_drawShapePlotPixelTable[] = {
- &Screen::drawShapePlotPixelCallback1
- // XXX
+// CD Version *could* use an different opcodeTable
+#define Opcode(x) &KyraEngine::x
+KyraEngine::OpcodeProc KyraEngine::_opcodeTable[] = {
+ // 0x00
+ Opcode(cmd_magicInMouseItem),
+ Opcode(cmd_characterSays),
+ Opcode(cmd_pauseTicks),
+ Opcode(cmd_drawSceneAnimShape),
+ // 0x04
+ Opcode(cmd_queryGameFlag),
+ Opcode(cmd_setGameFlag),
+ Opcode(cmd_resetGameFlag),
+ Opcode(cmd_runNPCScript),
+ // 0x08
+ Opcode(cmd_setSpecialExitList),
+ Opcode(cmd_blockInWalkableRegion),
+ Opcode(cmd_blockOutWalkableRegion),
+ Opcode(cmd_walkPlayerToPoint),
+ // 0x0c
+ Opcode(cmd_dropItemInScene),
+ Opcode(cmd_drawAnimShapeIntoScene),
+ Opcode(cmd_createMouseItem),
+ Opcode(cmd_savePageToDisk),
+ // 0x10
+ Opcode(cmd_sceneAnimOn),
+ Opcode(cmd_sceneAnimOff),
+ Opcode(cmd_getElapsedSeconds),
+ Opcode(cmd_mouseIsPointer),
+ // 0x14
+ Opcode(cmd_destroyMouseItem),
+ Opcode(cmd_runSceneAnimUntilDone),
+ Opcode(cmd_fadeSpecialPalette),
+ Opcode(cmd_playAdlibSound),
+ // 0x18
+ Opcode(cmd_playAdlibScore),
+ Opcode(cmd_phaseInSameScene),
+ Opcode(cmd_setScenePhasingFlag),
+ Opcode(cmd_resetScenePhasingFlag),
+ // 0x1c
+ Opcode(cmd_queryScenePhasingFlag),
+ Opcode(cmd_sceneToDirection),
+ Opcode(cmd_setBirthstoneGem),
+ Opcode(cmd_placeItemInGenericMapScene),
+ // 0x20
+ Opcode(cmd_setBrandonStatusBit),
+ Opcode(cmd_pauseSeconds),
+ Opcode(cmd_getCharactersLocation),
+ Opcode(cmd_runNPCSubscript),
+ // 0x24
+ Opcode(cmd_magicOutMouseItem),
+ Opcode(cmd_internalAnimOn),
+ Opcode(cmd_forceBrandonToNormal),
+ Opcode(cmd_poisonDeathNow),
+ // 0x28
+ Opcode(cmd_setScaleMode),
+ Opcode(cmd_openWSAFile),
+ Opcode(cmd_closeWSAFile),
+ Opcode(cmd_runWSAFromBeginningToEnd),
+ // 0x2c
+ Opcode(cmd_displayWSAFrame),
+ Opcode(cmd_enterNewScene),
+ Opcode(cmd_setSpecialEnterXAndY),
+ Opcode(cmd_runWSAFrames),
+ // 0x30
+ Opcode(cmd_popBrandonIntoScene),
+ Opcode(cmd_restoreAllObjectBackgrounds),
+ Opcode(cmd_setCustomPaletteRange),
+ Opcode(cmd_loadPageFromDisk),
+ // 0x34
+ Opcode(cmd_customPrintTalkString),
+ Opcode(cmd_restoreCustomPrintBackground),
+ Opcode(cmd_hideMouse),
+ Opcode(cmd_showMouse),
+ // 0x38
+ Opcode(cmd_getCharacterX),
+ Opcode(cmd_getCharacterY),
+ Opcode(cmd_changeCharactersFacing),
+ Opcode(cmd_CopyWSARegion),
+ // 0x3c
+ Opcode(cmd_printText),
+ Opcode(cmd_random),
+ Opcode(cmd_loadSoundFile),
+ Opcode(cmd_displayWSAFrameOnHidPage),
+ // 0x40
+ Opcode(cmd_displayWSASequentialFrames),
+ Opcode(cmd_drawCharacterStanding),
+ Opcode(cmd_internalAnimOff),
+ Opcode(cmd_changeCharactersXAndY),
+ // 0x44
+ Opcode(cmd_clearSceneAnimatorBeacon),
+ Opcode(cmd_querySceneAnimatorBeacon),
+ Opcode(cmd_refreshSceneAnimator),
+ Opcode(cmd_placeItemInOffScene),
+ // 0x48
+ Opcode(cmd_wipeDownMouseItem),
+ Opcode(cmd_placeCharacterInOtherScene),
+ Opcode(cmd_getKey),
+ Opcode(cmd_specificItemInInventory),
+ // 0x4c
+ Opcode(cmd_popMobileNPCIntoScene),
+ Opcode(cmd_mobileCharacterInScene),
+ Opcode(cmd_hideMobileCharacter),
+ Opcode(cmd_unhideMobileCharacter),
+ // 0x50
+ Opcode(cmd_setCharactersLocation),
+ Opcode(cmd_walkCharacterToPoint),
+ Opcode(cmd_specialEventDisplayBrynnsNote),
+ Opcode(cmd_specialEventRemoveBrynnsNote),
+ // 0x54
+ Opcode(cmd_setLogicPage),
+ Opcode(cmd_fatPrint),
+ Opcode(cmd_preserveAllObjectBackgrounds),
+ Opcode(cmd_updateSceneAnimations),
+ // 0x58
+ Opcode(cmd_sceneAnimationActive),
+ Opcode(cmd_setCharactersMovementDelay),
+ Opcode(cmd_getCharactersFacing),
+ Opcode(cmd_bkgdScrollSceneAndMasksRight),
+ // 0x5c
+ Opcode(cmd_dispelMagicAnimation),
+ Opcode(cmd_findBrightestFireberry),
+ Opcode(cmd_setFireberryGlowPalette),
+ Opcode(cmd_setDeathHandlerFlag),
+ // 0x60
+ Opcode(cmd_drinkPotionAnimation),
+ Opcode(cmd_makeAmuletAppear),
+ Opcode(cmd_drawItemShapeIntoScene),
+ Opcode(cmd_setCharactersCurrentFrame),
+ // 0x64
+ Opcode(cmd_waitForConfirmationMouseClick),
+ Opcode(cmd_pageFlip),
+ Opcode(cmd_setSceneFile),
+ Opcode(cmd_getItemInMarbleVase),
+ // 0x68
+ Opcode(cmd_setItemInMarbleVase),
+ Opcode(cmd_addItemToInventory),
+ Opcode(cmd_intPrint),
+ Opcode(cmd_shakeScreen),
+ // 0x6c
+ Opcode(cmd_createAmuletJewel),
+ Opcode(cmd_setSceneAnimCurrXY),
+ Opcode(cmd_Poison_Brandon_And_Remaps),
+ Opcode(cmd_fillFlaskWithWater),
+ // 0x70
+ Opcode(cmd_getCharactersMovementDelay),
+ Opcode(cmd_getBirthstoneGem),
+ Opcode(cmd_queryBrandonStatusBit),
+ Opcode(cmd_playFluteAnimation),
+ // 0x74
+ Opcode(cmd_playWinterScrollSequence),
+ Opcode(cmd_getIdolGem),
+ Opcode(cmd_setIdolGem),
+ Opcode(cmd_totalItemsInScene),
+ // 0x78
+ Opcode(cmd_restoreBrandonsMovementDelay),
+ Opcode(cmd_setMousePos),
+ Opcode(cmd_getMouseState),
+ Opcode(cmd_setEntranceMouseCursorTrack),
+ // 0x7c
+ Opcode(cmd_itemAppearsOnGround),
+ Opcode(cmd_setNoDrawShapesFlag),
+ Opcode(cmd_fadeEntirePalette),
+ Opcode(cmd_itemOnGroundHere),
+ // 0x80
+ Opcode(cmd_queryCauldronState),
+ Opcode(cmd_setCauldronState),
+ Opcode(cmd_queryCrystalState),
+ Opcode(cmd_setCrystalState),
+ // 0x84
+ Opcode(cmd_setPaletteRange),
+ Opcode(cmd_shrinkBrandonDown),
+ Opcode(cmd_growBrandonUp),
+ Opcode(cmd_setBrandonScaleXAndY),
+ // 0x88
+ Opcode(cmd_resetScaleMode),
+ Opcode(cmd_getScaleDepthTableValue),
+ Opcode(cmd_setScaleDepthTableValue),
+ Opcode(cmd_message),
+ // 0x8c
+ Opcode(cmd_checkClickOnNPC),
+ Opcode(cmd_getFoyerItem),
+ Opcode(cmd_setFoyerItem),
+ Opcode(cmd_setNoItemDropRegion),
+ // 0x90
+ Opcode(cmd_walkMalcolmOn),
+ Opcode(cmd_passiveProtection),
+ Opcode(cmd_setPlayingLoop),
+ Opcode(cmd_brandonToStoneSequence),
+ // 0x94
+ Opcode(cmd_brandonHealingSequence),
+ Opcode(cmd_protectCommandLine),
+ Opcode(cmd_pauseMusicSeconds),
+ Opcode(cmd_resetMaskRegion),
+ // 0x98
+ Opcode(cmd_setPaletteChangeFlag),
+ Opcode(cmd_fillRect),
+ Opcode(cmd_dummy)
};
+#undef Opcode
-const int Screen::_drawShapePlotPixelCount = ARRAYSIZE(_drawShapePlotPixelTable);
+const int KyraEngine::_opcodeTableSize = ARRAYSIZE(_opcodeTable);
const char *KyraEngine::_xmidiFiles[] = {
"INTRO.XMI",
@@ -301,4 +573,12 @@
const int KyraEngine::_xmidiFilesCount = ARRAYSIZE(_xmidiFiles);
+const int8 KyraEngine::_charXPosTable[] = {
+ 0x00, 0x04, 0x04, 0x04, 0x00, 0xFC, 0xFC, 0xFC
+};
+
+const int8 KyraEngine::_charYPosTable[] = {
+ 0xFE, 0xFE, 0x00, 0x03, 0x02, 0x02, 0x00, 0xFE
+};
+
} // End of namespace Kyra
More information about the Scummvm-git-logs
mailing list