/****************************************************************************
 * [S]imulated [M]edieval [A]dventure multi[U]ser [G]ame      |				*
 * -----------------------------------------------------------|   \\._.//	*
 * SmaugWiz (C) 1998 by Russ Pillsbury (Windows NT version)   |   (0...0)	*
 * -----------------------------------------------------------|    ).:.(	*
 * SMAUG (C) 1994, 1995, 1996 by Derek Snider                 |    {o o}	*
 * -----------------------------------------------------------|   / ' ' \	*
 * SMAUG code team: Thoric, Altrag, Blodkai, Narn, Haus,      |~'~.VxvxV.~'~*
 * Scryn, Swordbearer, Rennard, Tricops, and Gorog.           |				*
 * ------------------------------------------------------------------------ *
 * Merc 2.1 Diku Mud improvments copyright (C) 1992, 1993 by Michael        *
 * Chastain, Michael Quan, and Mitchell Tse.                                *
 * Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,          *
 * Michael Seifert, Hans Henrik Staerfeldt, Tom Madsen, and Katja Nyboe.    *
 * ------------------------------------------------------------------------ *
 *			    Objects Interface file										*
 ****************************************************************************/

#ifndef	OBJECTS_H
#define	OBJECTS_H

// object saving defines for fread/write_obj. -- Altrag
enum ObjStorageTypes { OS_CARRY, OS_CORPSE };

class	CAreaList;			// forward declaration

#include "affect.h"
#include "ExtraFlags.h"

#ifndef	BITVECTOR_H
	#include "bitvector.h"
#endif

#define		ADDBYLEVEL	TRUE	// for AddByLevel function

enum ObjCountTypes { COUNT_OBJS, COUNT_TOTAL };


class	CObjData;			// forward declarations

class CParseinfo {
public:
				CParseinfo () { Reset (); }

	void		Reset ()
				{ ZeroMemory (this, sizeof (CParseinfo)); bFirst = TRUE; }

	int			GetCount (ObjCountTypes type);
	CObjData	*Parse (CAreaList& AList);
	CObjData	*ParseAreaLists (CPtrList& AllAreasList);

	POSITION	AApos;			// All areas list position
	POSITION	Apos;			// area list position
	POSITION	Ipos;			// Obj Index list position
	POSITION	Opos;			// Obj List position
	CAreaList	*pAreaList;
	CPtrList	*pIdxList;		// Current Index list
	CObjectList	*pObjList;		// Current Object List
	BOOL		bFirst;
};



class CObjectList : public CPtrList {
public:
				CObjectList () { m_Loaded = 0; }

	void		AddByLevel (CObjData* pObj, BOOL bLevSort);
	CObjData	*FindObject (int vnum);
	void		AddTail (CObjData* obj);
	CObjData	*GetNext (POSITION& pos) const
				{ return pos ? (CObjData*) CPtrList::GetNext (pos) : NULL; }
	CObjData	*GetPrev (POSITION& pos)
				{ return pos ? (CObjData*) CPtrList::GetPrev (pos) : NULL; }
	void		Remove (CObjData* obj);
	CObjData	*RemoveTail () { return (CObjData*) CPtrList::RemoveTail (); }
	void		RemoveAll ();
	int			GetTotalObjs () { return m_Loaded; }
	void		AdjustTotal (int n) { m_Loaded += n; }
	CObjData	*GetFirst ()
				{ return IsEmpty () ? NULL : (CObjData*) GetHead (); }
	CObjData	*GetLast ()
				{ return IsEmpty () ? NULL : (CObjData*) GetTail (); }

private:
	int			m_Loaded;
};

#ifdef	SMAUGSERVER_CPP
	CObjectList	ExtractedObjList;
#endif

extern CObjectList	ExtractedObjList;





// One object.
#ifdef _DEBUG
class CObjData : public CObject {
public:
				CObjData ()
				{ ClearAddrRange (&in_obj, &serial, sizeof (serial)); }

	virtual void Dump (CDumpContext& dc) const;
#else
class CObjData {
public:
				CObjData ()
				{ ClearAddrRange (&in_obj, &serial, sizeof (serial)); }
#endif

				~CObjData ();

	void		Write (FILE *fp, int iNest, short StorageType,
					   short ChLevel = 0);

