scummvm/engines/saga2/contain.h

/* 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/>.
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#ifndef SAGA2_CONTAIN_H
#define SAGA2_CONTAIN_H

#include "saga2/floating.h"

namespace Saga2 {

//	gPanel
//		gControl
class ContainerView;
class ScrollingContainerView;
class ActorContainerView;
class ReadyContainerView;
class SmallContainerView;
class EnchantContainerView;
//		gWindow
//			DecoratedWindow
//				FloatingWindow
class ContainerWindow;
class ContainerNode;
class ContainerManager;
struct ContainerAppearanceDef;

class CMassWeightIndicator;
class ProtoObj;

class GfxCompButton;
class GfxCompImage;
class GfxMultCompButton;
struct TilePoint;

/* ===================================================================== *
   Class definitions
 * ===================================================================== */

//  The base class for all container panels

class ContainerView : public gControl {

	friend class ContainerWindow;
	friend class TangibleContainerWindow;
	friend class IntangibleContainerWindow;

protected:

	enum imageData {
		kSelectorX = 10,
		kSelectorY = 25
	};

public:

	ContainerNode   &_node;

	Point16         _iconOrigin;     //  of the top left icon.
	Point16         _iconSpacing;    //  The spacing between icons (in both X and Y)

	//  The number of rows and columns of icons that can be seen
	int16           _visibleRows,
	                _visibleCols;

	//  The total number of rows, and the scroll position of the control
	int16           _totalRows,
	                _scrollPosition;

	//  Pointer to the object that this control is showing the
	//  contents of.
	GameObject      *_containerObject;

	//  Mass and bulk indicators
	int16           _totalMass,
	                _totalBulk;

	//  Number of visible objects currently in the container
	int16           _numObjects;

	//  Constructor
	ContainerView(
	    gPanelList &,
	    const Rect16 &,
	    ContainerNode &nd,
	    const ContainerAppearanceDef &app,
	    AppFunc *cmd = NULL);

	//  Destructor
	~ContainerView();

	// redraw the panel offscreen
	virtual void drawClipped(gPort &port, const Point16 &offset, const Rect16 &clip);

	// draws the mereged object multi-item selector
	void drawSelector(gPort &port, Point16 &pos);

	//  Draw the quantity indicator below the object if quantity > 1
	void drawQuantity(gPort &port, GameObject *item, ProtoObj *objProto, int16 x, int16 y);

	//  returns true if the object is visible for this type of
	//  container.
	virtual bool isVisible(GameObject *obj);

	//  total the mass, bulk, and number of all objects in container.
	void totalObjects();

	//  Get the Nth visible object from this container.
	ObjectID getObject(int16 slotNum);

	void setContainer(GameObject *container);

	// get the slot the point is over
	TilePoint pickObjectSlot(const Point16 &pickPos);

	//  Get the object in a slot (u/v)
	GameObject *getObject(const TilePoint &slot);

	// Get the object that the point is over
	GameObject *pickObject(const Point16 &pickPos);

	//  Get the object ID that the point is over
	ObjectID  pickObjectID(const Point16 &pickPos);

protected: // actions within a container

	// These are the actions when there is no Item in the mouse
	virtual void clickOn(gPanelMessage &msg, GameObject *mObj,  GameObject *cObj);
	virtual void dblClickOn(gPanelMessage &msg, GameObject *mObj,  GameObject *cObj);

	// this gets a merged item
	void getMerged(GameObject *obj);

	// drop Physical Object into container
	virtual void dropPhysical(gPanelMessage &msg, GameObject *mObj,  GameObject *cObj, int16 num = 1);

	// Use Physical Object on other object in container
	virtual void usePhysical(gPanelMessage &msg, GameObject *mObj,  GameObject *cObj);

	// Use Concept or Psycological object in container
	// note: only valid container use is to drop into
	//       center characters's ready container.
	virtual void useConcept(gPanelMessage &msg, GameObject *mObj,  GameObject *cObj);

	// Use Spell or Skill on other object in container or
	// drop into center characters's ready container.
	virtual void useSpell(gPanelMessage &msg, GameObject *mObj,  GameObject *cObj);

	//  Event-handling functions

	bool activate(gEventType why);       // activate the control
	void deactivate();

	virtual void pointerMove(gPanelMessage &msg);
	virtual bool pointerHit(gPanelMessage &msg);
	virtual void pointerRelease(gPanelMessage &msg);
	virtual void timerTick(gPanelMessage &msg);

	void dblClick(GameObject *mouseObject, GameObject *slotObject, gPanelMessage &msg);

private:
	//  Container manipulation functions
	void add(ObjectID newObj);
	void remove(ObjectID obj);
	void swap(ObjectID newObj, ObjectID oldObj);

	//  Determine if the mouse is pointing a new object, and if so,
	//  adjust the mouse text
	void updateMouseText(Point16 &pickPos);
	void setCursorText(GameObject *obj);
	void setDelayedCursorText(GameObject *obj);
};

