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

#ifndef	ACTFLAGS_H
#define	ACTFLAGS_H

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


// ACT bits for players.
enum PlayerActs {
	PLR_IS_NPC,PLR_BOUGHT_PET, PLR_SHOVEDRAG, PLR_AUTOEXIT, PLR_AUTOLOOT, 
	PLR_AUTOSAC, PLR_BLANK, PLR_OUTCAST, PLR_BRIEF, PLR_COMBINE, PLR_PROMPT, 
	PLR_TELNET_GA, PLR_HOLYLIGHT, PLR_WIZINVIS, PLR_ROOMVNUM, PLR_SILENCE, 
	PLR_NO_EMOTE, PLR_ATTACKER, PLR_NO_TELL, PLR_LOG, PLR_DENY, PLR_FREEZE, 
	PLR_THIEF, PLR_KILLER, PLR_LITTERBUG, PLR_ANSI, PLR_RIP, PLR_NICE,
	PLR_FLEE, PLR_AUTOGOLD, PLR_AUTOMAP, PLR_AFK, PLR_INVISPROMPT,
	PLR_MAX };

#ifdef SMAUGSERVER_CPP
const char*	PlrActNames [PLR_MAX] = {
	"npc", "boughtpet", "shovedrag", "autoexits", "autoloot", "autosac",
	"blank", "outcast", "brief", "combine", "prompt", "telnet_ga",
	"holylight", "wizinvis", "roomvnum","silence", "noemote", "attacker",
	"notell", "log", "deny", "freeze", "thief","killer", "litterbug",
	"ansi", "rip", "nice", "flee" ,"autogold", "automap", "afk",
	"invisprompt"
};
#endif

extern	const char* PlrActNames [PLR_MAX];

// ACT bits for mobs.
enum MobActs {
	ACT_IS_NPC,			// Auto set for mobs
	ACT_SENTINEL,		// Stays in one room
	ACT_SCAVENGER,		// Picks up objects
	ACT_R3,
	ACT_R4,
	ACT_AGGRESSIVE,		// Attacks PC's
	ACT_STAY_AREA,		// Won't leave area
	ACT_WIMPY,			// Flees when hurt
	ACT_PET,			// Auto set for pets
	ACT_TRAIN,			// Can train PC's
	ACT_PRACTICE,		// Can practice PC's
	ACT_IMMORTAL,		// Cannot be killed
	ACT_DEADLY,			// Has a deadly poison
	ACT_POLYSELF,
	ACT_META_AGGR,		// Extremely aggressive
	ACT_GUARDIAN,		// Protects master
	ACT_RUNNING,		// Hunts quickly
	ACT_NOWANDER,		// Doesn't wander
	ACT_MOUNTABLE,		// Can be mounted
	ACT_MOUNTED,		// Is mounted
	ACT_SCHOLAR,		// Can teach languages
	ACT_SECRETIVE,		// actions aren't seen
	ACT_POLYMORPHED,	// Mob is a ch
	ACT_MOBINVIS,		// Like wizinvis
	ACT_NOASSIST,		// Doesn't assist mobs
	ACT_AUTONOMOUS,		// Doesn't auto switch tanks
	ACT_PACIFIST,		// Doesn't ever fight
	ACT_NOATTACK,		// No physical attacks
	ACT_ANNOYING,		// Other mobs will attack
	ACT_R29,
	ACT_PROTOTYPE,		// A prototype mob
	ACT_MAX };

#ifdef SMAUGSERVER_CPP
const char*	MobActNames [ACT_MAX] = {
	"npc", "sentinel", "scavenger", "r3", "r4", "aggressive", "stayarea",
	"wimpy", "pet", "train", "practice", "immortal", "deadly", "polyself",
	"meta_aggr", "guardian", "running", "nowander", "mountable", "mounted",
	"scholar", "secretive", "polymorphed", "mobinvis", "noassist",
	"autonomous", "pacifist", "noattack", "annoying", "r29", "prototype"
};
#endif

extern	const char* MobActNames [ACT_MAX];


class CActFlags : public CBitVector {
public:
	CActFlags	GetActFlags () { return *this; }
	void		SetActFlags (const CActFlags& f) { *this = f; }
	CString		PrintString (BOOL bNpc)
				{ return CBitVector::PrintString (
				    bNpc ? MobActNames : PlrActNames,
				    bNpc ? DIM (MobActNames) : DIM (PlrActNames)); }

