item.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/>.
 *
 */

#ifndef ULTIMA8_WORLD_ITEM_H
#define ULTIMA8_WORLD_ITEM_H

#include "ultima/ultima8/kernel/object.h"
#include "ultima/ultima8/gfx/shape_info.h"

#include "ultima/ultima8/usecode/intrinsics.h"
#include "ultima/ultima8/misc/box.h"
#include "ultima/ultima8/misc/point3.h"
#include "ultima/ultima8/misc/direction.h"

namespace Ultima {
namespace Ultima8 {

class Container;
class ShapeInfo;
class Shape;
class Gump;
class GravityProcess;

class Item : public Object {
    friend class ItemFactory;

public:
    Item();
    ~Item() override;

    ENABLE_RUNTIME_CLASSTYPE()

    
    ObjId getParent() const {
        return _parent;
    }

    void setParent(ObjId p) {
        _parent = p;
    }

    Container *getParentAsContainer() const;

    Container *getRootContainer() const;

    const Item *getTopItem() const;

    void setLocation(int32 x, int32 y, int32 z); // this only sets the loc.
    void setLocation(const Point3 &pt); // this only sets the loc.

    virtual void move(int32 x, int32 y, int32 z);

    void move(const Point3 &pt);

    bool moveToContainer(Container *container, bool checkwghtvol = false);

    void moveToEtherealVoid();

    void returnFromEtherealVoid();

    void movedByPlayer();

    Point3 getLocationAbsolute() const;

    inline Point3 getLocation() const {
        return Point3(_x, _y, _z);
    }

    int32 getZ() const;

    void setZ(int32 z) {
        _z = z;
    }

    void getGumpLocation(int32 &x, int32 &y) const;

    void setGumpLocation(int32 x, int32 y);

    void randomGumpLocation();

    Point3 getCentre() const;

    inline void getFootpadWorld(int32 &x, int32 &y, int32 &z) const;

    inline void getFootpadData(int32 &x, int32 &y, int32 &z) const;

    Box getWorldBox() const;

    inline uint16 getFlags() const {
        return _flags;
    }

    inline bool hasFlags(uint16 flags) const {
        return (_flags & flags) != 0;
    }

    void setFlag(uint32 mask) {
        _flags |= mask;
    }

    virtual void setFlagRecursively(uint32 mask) {
        setFlag(mask);
    }

    void clearFlag(uint32 mask) {
        _flags &= ~mask;
    }

    void setExtFlags(uint32 f) {
        _extendedFlags = f;
    }

    inline uint32 getExtFlags() const {
        return _extendedFlags;
    }

    inline bool hasExtFlags(uint32 flags) const {
        return (_extendedFlags & flags) != 0;
    }

    void setExtFlag(uint32 mask) {
        _extendedFlags |= mask;
    }

    void clearExtFlag(uint32 mask) {
        _extendedFlags &= ~mask;
    }

    uint32 getShape() const {
        return _shape;
    }

    void setShape(uint32 shape);

    uint32 getFrame() const {
        return _frame;
    }

    void setFrame(uint32 frame) {
        _frame = frame;
    }

    uint16 getQuality() const {
        return _quality;
    }

    void setQuality(uint16 quality) {
        _quality = quality;
    }

    uint16 getNpcNum() const {
        return _npcNum;
    }

    void setNpcNum(uint16 npcnum) {
        _npcNum = npcnum;
    }

    uint16 getMapNum() const {
        return _mapNum;
    }

    void setMapNum(uint16 mapnum) {
        _mapNum = mapnum;
    }

    inline const ShapeInfo *getShapeInfo() const;

    virtual const ShapeInfo *getShapeInfoFromGameInstance() const;

    const Shape *getShapeObject() const;

    uint16 getFamily() const;

    bool canMergeWith(const Item *other) const;

    ObjId getGump() const {
        return _gump;
    }
    void clearGump(); // set gump to 0 and clear the GUMP_OPEN flag
    ObjId openGump(uint32 gumpshape);
    void closeGump();

    ProcId bark(const Std::string &msg, ObjId id = 0);
    void clearBark(); // set bark to 0
    void closeBark();

    virtual void destroy(bool delnow = false);

    bool overlaps(const Item &item2) const;

    bool overlapsxy(const Item &item2) const;

    bool isOn(const Item &item2) const;

    bool isCompletelyOn(const Item &item2) const;

    bool isCentreOn(const Item &item2) const;

    bool isOnScreen() const;

    bool isPartlyOnScreen() const;

    bool canExistAt(int32 x, int32 y, int32 z, bool needsupport = false) const;
    bool canExistAt(const Point3 &pt, bool needsupport = false) const;

