/****************************************************************************
 * [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.    *
 * ------------------------------------------------------------------------ *
 *			    Extra Flags Interface file									*
 ***************************************************************************/

#ifndef	EXTRAFLAGS_H
#define	EXTRAFLAGS_H

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


// Extra flags.
// Used in #OBJECTS.  Note that the following values are now unused:
//#define ITEM_ANTI_MAGE	BV14
//#define ITEM_ANTI_THIEF	BV15
//#define ITEM_ANTI_WARRIOR	BV16
//#define ITEM_ANTI_CLERIC	BV17
//#define ITEM_ANTI_VAMPIRE	BV23
//#define ITEM_ANTI_DRUID	BV24

enum ItemExtraFlags {
	ITEM_GLOW, ITEM_HUM, ITEM_DARK, ITEM_LOYAL, ITEM_EVIL, ITEM_INVIS,
	ITEM_MAGIC, ITEM_NODROP, ITEM_BLESS, ITEM_ANTI_GOOD, ITEM_ANTI_EVIL,
	ITEM_ANTI_NEUTRAL, ITEM_NOREMOVE, ITEM_INVENTORY,
	ITEM_ANTI_MAGE, ITEM_ANTI_THIEF, ITEM_ANTI_WARRIOR, ITEM_ANTI_CLERIC,
	ITEM_ORGANIC, ITEM_METAL, ITEM_DONATION, ITEM_CLANOBJECT,
	ITEM_CLANCORPSE,
	ITEM_ANTI_VAMPIRE, ITEM_ANTI_DRUID, 
	ITEM_HIDDEN, ITEM_POISONED, ITEM_COVERING, ITEM_DEATHROT, ITEM_BURIED, 
	ITEM_PROTOTYPE, ITEM_NOLOCATE, ITEM_GROUNDROT, MAX_ITEM_FLAGS
};


#ifdef SMAUGSERVER_CPP
const char*	ItemFlagNames [MAX_ITEM_FLAGS] =
{
"glow", "hum", "dark", "loyal", "evil", "invis", "magic", "nodrop", "bless",
"antigood", "antievil", "antineutral", "noremove", "inventory",
"antimage", "antithief", "antiwarrior", "anticleric", "organic", "metal",
"donation", "clanobject", "clancorpse", "antivampire", "antidruid", 
"hidden", "poisoned", "covering", "deathrot", "buried", "prototype", 
"nolocate", "groundrot" };
#endif

extern	const char* ItemFlagNames [MAX_ITEM_FLAGS];


class CExtraFlags : public CBitVector {
public:
	CExtraFlags	GetActFlags () { return *this; }
	void		SetActFlags (const CExtraFlags& f) { *this = f; }
	CString		PrintString ()
				{ return CBitVector::PrintString (ItemFlagNames,
				    DIM (ItemFlagNames)); }

	BOOL	IsGlowing () const { return IsSet (ITEM_GLOW); }
	void	SetGlowing () { SetBit (ITEM_GLOW); }
	void	ClrGlowing () { ClrBit (ITEM_GLOW); }

	BOOL	IsHumming () const { return IsSet (ITEM_HUM); }
	void	SetHumming () { SetBit (ITEM_HUM); }
	void	ClrHumming () { ClrBit (ITEM_HUM); }

	BOOL	IsDark () const { return IsSet (ITEM_DARK); }
	void	SetDark () { SetBit (ITEM_DARK); }
	void	ClrDark () { ClrBit (ITEM_DARK); }

	BOOL	IsLoyal () const { return IsSet (ITEM_LOYAL); }
	void	SetLoyal () { SetBit (ITEM_LOYAL); }
	void	ClrLoyal () { ClrBit (ITEM_LOYAL); }

	BOOL	IsEvil () const { return IsSet (ITEM_EVIL); }
	void	SetEvil () { SetBit (ITEM_EVIL); }
	void	ClrEvil () { ClrBit (ITEM_EVIL); }

	BOOL	IsInvisible () const { return IsSet (ITEM_INVIS); }
	void	SetInvisible () { SetBit (ITEM_INVIS); }
	void	ClrInvisible () { ClrBit (ITEM_INVIS); }

	BOOL	IsMagic () const { return IsSet (ITEM_MAGIC); }
	void	SetMagic () { SetBit (ITEM_MAGIC); }
	void	ClrMagic () { ClrBit (ITEM_MAGIC); }

	BOOL	IsNoDrop () const { return IsSet (ITEM_NODROP); }
	void	SetNoDrop () { SetBit (ITEM_NODROP); }
	void	ClrNoDrop () { ClrBit (ITEM_NODROP); }

	BOOL	IsBlessed () const { return IsSet (ITEM_BLESS); }
	void	SetBlessed () { SetBit (ITEM_BLESS); }
	void	ClrBlessed () { ClrBit (ITEM_BLESS); }

	BOOL	IsAntiGood () const { return IsSet (ITEM_ANTI_GOOD); }
	void	SetAntiGood () { SetBit (ITEM_ANTI_GOOD); }
	void	ClrAntiGood () { ClrBit (ITEM_ANTI_GOOD); }

	BOOL	IsAntiEvil () const { return IsSet (ITEM_ANTI_EVIL); }
	void	SetAntiEvil () { SetBit (ITEM_ANTI_EVIL); }
	void	ClrAntiEvil () { ClrBit (ITEM_ANTI_EVIL); }

