diff options
Diffstat (limited to 'engines/prince/prince.h')
-rw-r--r-- | engines/prince/prince.h | 668 |
1 files changed, 668 insertions, 0 deletions
diff --git a/engines/prince/prince.h b/engines/prince/prince.h new file mode 100644 index 0000000000..3d10c671f0 --- /dev/null +++ b/engines/prince/prince.h @@ -0,0 +1,668 @@ +/* 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. + * + */ + +#ifndef PRINCE_H +#define PRINCE_H + +#include "common/random.h" +#include "common/system.h" +#include "common/debug.h" +#include "common/debug-channels.h" +#include "common/textconsole.h" +#include "common/rect.h" +#include "common/events.h" +#include "common/endian.h" +#include "common/savefile.h" +#include "common/serializer.h" + +#include "image/bmp.h" + +#include "gui/debugger.h" + +#include "engines/engine.h" +#include "engines/util.h" + +#include "audio/mixer.h" + +#include "video/flic_decoder.h" + +#include "prince/mob.h" +#include "prince/object.h" +#include "prince/pscr.h" + +namespace Prince { + +struct PrinceGameDescription; +struct SavegameHeader; + +class PrinceEngine; +class GraphicsMan; +class Script; +class Interpreter; +class InterpreterFlags; +class Debugger; +class MusicPlayer; +class VariaTxt; +class Cursor; +class MhwanhDecoder; +class Font; +class Hero; +class Animation; +class Room; +class Pscr; + +struct Text { + const char *_str; + uint16 _x, _y; + uint16 _time; + uint32 _color; + + Text() : _str(nullptr), _x(0), _y(0), _time(0), _color(255){ + } +}; + +struct AnimListItem { + uint16 _type; // type of animation - for background anims RND of frame + uint16 _fileNumber; + uint16 _startPhase; // first phase number + uint16 _endPhase; + uint16 _loopPhase; + int16 _x; + int16 _y; + uint16 _loopType; + uint16 _nextAnim; // number of animation to do for loop = 3 + uint16 _flags; // byte 0 - draw masks, byte 1 - draw in front of mask, byte 2 - load but turn off drawing + bool loadFromStream(Common::SeekableReadStream &stream); +}; + +struct BAS { + int32 _type; // type of sequence + int32 _data; // additional data + int32 _anims; // number of animations + int32 _current; // actual number of animation + int32 _counter; // time counter for animation + int32 _currRelative; //actual relative number for animation + int32 _data2; // additional data for measurements +}; + +const int kStructSizeBAS = 28; + +struct BASA { + int16 _num; // animation number + int16 _start; // initial frame + int16 _end; // final frame + //int16 _pad; // fulfilment to 8 bytes +}; + +const int kStructSizeBASA = 8; + +// background and normal animation +struct Anim { + BASA _basaData; + int32 _addr; //animation adress + int16 _usage; + int16 _state; // state of animation: 0 - turning on, 1 - turning off + int16 _flags; + int16 _frame; // number of phase to show + int16 _lastFrame; // last phase + int16 _loopFrame; // first frame of loop + int16 _showFrame; // actual visible frame of animation + int16 _loopType; // type of loop (0 - last frame; 1 - normal loop (begin from _loopFrame); 2 - no loop; 3 - load new animation) + int16 _nextAnim; // number of next animation to load after actual + int16 _x; + int16 _y; + int32 _currFrame; + int16 _currX; + int16 _currY; + int16 _currW; + int16 _currH; + int16 _packFlag; + int32 _currShadowFrame; + int16 _packShadowFlag; + int32 _shadowBack; + int16 _relX; + int16 _relY; + Animation *_animData; + Animation *_shadowData; + + enum AnimOffsets { + kAnimState = 10, + kAnimFrame = 14, + kAnimLastFrame = 16, + kAnimX = 26 + }; + + int16 getAnimData(Anim::AnimOffsets offset) { + switch (offset) { + case kAnimState: + return _state; + case kAnimFrame: + return _frame + 1; // fix for location 30 - man with a dog animation + case kAnimX: + return _x; + default: + error("getAnimData() - Wrong offset type: %d", (int) offset); + } + } + + void setAnimData(Anim::AnimOffsets offset, int16 value) { + if (offset == kAnimX) { + _x = value; + } else { + error("setAnimData() - Wrong offset: %d, value: %d", (int) offset, value); + } + } +}; + +struct BackgroundAnim { + BAS _seq; + Common::Array<Anim> backAnims; +}; + +enum AnimType { + kBackgroundAnimation, + kNormalAnimation +}; + +// Nak (PL - Nakladka) +struct Mask { + int16 _state; // visible / invisible + int16 _flags; // turning on / turning off of an mask + int16 _x1; + int16 _y1; + int16 _x2; + int16 _y2; + int16 _z; + int16 _number; // number of mask for background recreating + int16 _width; + int16 _height; + byte *_data; + + int16 getX() const { + return READ_LE_UINT16(_data); + } + + int16 getY() const { + return READ_LE_UINT16(_data + 2); + } + + int16 getWidth() const { + return READ_LE_UINT16(_data + 4); + } + + int16 getHeight() const { + return READ_LE_UINT16(_data + 6); + } + + byte *getMask() const { + return (byte *)(_data + 8); + } +}; + +struct InvItem { + int _x; + int _y; + Graphics::Surface *_surface; + Graphics::Surface *getSurface() const { return _surface; } +}; + +struct DrawNode { + int posX; + int posY; + int posZ; + int32 width; + int32 height; + int32 scaleValue; + Graphics::Surface *s; + Graphics::Surface *originalRoomSurface; + void *data; + void (*drawFunction)(Graphics::Surface *, DrawNode *); +}; + +struct DebugChannel { + +enum Type { + kScript, + kEngine +}; + +}; + +class PrinceEngine : public Engine { +protected: + Common::Error run(); + +public: + PrinceEngine(OSystem *syst, const PrinceGameDescription *gameDesc); + virtual ~PrinceEngine(); + + virtual bool hasFeature(EngineFeature f) const; + virtual bool canSaveGameStateCurrently(); + virtual bool canLoadGameStateCurrently(); + virtual Common::Error saveGameState(int slot, const Common::String &desc); + virtual Common::Error loadGameState(int slot); + + static bool readSavegameHeader(Common::InSaveFile *in, SavegameHeader &header); + Common::String generateSaveName(int slot); + void writeSavegameHeader(Common::OutSaveFile *out, SavegameHeader &header); + void syncGame(Common::SeekableReadStream *readStream, Common::WriteStream *writeStream); + bool loadGame(int slotNumber); + void resetGame(); + + int32 _creditsDataSize; + byte *_creditsData; + void scrollCredits(); + + int getGameType() const; + const char *getGameId() const; + uint32 getFeatures() const; + Common::Language getLanguage() const; + + const PrinceGameDescription *_gameDescription; + Video::FlicDecoder _flicPlayer; + const Graphics::Surface *_flcFrameSurface; + VariaTxt *_variaTxt; + + uint32 _talkTxtSize; + byte *_talkTxt; + + bool loadLocation(uint16 locationNr); + bool loadAnim(uint16 animNr, bool loop); + bool loadVoice(uint32 textSlot, uint32 sampleSlot, const Common::String &name); + bool loadSample(uint32 sampleSlot, const Common::String &name); + bool loadZoom(byte *zoomBitmap, uint32 dataSize, const char *resourceName); + bool loadShadow(byte *shadowBitmap, uint32 dataSize, const char *resourceName1, const char *resourceName2); + bool loadTrans(byte *transTable, const char *resourceName); + bool loadMobPriority(const char *resourceName); + + bool loadMusic(int musNumber); + void stopMusic(); + + void playSample(uint16 sampleId, uint16 loopType); + void stopSample(uint16 sampleId); + void stopAllSamples(); + void freeSample(uint16 sampleId); + void freeAllSamples(); + + void setVoice(uint16 slot, uint32 sampleSlot, uint16 flag); + + virtual GUI::Debugger *getDebugger(); + + void changeCursor(uint16 curId); + void printAt(uint32 slot, uint8 color, char *s, uint16 x, uint16 y); + int calcTextLines(const char *s); + int calcTextTime(int numberOfLines); + void correctStringDEU(char *s); + + static const uint8 kMaxTexts = 32; + Text _textSlots[kMaxTexts]; + + Hero *_mainHero; + Hero *_secondHero; + + enum HeroId { + kMainHero, + kSecondHero + }; + + int _mouseFlag; + uint32 _currentTime; + uint16 _locationNr; + uint16 _sceneWidth; + int32 _picWindowX; + int32 _picWindowY; + + Image::BitmapDecoder *_roomBmp; + MhwanhDecoder *_suitcaseBmp; + Room *_room; + Script *_script; + InterpreterFlags *_flags; + Interpreter *_interpreter; + GraphicsMan *_graph; + uint8 _currentMidi; + byte *_zoomBitmap; + byte *_shadowBitmap; + byte *_transTable; + + int16 _scaleValue; // scale for hero or special shadow animation + int16 _lightX; // for hero shadow + int16 _lightY; + int32 _shadScaleValue; + int32 _shadLineLen; + byte *_shadowLine; + void setShadowScale(int32 shadowScale); + static void plotShadowLinePoint(int x, int y, int color, void *data); + + static const int16 kFPS = 15; + static const int32 kIntMax = 2147483647; + + static const int16 kMaxPicWidth = 1280; + static const int16 kMaxPicHeight = 480; + static const int16 kZoomStep = 4; + static const int32 kZoomBitmapLen = kMaxPicHeight / kZoomStep * kMaxPicWidth / kZoomStep; + static const int32 kShadowBitmapSize = kMaxPicWidth * kMaxPicHeight / 8; + static const int16 kShadowLineArraySize = 2 * 1280 * 4; + static const int16 kZoomBitmapWidth = kMaxPicWidth / kZoomStep; + static const int16 kZoomBitmapHeight = kMaxPicHeight / kZoomStep; + static const int16 kNormalWidth = 640; + static const int16 kNormalHeight = 480; + static const int32 kTransTableSize = 256 * 256; + + static const int kMaxNormAnims = 64; + static const int kMaxBackAnims = 64; + static const int kMaxObjects = 64; + static const int kMaxMobs = 64; + + Common::Array<DrawNode> _drawNodeList; + Common::Array<AnimListItem> _animList; + Common::Array<BackgroundAnim> _backAnimList; + Common::Array<Anim> _normAnimList; + Common::Array<Mob> _mobList; + Common::Array<uint32> _mobPriorityList; + Common::Array<Mask> _maskList; + Common::Array<Object *> _objList; + uint16 *_objSlot; + + void freeNormAnim(int slot); + void freeAllNormAnims(); + void removeSingleBackAnim(int slot); + + Common::RandomSource _randomSource; + + void checkMasks(int x1, int y1, int sprWidth, int sprHeight, int z); + void insertMasks(Graphics::Surface *originalRoomSurface); + void showMask(int maskNr, Graphics::Surface *originalRoomSurface); + void clsMasks(); + + void grabMap(); + + int _selectedMob; // number of selected Mob / inventory item + int _selectedItem; // number of item on mouse cursor + int _selectedMode; + int _currentPointerNumber; + + static const int16 kMaxInv = 90; // max amount of inventory items in whole game + static const int16 kMaxItems = 30; // size of inventory + + uint32 _invTxtSize; + byte *_invTxt; + + Graphics::Surface *_optionsPic; + Graphics::Surface *_optionsPicInInventory; + + bool _optionsFlag; + int _optionEnabled; + int _optionsMob; + int _optionsX; + int _optionsY; + int _optionsWidth; + int _optionsHeight; + int _invOptionsWidth; + int _invOptionsHeight; + int _optionsStep; + int _invOptionsStep; + int _optionsNumber; + int _invOptionsNumber; + int _optionsColor1; // color for non-selected options + int _optionsColor2; // color for selected option + + bool _showInventoryFlag; + int _invExamY; + bool _inventoryBackgroundRemember; + int _invLineX; + int _invLineY; + int _invLine; // number of items in one line + int _invLines; // number of lines with inventory items + int _invLineW; + int _invLineH; + int _maxInvW; + int _maxInvH; + int _invLineSkipX; + int _invLineSkipY; + int _invX1; + int _invY1; + int _invWidth; + int _invHeight; + bool _invCurInside; + int _mst_shadow; + int _mst_shadow2; // blinking after adding new item + int _candleCounter; // special counter for candle inventory item + int _invMaxCount; // time to turn inventory on + int _invCounter; // turning on counter + + void inventoryFlagChange(bool inventoryState); + bool loadAllInv(); + void rememberScreenInv(); + void prepareInventoryToView(); + void drawInvItems(); + void displayInventory(); + void addInv(int heroId, int item, bool addItemQuiet); + void remInv(int heroId, int item); + void clearInv(int heroId); + void swapInv(int heroId); + void addInvObj(); + void makeInvCursor(int itemNr); + void enableOptions(bool checkType); + void checkOptions(); + void checkInvOptions(); + void openInventoryCheck(); + + void leftMouseButton(); + void rightMouseButton(); + void inventoryLeftMouseButton(); + void inventoryRightMouseButton(); + void dialogLeftMouseButton(byte *string, int dialogSelected); + + uint32 _dialogDatSize; + byte *_dialogDat; + byte *_dialogData; // on, off flags for lines of dialog text + + byte *_dialogBoxAddr[32]; // adresses of dialog windows + byte *_dialogOptAddr[32]; // adresses of dialog options + int _dialogOptLines[4 * 32]; // numbers of initial dialog lines + + byte *_dialogText; + int _dialogLines; + bool _dialogFlag; + int _dialogWidth; + int _dialogHeight; + int _dialogLineSpace; + int _dialogColor1; // color for non-selected options + int _dialogColor2; // color for selected option + Graphics::Surface *_dialogImage; + + void createDialogBox(int dialogBoxNr); + void runDialog(); + void talkHero(int slot); + void doTalkAnim(int animNumber, int slot, AnimType animType); + + static const uint8 zoomInStep = 8; + void initZoomIn(int slot); + void initZoomOut(int slot); + void doZoomIn(int slot); + void doZoomOut(int slot); + void freeZoomObject(int slot); + + static const uint8 kFadeStep = 4; + void blackPalette(); + void setPalette(const byte *palette); + + int getMob(Common::Array<Mob> &mobList, bool usePriorityList, int posX, int posY); + + // 'Throw a rock' mini-game: + static const int16 kCurveLen = 17; + static const int kCelStep = 4; + int16 *_curveData; + int _curvPos; + void makeCurve(); + void getCurve(); + void mouseWeirdo(); + + static const uint16 kPowerBarPosX = 288; + static const uint16 kPowerBarPosY = 430; + static const uint8 kPowerBarWidth = 64; + static const uint8 kPowerBarHeight = 16; + static const uint8 kPowerBarBackgroundColor = 0; + static const uint16 kPowerBarGreenPosY = 434; + static const uint8 kPowerBarGreenColor1 = 202; + static const uint8 kPowerBarGreenColor2 = 235; + static const uint8 kPowerBarGreenHeight = 8; + void showPower(); + + // Pathfinding + static const int16 kPathGridStep = 2; + static const int32 kPathBitmapLen = (kMaxPicHeight / kPathGridStep * kMaxPicWidth / kPathGridStep) / 8; + static const int32 kTracePts = 8000; + static const int32 kPBW = kMaxPicWidth / 16; // PathBitmapWidth + static const int kMinDistance = 2500; + + byte *_roomPathBitmap; // PL - Sala + byte *_roomPathBitmapTemp; // PL - SSala + byte *_coordsBufEnd; + byte *_coordsBuf; // optimal path + byte *_coords; // last path point adress from coordsBuf + byte *_coordsBuf2; + byte *_coords2; + byte *_coordsBuf3; + byte *_coords3; + int _traceLineLen; + bool _traceLineFirstPointFlag; // if plotTraceLine after first point + bool _tracePointFirstPointFlag; // if plotTracePoint after first point + byte *_directionTable; + int _shanLen; + + byte *_checkBitmapTemp; + byte *_checkBitmap; + int _checkMask; + int _checkX; + int _checkY; + + byte *_rembBitmapTemp; + byte *_rembBitmap; + int _rembMask; + int _rembX; + int _rembY; + + int _fpX; + int _fpY; + + int drawLine(int x0, int y0, int x1, int y1, int (*plotProc)(int, int, void *), void *data); + bool loadPath(const char *resourceName); + byte *makePath(int heroId, int currX, int currY, int destX, int destY); + void findPoint(int x, int y); + int getPixelAddr(byte *pathBitmap, int x, int y); + static int plotTraceLine(int x, int y, void *data); + void specialPlotInside(int x, int y); + bool tracePath(int x1, int y1, int x2, int y2); + Direction makeDirection(int x1, int y1, int x2, int y2); + void specialPlot(int x, int y); + void specialPlot2(int x, int y); + void allocCoords2(); + void freeCoords2(); + void freeCoords3(); + static int plotTracePoint(int x, int y, void *data); + void specialPlotInside2(int x, int y); + void approxPath(); + void freeDirectionTable(); + void scanDirections(); + int scanDirectionsFindNext(byte *coords, int xDiff, int yDiff); + void moveShandria(); + void walkTo(); + void moveRunHero(int heroId, int x, int y, int dir, bool runHeroFlag); + + int leftDownDir(); + int leftDir(); + int leftUpDir(); + int rightDownDir(); + int rightDir(); + int rightUpDir(); + int upLeftDir(); + int upDir(); + int upRightDir(); + int downLeftDir(); + int downDir(); + int downRightDir(); + + int cpe(); + int checkLeftDownDir(); + int checkLeftDir(); + int checkDownDir(); + int checkUpDir(); + int checkRightDir(); + int checkLeftUpDir(); + int checkRightDownDir(); + int checkRightUpDir(); + +private: + bool playNextFLCFrame(); + void keyHandler(Common::Event event); + int checkMob(Graphics::Surface *screen, Common::Array<Mob> &mobList, bool usePriorityList); + void drawScreen(); + void showTexts(Graphics::Surface *screen); + void init(); + void showLogo(); + void showAnim(Anim &anim); + void showNormAnims(); + void setBackAnim(Anim &backAnim); + void showBackAnims(); + void clearBackAnimList(); + bool spriteCheck(int sprWidth, int sprHeight, int destX, int destY); + void showSprite(Graphics::Surface *spriteSurface, int destX, int destY, int destZ); + void showSpriteShadow(Graphics::Surface *shadowSurface, int destX, int destY, int destZ); + void showObjects(); + void showParallax(); + static bool compareDrawNodes(DrawNode d1, DrawNode d2); + void runDrawNodes(); + void makeShadowTable(int brightness); + void pause(); + void pause2(); + + uint32 getTextWidth(const char *s); + void debugEngine(const char *s, ...); + + uint8 _cursorNr; + + Common::RandomSource *_rnd; + Cursor *_cursor1; + Graphics::Surface *_cursor2; + Cursor *_cursor3; + Debugger *_debugger; + Font *_font; + MusicPlayer *_midiPlayer; + + static const uint32 kMaxSamples = 60; + Audio::RewindableAudioStream *_audioStream[kMaxSamples]; + Audio::SoundHandle _soundHandle[kMaxSamples]; + + Common::Array<PScr *> _pscrList; + Common::Array<InvItem> _allInvList; + Common::Array<Mob> _invMobList; + + bool _flicLooped; + + void mainLoop(); + +}; + +} // End of namespace Prince + +#endif |