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

#ifndef	ATCKFLAGS_H
#define	ATCKFLAGS_H

#include	"BitVector.h"


// Damage types from the attack_table []
enum DamageTypes {
   DAM_HIT, DAM_SLICE, DAM_STAB, DAM_SLASH, DAM_WHIP, DAM_CLAW,
   DAM_BLAST, DAM_POUND, DAM_CRUSH, DAM_GREP, DAM_BITE, DAM_PIERCE,
   DAM_SUCTION, DAM_BOLT, DAM_ARROW, DAM_DART, DAM_STONE, DAM_PEA,
   DAM_MAX };

// ATTACK bits
enum AttackBits {
	ATCK_BITE, ATCK_CLAWS, ATCK_TAIL, ATCK_STING, ATCK_PUNCH, ATCK_KICK,
	ATCK_TRIP, ATCK_BASH, ATCK_STUN, ATCK_GOUGE, ATCK_BACKSTAB, ATCK_FEED,
	ATCK_DRAIN,  ATCK_FIREBREATH, ATCK_FROSTBREATH, ATCK_ACIDBREATH,
	ATCK_LIGHTNBREATH, ATCK_GASBREATH, ATCK_POISON, ATCK_NASTYPOISON, ATCK_GAZE,
	ATCK_BLINDNESS, ATCK_CAUSESERIOUS, ATCK_EARTHQUAKE, ATCK_CAUSECRITICAL,
	ATCK_CURSE, ATCK_FLAMESTRIKE, ATCK_HARM, ATCK_FIREBALL, ATCK_COLORSPRAY,
	ATCK_WEAKEN, ATCK_SPIRALBLAST,
	MAX_ATTACK_TYPE };

#ifdef SMAUGSERVER_CPP
const char*	AttackNames [MAX_ATTACK_TYPE] = {
	"bite", "claws", "tail", "sting", "punch", "kick",
	"trip", "bash", "stun", "gouge", "backstab", "feed",
	"drain", "firebreath", "frostbreath", "acidbreath",
	"lightnbreath", "gasbreath", "poison", "nastypoison", "gaze",
	"blindness", "causeserious", "earthquake", "causecritical",
	"curse", "flamestrike", "harm", "fireball", "colorspray",
	"weaken", "spiralblast"
};
#endif

extern	const char* AttackNames [MAX_ATTACK_TYPE];

class CAttackFlags : public CBitVector {
public:
	const CAttackFlags&	GetAttackFlags () { return *this; }

	void	SetAttackFlags (const CAttackFlags& f) { *this = f; }
	CString	PrintString () const
			{ return CBitVector::PrintString (AttackNames, MAX_ATTACK_TYPE); }

	BOOL	CanBite () { return IsSet (ATCK_BITE); }
	void	SetBite () { SetBit (ATCK_BITE); }
	void	ClrBite () { ClrBit (ATCK_BITE); }

	BOOL	CanUseClaws () { return IsSet (ATCK_CLAWS); }
	void	SetClaws () { SetBit (ATCK_CLAWS); }
	void	ClrClaws () { ClrBit (ATCK_CLAWS); }

	BOOL	CanUseTail () { return IsSet (ATCK_TAIL); }
	void	SetTail () { SetBit (ATCK_TAIL); }
	void	ClrTail () { ClrBit (ATCK_TAIL); }

	BOOL	CanSting () { return IsSet (ATCK_STING); }
	void	SetSting () { SetBit (ATCK_STING); }
	void	ClrSting () { ClrBit (ATCK_STING); }

	BOOL	CanPunch () { return IsSet (ATCK_PUNCH); }
	void	SetPunch () { SetBit (ATCK_PUNCH); }
	void	ClrPunch () { ClrBit (ATCK_PUNCH); }

	BOOL	CanKick () { return IsSet (ATCK_KICK); }
	void	SetKick () { SetBit (ATCK_KICK); }
	void	ClrKick () { ClrBit (ATCK_KICK); }

	BOOL	CanTrip () { return IsSet (ATCK_TRIP); }
	void	SetTrip () { SetBit (ATCK_TRIP); }
	void	ClrTrip () { ClrBit (ATCK_TRIP); }

	BOOL	CanBash () { return IsSet (ATCK_BASH); }
	void	SetBash () { SetBit (ATCK_BASH); }
	void	ClrBash () { ClrBit (ATCK_BASH); }

	BOOL	CanStun () { return IsSet (ATCK_STUN); }
	void	SetStun () { SetBit (ATCK_STUN); }
	void	ClrStun () { ClrBit (ATCK_STUN); }

	BOOL	CanGouge () { return IsSet (ATCK_GOUGE); }
	void	SetGouge () { SetBit (ATCK_GOUGE); }
	void	ClrGouge () { ClrBit (ATCK_GOUGE); }

	BOOL	CanBackStab () { return IsSet (ATCK_BACKSTAB); }
	void	SetBackStab () { SetBit (ATCK_BACKSTAB); }
	void	ClrBackStab () { ClrBit (ATCK_BACKSTAB); }

	BOOL	CanFeed () { return IsSet (ATCK_FEED); }
	void	SetFeed () { SetBit (ATCK_FEED); }
	void	ClrFeed () { ClrBit (ATCK_FEED); }