	BOOL	IsAntiNeutral () const { return IsSet (ITEM_ANTI_NEUTRAL); }
	void	SetAntiNeutral () { SetBit (ITEM_ANTI_NEUTRAL); }
	void	ClrAntiNeutral () { ClrBit (ITEM_ANTI_NEUTRAL); }

	BOOL	IsNoRemove () const { return IsSet (ITEM_NOREMOVE); }
	void	SetNoRemove () { SetBit (ITEM_NOREMOVE); }
	void	ClrNoRemove () { ClrBit (ITEM_NOREMOVE); }

	BOOL	IsInventory () const { return IsSet (ITEM_INVENTORY); }
	void	SetInventory () { SetBit (ITEM_INVENTORY); }
	void	ClrInventory () { ClrBit (ITEM_INVENTORY); }

	BOOL	IsAntiMage () const { return IsSet (ITEM_ANTI_MAGE); }
	void	SetAntiMage () { SetBit (ITEM_ANTI_MAGE); }
	void	ClrAntiMage () { ClrBit (ITEM_ANTI_MAGE); }

	BOOL	IsAntiThief () const { return IsSet (ITEM_ANTI_THIEF); }
	void	SetAntiThief () { SetBit (ITEM_ANTI_THIEF); }
	void	ClrAntiThief () { ClrBit (ITEM_ANTI_THIEF); }

	BOOL	IsAntiWarrior () const { return IsSet (ITEM_ANTI_WARRIOR); }
	void	SetAntiWarrior () { SetBit (ITEM_ANTI_WARRIOR); }
	void	ClrAntiWarrior () { ClrBit (ITEM_ANTI_WARRIOR); }

	BOOL	IsAntiCleric () const { return IsSet (ITEM_ANTI_CLERIC); }
	void	SetAntiCleric () { SetBit (ITEM_ANTI_CLERIC); }
	void	ClrAntiCleric () { ClrBit (ITEM_ANTI_CLERIC); }

	BOOL	IsOrganic () const { return IsSet (ITEM_ORGANIC); }
	void	SetOrganic () { SetBit (ITEM_ORGANIC); }
	void	ClrOrganic () { ClrBit (ITEM_ORGANIC); }

	BOOL	IsMetal () const { return IsSet (ITEM_METAL); }
	void	SetMetal () { SetBit (ITEM_METAL); }
	void	ClrMetal () { ClrBit (ITEM_METAL); }

	BOOL	IsDonation () const { return IsSet (ITEM_DONATION); }
	void	SetDonation () { SetBit (ITEM_DONATION); }
	void	ClrDonation () { ClrBit (ITEM_DONATION); }

	BOOL	IsClanObject () const { return IsSet (ITEM_CLANOBJECT); }
	void	SetClanObject () { SetBit (ITEM_CLANOBJECT); }
	void	ClrClanObject () { ClrBit (ITEM_CLANOBJECT); }

	BOOL	IsClanCorpse () const { return IsSet (ITEM_CLANCORPSE); }
	void	SetClanCorpse () { SetBit (ITEM_CLANCORPSE); }
	void	ClrClanCorpse () { ClrBit (ITEM_CLANCORPSE); }

	BOOL	IsAntiVampire () const { return IsSet (ITEM_ANTI_VAMPIRE); }
	void	SetAntiVampire () { SetBit (ITEM_ANTI_VAMPIRE); }
	void	ClrAntiVampire () { ClrBit (ITEM_ANTI_VAMPIRE); }

	BOOL	IsAntiDruid () const { return IsSet (ITEM_ANTI_DRUID); }
	void	SetAntiDruid () { SetBit (ITEM_ANTI_DRUID); }
	void	ClrAntiDruid () { ClrBit (ITEM_ANTI_DRUID); }

	BOOL	IsHidden () const { return IsSet (ITEM_HIDDEN); }
	void	SetHidden () { SetBit (ITEM_HIDDEN); }
	void	ClrHidden () { ClrBit (ITEM_HIDDEN); }

	BOOL	IsPoisoned () const { return IsSet (ITEM_POISONED); }
	void	SetPoisoned () { SetBit (ITEM_POISONED); }
	void	ClrPoisoned () { ClrBit (ITEM_POISONED); }

	BOOL	IsCovering () const { return IsSet (ITEM_COVERING); }
	void	SetCovering () { SetBit (ITEM_COVERING); }
	void	ClrCovering () { ClrBit (ITEM_COVERING); }

	BOOL	IsDeathrot () const { return IsSet (ITEM_DEATHROT); }
	void	SetDeathrot () { SetBit (ITEM_DEATHROT); }
	void	ClrDeathrot () { ClrBit (ITEM_DEATHROT); }

	BOOL	IsBuried () const { return IsSet (ITEM_BURIED); }
	void	SetBuried () { SetBit (ITEM_BURIED); }
	void	ClrBuried () { ClrBit (ITEM_BURIED); }

	BOOL	IsPrototype () const { return IsSet (ITEM_PROTOTYPE); }
	void	SetPrototype () { SetBit (ITEM_PROTOTYPE); }
	void	ClrPrototype () { ClrBit (ITEM_PROTOTYPE); }

	BOOL	IsNoLocate () const { return IsSet (ITEM_NOLOCATE); }
	void	SetNoLocate () { SetBit (ITEM_NOLOCATE); }
	void	ClrNoLocate () { ClrBit (ITEM_NOLOCATE); }

	BOOL	IsGroundRot () const { return IsSet (ITEM_GROUNDROT); }
	void	SetGroundRot () { SetBit (ITEM_GROUNDROT); }
	void	ClrGroundRot () { ClrBit (ITEM_GROUNDROT); }
};

#endif