// sub class for ready inventory items

class ReadyContainerView : public ContainerView {
private:
	void            **_backImages;       // pointers to background imagery
	int16           _numIm;

public:

	ReadyContainerView(gPanelList &,
	                   const Rect16 &,
	                   ContainerNode &,
	                   void **backgrounds,
	                   int16 numRes,
	                   int16 numRows,
	                   int16 numCols,
	                   int16 totRows,
	                   AppFunc *cmd);

	// redraw the panel offscreen
	virtual void drawClipped(gPort &port, const Point16 &offset, const Rect16 &clip);

	void setScrollOffset(int8 num);
	void timerTick(gPanelMessage &msg);
};

//  sub class for enchantment container panels

class EnchantmentContainerView : public ContainerView {
public:
	EnchantmentContainerView(gPanelList &list,
	                         ContainerNode &nd,
	                         const ContainerAppearanceDef &app,
	                         AppFunc *cmd = NULL);

	virtual void pointerMove(gPanelMessage &msg);
	virtual bool pointerHit(gPanelMessage &msg);
};


//  The container window is simply a floating window with an embedded
//  container view panel and a close button control

class ContainerWindow : public FloatingWindow {
protected:
	GfxCompButton   *_closeCompButton;       //  the close button object
	ContainerView   *_view;          //  the container view object

public:
	ContainerWindow(ContainerNode &nd,
	                const ContainerAppearanceDef &app,
	                const char saveas[]);

	virtual ~ContainerWindow();

	ContainerView &getView();
	GameObject *containerObject() {
		return getView()._containerObject;
	}

	virtual void massBulkUpdate() {}
};

//  Base class for all container windows with scroll control
class ScrollableContainerWindow : public ContainerWindow {
protected:
	GfxCompButton     *_scrollCompButton;

public:
	ScrollableContainerWindow(ContainerNode &nd,
	                          const ContainerAppearanceDef &app,
	                          const char saveas[]);

	void scrollUp() {
		if (_view->_scrollPosition > 0) _view->_scrollPosition--;
	}

	void scrollDown() {
		if (_view->_scrollPosition + _view->_visibleRows < _view->_totalRows)
			_view->_scrollPosition++;
	}
};

//  A container window for tangible containers
class TangibleContainerWindow : public ScrollableContainerWindow {
private:
	GfxCompImage      *_containerSpriteImg;
	CMassWeightIndicator *_massWeightIndicator;

	Rect16          _objRect;
	bool            _deathFlag;

private:
	void setContainerSprite();

public:

	TangibleContainerWindow(ContainerNode &nd,
	                        const ContainerAppearanceDef &app);
	~TangibleContainerWindow();

	void drawClipped(gPort &port, const Point16 &offset, const Rect16 &clip);

	// this sets the mass and bulk gauges for physical containers
	void massBulkUpdate();
};

class IntangibleContainerWindow : public ScrollableContainerWindow {
protected:
	friend  void setMindContainer(int index, IntangibleContainerWindow &cw);
private:
	GfxMultCompButton *_mindSelectorCompButton;

public:

	IntangibleContainerWindow(ContainerNode &nd, const ContainerAppearanceDef &app);
};

class EnchantmentContainerWindow : public ContainerWindow {
protected:
	GfxCompButton     *_scrollCompButton;

public:
	EnchantmentContainerWindow(ContainerNode &nd,
	                           const ContainerAppearanceDef &app);
};

/* ===================================================================== *
    ContainerAppearanceDef: A record listing container appearance info
 * ===================================================================== */

struct ContainerAppearanceDef {
	StaticRect defaultWindowPos;       //  default position of window
	StaticRect viewRect;               //  position of view within window
	StaticRect closeRect,              //  position of close button
	           scrollRect,             //  position of scrolling button
	           iconRect,               //  position of container icon
	           massRect;               //  position of mass & bulk indicator

	hResID closeResID[2],              //  resource ID's for close box
	       scrollResID[2];             //  resource ID's for scroll indicator

	StaticPoint16 iconOrigin,
	              iconSpacing;
	uint16 rows,
	       cols,
	       totRows;
};

/* ===================================================================== *
    ContainerNode: records the fact that a container was open for a
    specific player
 * ===================================================================== */

//  ContainerNode records the fact that a container was opened for a
//  specific player

//  REM: What about the ordering of windows?

class ContainerNode {

	friend class    ContainerManager;
	friend class    ContainerView;
	friend class    ContainerWindow;

public:
	enum ContainerNodeOwnerType {
		kReadyType   = 0,                    //  This is a player ready container
		kDeadType,                           //  The "dead" container
		kMentalType,                         //  A player's mental container
		kPhysicalType,                       //  Physical container
		kEnchantType                         //  Enchantment container
	};

	enum ContainerNodeOwners {
		kNobody = 255                        //  owner = 255 means it's on the ground
	};