    Direction getDirToItemCentre(const Item &item2) const;

    Direction getDirToItemCentre(const Point3 &pt) const;

    int getRange(const Item &item2, bool checkz = false) const;

    int getRangeIfVisible(const Item &item2) const;

    bool canReach(const Item *other, int range, int32 x = 0, int32 y = 0, int32 z = 0) const;

    //         directions in which movement was blocked (bit 0=x,1=y,2=z)
    virtual int32 collideMove(int32 x, int32 y, int32 z, bool teleport, bool force,
                      ObjId *hititem = 0, uint8 *dirs = 0);

    int32 ascend(int delta);

    void fall();

    void grab();

    void hurl(int xs, int ys, int zs, int grav);

    void setGravityPID(ProcId pid) {
        assert(_gravityPid == 0 || pid == 0);
        _gravityPid = pid;
    }

    ProcId getGravityPID() const {
        return _gravityPid;
    }

    virtual GravityProcess *ensureGravityProcess();

    virtual uint32 getWeight() const;

    virtual uint32 getTotalWeight() const;

    virtual uint32 getVolume() const;

    void explode(int explosion_type, bool destroy_item, bool cause_damage = true);

    virtual uint16 getDamageType() const;

    virtual void receiveHit(ObjId other, Direction dir, int damage, uint16 type);

    uint16 fireWeapon(int32 x, int32 y, int32 z, Direction dir, int firetype, bool findtarget);

    uint16 fireDistance(const Item *other, Direction dir, int16 xoff, int16 yoff, int16 zoff) const;

    uint8 getDamagePoints() const {
        return _damagePoints;
    }

    void setDamagePoints(uint8 points) {
        _damagePoints = points;
    }

    int32 getTargetZRelativeToAttackerZ(int32 attackerz) const;

    unsigned int countNearby(uint32 shape, uint16 range) const;

    bool canDrag() const;

    int getThrowRange() const;

    bool checkLoopScript(const uint8 *script, uint32 scriptsize) const;

    uint32 callUsecodeEvent_look();                             // event 0
    uint32 callUsecodeEvent_use();                              // event 1
    uint32 callUsecodeEvent_anim();                             // event 2
    uint32 callUsecodeEvent_cachein();                          // event 4
    uint32 callUsecodeEvent_hit(ObjId hitted, int16 hitforce);  // event 5
    uint32 callUsecodeEvent_gotHit(ObjId hitter, int16 hitforce);// event 6
    uint32 callUsecodeEvent_hatch();                            // event 7
    uint32 callUsecodeEvent_schedule(uint32 time);              // event 8
    uint32 callUsecodeEvent_release();                          // event 9
    uint32 callUsecodeEvent_equip();                            // event A
    uint32 callUsecodeEvent_equipWithParam(ObjId param);        // event A
    uint32 callUsecodeEvent_unequip();                          // event B
    uint32 callUsecodeEvent_unequipWithParam(ObjId param);      // event B
    uint32 callUsecodeEvent_combine();                          // event C
    uint32 callUsecodeEvent_calledFromAnim();                   // event E
    uint32 callUsecodeEvent_enterFastArea();                    // event F
    uint32 callUsecodeEvent_leaveFastArea();                    // event 10
    uint32 callUsecodeEvent_cast(uint16 unk);                   // event 11
    uint32 callUsecodeEvent_justMoved();                        // event 12
    uint32 callUsecodeEvent_AvatarStoleSomething(uint16 unk);   // event 14
    uint32 callUsecodeEvent_guardianBark(int16 unk);            // event 15 (Ultima)
    uint32 callUsecodeEvent_unhatch();                          // event 15 (Crusader)

    uint32 use();

    inline Point3 getLerped() const {
        return Point3(_ix, _iy, _iz);
    }

    inline void doLerp(int32 factor) {
        // Should be noted that this does indeed limit us to 'only' 24bit coords
        // not that it matters because on disk they are unsigned 16 bit

        if (factor == 256) {
            _ix = _lNext._x;
            _iy = _lNext._y;
            _iz = _lNext._z;
        } else if (factor == 0) {
            _ix = _lPrev._x;
            _iy = _lPrev._y;
            _iz = _lPrev._z;
        } else {
#if 1
            // This way while possibly slower is more accurate
            _ix = ((_lPrev._x * (256 - factor) + _lNext._x * factor) >> 8);
            _iy = ((_lPrev._y * (256 - factor) + _lNext._y * factor) >> 8);
            _iz = ((_lPrev._z * (256 - factor) + _lNext._z * factor) >> 8);
#else
            _ix = _lPrev.x + (((_lNext.x - _lPrev.x) * factor) >> 8);
            _iy = _lPrev.y + (((_lNext.y - _lPrev.y) * factor) >> 8);
            _iz = _lPrev.z + (((_lNext.z - _lPrev.z) * factor) >> 8);
#endif
        }
    }