	short		GetLevel () { return level; }
	void		SetLevel (short l) { level = l; }
	const char	*GetName () const { return m_pName; }
	void		SetName (const char* n)
				{ STRFREE (m_pName); m_pName = STRALLOC (n); }
	const char	*GetShortDescr () const { return m_pShortDescr; }
	void		SetShortDescr (const char* d)
				{ STRFREE (m_pShortDescr); m_pShortDescr = STRALLOC (d); }
	const char	*GetDescription () const { return m_pDescription; }
	void		SetDescription (const char* p)
				{ STRFREE (m_pDescription); m_pDescription = STRALLOC (p); }
	// Special for GetEditBuffer
	void		SetDescriptionNA (const char* p)
				{ STRFREE (m_pDescription); m_pDescription = NCCP p; }

	const char	*GetActionDescr () const { return m_pActionDesc; }
	void		SetActionDescr (const char* d)
				{ STRFREE (m_pActionDesc); m_pActionDesc = STRALLOC (d); }
	BOOL		HasValidActionDescr ()
				{ return m_pActionDesc && *m_pActionDesc != 0; }
	
	CRoomIndexData	*GetInRoom () { return in_room; }
	CObjIndexData	*GetIndex () { return pIndexData; }

	BOOL		CanWear (int part)
				{ return IS_SET (wear_flags, part); }
	BOOL		IsPrototype () const { return m_ExtraFlags.IsPrototype (); }
	void		SetPrototype () { m_ExtraFlags.SetPrototype (); }
	void		ClrPrototype () { m_ExtraFlags.ClrPrototype (); }
	BOOL		IsMagic () const { return m_ExtraFlags.IsMagic (); }
	BOOL		IsBuried () const { return m_ExtraFlags.IsBuried (); }
	void		SetBuried () { m_ExtraFlags.SetBuried (); }
	void		ClrBuried () { m_ExtraFlags.ClrBuried (); }
	BOOL		IsClanObject () const { return m_ExtraFlags.IsClanObject (); }
	void		SetClanObject () { m_ExtraFlags.SetClanObject (); }
	BOOL		IsPoisoned () const { return m_ExtraFlags.IsPoisoned (); }
	void		SetPoisoned () { m_ExtraFlags.SetPoisoned (); }
	BOOL		IsAntiEvil () const { return m_ExtraFlags.IsAntiEvil (); }
	void		SetAntiEvil () { m_ExtraFlags.SetAntiEvil (); }
	BOOL		IsAntiGood () const { return m_ExtraFlags.IsAntiGood (); }
	void		SetAntiGood () { m_ExtraFlags.SetAntiGood (); }
	BOOL		IsAntiNeutral () { return m_ExtraFlags.IsAntiNeutral (); }
	BOOL		IsInvisible () const { return m_ExtraFlags.IsInvisible (); }
	void		SetInvisible () { m_ExtraFlags.SetInvisible (); }
	void		ClrInvisible () { m_ExtraFlags.ClrInvisible (); }
	BOOL		IsNoRemove () const { return m_ExtraFlags.IsNoRemove (); }
	void		ClrNoRemove () { m_ExtraFlags.ClrNoRemove (); }
	BOOL		IsNoDrop () const { return m_ExtraFlags.IsNoDrop (); }
	void		ClrNoDrop () { m_ExtraFlags.ClrNoDrop (); }
	BOOL		IsClanCorpse () const { return m_ExtraFlags.IsClanCorpse (); }
	void		SetClanCorpse () { m_ExtraFlags.SetClanCorpse (); }
	BOOL		IsEvil () const { return m_ExtraFlags.IsEvil (); }
	BOOL		IsHidden () const { return m_ExtraFlags.IsHidden (); }
	void		SetHidden () { m_ExtraFlags.SetHidden (); }
	void		ClrHidden () { m_ExtraFlags.ClrHidden (); }
	BOOL		IsInventory () const { return m_ExtraFlags.IsInventory (); }
	void		SetInventory () { m_ExtraFlags.SetInventory (); }
	BOOL		IsGlowing () const { return m_ExtraFlags.IsGlowing (); }
	BOOL		IsBlessed () const { return m_ExtraFlags.IsBlessed (); }
	BOOL		IsDonation () const { return m_ExtraFlags.IsDonation (); }
	BOOL		IsHumming () const { return m_ExtraFlags.IsHumming (); }
	BOOL		IsMetal () const { return m_ExtraFlags.IsMetal (); }
	BOOL		IsDark () const { return m_ExtraFlags.IsDark (); }
	BOOL		IsOrganic () const { return m_ExtraFlags.IsOrganic (); }
	BOOL		IsLoyal () const { return m_ExtraFlags.IsLoyal (); }
	BOOL		IsDeathrot () const { return m_ExtraFlags.IsDeathrot (); }
	BOOL		IsCovering () const { return m_ExtraFlags.IsCovering (); }
	BOOL		IsTrapped () const;

