---

/home/groups/n/no/noxwizard/cvs/src/items.h

Go to the documentation of this file.

  /*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
    || NoX-Wizard UO Server Emulator (NXW) [http://noxwizard.sourceforge.net]  ||
    ||                                                                         ||
    || This software is free software released under GPL2 license.             ||
    || You can find detailed license information in nox-wizard.cpp file.       ||
    ||                                                                         ||
    || For any question post to NoX-Wizard forums.                             ||
    -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

#ifndef __ITEMS_H
#define __ITEMS_H

#include "amx/amxcback.h"
#include "object.h"
#include "magic.h"
#include "item.h"
#include "globals.h"

enum AmxItemEvents {
        EVENT_IONSTART = 0,
        EVENT_IONDAMAGE,
        EVENT_IONEQUIP,
        EVENT_IONUNEQUIP,
        EVENT_IONCLICK,
        EVENT_IONDBLCLICK,
        EVENT_IPUTINBACKPACK,
        EVENT_IDROPINLAND,
        EVENT_IDROPONCHAR,
        EVENT_IONCHECKCANUSE,
        EVENT_IONTRANSFER,
        EVENT_IONSTOLEN,
        EVENT_IONPOISONED,
        EVENT_IONDECAY,
        EVENT_IONREMOVETRAP,
        EVENT_IONLOCKPICK,
        EVENT_IONWALKOVER,
        EVENT_IONPUTITEM,
        EVENT_ITAKEFROMCONTAINER,
        ALLITEMEVENTS
};

enum DelType
{
        DELTYPE_UNKNOWN,
        DELTYPE_DECAY,
        DELTYPE_GMREMOVE
};

class cItem : public cObject
{
public:
        cItem& operator=(cItem& b);

        static void     archive();
        static void     safeoldsave();

public:
        cItem(SERIAL serial);
        ~cItem();



        AmxEvent        *amxevents[ALLITEMEVENTS];

        SI32            hp;     
        SI32            maxhp;  

        void            Refresh();
        SI32            getName(char* itemname);
        const char*     getRealItemName();


        inline SI16 animid()
        { return ( animid1 && animid2 ) ? (SI16)((animid1<<8)|animid2) : getId(); }
        SI08    isFieldSpellItem();

        LOGICAL IsCorpse();
        LOGICAL IsSpellScroll();        
        LOGICAL IsSpellScroll72();      
        LOGICAL IsTree();               
        LOGICAL IsTree2();              
        LOGICAL IsInstrument();

        LOGICAL IsAxe();
        LOGICAL IsSword();
        LOGICAL IsSwordType();
        LOGICAL IsMace1H();
        LOGICAL IsMace2H();
        LOGICAL IsMaceType();
        LOGICAL IsFencing1H();
        LOGICAL IsFencing2H();
        LOGICAL IsFencingType();
        LOGICAL IsBow();
        LOGICAL IsCrossbow();
        LOGICAL IsHeavyCrossbow();
        LOGICAL IsBowType();
        LOGICAL IsArrow();
        LOGICAL IsBolt();
        LOGICAL IsStave();
        LOGICAL IsSpecialMace();
        LOGICAL IsChaosOrOrderShield();
        LOGICAL IsShield();

        LOGICAL IsLog();
        LOGICAL IsShaft();
        LOGICAL IsBoard();
        LOGICAL IsFeather();
        LOGICAL IsCutLeather();
        LOGICAL IsHide();
        LOGICAL IsBoltOfCloth();
        LOGICAL IsCutCloth();
        LOGICAL IsCloth();
        LOGICAL IsChest();

        LOGICAL IsForge();
        LOGICAL IsAnvil();
        LOGICAL IsCookingPlace();
        LOGICAL IsDagger();

        LOGICAL IsFish();
        LOGICAL IsFishWater();

        LOGICAL IsSign();
        LOGICAL IsBrassSign();
        LOGICAL IsWoodenSign();
        LOGICAL IsGuildSign();
        LOGICAL IsTradeSign();
        LOGICAL IsBankSign();
        LOGICAL IsTheatreSign();
        LOGICAL IsHouse();
        LOGICAL isSpawner();

        UI08            animid1;        
        UI08            animid2;        
        void            animSetId(SI16 id);     
        LOGICAL         useAnimId;
        SI08            layer;          
        SI08            oldlayer;       
        SI08            scriptlayer;    

        SI08            magic;          
        SI08            visible;        
        SI16            dir;


private:
        Serial          contserial;
        Serial          oldcontserial;
        
public:
        SI32            getContSerial(LOGICAL old= 0) const;
        BYTE            getContSerialByte(UI32 nByte, LOGICAL old= false) const;
        const cObject*  getContainer() const;

        inline void     setCont(P_OBJECT obj)
        { setContSerial(obj->getSerial32()); }

        void            setContSerial(SI32 serial, LOGICAL old= false, LOGICAL update= true);
        void            setContSerialByte(UI32 nByte, BYTE value, LOGICAL old= false);

        inline const LOGICAL isContainer() const
        { return type==1 || type==12 || type==63 || type==8 || type==13 || type==64; }

        inline const LOGICAL isSecureContainer() const
        { return type==8 || type==13 || type==64; }

        //SI16          GetContGumpType();
        void            SetRandPosInCont(P_ITEM pCont);
        bool            ContainerPileItem( P_ITEM pItem );      // try to find an item in the container to stack with
        SI32            secureIt; // secured chests
        LOGICAL         AddItem(P_ITEM pItem, short xx=-1, short yy=-1);        // Add Item to container
        SI32            DeleteAmountByID(int amount, unsigned int scriptID);
        SI16            getContGump();
        void            putInto( P_ITEM pi );

/********************************
        Extra info
********************************/
        UI08            more1;          // For various stuff
        UI08            more2;
        UI08            more3;
        UI08            more4;
        SI08            moreb1;
        SI08            moreb2;
        SI08            moreb3;
        SI08            moreb4;
        UI32            morex;
        UI32            morey;
        UI32            morez;


        UI16            amount;         
        UI16            amount2;        
        SI32            ReduceAmount(const SI16 amount);
        SI32            IncreaseAmount(const SI16 amount);

        inline void     setAmount(const UI16 amt)
        { amount= amt; Refresh(); }

        SI32                    DeleteAmount(int amount, short id, short color=-1);
        inline const SI32       CountItems(short ID=-1, short col= -1,LOGICAL bAddAmounts = true) const
        { return pointers::containerCountItems(getSerial32(), ID, col, bAddAmounts); }

        inline const SI32       CountItemsByID(unsigned int scriptID, LOGICAL bAddAmounts) const
        { return pointers::containerCountItemsByID(getSerial32(), scriptID, bAddAmounts); }
        inline const SI32       CountItemsByType(unsigned int type, LOGICAL bAddAmounts) const
        { return pointers::containerCountItemsByType(getSerial32(), type, bAddAmounts); }


        UI32                    weight;
        R32                     getWeight();

        inline const R32        getWeightActual()
        { return (amount>1)? getWeight()*amount : getWeight(); }


        inline const LOGICAL    isInWorld() const
        { return contserial.serial32==INVALID; }

        void                    MoveTo(Location newloc);

        inline void             MoveTo(SI32 x, SI32 y, SI32 z)
        { MoveTo( Loc(x, y, z) ); }


        Skill           getCombatSkill();
        UI32            att;            
        UI32            def;            
        Skill           fightskill;     
        SI32            reqskill[2];    
        DamageType      damagetype;     
        DamageType      auxdamagetype;  
        SI32            auxdamage;      
        SI32            lodamage;       
        SI32            hidamage;       
        SI32            wpsk;           
        SI32            spd;            
        SI32            itmhand;        
        SI32            resists[MAX_RESISTANCE_INDEX];  
        SI32            st;             
        SI32            st2;            
        SI32            dx;             
        SI32            dx2;            
        SI32            in;             
        SI32            in2;            
        PoisonType      poisoned;       
        UI32            ammo;           
        UI32            ammoFx;         



        SI32            countSpellsInSpellBook();
        LOGICAL         containsSpell(magic::SpellId spellnumber);
        UI32            gatetime;
        SI32            gatenumber;
        SI08            offspell;


        LOGICAL         corpse;         
        string          murderer;       
        SI32            murdertime;     



        SI32            smelt;          

        SI32            rank;

        //char          creator[50];    //!< Store the name of the player made this item
        std::string     creator;        
        SI32            good;           
        SI32            rndvaluerate;   

        SI32            madewith;
        //char          desc[100];      //!< vendor description
        std::string     vendorDescription;


        void            SetMultiSerial(SI32 mulser);


        SI32            value;          
        SI32            restock;        



        SI32            trigger;        
        SI32            trigtype;       
        SI32            tuses;          



        UI32            type;           
        UI32            type2;
        SI32            carve;          
        LOGICAL         incognito;      
        SI32            wipe;           
        UI32            time_unused;    
        UI32            timeused_last;  