    void setupLerp(int32 gametick);

    virtual uint32 enterFastArea();

    virtual void leaveFastArea();

    Common::String dumpInfo() const override;

    bool loadData(Common::ReadStream *rs, uint32 version);
    void saveData(Common::WriteStream *ws) override;

    // Intrinsics
    INTRINSIC(I_touch);
    INTRINSIC(I_getX);
    INTRINSIC(I_getY);
    INTRINSIC(I_getZ);
    INTRINSIC(I_getCX);
    INTRINSIC(I_getCY);
    INTRINSIC(I_getCZ);
    INTRINSIC(I_getPoint);
    INTRINSIC(I_getShape);
    INTRINSIC(I_setShape);
    INTRINSIC(I_getFrame);
    INTRINSIC(I_setFrame);
    INTRINSIC(I_getQuality);
    INTRINSIC(I_getUnkEggType);
    INTRINSIC(I_setUnkEggType);
    INTRINSIC(I_getQuantity);
    INTRINSIC(I_getContainer);
    INTRINSIC(I_getRootContainer);
    INTRINSIC(I_getQ);
    INTRINSIC(I_getQHi);
    INTRINSIC(I_getQLo);
    INTRINSIC(I_setQ);
    INTRINSIC(I_setQHi);
    INTRINSIC(I_setQLo);
    INTRINSIC(I_setQuality);
    INTRINSIC(I_setQuantity);
    INTRINSIC(I_setQAndCombine);
    INTRINSIC(I_getFamily);
    INTRINSIC(I_getTypeFlag);
    INTRINSIC(I_getStatus);
    INTRINSIC(I_orStatus);
    INTRINSIC(I_andStatus);
    INTRINSIC(I_getFootpadData);
    INTRINSIC(I_overlaps);
    INTRINSIC(I_overlapsXY);
    INTRINSIC(I_isOn);
    INTRINSIC(I_isCompletelyOn);
    INTRINSIC(I_isCentreOn);
    INTRINSIC(I_isInNpc);
    INTRINSIC(I_ascend);
    INTRINSIC(I_getWeight);
    INTRINSIC(I_getWeightIncludingContents);
    INTRINSIC(I_getVolume);
    INTRINSIC(I_bark);
    INTRINSIC(I_getMapArray);
    INTRINSIC(I_setMapArray);
    INTRINSIC(I_getNpcNum);
    INTRINSIC(I_setNpcNum);
    INTRINSIC(I_getDirToCoords);
    INTRINSIC(I_getDirFromCoords);
    INTRINSIC(I_getDirToItem);
    INTRINSIC(I_getDirFromItem);
    INTRINSIC(I_getDirFromTo16);
    INTRINSIC(I_getClosestDirectionInRange);
    INTRINSIC(I_look);
    INTRINSIC(I_use);
    INTRINSIC(I_gotHit);
    INTRINSIC(I_enterFastArea);
    INTRINSIC(I_cast);
    INTRINSIC(I_ask);
    INTRINSIC(I_getSliderInput);
    INTRINSIC(I_openGump);
    INTRINSIC(I_closeGump);
    INTRINSIC(I_create);
    INTRINSIC(I_legalCreateAtPoint);
    INTRINSIC(I_legalCreateAtCoords);
    INTRINSIC(I_legalCreateInCont);
    INTRINSIC(I_push);
    INTRINSIC(I_pop);
    INTRINSIC(I_popToCoords);
    INTRINSIC(I_popToContainer);
    INTRINSIC(I_popToEnd);
    INTRINSIC(I_destroy);
    INTRINSIC(I_move);
    INTRINSIC(I_legalMoveToPoint);
    INTRINSIC(I_legalMoveToContainer);
    INTRINSIC(I_hurl);
    INTRINSIC(I_shoot);
    INTRINSIC(I_fall);
    INTRINSIC(I_grab);
    INTRINSIC(I_igniteChaos);
    INTRINSIC(I_getFamilyOfType);
    INTRINSIC(I_getEtherealTop);
    INTRINSIC(I_guardianBark);
    INTRINSIC(I_getSurfaceWeight);
    INTRINSIC(I_isExplosive);
    INTRINSIC(I_receiveHit);
    INTRINSIC(I_explode);
    INTRINSIC(I_canReach);
    INTRINSIC(I_getRange);
    INTRINSIC(I_getRangeIfVisible);
    INTRINSIC(I_isCrusTypeNPC);
    INTRINSIC(I_setBroken);
    INTRINSIC(I_inFastArea);
    INTRINSIC(I_equip);
    INTRINSIC(I_unequip);
    INTRINSIC(I_avatarStoleSomething);
    INTRINSIC(I_isPartlyOnScreen);
    INTRINSIC(I_fireWeapon);
    INTRINSIC(I_fireDistance);

private:
    uint32 _shape;   // DO NOT modify this directly! Always use setShape()!

protected:
    uint32 _frame;