	BOOL	CanDrain () { return IsSet (ATCK_DRAIN); }
	void	SetDrain () { SetBit (ATCK_DRAIN); }
	void	ClrDrain () { ClrBit (ATCK_DRAIN); }

	BOOL	CanBreatheFire () { return IsSet (ATCK_FIREBREATH); }
	void	SetBreatheFire () { SetBit (ATCK_FIREBREATH); }
	void	ClrBreatheFire () { ClrBit (ATCK_FIREBREATH); }

	BOOL	CanBreatheFrost () { return IsSet (ATCK_FROSTBREATH); }
	void	SetBreatheFrost () { SetBit (ATCK_FROSTBREATH); }
	void	ClrBreatheFrost () { ClrBit (ATCK_FROSTBREATH); }

	BOOL	CanBreatheAcid () { return IsSet (ATCK_ACIDBREATH); }
	void	SetBreatheAcid () { SetBit (ATCK_ACIDBREATH); }
	void	ClrBreatheAcid () { ClrBit (ATCK_ACIDBREATH); }

	BOOL	CanBreatheLightning () { return IsSet (ATCK_LIGHTNBREATH); }
	void	SetBreatheLightning () { SetBit (ATCK_LIGHTNBREATH); }
	void	ClrBreatheLightning () { ClrBit (ATCK_LIGHTNBREATH); }

	BOOL	CanBreatheGas () { return IsSet (ATCK_GASBREATH); }
	void	SetBreatheGas () { SetBit (ATCK_GASBREATH); }
	void	ClrBreatheGas () { ClrBit (ATCK_GASBREATH); }

	BOOL	CanPoison () { return IsSet (ATCK_POISON); }
	void	SetPoison () { SetBit (ATCK_POISON); }
	void	ClrPoison () { ClrBit (ATCK_POISON); }

	BOOL	CanNastyPoison () { return IsSet (ATCK_NASTYPOISON); }
	void	SetNastyPoison () { SetBit (ATCK_NASTYPOISON); }
	void	ClrNastyPoison () { ClrBit (ATCK_NASTYPOISON); }

	BOOL	CanGaze () { return IsSet (ATCK_GAZE); }
	void	SetGaze () { SetBit (ATCK_GAZE); }
	void	ClrGaze () { ClrBit (ATCK_GAZE); }

	BOOL	CanBlind () { return IsSet (ATCK_BLINDNESS); }
	void	SetBlind () { SetBit (ATCK_BLINDNESS); }
	void	ClrBlind () { ClrBit (ATCK_BLINDNESS); }

	BOOL	CanCauseSerious () { return IsSet (ATCK_CAUSESERIOUS); }
	void	SetCauseSerious () { SetBit (ATCK_CAUSESERIOUS); }
	void	ClrCauseSerious () { ClrBit (ATCK_CAUSESERIOUS); }

	BOOL	CanQuake () { return IsSet (ATCK_EARTHQUAKE); }
	void	SetQuake () { SetBit (ATCK_EARTHQUAKE); }
	void	ClrQuake () { ClrBit (ATCK_EARTHQUAKE); }

	BOOL	CanCauseCritical () { return IsSet (ATCK_CAUSECRITICAL); }
	void	SetCauseCritical () { SetBit (ATCK_CAUSECRITICAL); }
	void	ClrCauseCritical () { ClrBit (ATCK_CAUSECRITICAL); }

	BOOL	CanCurse () { return IsSet (ATCK_CURSE); }
	void	SetCurse () { SetBit (ATCK_CURSE); }
	void	ClrCurse () { ClrBit (ATCK_CURSE); }

	BOOL	CanFlameStrike () { return IsSet (ATCK_FLAMESTRIKE); }
	void	SetFlameStrike () { SetBit (ATCK_FLAMESTRIKE); }
	void	ClrFlameStrike () { ClrBit (ATCK_FLAMESTRIKE); }

	BOOL	CanHarm () { return IsSet (ATCK_HARM); }
	void	SetHarm () { SetBit (ATCK_HARM); }
	void	ClrHarm () { ClrBit (ATCK_HARM); }

	BOOL	CanFireball () { return IsSet (ATCK_FIREBALL); }
	void	SetFireball () { SetBit (ATCK_FIREBALL); }
	void	ClrFireball () { ClrBit (ATCK_FIREBALL); }

	BOOL	CanColorSpray () { return IsSet (ATCK_COLORSPRAY); }
	void	SetColorSpray () { SetBit (ATCK_COLORSPRAY); }
	void	ClrColorSpray () { ClrBit (ATCK_COLORSPRAY); }

	BOOL	CanWeaken () { return IsSet (ATCK_WEAKEN); }
	void	SetWeaken () { SetBit (ATCK_WEAKEN); }
	void	ClrWeaken () { ClrBit (ATCK_WEAKEN); }

	BOOL	CanSpiralBlast () { return IsSet (ATCK_SPIRALBLAST); }
	void	SetSpiralBlast () { SetBit (ATCK_SPIRALBLAST); }
	void	ClrSpiralBlast () { ClrBit (ATCK_SPIRALBLAST); }
};

#endif