/********************************
        Effect related
********************************/
//      SI32            glow; // LB identifies glowing objects
//      SI08            glow_c1; // for backup of old color
//      SI08            glow_c2;
//      SI08            glow_effect;
        SI08            doordir; // Reserved for doors
        LOGICAL         dooropen;
        SI32            itemSoundEffect;
        void            explode(NXWSOCKET  s);


        LOGICAL         dye;            

        SI08            priv;           

private:
        TIMERVAL        decaytime;

public:
        inline const SI32 getSound() const
        { return itemSoundEffect; }
        inline          void setSound(UI16 newSound) 
        { itemSoundEffect = newSound; }

        inline  UI32    getType()
        { return type; };

        inline  void setType(UI32 newType)
        { type=newType; };

        LOGICAL         doDecay();

        inline const LOGICAL canDecay() const
        { return priv&0x01; }

        void            setDecay( const LOGICAL on = true );

        inline const void setDecayTime( const TIMERVAL delay = uiCurrentTime+(SrvParms->decaytimer*MY_CLOCKS_PER_SEC) )
        { decaytime = delay; }

        inline const TIMERVAL getDecayTime() const
        { return decaytime; }

        inline const LOGICAL isNewbie() const
        { return priv&0x02; }

        void            setNewbie( const LOGICAL on = true );

        inline const LOGICAL isDispellable() const
        { return priv&0x04; }

        void            setDispellable( const LOGICAL on = true );

        LOGICAL         pileable; // Can item be piled
        bool            PileItem( P_ITEM pItem );

        P_ITEM          getOutMostCont( short rec=50 );
        P_CHAR          getPackOwner();

        UI32            distFrom( P_CHAR pc );
        UI32            distFrom( P_ITEM pi );