	CBitVector	GetAntiClassFlags () { return m_AntiClassFlags; }
	void		SetAntiClassFlags (CBitVector f) { m_AntiClassFlags = f; }
	BOOL		IsAntiClass (int cl) { return m_AntiClassFlags.IsSet (cl); }
	void		SetAntiClass (int cl) { m_AntiClassFlags.SetBit (cl); }
	void		ClrAntiClass (int cl) { m_AntiClassFlags.ClrBit (cl); }
	void		ToggleAntiClass (int cl) { m_AntiClassFlags.ToggleBit (cl); }
	CString		AntiClassNames ();


	CExitData	*GetExit (short door)
				{ return get_exit (GetInRoom (), door); }
	BOOL		CanGo (short door);

	void	AddAffect (CAffectData* aff) { AffList.AddTail (aff); }
	BOOL	HasAffects () { return ! AffList.IsEmpty (); }


	BOOL		IsEmpty () const { return m_Content.IsEmpty (); }
	void		AddContent (CObjData* pObj, BOOL bLevSort = FALSE)
				{ m_Content.AddByLevel (pObj, bLevSort); }
	void		RemoveContent (CObjData* pObj) { m_Content.Remove (pObj); }
	CObjData	*GetFirstContent () { return m_Content.GetFirst (); }
	CObjData	*GetLastContent () { return m_Content.GetLast (); }

	POSITION	GetHeadContentPos () { return m_Content.GetHeadPosition (); }
	POSITION	GetTailContentPos () { return m_Content.GetTailPosition (); }
	CObjData	*GetNextContent (POSITION& pos)
				{ return m_Content.GetNext (pos); }
	CObjData	*GetPreviousContent (POSITION& pos)
				{ return m_Content.GetPrev (pos); }
	CObjectList	&GetContentList () { return m_Content; }


	CObjData		*in_obj;
	CCharacter		*carried_by;
	CObjIndexData	*pIndexData;
	CRoomIndexData	*in_room;
	char			*m_pName;
	char			*m_pShortDescr;
	char			*m_pDescription;
	char			*m_pActionDesc;
	short			item_type;
	short			mpscriptpos;
	CExtraFlags		m_ExtraFlags;
	int				magic_flags;  // Need more bitvectors for spells - Scryn
	int				wear_flags;
	CBitVector		m_AntiClassFlags;
	CMobProgActList	*mpact;				// mudprogs
	int				mpactnum;			// mudprogs
	short			wear_loc;
	short			weight;
	int				cost;
	short			level;
	short			timer;
	int				value [6];
	short			count;				// support for object grouping
	int				serial;				// serial number

	CAffectList		AffList;
	CPtrList		ExDesList;
	CObjectList		m_Content;
};





// Prototype for an object.
#ifdef _DEBUG
class CObjIndexData : public CObject {
public:
			CObjIndexData (int v)
			{ ClearAddrRange (&m_pNext, &cost, sizeof (cost)); vnum = v; }

	virtual void Dump (CDumpContext& dc) const;
#else
class CObjIndexData {
public:
			CObjIndexData (int v)
			{ ClearAddrRange (&m_pNext, &cost, sizeof (cost)); vnum = v; }
#endif

					~CObjIndexData ();
	CObjIndexData	*GetNext () { return m_pNext; }
	void			SetNext (CObjIndexData* n) { m_pNext = n; }
	void			Clear ();

	const char		*GetName () const { return m_pName; }
	void			SetName (const char* n)
					{ STRFREE (m_pName); m_pName = STRALLOC (n); }

	const char		*GetShortDescr () const { return m_pShortDescr; }
	void			SetShortDescr (const char* d)
					{ STRFREE (m_pShortDescr); m_pShortDescr = STRALLOC (d); }
	const char		*GetDescription () const { return m_pDescription; }
	void			SetDescription (const char* p)
					{ STRFREE (m_pDescription); m_pDescription = STRALLOC (p); }
	// Special for GetEditBuffer
	void			SetDescriptionNA (const char* p)
					{ STRFREE (m_pDescription); m_pDescription = NCCP p; }

