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