public:
        virtual void    Delete();
/*
public:
        LOGICAL         isValidAmxEvent( UI32 eventId );
*/
} PACK_NEEDED;

// will be fully implemented in 0.83
// Anthalir
/*

  properties of containers:
        - one or more key(s)
        - a list of items stored in it
        - a gump
*/
class cContainerItem : public cItem
{
private:
        vector<SI32>            ItemList;

        SI16                            getGumpType();
        LOGICAL                         pileItem(P_ITEM pItem);
        void                            setRandPos(P_ITEM pItem);

public:
                                                cContainerItem(LOGICAL ser= true);
        UI32                            removeItems(UI32 scriptID, UI32 amount/*= 1*/);
        void                            dropItem(P_ITEM pi);
        UI32                            countItems(UI32 scriptID, LOGICAL bAddAmounts= false);
        UI32                            countItemsByType(short type, LOGICAL bAddAmounts=false);

} PACK_NEEDED;

class cWeapon : public cItem
{
public:
        cWeapon(SERIAL serial);
} PACK_NEEDED;

extern LOGICAL LoadItemEventsFromScript (P_ITEM pi, char *script1, char *script2);


#define MAKE_ITEM_REF(i) pointers::findItemBySerial(i)

#define DEREF_P_ITEM(pi) ( ( ISVALIDPI(pi) ) ? pi->getSerial32() : INVALID )

#define ISVALIDPI(pi) ( ( pi!=NULL && sizeof(*pi) == sizeof(cItem) ) ? (pi->getSerial32() > 0) : false )

#define VALIDATEPI(pi) if (!ISVALIDPI(pi)) { LogWarning("Warning: a non-valid P_ITEM pointer was used in %s:%d", basename(__FILE__), __LINE__); return; }
#define VALIDATEPIR(pi, r) if (!ISVALIDPI(pi)) { LogWarning("Warning: a non-valid P_ITEM pointer was used in %s:%d", basename(__FILE__), __LINE__); return r; }



#endif