	const char		*GetActionDescr () const { return m_pActionDesc; }
	void			SetActionDescr (const char* p)
					{ STRFREE (m_pActionDesc); m_pActionDesc = STRALLOC (p); }

	void			AddAffect (CAffectData* aff) { AffList.AddTail (aff); }

	BOOL		IsPrototype () { return m_ExtraFlags.IsPrototype (); }
	void		SetPrototype () { m_ExtraFlags.SetPrototype (); }
	void		ClrPrototype () { m_ExtraFlags.ClrPrototype (); }
	BOOL		IsMagic () { return m_ExtraFlags.IsMagic (); }
	BOOL		IsBuried () { return m_ExtraFlags.IsBuried (); }
	void		SetBuried () { m_ExtraFlags.SetBuried (); }
	void		ClrBuried () { m_ExtraFlags.ClrBuried (); }
	BOOL		IsClanObject () { return m_ExtraFlags.IsClanObject (); }
	void		SetClanObject () { m_ExtraFlags.SetClanObject (); }
	BOOL		IsPoisoned () { return m_ExtraFlags.IsPoisoned (); }
	void		SetPoisoned () { m_ExtraFlags.SetPoisoned (); }
	BOOL		IsAntiEvil () { return m_ExtraFlags.IsAntiEvil (); }
	void		SetAntiEvil () { m_ExtraFlags.SetAntiEvil (); }
	BOOL		IsAntiGood () { return m_ExtraFlags.IsAntiGood (); }
	void		SetAntiGood () { m_ExtraFlags.SetAntiGood (); }
	BOOL		IsAntiNeutral () { return m_ExtraFlags.IsAntiNeutral (); }
	BOOL		IsInvisible () { return m_ExtraFlags.IsInvisible (); }
	void		SetInvisible () { m_ExtraFlags.SetInvisible (); }
	void		ClrInvisible () { m_ExtraFlags.ClrInvisible (); }
	BOOL		IsNoRemove () { return m_ExtraFlags.IsNoRemove (); }
	void		ClrNoRemove () { m_ExtraFlags.ClrNoRemove (); }
	BOOL		IsNoDrop () { return m_ExtraFlags.IsNoDrop (); }
	void		ClrNoDrop () { m_ExtraFlags.ClrNoDrop (); }
	BOOL		IsClanCorpse () { return m_ExtraFlags.IsClanCorpse (); }
	void		SetClanCorpse () { m_ExtraFlags.SetClanCorpse (); }
	BOOL		IsEvil () { return m_ExtraFlags.IsEvil (); }
	BOOL		IsHidden () { return m_ExtraFlags.IsHidden (); }
	void		SetHidden () { m_ExtraFlags.SetHidden (); }
	void		ClrHidden () { m_ExtraFlags.ClrHidden (); }
	BOOL		IsInventory () { return m_ExtraFlags.IsInventory (); }
	void		SetInventory () { m_ExtraFlags.SetInventory (); }
	BOOL		IsGlowing () { return m_ExtraFlags.IsGlowing (); }
	BOOL		IsBlessed () { return m_ExtraFlags.IsBlessed (); }
	BOOL		IsDonation () { return m_ExtraFlags.IsDonation (); }
	BOOL		IsHumming () { return m_ExtraFlags.IsHumming (); }
	BOOL		IsMetal () { return m_ExtraFlags.IsMetal (); }
	BOOL		IsDark () { return m_ExtraFlags.IsDark (); }
	BOOL		IsOrganic () { return m_ExtraFlags.IsOrganic (); }
	BOOL		IsLoyal () { return m_ExtraFlags.IsLoyal (); }
	BOOL		IsDeathrot () { return m_ExtraFlags.IsDeathrot (); }
	BOOL		IsCovering () { return m_ExtraFlags.IsCovering (); }