    int32 _x, _y, _z; // world coordinates
    uint16 _flags;
    uint16 _quality;
    uint16 _npcNum;
    uint16 _mapNum;

    uint32 _extendedFlags; // pentagram's own flags

    ObjId _parent; // objid container this item is in (or 0 for top-level items)

    mutable const Shape *_cachedShape;
    mutable const ShapeInfo *_cachedShapeInfo;

    // This is stuff that is used for displaying and interpolation
    struct Lerped {
        Lerped() : _x(0), _y(0), _z(0), _shape(0), _frame(0) {};
        int32 _x, _y, _z;
        uint32 _shape, _frame;
    };

    Lerped  _lPrev;         // Previous state (relative to camera)
    Lerped  _lNext;         // Next (current) state (relative to camera)
    int32   _ix, _iy, _iz;  // Interpolated position in camera space

    ObjId _gump;             // Item's container gump
    ObjId _bark;             // Item's bark gump
    ProcId _gravityPid;      // Item's GravityTracker (or 0)

    uint8 _damagePoints;    // Damage points, used for item damage in Crusader

    bool isRobotCru() const;

    int scaleReceivedDamageCru(int damage, uint16 type) const;

private:

    uint32 callUsecodeEvent(uint32 event, const uint8 *args = 0, int argsize = 0);

    int32 _lastSetup;

    void animateItem();

    void receiveHitU8(ObjId other, Direction dir, int damage, uint16 type);

    void receiveHitCru(ObjId other, Direction dir, int damage, uint16 type);

public:
    enum statusflags {
        FLG_DISPOSABLE   = 0x0002,  
        FLG_OWNED        = 0x0004,  
        FLG_CONTAINED    = 0x0008,  
        FLG_INVISIBLE    = 0x0010,  
        FLG_FLIPPED      = 0x0020,  
        FLG_IN_NPC_LIST  = 0x0040,  
        FLG_FAST_ONLY    = 0x0080,  
        FLG_GUMP_OPEN    = 0x0100,  
        FLG_EQUIPPED     = 0x0200,  
        FLG_BOUNCING     = 0x0400,  
        FLG_ETHEREAL     = 0x0800,  
        FLG_HANGING      = 0x1000,  
        FLG_FASTAREA     = 0x2000,  
        FLG_LOW_FRICTION = 0x4000,  
        FLG_BROKEN       = 0x8000   
    };

    enum extflags {
        EXT_FIXED        = 0x0001,  
        EXT_INCURMAP     = 0x0002,  
        EXT_LERP_NOPREV  = 0x0008,  
        EXT_HIGHLIGHT    = 0x0010,  
        EXT_CAMERA       = 0x0020,  
        EXT_SPRITE       = 0x0040,  
        EXT_TRANSPARENT  = 0x0080,  
        EXT_PERMANENT_NPC = 0x0100, 
        EXT_TARGET       = 0x0200,  
        EXT_FEMALE       = 0x8000   
    };

    // easter egg as in original: items stack to max quantity of 666
    static const int MAX_QUANTITY = 666;
};

inline const ShapeInfo *Item::getShapeInfo() const {
    if (!_cachedShapeInfo)
        _cachedShapeInfo = getShapeInfoFromGameInstance();
    return _cachedShapeInfo;
}

inline void Item::getFootpadData(int32 &X, int32 &Y, int32 &Z) const {
    const ShapeInfo *si = getShapeInfo();
    Z = si->_z;

    if (_flags & Item::FLG_FLIPPED) {
        X = si->_y;
        Y = si->_x;
    } else {
        X = si->_x;
        Y = si->_y;
    }
}

// like getFootpadData, but scaled to world coordinates
inline void Item::getFootpadWorld(int32 &X, int32 &Y, int32 &Z) const {
    const ShapeInfo *si = getShapeInfo();
    si->getFootpadWorld(X, Y, Z, _flags & Item::FLG_FLIPPED);
}

} // End of namespace Ultima8
} // End of namespace Ultima

#endif