Item.h

Go to the documentation of this file.

/*
Copyright (C) 2003-2007 The Pentagram team

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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

#ifndef ITEM_H
#define ITEM_H

#include "Object.h"
#include "ShapeInfo.h"

#include "intrinsics.h"
#include "Box.h"
class Container;
class ShapeInfo;
class Shape;
class Gump;
class ODataSource;
class GravityProcess;

class Item : public Object
{
        friend class ItemFactory;

public:
        Item();
        virtual ~Item();

        // p_dynamic_cast stuff
        ENABLE_RUNTIME_CLASSTYPE();

        ObjId getParent() const { return parent; }

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

        Container *getParentAsContainer() const;

        Item* getTopItem();

        void setLocation(sint32 x, sint32 y, sint32 z); // this only sets the loc.

        void move(sint32 x, sint32 y, sint32 z);

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

        void moveToEtherealVoid();

        void returnFromEtherealVoid();

        void movedByPlayer();

        void getLocationAbsolute(sint32& x, sint32& y, sint32& z) const;

        inline void getLocation(sint32& x, sint32& y, sint32& z) const;

        sint32 getZ() const;

        void setZ(sint32 z_) { z = z_; }

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

        void setGumpLocation(sint32 x, sint32 y);

        void randomGumpLocation();

        void getCentre(sint32& x, sint32& y, sint32& z) const;

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

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

        Pentagram::Box getWorldBox() const;

        inline uint16 getFlags() const { return flags; }

        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; }

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

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

        uint32 getShape() const { return shape; }

        void setShape(uint32 shape_)
                { shape = shape_; cachedShapeInfo = 0; cachedShape = 0; }

        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 ShapeInfo* getShapeInfo() const;

        ShapeInfo* getShapeInfoFromGameInstance() const;

        Shape* getShapeObject() const;

        uint16 getFamily();

        bool canMergeWith(Item* other);

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

        virtual void destroy(bool delnow = false);

        bool overlaps(Item& item2) const;

        bool overlapsxy(Item& item2) const;

        bool isOn(Item& item2) const;

        bool canExistAt(sint32 x,sint32 y,sint32 z, bool needsupport=false) const;

        int getDirToItemCentre(Item& item2) const;

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

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

        sint32 collideMove(sint32 x,sint32 y,sint32 z, bool teleport, bool force,
                                           ObjId* hititem=0);

        sint32 ascend(int delta);

        void fall();

        void grab();

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

        void setGravityPID(ProcId pid) { gravitypid = pid; }

        ProcId getGravityPID() const { return gravitypid; }

        virtual GravityProcess* ensureGravityProcess();

        virtual uint32 getWeight();

        virtual uint32 getTotalWeight();

        virtual uint32 getVolume();

        void explode();

        virtual uint16 getDamageType();

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

        unsigned int countNearby(uint32 shape, uint16 range);

        bool canDrag();

        int getThrowRange();

        bool checkLoopScript(const uint8* script, uint32 scriptsize);
        
        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, sint16 hitforce);     // event 5
        uint32 callUsecodeEvent_gotHit(ObjId hitter, sint16 hitforce);// event 6
        uint32 callUsecodeEvent_hatch();                                                        // event 7
        uint32 callUsecodeEvent_schedule(uint32 time);                          // event 8
        uint32 callUsecodeEvent_release();                                                      // event 9
        uint32 callUsecodeEvent_combine();                                                      // event C
        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(sint16 unk);                       // event 15

        uint32 use();

        inline void getLerped(sint32& x, sint32& y, sint32& z) const
                { x = ix; y = iy; z = iz; }

        inline void doLerp(sint32 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 = l_next.x;
                        iy = l_next.y;
                        iz = l_next.z;
                }
                else if (factor == 0)
                {
                        ix = l_prev.x;
                        iy = l_prev.y;
                        iz = l_prev.z;
                }
                else
                {
#if 1
                        // This way while possibly slower is more accurate
                        ix = ((l_prev.x*(256-factor) + l_next.x*factor)>>8);
                        iy = ((l_prev.y*(256-factor) + l_next.y*factor)>>8);
                        iz = ((l_prev.z*(256-factor) + l_next.z*factor)>>8);
#else
                        ix = l_prev.x + (((l_next.x-l_prev.x)*factor)>>8);
                        iy = l_prev.y + (((l_next.y-l_prev.y)*factor)>>8);
                        iz = l_prev.z + (((l_next.z-l_prev.z)*factor)>>8);
#endif
                }
        }

        void setupLerp(sint32 gametick);                

        virtual void enterFastArea(); 

        virtual void leaveFastArea();

        virtual void dumpInfo();

        bool loadData(IDataSource* ids, uint32 version);

        // 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_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_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_ascend);
        INTRINSIC(I_getWeight);
        INTRINSIC(I_getWeightIncludingContents);
        INTRINSIC(I_getVolume);
        INTRINSIC(I_bark);
        INTRINSIC(I_getMapArray);
        INTRINSIC(I_setMapArray);
        INTRINSIC(I_getNpcNum);
        INTRINSIC(I_getDirToCoords);
        INTRINSIC(I_getDirFromCoords);
        INTRINSIC(I_getDirToItem);
        INTRINSIC(I_getDirFromItem);
        INTRINSIC(I_look);
        INTRINSIC(I_use);
        INTRINSIC(I_gotHit);
        INTRINSIC(I_enterFastArea);
        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_isCrusTypeNPC);

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

protected:
        uint32 frame;

        sint32 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 Shape *cachedShape;
        mutable ShapeInfo *cachedShapeInfo;

        // This is stuff that is used for displaying and interpolation
        struct Lerped
        {
                sint32 x,y,z;
                uint32 shape,frame;
        };
        
        Lerped  l_prev;                 // Previous state (relative to camera)
        Lerped  l_next;                 // Next (current) state (relative to camera)
        sint32  ix,iy,iz;               // Interpolated position in camera space

        ObjId gump;                     // Item's gump
        ProcId gravitypid;              // Item's GravityTracker (or 0)

        virtual void saveData(ODataSource* ods);

private:

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

        sint32  last_setup;     

        void animateItem();

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       
        };

        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       
        };
};

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

inline void Item::getFootpadData(sint32& X, sint32& Y, sint32& Z) 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(sint32& X, sint32& Y, sint32& Z) const
{
        ShapeInfo* si = getShapeInfo();
        Z = si->z * 8;

        if (flags & Item::FLG_FLIPPED) {
                X = si->y * 32;
                Y = si->x * 32;
        } else {
                X = si->x * 32;
                Y = si->y * 32;
        }
}

inline void Item::getLocation(sint32& X, sint32& Y, sint32& Z) const
{
        X = x;
        Y = y;
        Z = z;
}

#endif

---