	BOOL	IsNpc () { return IsSet (ACT_IS_NPC); }
	void	SetNpc () { SetBit (ACT_IS_NPC); }
	void	ClrNpc () { ClrBit (ACT_IS_NPC); }

	BOOL	IsAggressive () { return IsSet (ACT_AGGRESSIVE); }
	void	SetAggressive () { SetBit (ACT_AGGRESSIVE); }
	void	ClrAggressive () { ClrBit (ACT_AGGRESSIVE); }

	BOOL	IsWimpy () { return IsSet (ACT_WIMPY); }
	void	SetWimpy () { SetBit (ACT_WIMPY); }
	void	ClrWimpy () { ClrBit (ACT_WIMPY); }

	BOOL	IsSilent () { return IsSet (PLR_SILENCE); }
	void	SetSilent () { SetBit (PLR_SILENCE); }
	void	ClrSilent () { ClrBit (PLR_SILENCE); }

	BOOL	IsDenied () { return IsSet (PLR_DENY); }
	void	SetDeny () { SetBit (PLR_DENY); }
	void	ClrDeny () { ClrBit (PLR_DENY); }

	BOOL	IsNice () { return IsSet (PLR_NICE); }
	void	SetNice () { SetBit (PLR_NICE); }
	void	ClrNice () { ClrBit (PLR_NICE); }

	BOOL	IsAttacker () { return IsSet (PLR_ATTACKER); }
	void	SetAttacker () { SetBit (PLR_ATTACKER); }
	void	ClrAttacker () { ClrBit (PLR_ATTACKER); }

	BOOL	IsKiller () { return IsSet (PLR_KILLER); }
	void	SetKiller () { SetBit (PLR_KILLER); }
	void	ClrKiller () { ClrBit (PLR_KILLER); }

	BOOL	IsThief () { return IsSet (PLR_THIEF); }
	void	SetThief () { SetBit (PLR_THIEF); }
	void	ClrThief () { ClrBit (PLR_THIEF); }

	BOOL	IsLitterBug () { return IsSet (PLR_LITTERBUG); }
	void	SetLitterBug () { SetBit (PLR_LITTERBUG); }
	void	ClrLitterBug () { ClrBit (PLR_LITTERBUG); }

	BOOL	IsFrozen () { return IsSet (PLR_FREEZE); }
	void	SetFrozen () { SetBit (PLR_FREEZE); }
	void	ClrFrozen () { ClrBit (PLR_FREEZE); }

	BOOL	IsLogged () { return IsSet (PLR_LOG); }
	void	SetLogged () { SetBit (PLR_LOG); }
	void	ClrLogged () { ClrBit (PLR_LOG); }

	BOOL	IsNoEmote () { return IsSet (PLR_NO_EMOTE); }
	void	SetNoEmote () { SetBit (PLR_NO_EMOTE); }
	void	ClrNoEmote () { ClrBit (PLR_NO_EMOTE); }

	BOOL	IsNoTell () { return IsSet (PLR_NO_TELL); }
	void	SetNoTell () { SetBit (PLR_NO_TELL); }
	void	ClrNoTell () { ClrBit (PLR_NO_TELL); }

	BOOL	IsWizInvis () { return IsSet (PLR_WIZINVIS); }
	void	SetWizInvis () { SetBit (PLR_WIZINVIS); }
	void	ClrWizInvis () { ClrBit (PLR_WIZINVIS); }

	BOOL	IsMobInvis () { return IsSet (ACT_MOBINVIS); }
	void	SetMobInvis () { SetBit (ACT_MOBINVIS); }
	void	ClrMobInvis () { ClrBit (ACT_MOBINVIS); }

	BOOL	IsSecretive () { return IsSet (ACT_SECRETIVE); }
	void	SetSecretive () { SetBit (ACT_SECRETIVE); }
	void	ClrSecretive () { ClrBit (ACT_SECRETIVE); }

	BOOL	IsHolyLight () { return IsSet (PLR_HOLYLIGHT); }
	void	SetHolyLight () { SetBit (PLR_HOLYLIGHT); }
	void	ClrHolyLight () { ClrBit (PLR_HOLYLIGHT); }

	BOOL	IsCombined () { return IsSet (PLR_COMBINE); }
	void	SetCombine () { SetBit (PLR_COMBINE); }
	void	ClrCombine () { ClrBit (PLR_COMBINE); }