	enum containerAction {
		kActionUpdate    = (1 << 0),         //  Refresh this window
		kActionDelete    = (1 << 1),         //  Delete this window
		kActionHide      = (1 << 2),         //  Refresh this window
		kActionShow      = (1 << 3)          //  Refresh this window
	};

private:
	ObjectID        _object;                 //  Object being viewed
	uint8           _type;                   //  type of container
	uint8           _owner;                  //  which brother owns this container
	Rect16          _position;               //  position of window
	ContainerWindow *_window;                //  window, which may be NULL if hidden.
	uint8           _action;                 //  What action to take on container
public:
	uint8           _mindType;               //  mindContainer type

private:
	//  Nested structure used to archive ContainerNodes
	struct Archive {
		ObjectID        object;
		uint8           type;
		uint8           owner;
		Rect16          position;
		uint8           mindType;
		bool            shown;
	};

public:
	ContainerNode() {
		_object = 0;
		_type = 0;
		_owner = 0;
		_window = nullptr;
		_action = 0;
		_mindType = 0;
	}
	ContainerNode(ContainerManager &cl, ObjectID id, int type);
	~ContainerNode();

	static int32 archiveSize() {
		return sizeof(Archive);
	}

	void read(Common::InSaveFile *in);
	void write(Common::MemoryWriteStreamDynamic *out);

	//  Hide or show this container window.
	void hide();
	void show();
	void update();                   //  Update container associated with this node

	//  Set for lazy deletion
	void markForDelete()   {
		_action |= kActionDelete;
	}
	void markForShow() {
		_action |= kActionShow;
		_action &= ~kActionHide;
	}
	void markForHide() {
		_action |= kActionHide;
		_action &= ~kActionShow;
	}
	void markForUpdate()   {
		_action |= kActionUpdate;
	}

	//  Find the address of the window and/or view
	ContainerWindow *getWindow();
	ContainerView   *getView();

	//  Access functions
	uint8 getType() {
		return _type;
	}
	uint8 getOwnerIndex() {
		return _owner;
	}
	ObjectID getObject() {
		return _object;
	}
	Rect16 &getPosition() {
		return _position;
	}
	void setObject(ObjectID id) {
		_object = id;
	}

	//  returns true if the object represented by the container can be
	//  accessed by the player.
	bool isAccessable(ObjectID enactor);

	void changeOwner(int16 newOwner);
};

//  A list of container nodes

class ContainerManager {
public:
	Common::List<ContainerNode *> _list;

	enum {
		kBufSize     = 60,
	};

	// used to ignore doubleClick when doubleClick == singleClick
	bool _alreadyDone;

	// this will be used to determine if the cursor has been
	// held over an object long enough to qualify for the hint to be displayed
	bool _objTextAlarm;

	// determines if the cursor is in *A* container view
	bool _mouseInView;

	ObjectID _lastPickedObjectID;

	// number of items to move for merged objects
	uint16 _numPicked;

	int16 _amountIndY;

	// this will be used to hold a value of uint16 plus a -1 as a flag
	int32 _lastPickedObjectQuantity;

	int32 _amountAccumulator;

	// merged object currently being gotten
	GameObject *_objToGet;

	// selector image pointer
	void *_selImage;

	// buffer for the mouse text
	char _mouseText[kBufSize];

	ContainerManager() {
		_alreadyDone = _objTextAlarm = _mouseInView = false;
		_lastPickedObjectID = Nothing;
		_numPicked = 1;
		_amountIndY = -1;
		_lastPickedObjectQuantity = - 1;
		_amountAccumulator = 0;
		_objToGet = nullptr;
		_selImage = nullptr;
		memset(_mouseText, 0, sizeof(_mouseText));
	}

	void add(ContainerNode *cn) {
		_list.push_front(cn);
	}

	void remove(ContainerNode *cn) {
		_list.remove(cn);
	}

	void moveToFront(ContainerNode *cn) {
		remove(cn);
		add(cn);
	}

	ContainerNode *find(ObjectID id);
	ContainerNode *find(ObjectID id, int16 type);

	//  Set which player is viewing the container windows.
	void setPlayerNum(PlayerActorID playerNum);
	void doDeferredActions();
	void setUpdate(ObjectID id);
};

ContainerNode *CreateContainerNode(ObjectID id, bool open = true, int16 mindType = 0);
ContainerNode *CreateReadyContainerNode(PlayerActorID player);
ContainerNode *OpenMindContainer(PlayerActorID player, int16 open, int16 type);

/* ===================================================================== *
   Exports
 * ===================================================================== */

void initContainers();
void cleanupContainers();

void initContainerNodes();
void saveContainerNodes(Common::OutSaveFile *outS);
void loadContainerNodes(Common::InSaveFile *in);
void cleanupContainerNodes();

extern void updateContainerWindows();

extern APPFUNC(cmdCloseButtonFunc);
extern APPFUNC(cmdMindContainerFunc);
extern APPFUNC(cmdScrollFunc);

} // end of namespace Saga2

#endif