Initial commit

engines/parallaction/objects.h

@@ -0,0 +1,548 @@
+/* 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 3 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef PARALLACTION_ZONE_H
+#define PARALLACTION_ZONE_H
+
+#include "common/list.h"
+#include "common/ptr.h"
+
+#include "parallaction/graphics.h"
+
+
+namespace Parallaction {
+
+struct Zone;
+struct Animation;
+struct Command;
+struct Question;
+struct Answer;
+struct Instruction;
+struct Program;
+
+typedef Common::SharedPtr<Zone> ZonePtr;
+typedef Common::List<ZonePtr> ZoneList;
+
+typedef Common::SharedPtr<Animation> AnimationPtr;
+typedef Common::List<AnimationPtr> AnimationList;
+
+typedef Common::SharedPtr<Instruction> InstructionPtr;
+typedef Common::Array<InstructionPtr> InstructionList;
+
+typedef Common::List<Common::Point> PointList;
+
+enum ZoneTypes {
+	kZoneExamine	   = 1,					// zone displays comment if activated
+	kZoneDoor		   = 2,					// zone activated on click (after some walk if needed)
+	kZoneGet		   = 3,					// for pickable items
+	kZoneMerge		   = 4,					// tags items which can be merged in inventory
+	kZoneTaste		   = 5,				// NEVER USED
+	kZoneHear		   = 6,				// NEVER USED: they ran out of time before integrating sfx
+	kZoneFeel		   = 7,				// NEVER USED
+	kZoneSpeak		   = 8,				// tags NPCs the character can talk with
+	kZoneNone		   = 9,				// used to prevent parsing on peculiar Animations
+	kZoneTrap		   = 10,				// zone activated when character enters
+	kZoneYou		   = 11,				// marks the character
+	kZoneCommand	   = 12,
+
+	// BRA specific
+	kZonePath          = 13,			// defines nodes for assisting walk calculation routines
+	kZoneBox           = 14
+};
+
+
+enum ZoneFlags {
+	kFlagsClosed		= 1,				// Zone: door is closed / switch is off
+	kFlagsActive		= 2,				// Zone/Animation: object is visible
+	kFlagsRemove		= 4,				// Zone/Animation: object is soon to be removed
+	kFlagsActing		= 8,				// Animation: script execution is active
+	kFlagsLocked		= 0x10,				// Zone: door or switch cannot be toggled
+	kFlagsFixed			= 0x20,				// Zone: Zone item cannot be picked up
+	kFlagsNoName		= 0x40,				// Zone with no name (used to prevent some kEvEnterZone events)
+	kFlagsNoMasked		= 0x80,				// Animation is to be drawn ignoring z buffer
+	kFlagsLooping		= 0x100,			// Animation: script is to be executed repeatedly
+	kFlagsAdded			= 0x200,			// NEVER USED in Nippon Safes
+	kFlagsCharacter		= 0x400,			//
+	kFlagsNoWalk		= 0x800,			// Zone: character doesn't need to walk towards object to interact
+
+	// BRA specific
+	kFlagsYourself		= 0x1000,			// BRA: marks zones used by the character on him/herself
+	kFlagsScaled		= 0x2000,
+	kFlagsSelfuse		= 0x4000,			// BRA: marks zones to be preserved across location changes (see Parallaction::freeZones)
+	kFlagsIsAnimation	= 0x1000000,		// BRA: used in walk code (trap check), to tell is a Zone is an Animation
+	kFlagsAnimLinked	= 0x2000000
+};
+
+
+enum CommandFlags : uint {
+	kFlagsAll			= 0xFFFFFFFFU,
+
+	kFlagsVisited		= 1,
+	kFlagsExit			= 0x10000000,
+	kFlagsEnter			= 0x20000000,
+	kFlagsGlobal		= 0x40000000,
+
+	// BRA specific
+	kFlagsTestTrue		= 2
+};
+
+struct Command {
+	uint16			_id;
+	uint32			_flagsOn;
+	uint32			_flagsOff;
+	bool			_valid;
+
+	Command();
+
+	// Common fields
+	uint32			_flags;
+	ZonePtr			_zone;
+	Common::String	_zoneName;
+	Common::String	_string;
+	uint16			_callable;
+	uint16			_object;
+	Common::Point	 _move;
+
+	// BRA specific
+	Common::Point	_startPos;
+	Common::Point	_startPos2;
+	Common::String	_counterName;
+	int				_counterValue;
+	int				_zeta0;
+	int				_zeta1;
+	int				_zeta2;
+	Common::String	_characterName;
+	Common::String	_string2;
+	int				_musicCommand;
+	int				_musicParm;
+};
+
+typedef Common::SharedPtr<Command> CommandPtr;
+typedef Common::List<CommandPtr> CommandList;
+
+
+#define NUM_QUESTIONS		40
+#define NUM_ANSWERS			20
+
+struct Answer {
+	Common::String	_text;
+	uint16			_mood;
+	Common::String	_followingName;
+
+	CommandList	_commands;
+	uint32		_noFlags;
+	uint32		_yesFlags;
+
+	// BRA specific
+	bool _hasCounterCondition;
+	Common::String	_counterName;
+	int	_counterValue;
+	int	_counterOp;
+
+	Answer();
+	bool textIsNull();
+	int speakerMood();
+};
+
+struct Question {
+	Common::String	_name;
+	Common::String	_text;
+	uint16			_mood;
+	Answer*			_answers[NUM_ANSWERS];
+
+	Question(const Common::String &name);
+	~Question();
+	bool textIsNull();
+	int speakerMood();
+	int balloonWinding();
+};
+
+struct Dialogue {
+	Question	*_questions[NUM_QUESTIONS];
+	uint		_numQuestions;
+
+	Question *findQuestion(const Common::String &name) const;
+	void addQuestion(Question *q);
+
+	Dialogue();
+	~Dialogue();
+};
+
+#define MAX_WALKPOINT_LISTS	20
+#define FREE_HEAR_CHANNEL		-1
+#define MUSIC_HEAR_CHANNEL		-2
+
+struct TypeData {
+	// common
+	GfxObj		*_gfxobj;	// get, examine, door
+	Common::String	_filename; // speak, examine, hear
+
+	// get
+	uint32		_getIcon;
+
+	// speak
+	Dialogue		*_speakDialogue;
+
+	// examine
+	Common::String	_examineText;
+
+	// door
+	Common::String	_doorLocation;
+	Common::Point	_doorStartPos;
+	uint16		_doorStartFrame;
+	Common::Point	_doorStartPos2_br;
+	uint16		_doorStartFrame2_br;
+
+	// hear
+	int		_hearChannel;
+	int		_hearFreq;
+
+	// merge
+	uint32	_mergeObj1;
+	uint32	_mergeObj2;
+	uint32	_mergeObj3;
+
+	// path
+	int		_pathNumLists;
+	PointList	_pathLists[MAX_WALKPOINT_LISTS];
+
+	TypeData() {
+		_gfxobj = 0;
+		_getIcon = 0;
+		_speakDialogue = 0;
+		_doorStartFrame = 0;
+		_doorStartPos.x = -1000;
+		_doorStartPos.y = -1000;
+		_doorStartFrame2_br = 0;
+		_doorStartPos2_br.x = -1000;
+		_doorStartPos2_br.y = -1000;
+		_hearChannel = FREE_HEAR_CHANNEL;
+		_hearFreq = -1;
+		_mergeObj1 = 0;
+		_mergeObj2 = 0;
+		_mergeObj3 = 0;
+		_pathNumLists = 0;
+	}
+
+	~TypeData() {
+		if (_gfxobj) {
+			_gfxobj->release();
+		}
+		delete _speakDialogue;
+	}
+};
+
+#define ACTIONTYPE(z) ((z)->_type & 0xFFFF)
+#define ITEMTYPE(z) ((z)->_type & 0xFFFF0000)
+
+#define PACK_ZONETYPE(zt,it) (((zt) & 0xFFFF) | (((it) & 0xFFFF) << 16))
+
+#define ZONENAME_LENGTH 32
+
+#define INVALID_LOCATION_INDEX ((uint32)-1)
+#define INVALID_ZONE_INDEX ((uint32)-1)
+
+struct Zone {
+private:
+	int16			_right;
+	int16			_bottom;
+
+protected:
+	int16			_left;
+	int16			_top;
+
+public:
+	char			_name[ZONENAME_LENGTH];
+
+	uint32			_type;
+	uint32			_flags;
+	GfxObj			*_label;
+
+	TypeData		u;
+	CommandList		_commands;
+	Common::Point	_moveTo;
+
+	// BRA specific
+	uint			_index;
+	uint			_locationIndex;
+	Common::String	_linkedName;
+	AnimationPtr	_linkedAnim;
+
+	Zone();
+	virtual ~Zone();
+
+	void translate(int16 x, int16 y);
+
+	bool hitRect(int x, int y) const;
+
+	void setRect(int16 left, int16 top, int16 right, int16 bottom) {
+		setX(left);
+		setY(top);
+		_right = right;
+		_bottom = bottom;
+	}
+
+	void getRect(Common::Rect& r) {
+		r.left = _left;	r.right = _right;
+		r.top = _top; r.bottom = _bottom;
+	}
+
+
+	// getters/setters
+	virtual int16 getX()			{ return _left; }
+	virtual void  setX(int16 value) { _left = value; }
+
+	virtual int16 getY()			{ return _top; }
+	virtual void  setY(int16 value) { _top = value; }
+};
+
+
+struct LocalVariable {
+protected:
+	int16		_value;
+	int16		_min;
+	int16		_max;
+
+public:
+
+	LocalVariable() {
+		_value = 0;
+		_min = -10000;
+		_max = 10000;
+	}
+
+	void setRange(int16 min, int16 max);
+
+	int16 getValue() const;
+	void setValue(int16 value);
+};
+
+
+enum ParaFlags {
+	kParaImmediate	= 1,				// instruction is using an immediate parameter
+	kParaLocal		= 2,				// instruction is using a local variable
+	kParaField		= 0x10,				// instruction is using an animation's field
+	kParaRandom		= 0x100,
+
+	kParaLValue		= 0x20
+};
+
+
+struct AnimationField {
+	typedef Common::Functor0Mem<int16, Animation> Accessor;
+	typedef Common::Functor1Mem<int16, void, Animation> Mutator;
+
+	typedef Accessor::FuncType AccessorFunc;
+	typedef Mutator::FuncType MutatorFunc;
+
+protected:
+	Accessor *_accessor;
+	Mutator *_mutator;
+
+public:
+	AnimationField(Animation* instance, AccessorFunc accessor, MutatorFunc mutator) {
+		_accessor = new Accessor(instance, accessor);
+		_mutator = new Mutator(instance, mutator);
+	}
+
+	AnimationField(Animation* instance, AccessorFunc accessor) {
+		_accessor = new Accessor(instance, accessor);
+		_mutator = 0;
+	}
+
+	~AnimationField() {
+		delete _accessor;
+		delete _mutator;
+	}
+
+	int16 getValue() const {
+		assert(_accessor);
+		return (*_accessor)();
+	}
+
+	void setValue(int16 value) {
+		assert(_mutator);
+		(*_mutator)(value);
+	}
+};
+
+
+struct ScriptVar {
+	uint32			_flags;
+
+	int16			_value;
+	LocalVariable*	_local;
+	AnimationField*	_field;
+
+	ScriptVar();
+	~ScriptVar();
+
+	int16	getValue();
+	void	setValue(int16 value);
+
+	void	setLocal(LocalVariable *local);
+	void	setField(Animation *anim, AnimationField::AccessorFunc accessor, AnimationField::MutatorFunc mutator);
+	void	setField(Animation *anim, AnimationField::AccessorFunc accessor);
+	void	setImmediate(int16 value);
+	void	setRandom(int16 seed);
+};
+
+enum InstructionFlags {
+	kInstMod			= 4,
+	kInstMaskedPut		= 8,
+	kInstUnk20			= 0x20
+};
+
+
+struct Instruction {
+	uint32	_index;
+	uint32	_flags;
+
+	// common
+	AnimationPtr	_a;
+	ZonePtr		_z;
+	int16		_immediate;
+	ScriptVar	_opA;
+	ScriptVar	_opB;
+
+	// BRA specific
+	byte		_colors[3];
+	ScriptVar	_opC;
+	Common::String _text;
+	Common::String _text2;
+	int			_y;
+	uint32		_endif;
+
+	Instruction();
+};
+
+enum {
+	kProgramIdle,		// awaiting execution
+	kProgramRunning,	// running
+	kProgramDone		// execution completed
+};
+
+struct Program {
+	AnimationPtr	_anim;
+	LocalVariable	*_locals;
+
+	uint16		_loopCounter;
+	uint16		_numLocals;
+
+	uint32				_ip;
+	uint32				_loopStart;
+	InstructionList		_instructions;
+
+	uint32	_status;
+
+	Program();
+	~Program();
+
+	int16		findLocal(const char* name);
+	int16		addLocal(const char *name, int16 value = 0, int16 min = -10000, int16 max = 10000);
+};
+
+typedef Common::SharedPtr<Program> ProgramPtr;
+typedef Common::List<ProgramPtr> ProgramList;
+
+struct Animation : public Zone {
+protected:
+	int16		_frame;
+	int16		_z;
+public:
+
+	GfxObj		*gfxobj;
+	Common::String _scriptName;
+
+	Animation();
+	~Animation() override;
+	uint16 getFrameNum() const;
+	byte* getFrameData() const;
+
+	void resetZ();
+	bool hitFrameRect(int x, int y) const;
+	void getFrameRect(Common::Rect &r) const;
+	int16 getBottom() const;
+
+	// HACK: this routine is only used to download initialisation
+	// parameter to a script used when moving sarcophagi around in
+	// the museum. It bypasses all the consistency checks that
+	// can be performed by the individual setters. See the comment
+	// in startMovingSarcophagus() in callables_ns.cpp
+	void forceXYZF(int16 x, int16 y, int16 z, int16 f);
+
+	// getters/setters used by scripts
+	int16 getX() override			{ return _left; }
+	void  setX(int16 value) override { _left = value; }
+
+	int16 getY() override			{ return _top; }
+	void  setY(int16 value) override { _top = value; }
+
+	int16 getZ()			{ return _z; }
+	void  setZ(int16 value) { _z = value; }
+
+	int16 getF()			{ return _frame; }
+	void  setF(int16 value);
+
+	void getFoot(Common::Point &foot);
+	void setFoot(const Common::Point &foot);
+};
+
+class Table {
+
+protected:
+	char	**_data;
+	uint16	_size;
+	uint16	_used;
+	bool	_disposeMemory;
+
+public:
+	Table(uint32 size);
+	Table(uint32 size, const char** data);
+
+	virtual ~Table();
+
+	enum {
+		notFound = 0
+	};
+
+	uint count() const { return _used; }
+	const char *item(uint index) const;
+
+	virtual void addData(const char* s);
+	virtual void clear();
+	virtual uint16 lookup(const char* s);
+};
+
+class FixedTable : public Table {
+
+	uint16	_numFixed;
+
+public:
+	FixedTable(uint32 size, uint32 fixed);
+	void clear() override;
+};
+
+Table* createTableFromStream(uint32 size, Common::SeekableReadStream *stream);
+
+} // namespace Parallaction
+
+#endif