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

#ifndef	DFNDFLAGS_H
#define	DFNDFLAGS_H

#include	"BitVector.h"


// ATTACK bits
enum DefenseBits {
	DFND_PARRY, DFND_DODGE, DFND_HEAL, DFND_CURELIGHT, DFND_CURESERIOUS, 
	DFND_CURECRITICAL, DFND_DISPELMAGIC, DFND_DISPELEVIL, DFND_SANCTUARY, 
	DFND_FIRESHIELD, DFND_SHOCKSHIELD, DFND_SHIELD, DFND_BLESS,
	DFND_STONESKIN, DFND_TELEPORT, DFND_MONSUM1, DFND_MONSUM2, DFND_MONSUM3,
	DFND_MONSUM4, DFND_DISARM, DFND_ICESHIELD, DFND_GRIP, DFND_TRUESIGHT,
	MAX_DEFENSE_TYPE };
// Defense types

#ifdef SMAUGSERVER_CPP
const char*	DefenseNames [MAX_DEFENSE_TYPE] = {
	"parry", "dodge", "heal", "curelight", "cureserious",
	"curecritical", "dispelmagic", "dispelevil", "sanctuary",
	"fireshield", "shockshield", "shield", "bless",
	"stoneskin", "teleport", "monsum1", "monsum2", "monsum3",
	"monsum4", "disarm", "iceshield", "grip", "truesight"
};
#endif

extern	const char* DefenseNames [MAX_DEFENSE_TYPE];

class CDefenseFlags : public CBitVector {
public:
	const CDefenseFlags&	GetDefenseFlags () { return *this; }

	void	SetDefenseFlags (const CDefenseFlags& f) { *this = f; }
	CString	PrintString () const
			{ return CBitVector::PrintString (DefenseNames, MAX_DEFENSE_TYPE); }

	BOOL	CanParry () { return IsSet (DFND_PARRY); }
	void	SetParry () { SetBit (DFND_PARRY); }
	void	ClrParry () { ClrBit (DFND_PARRY); }

	BOOL	CanDodge () { return IsSet (DFND_DODGE); }
	void	SetDodge () { SetBit (DFND_DODGE); }
	void	ClrDodge () { ClrBit (DFND_DODGE); }

	BOOL	CanHeal () { return IsSet (DFND_HEAL); }
	void	SetHeal () { SetBit (DFND_HEAL); }
	void	ClrHeal () { ClrBit (DFND_HEAL); }

	BOOL	CanCureLight () { return IsSet (DFND_CURELIGHT); }
	void	SetCureLight () { SetBit (DFND_CURELIGHT); }
	void	ClrCureLight () { ClrBit (DFND_CURELIGHT); }

	BOOL	CanCureSerious () { return IsSet (DFND_CURESERIOUS); }
	void	SetCureSerious () { SetBit (DFND_CURESERIOUS); }
	void	ClrCureSerious () { ClrBit (DFND_CURESERIOUS); }

	BOOL	CanCureCritical () { return IsSet (DFND_CURECRITICAL); }
	void	SetCureCritical () { SetBit (DFND_CURECRITICAL); }
	void	ClrCureCritical () { ClrBit (DFND_CURECRITICAL); }

	BOOL	CanDispelMagic () { return IsSet (DFND_DISPELMAGIC); }
	void	SetDispelMagic () { SetBit (DFND_DISPELMAGIC); }
	void	ClrDispelMagic () { ClrBit (DFND_DISPELMAGIC); }

	BOOL	CanDispelEvil () { return IsSet (DFND_DISPELEVIL); }
	void	SetDispelEvil () { SetBit (DFND_DISPELEVIL); }
	void	ClrDispelEvil () { ClrBit (DFND_DISPELEVIL); }

	BOOL	CanUseSanctuary () { return IsSet (DFND_SANCTUARY); }
	void	SetSanctuary () { SetBit (DFND_SANCTUARY); }
	void	ClrSanctuary () { ClrBit (DFND_SANCTUARY); }

	BOOL	CanFireShield () { return IsSet (DFND_FIRESHIELD); }
	void	SetFireShield () { SetBit (DFND_FIRESHIELD); }
	void	ClrFireShield () { ClrBit (DFND_FIRESHIELD); }

	BOOL	CanShockShield () { return IsSet (DFND_SHOCKSHIELD); }
	void	SetShockShield () { SetBit (DFND_SHOCKSHIELD); }
	void	ClrShockShield () { ClrBit (DFND_SHOCKSHIELD); }

	BOOL	CanShield () { return IsSet (DFND_SHIELD); }
	void	SetShield () { SetBit (DFND_SHIELD); }
	void	ClrShield () { ClrBit (DFND_SHIELD); }

	BOOL	CanBless () { return IsSet (DFND_BLESS); }
	void	SetBless () { SetBit (DFND_BLESS); }
	void	ClrBless () { ClrBit (DFND_BLESS); }

	BOOL	CanStoneSkin () { return IsSet (DFND_STONESKIN); }
	void	SetStoneSkin () { SetBit (DFND_STONESKIN); }
	void	ClrStoneSkin () { ClrBit (DFND_STONESKIN); }

	BOOL	CanTeleport () { return IsSet (DFND_TELEPORT); }
	void	SetTeleport () { SetBit (DFND_TELEPORT); }
	void	ClrTeleport () { ClrBit (DFND_TELEPORT); }

	BOOL	CanMonsum1 () { return IsSet (DFND_MONSUM1); }
	void	SetMonsum1 () { SetBit (DFND_MONSUM1); }
	void	ClrMonsum1 () { ClrBit (DFND_MONSUM1); }

	BOOL	CanMonsum2 () { return IsSet (DFND_MONSUM2); }
	void	SetMonsum2 () { SetBit (DFND_MONSUM2); }
	void	ClrMonsum2 () { ClrBit (DFND_MONSUM2); }

	BOOL	CanMonsum3 () { return IsSet (DFND_MONSUM3); }
	void	SetMonsum3 () { SetBit (DFND_MONSUM3); }
	void	ClrMonsum3 () { ClrBit (DFND_MONSUM3); }

	BOOL	CanMonsum4 () { return IsSet (DFND_MONSUM4); }
	void	SetMonsum4 () { SetBit (DFND_MONSUM4); }
	void	ClrMonsum4 () { ClrBit (DFND_MONSUM4); }

	BOOL	CanDisarm () { return IsSet (DFND_DISARM); }
	void	SetDisarm () { SetBit (DFND_DISARM); }
	void	ClrDisarm () { ClrBit (DFND_DISARM); }

	BOOL	CanIceShield () { return IsSet (DFND_ICESHIELD); }
	void	SetIceShield () { SetBit (DFND_ICESHIELD); }
	void	ClrIceShield () { ClrBit (DFND_ICESHIELD); }

	BOOL	CanGrip () { return IsSet (DFND_GRIP); }
	void	SetGrip () { SetBit (DFND_GRIP); }
	void	ClrGrip () { ClrBit (DFND_GRIP); }

	BOOL	CanTrueSight () { return IsSet (DFND_TRUESIGHT); }
	void	SetTrueSight () { SetBit (DFND_TRUESIGHT); }
	void	ClrTrueSight () { ClrBit (DFND_TRUESIGHT); }
};

#endif