scummvm/engines/prince/prince.h
2014-06-22 20:09:24 +02:00

433 lines
10 KiB
C++

/* ScummVM - Graphic Adventure Engine
*
* ScummVM is the legal property of its developers, whose names
* are too numerous to list here. Please refer to the COPYRIGHT
* file distributed with this source distribution.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
#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 "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;
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(NULL), _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
};
struct BASA {
int16 _num; // animation number
int16 _start; // initial frame
int16 _end; // final frame
int16 _pad; // fulfilment to 8 bytes
};
// 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;
};
struct BackgroundAnim {
BAS _seq;
Common::Array<Anim> backAnims;
};
// 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;
Graphics::Surface *s;
Graphics::Surface *originalRoomSurface;
byte *data;
bool freeSurfaceSMemory;
void (*drawFunction)(Graphics::Surface *, DrawNode *);
};
struct DialogLine {
int _nr;
Common::String _line;
};
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;
int getGameType() const;
const char *getGameId() const;
uint32 getFeatures() const;
Common::Language getLanguage() const;
const PrinceGameDescription *_gameDescription;
Video::FlicDecoder _flicPlayer;
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);
void playSample(uint16 sampleId, uint16 loopType);
void stopSample(uint16 sampleId);
virtual GUI::Debugger *getDebugger();
void changeCursor(uint16 curId);
void printAt(uint32 slot, uint8 color, const char *s, uint16 x, uint16 y);
int calcText(const char *s);
static const uint8 MAXTEXTS = 32;
Text _textSlots[MAXTEXTS];
uint64 _frameNr;
Hero *_mainHero;
Hero *_secondHero;
uint16 _sceneWidth;
int32 _picWindowX;
int32 _picWindowY;
Image::BitmapDecoder *_roomBmp;
MhwanhDecoder *_suitcaseBmp;
Common::Array<AnimListItem> _animList;
Common::Array<BackgroundAnim> _backAnimList;
Common::Array<Common::Array<DialogLine>> _dialogBoxList;
Common::RandomSource _randomSource;
static const int16 kNormalWidth = 640;
static const int16 kNormalHeight = 480;
static const int16 kMaxPicWidth = 1280;
static const int16 kMaxPicHeight = 480;
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();
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
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 addInvObj();
void makeInvCursor(int itemNr);
void enableOptions();
void checkOptions();
void checkInvOptions();
void leftMouseButton();
void rightMouseButton();
void inventoryLeftMouseButton();
void inventoryRightMouseButton();
void dialogLeftMouseButton(int dialogSelected, const char *s);
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(Common::Array<DialogLine> &dialogData);
void runDialog(Common::Array<DialogLine> &dialogData);
void talkHero(int slot, const char *s);
void testDialog();
int testAnimNr;
int testAnimFrame;
private:
bool playNextFrame();
void keyHandler(Common::Event event);
int hotspot(Graphics::Surface *screen, Common::Array<Mob> &mobList);
void drawScreen();
void showTexts(Graphics::Surface *screen);
void init();
void showLogo();
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, bool freeSurfaceMemory);
void showSpriteShadow(Graphics::Surface *shadowSurface, int destX, int destY, int destZ, bool freeSurfaceMemory);
void showObjects();
void showParallax();
static bool compareDrawNodes(DrawNode d1, DrawNode d2);
void runDrawNodes();
void freeDrawNodes();
void makeShadowTable(int brightness);
void pause();
uint32 getTextWidth(const char *s);
void debugEngine(const char *s, ...);
uint16 _locationNr;
uint8 _cursorNr;
Common::RandomSource *_rnd;
Cursor *_cursor1;
Graphics::Surface *_cursor2;
Cursor *_cursor3;
Debugger *_debugger;
GraphicsMan *_graph;
Script *_script;
InterpreterFlags *_flags;
Interpreter *_interpreter;
Font *_font;
MusicPlayer *_midiPlayer;
Room *_room;
static const uint32 MAX_SAMPLES = 60;
Common::SeekableReadStream *_voiceStream[MAX_SAMPLES];
Audio::SoundHandle _soundHandle[MAX_SAMPLES];
Common::Array<PScr *> _pscrList;
Common::Array<Mob> _mobList;
Common::Array<Object *> _objList;
Common::Array<Mask> _maskList;
Common::Array<DrawNode> _drawNodeList;
Common::Array<InvItem> _allInvList;
Common::Array<Mob> _invMobList;
bool _flicLooped;
void mainLoop();
};
} // End of namespace Prince
#endif
/* vim: set tabstop=4 noexpandtab: */