	BOOL		HasDropProg () { return m_Progtypes.IsSet (DROP_PROG); }
	BOOL		HasPullProg () { return m_Progtypes.IsSet (PULL_PROG); }
	BOOL		HasPushProg () { return m_Progtypes.IsSet (PUSH_PROG); }
	BOOL		HasScriptProg () { return m_Progtypes.IsSet (SCRIPT_PROG); }
	BOOL		HasGreetProg () { return m_Progtypes.IsSet (GREET_PROG); }
	BOOL		HasSpeechProg () { return m_Progtypes.IsSet (SPEECH_PROG); }
	BOOL		HasRandProg () { return m_Progtypes.IsSet (RAND_PROG); }
	BOOL		HasWearProg () { return m_Progtypes.IsSet (WEAR_PROG); }
	BOOL		HasUseProg () { return m_Progtypes.IsSet (USE_PROG); }
	BOOL		HasRemoveProg () { return m_Progtypes.IsSet (REMOVE_PROG); }
	BOOL		HasSacProg () { return m_Progtypes.IsSet (SAC_PROG); }
	BOOL		HasGetProg () { return m_Progtypes.IsSet (GET_PROG); }
	BOOL		HasDamageProg () { return m_Progtypes.IsSet (DAMAGE_PROG); }
	BOOL		HasRepairProg () { return m_Progtypes.IsSet (REPAIR_PROG); }
	BOOL		HasExamineProg () { return m_Progtypes.IsSet (EXA_PROG); }
	BOOL		HasZapProg () { return m_Progtypes.IsSet (ZAP_PROG); }
	BOOL		HasActProg () { return m_Progtypes.IsSet (ACT_PROG); }

	CBitVector	GetAntiClassFlags () { return m_AntiClassFlags; }
	void		SetAntiClassFlags (CBitVector f) { m_AntiClassFlags = f; }
	BOOL		IsAntiClass (int cl) { return m_AntiClassFlags.IsSet (cl); }
	void		SetAntiClass (int cl) { m_AntiClassFlags.SetBit (cl); }
	void		ToggleAntiClass (int cl) { m_AntiClassFlags.ToggleBit (cl); }

	char	*Read (FILE* fp, int AreaVersion);
	void	ReadPrograms (char* pLine, FILE *fp);
	void	Write (FILE* fp);

	int		GetCount () { return count; }

	CObjData	*GetLast () { return m_ObjList.GetLast (); }

	friend class	CObjIdxTable;

private:
	CObjIndexData	*m_pNext;
	char			*m_pName;
	char			*m_pShortDescr;
	char			*m_pDescription;
	char			*m_pActionDesc;

public:
	CObjIndexData	*next_sort;
	CBitVector		m_Progtypes;				// objprogs
	int				vnum;
	short			level;
	short			item_type;
	CExtraFlags		m_ExtraFlags;
	int				magic_flags; // Need more bitvectors for spells - Scryn
	int				wear_flags;
	CBitVector		m_AntiClassFlags;
	short			count;
	short			weight;
	int				value [6];
	int				serial;
	short			layers;
	int				cost;

	CAffectList		AffList;
	CPtrList		ObjPrgList;
	CPtrList		ExDesList;

	// Each object index has a list of all the objects made from it
	CObjectList		m_ObjList;
};





class CObjIdxTable {
public:
				CObjIdxTable () { Empty (); }
				~CObjIdxTable () { RemoveAll (); }

	int				GetCount () { return m_Count; }
	CObjIndexData	*Find (int vnum);

	int				GetHash (int vnum) { return vnum % MAX_KEY_HASH; }
	CObjIndexData	*GetFirstByHash (int hash)
					{ ASSERT (hash >= 0 && hash < MAX_KEY_HASH);
					  return m_ot [hash]; }
	CObjIndexData	*GetFirst (int vnum)
					{ return GetFirstByHash (GetHash (vnum)); }
	void			SetFirst (int hash, CObjIndexData* i)
					{ ASSERT (hash >= 0 && hash < MAX_KEY_HASH);
					  m_ot [hash] = i; }
	void			Add (CObjIndexData *pIndex, int vnum);
	CObjIndexData	*GetObj (int vnum, BOOL bBug = FALSE);

	void			Load ();
	void			Save ();
	void			Empty () { memset (this, 0, sizeof (CObjIdxTable)); }
	void			Remove (CObjIndexData* pIdx);
	void			RemoveAll ();

private:
	int				m_Count;
	CObjIndexData	*m_ot [MAX_KEY_HASH];
};


#ifdef	SMAUGSERVER_CPP
	CObjIdxTable	OIdxTable;
#endif

extern CObjIdxTable	OIdxTable;



#endif