	BOOL	IsBrief () { return IsSet (PLR_BRIEF); }
	void	SetBrief () { SetBit (PLR_BRIEF); }
	void	ClrBrief () { ClrBit (PLR_BRIEF); }

	BOOL	IsBlank () { return IsSet (PLR_BLANK); }
	void	SetBlank () { SetBit (PLR_BLANK); }
	void	ClrBlank () { ClrBit (PLR_BLANK); }

	BOOL	HasPrompt () { return IsSet (PLR_PROMPT); }
	void	SetHasPrompt () { SetBit (PLR_PROMPT); }
	void	ClrHasPrompt () { ClrBit (PLR_PROMPT); }

	BOOL	IsTelenet () { return IsSet (PLR_TELNET_GA); }
	void	SetTelenet () { SetBit (PLR_TELNET_GA); }
	void	ClrTelenet () { ClrBit (PLR_TELNET_GA); }

	BOOL	IsRip () { return IsSet (PLR_RIP); }
	void	SetRip () { SetBit (PLR_RIP); }
	void	ClrRip () { ClrBit (PLR_RIP); }

	BOOL	IsPacifist () { return IsSet (ACT_PACIFIST); }
	void	SetPacifist () { SetBit (ACT_PACIFIST); }
	void	ClrPacifist () { ClrBit (ACT_PACIFIST); }

	BOOL	IsAutoExit () { return IsSet (PLR_AUTOEXIT); }
	void	SetAutoExit () { SetBit (PLR_AUTOEXIT); }
	void	ClrAutoExit () { ClrBit (PLR_AUTOEXIT); }

	BOOL	IsAutoLoot () { return IsSet (PLR_AUTOLOOT); }
	void	SetAutoLoot () { SetBit (PLR_AUTOLOOT); }
	void	ClrAutoLoot () { ClrBit (PLR_AUTOLOOT); }

	BOOL	IsAutoSac () { return IsSet (PLR_AUTOSAC); }
	void	SetAutoSac () { SetBit (PLR_AUTOSAC); }
	void	ClrAutoSac () { ClrBit (PLR_AUTOSAC); }

	BOOL	CanPractice () { return IsSet (ACT_PRACTICE); }
	void	SetPractice () { SetBit (ACT_PRACTICE); }
	void	ClrPractice () { ClrBit (ACT_PRACTICE); }

	BOOL	BoughtPet () { return IsSet (PLR_BOUGHT_PET); }
	void	SetBoughtPet () { SetBit (PLR_BOUGHT_PET); }
	void	ClrBoughtPet () { ClrBit (PLR_BOUGHT_PET); }

	BOOL	IsPet () { return IsSet (ACT_PET); }
	void	SetPet () { SetBit (ACT_PET); }
	void	ClrPet () { ClrBit (ACT_PET); }

	BOOL	IsAnsi () { return IsSet (PLR_ANSI); }
	void	SetAnsi () { SetBit (PLR_ANSI); }
	void	ClrAnsi () { ClrBit (PLR_ANSI); }

	BOOL	IsVnums () { return IsSet (PLR_ROOMVNUM); }
	void	SetVnums () { SetBit (PLR_ROOMVNUM); }
	void	ClrVnums () { ClrBit (PLR_ROOMVNUM); }

	BOOL	IsPolymorphed () { return IsSet (ACT_POLYMORPHED); }
	void	SetPolymorphed () { SetBit (ACT_POLYMORPHED); }
	void	ClrPolymorphed () { ClrBit (ACT_POLYMORPHED); }

	BOOL	IsNoAssist () { return IsSet (ACT_NOASSIST); }
	void	SetNoAssist () { SetBit (ACT_NOASSIST); }
	void	ClrNoAssist () { ClrBit (ACT_NOASSIST); }

	BOOL	IsAfk () { return IsSet (PLR_AFK); }
	void	SetAfk () { SetBit (PLR_AFK); }
	void	ClrAfk () { ClrBit (PLR_AFK); }

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

	BOOL	IsAutonomous () { return IsSet (ACT_AUTONOMOUS); }
	void	SetAutonomous () { SetBit (ACT_AUTONOMOUS); }
	void	ClrAutonomous () { ClrBit (ACT_AUTONOMOUS); }

};

#endif