/****************************************************************************
 * [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.    *
 * ------------------------------------------------------------------------ *
 *			    CCharacter class Interface file								*
 ****************************************************************************/

#ifndef	CHARACTER_H
#define	CHARACTER_H

#define		CurrentPlayerFileVersion		1000

#include	"ActFlags.h"
#include	"Affect.h"
#include	"Attack.h"
#include	"Defense.h"
#include	"clans.h"
#include	"races.h"
#include	"swtime.h"


enum FightingStyles { STYLE_BERSERK, STYLE_AGGRESSIVE, STYLE_FIGHTING,
					  STYLE_DEFENSIVE, STYLE_EVASIVE };

enum ConnectErrorTypes { CE_BADCLASS, CE_BADRACE, CE_MAX, CE_NONE };

// Character macros.
//#define IS_HERO(ch)			(ch->GetTrustLevel () >= LEVEL_HERO)

#define GET_HITROLL(ch)		(ch->GetHitroll() \
							+ str_app [ch->GetCurrentStrength()].tohit	\
							+ (2-(abs(ch->GetMentalState ())/10)))
#define GET_DAMROLL(ch)		(ch->GetDamroll () \
							+ str_app [ch->GetCurrentStrength()].todam	\
							+ ((ch->GetMentalState () > 5				\
							&& ch->GetMentalState () < 15) ? 1 : 0))

#define WAIT_STATE(ch,npulse)	(ch->SetWait(UMAX ((int)(ch)->GetWait(),(npulse))))

//#define MANA_COST(ch, sn)		(IS_NPC (ch) ? 0 : UMAX (				    \
//								skill_table [sn].min_mana,                  \
//								100 / (2 + ch->GetLevel() -                 \
//								skill_table[sn].skill_level[ch->GetClass()])))


// Description macros.
#define PERS(ch, looker)		(can_see (looker, (ch)) ?				 \
									(ch->IsNpc() ? (ch)->GetShortDescr() \
									: (ch)->GetName()) : "someone")



// Data which only PC's have.
class pc_data {
public:
	friend		class CCharacter;

				pc_data ()
				{ ClearAddrRange (&m_flags, &openedtourney,
					sizeof (openedtourney)); }
				~pc_data ();

	void		SetFlag (int bit) { m_flags |= bit; }
	void		ClrFlag (int bit) { m_flags &= ~bit; }
	void		ToggleFlag (int bit) { m_flags ^= bit; }
	BOOL		IsGagged () { return (m_flags & PCFLAG_GAG) != 0; }	
	BOOL		IsPagerOn () { return (m_flags & PCFLAG_PAGERON) != 0; }
	BOOL		IsNoTitle () { return (m_flags & PCFLAG_NOTITLE) != 0; }
	void		SetNoTitle () { m_flags |= PCFLAG_NOTITLE; }
	void		ClrNoTitle () { m_flags &= ~PCFLAG_NOTITLE; }
	BOOL		IsRetired () { return (m_flags & PCFLAG_RETIRED) != 0; }
	void		SetRetired () { m_flags |= PCFLAG_RETIRED; }
	void		ClrRetired () { m_flags &= ~PCFLAG_RETIRED; }
	BOOL		IsNoSummon () { return (m_flags & PCFLAG_NOSUMMON) != 0; }
	void		SetNoSummon () { m_flags |= PCFLAG_NOSUMMON; }
	void		ClrNoSummon () { m_flags &= ~PCFLAG_NOSUMMON; }
	BOOL		IsPkiller () { return (m_flags & PCFLAG_DEADLY) != 0; }
	void		SetPkiller () { m_flags |= PCFLAG_DEADLY; }
	void		ClrPkiller () { m_flags &= ~PCFLAG_DEADLY; }
	BOOL		IsNoRecall () { return (m_flags & PCFLAG_NORECALL) != 0; }
	void		SetNoRecall () { m_flags |= PCFLAG_NORECALL; }
	void		ClrNoRecall () { m_flags &= ~PCFLAG_NORECALL; }
	BOOL		IsUnauthed () { return (m_flags & PCFLAG_UNAUTHED) != 0; }
	void		SetUnauthed () { m_flags |= PCFLAG_UNAUTHED; }
	void		ClrUnauthed () { m_flags &= ~PCFLAG_UNAUTHED; }
	BOOL		IsNoIntro () { return (m_flags & PCFLAG_NOINTRO) != 0; }
	void		SetNoIntro () { m_flags |= PCFLAG_NOINTRO; }
	void		ClrNoIntro () { m_flags &= ~PCFLAG_NOINTRO; }
	BOOL		IsGuest () { return (m_flags & PCFLAG_GUEST) != 0; }

	BOOL		IsGuilded ()
				{ return m_pClan ? m_pClan->GetType () == CLAN_GUILD : FALSE; }

	CClanData	*GetClan () { return m_pClan; }
	void		SetClan (CClanData* p) { m_pClan = p; }

	BOOL		HasRank () { return m_pRank && *m_pRank; }
	char		*GetRank () { return m_pRank; }
	void		SetRank (char* p) { m_pRank = p; }
	BOOL		HasBestowments () { return m_pBestowments && *m_pBestowments; }
	char		*GetBestowments () { return m_pBestowments; }
	void		SetBestowments (char* p) { m_pBestowments = p; }
	BOOL		HasHomepage () { return m_pHomepage && *m_pHomepage; }
	char		*GetHomepage () { return m_pHomepage; }
	void		SetHomepage (char* p) { m_pHomepage = p; }
	BOOL		HasBio () { return bio && *bio; }
	BOOL		HasAuthedBy () { return authed_by && *authed_by; }
	BOOL		HasPrompt () { return m_Prompt && *m_Prompt; }
	char		*GetPrompt () { return m_Prompt; }
	void		SetPrompt (char* p) { m_Prompt = p; }
	BOOL		HasFightPrompt () { return m_Fprompt && *m_Fprompt; }
	char		*GetFightPrompt () { return m_Fprompt; }
	void		SetFightPrompt (char* p) { m_Fprompt = p; }
	BOOL		HasSubPrompt () { return m_Subprompt && *m_Subprompt; }
	char		*GetSubPrompt () { return m_Subprompt; }
	void		SetSubPrompt (char* p) { m_Subprompt = p; }
	BOOL		HasCouncilName () { return m_pCouncilName && *m_pCouncilName; }
	char		*GetCouncilName () { return m_pCouncilName; }
	void		SetCouncilName (char* p) { m_pCouncilName = p; }
	BOOL		HasDeityName () { return m_pDeityName && *m_pDeityName; }
	char		*GetDeityName () { return m_pDeityName; }
	void		SetDeityName (char* p) { m_pDeityName = p; }
	BOOL		HasClanName () { return m_pClanName && *m_pClanName; }
	char		*GetClanName () { return m_pClanName; }
	void		SetClanName (char* p) { m_pClanName = p; }
	BOOL		HasTitle () { return m_pTitle && *m_pTitle; }
	char		*GetTitle () { return m_pTitle; }
	void		SetTitle (char* p) { m_pTitle = p; }
	BOOL		HasPassWord () { return m_pPassWord && *m_pPassWord; }
	char		*GetPassWord () { return m_pPassWord; }
	void		SetPassWord (char* p) { m_pPassWord = p; }
	BOOL		HasBamfin () { return m_pBamfin && *m_pBamfin; }
	char		*GetBamfin () { return m_pBamfin; }
	void		SetBamfin (char* p) { m_pBamfin = p; }
	BOOL		HasBamfout () { return m_pBamfout && *m_pBamfout; }
	char		*GetBamfout () { return m_pBamfout; }
	void		SetBamfout (char* p) { m_pBamfout = p; }

	short		GetCondition (int c)
				{ ASSERT (c >= 0 && c < MAX_CONDS); return condition [c]; }

protected:
	int			m_flags;	// Whether the player is deadly and whatever else we add

	char		*m_pPassWord;
	char		*m_pBamfin;
	char		*m_pBamfout;
	char		*m_pTitle;
	char		*m_Prompt;				// User config prompts
	char		*m_Fprompt;				// User config fight prompts
	char		*m_Subprompt;			// Substate prompt
	char		*m_pClanName;
	char		*m_pBestowments;		// NC, Special bestowed commands
	char		*m_pDeityName;
	char		*m_pHomepage;
	char		*m_pCouncilName;
	char		*m_pRank;
	CClanData	*m_pClan;

public:
	CCouncilData	*council;
	CAreaData	*area;
	CDeityData	*deity;
	CCharacter	*m_pPet;
	int			pkills;					// Number of pkills on behalf of clan
	int			pdeaths;				// Number of times pkilled (legally)
	int			mkills;					// Number of mobs killed
	int			mdeaths;				// Number of deaths due to mobs
	int			illegal_pk;				// Number of illegal pk's committed
	long		outcast_time;	// The time at which the char was outcast
	int			r_range_lo;				// room range
	int			r_range_hi;
	int			m_range_lo;				// mob range
	int			m_range_hi;
	int			o_range_lo;				// obj range
	int			o_range_hi;		
	short		wizinvis;				// wizinvis level
	short		min_snoop;				// minimum snoop level
	short		quest_number;	// current *QUEST BEING DONE* DON'T REMOVE!
	short		quest_curr;		// current number of quest points
	int			quest_accum;	// quest points accumulated in players life
	short		favor;					// deity favor */
	int			auth_state;
	char		*helled_by;
	char		*bio;					// Personal Bio
	char		*authed_by;				// what crazy imm authed this name ;)
	int			m_Substate;
	short		pagerlen;				// For pager (NOT menus)
	int			m_MenuLen;
	int			imc_def;				// IMC channel def flags
	int			imc_allow;				// IMC channel allow flags
	int			imc_deny;				// IMC channel deny flags
	char		*rreply;				// IMC reply-to
	char		*rreply_name;			// IMC reply-to shown to char
	char		*ice_listen;			// ICE channels
	BOOL		m_bLockMenus;

	short		learned [MAX_SKILL];
	short		condition [MAX_CONDS];
	KILLED_DATA	killed [MAX_KILLTRACK];
	CSkill		*special_skills [5];	// personalized skills/spells(unused)
	BOOL		openedtourney;

	CSwTime		restore_time;	// The last time the char did a restore all
	CSwTime		release_date;	// Auto-helling.. Altrag
	CStringList	m_IgnoreList;
};


// One character (PC or NPC).
class CCharacter {
public:
					CCharacter () { Empty (); }
					~CCharacter ();
	void			Empty ()
					{ ClearAddrRange (&m_pNext, &regoto, sizeof (regoto)); }
	void			InitChar ();
	int				GetCurrentVersion () { return CurrentPlayerFileVersion; }
	BOOL			Read (FILE *fp, BOOL preload);
	void			Write (FILE *fp);
	void			ReadMob (FILE* fp);
	void			WriteMob (FILE *fp);
	void			ValidateLoad ();
	void			SendTextf (char *fmt, ...);
	void			SendText (const char *txt);
	void			SendColor (const char *txt);
	void			SendColorf (char *fmt, ...);
	void			PageColor (const char *txt);
	void			PageColorf (char *fmt, ...);

	BOOL			IsMenuActive () { return m_pEditMenu != NULL; }
	CSmaugMenu&		GetMenu () { return *m_pEditMenu; }
	void			DisplayMenu (char menu);
	BOOL			EditMenu (char* arg, const char* cmd);
	void			SetMenu (CSmaugMenu* m) { m_pEditMenu = m; }
	void			RemoveMenu ();
	void			SaveMenu ();
	void			ReturnToMenu (BOOL b);
	BOOL			AreMenusLocked ()
					{ return m_pPcdata ? m_pPcdata->m_bLockMenus : FALSE; }
	void			LockMenus (BOOL f)
					{ if (m_pPcdata) m_pPcdata->m_bLockMenus = f; }
	int				GetMenuPagelen ()
					{ return m_pPcdata ? m_pPcdata->m_MenuLen : 24; }
	void			SetMenuPagelen (int l)
					{ if (m_pPcdata) m_pPcdata->m_MenuLen = l; }
	int				GetSubstate ()
					{ return m_pPcdata ? m_pPcdata->m_Substate : 0; }
	void			SetSubstate (int s)
					{ if (m_pPcdata) m_pPcdata->m_Substate = s; }

	void			SetEditor (CEditor* ed) { m_pEditor = ed; }
	void			StopEditing ();
	void			Edit (char* arg);
	char*			GetEditBuffer ();

	int				GetConnectStatus ();
	void			SetConnectStatus (int st);

	int				GetCurrentStrength ();
	int				GetTrustLevel ();
	int				GetAge ();
	int				GetIntelligence ();
	int				GetWisdom ();
	int				GetDexterity ();
	int				GetConstitution ();
	int				GetMaxWeight ();
	int				GetMaxItems ();
	const char		*GetRaceName ();
	const char		*GetClassName ();

	void			StopIdling ();
	void			RemoveFromRoom ();
	void			SendToRoom (CRoomIndexData *pRoom);

	CCharacter		*GetNext () { return m_pNext; }
	void			SetNext (CCharacter* n) { m_pNext = n; }
	CCharacter		*GetPrev () { return m_pPrev; }
	void			SetPrev (CCharacter* n) { m_pPrev = n; }
	CCharacter		*GetNextInRoom () { return m_pNextInRoom; }
	void			SetNextInRoom (CCharacter* n) { m_pNextInRoom = n; }
	CCharacter		*GetPrevInRoom () { return m_pPrevInRoom; }
	void			SetPrevInRoom (CCharacter* n) { m_pPrevInRoom = n; }
	CCharacter		*GetMaster () { return m_pMaster; }
	void			SetMaster (CCharacter* p) { m_pMaster = p; }
	CCharacter		*GetLeader () { return m_pLeader; }
	void			SetLeader (CCharacter* p) { m_pLeader = p; }
	CFightData		*GetFightData () { return m_pFighting; }
	void			SetFightData (CFightData* p) { m_pFighting = p; }
	CCharacter		*GetFightWho ()
					{ ASSERT (this);
					  return m_pFighting ? m_pFighting->who : NULL; }
	void			SetFightWho (CCharacter* ch)
					{ ASSERT (this); if (m_pFighting) m_pFighting->who = ch; }
	CCharacter		*GetReplier () { return m_Reply; }
	void			SetReplier (CCharacter* p) { m_Reply = p; }
	CMobIndexData	*GetMobIndex () { return m_pIndexData; }
	void			SetMobIndex (CMobIndexData* p) { m_pIndexData = p; }
	CDescriptor		*GetDesc () { return m_pDesc; }
	void			SetDesc (CDescriptor* p) { m_pDesc = p; }
	CNoteData		*GetNotes () { return m_pNote; }
	void			SetNotes (CNoteData* p) { m_pNote = p; }
	CRoomIndexData	*GetInRoom () { return m_pInRoom; }
	void			SetInRoom (CRoomIndexData* p) { m_pInRoom = p; }
	CRoomIndexData	*GetWasInRoom () { return m_pWasInRoom; }
	void			SetWasInRoom (CRoomIndexData* p) { m_pWasInRoom = p; }
	pc_data			*GetPcData () { return m_pPcdata; }
	void			SetPcData (pc_data* p) { m_pPcdata = p; }
	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* p)
					{ STRFREE (m_pShortDescr); m_pShortDescr = STRALLOC (p); }
	BOOL			HasShortDescription ()
					{ return m_pShortDescr && *m_pShortDescr; }
	const char		*GetLongDescr () const { return m_pLongDescr; }
	void			SetLongDescr (const char* p)
					{ STRFREE (m_pLongDescr); m_pLongDescr = STRALLOC (p); }
	BOOL			HasLongDescription ()
					{ return m_pLongDescr && *m_pLongDescr; }
	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; }
	BOOL			HasDescription ()
					{ return m_pDescription && *m_pDescription; }
	CAreaData		*GetArea () { return m_pPcdata ? m_pPcdata->area : NULL; }


	int		GetLearnedPercent (int sn)
			{ return IsNpc () ? 80 : URANGE (0,m_pPcdata->learned [sn],101); }

	short		GetSex () { return m_Sex; }
	void		SetSex (short s) { ASSERT (s >= 0 && s <= 2); m_Sex=s; }
	void		AdjSex (short a)
				{ m_Sex += a; if (m_Sex < 0 || m_Sex > 2) m_Sex = 0; }

	BOOL		HasValidClass () { return m_Class >= 0; }
	short		GetClass () { return m_Class; }
	void		SetClass (short c) { ASSERT (c >= 0); m_Class = c; }
//				{ ASSERT (c >= 0 && c <= MAX_CLASS); m_Class = c; }
	short		GetRace () { return m_Race; }
	void		SetRace (short r)
				{ ASSERT (r >= 0 && r <= MAX_NPC_RACE); m_Race = r; }
	BOOL		HasValidRace ();
	short		GetLevel () { return m_Level; }
	void		SetLevel (short l) { ASSERT (l >= 0); m_Level = l; }
//				{ ASSERT (l >= 0 && l <= MAX_LEVEL); m_Level = l; }
	void		AddLevel (short i)
				{ ASSERT ((i+m_Level) <= MAX_LEVEL); m_Level += i; }
	short		GetTrust () { return m_Trust; }
	void		SetTrust (short t) { m_Trust = t; }
	WORD		GetMobInvisLevel () { return m_MobInvis; }
	void		SetMobInvisLevel (WORD i) { m_MobInvis = i; }
	CSwTime		GetLogonTime () { return m_LogTime; }
	void		SetLogonTime (CSwTime t) { m_LogTime = t; }
	CSwTime		GetSaveTime () { return m_SaveTime; }
	void		SetSaveTime (CSwTime t) { m_SaveTime = t; }
	short		GetPosition () { return m_Position; }
	void		SetPosition (short p) { m_Position = p; }
	short		GetStyle () { return m_Style; }
	void		SetStyle (short s) { m_Style = s; }

	short		GetTimer () { return m_Timer; }
	void		SetTimer (short t) { m_Timer = t; }
	void		AddTimer (short t) { m_Timer += t; }

	short		GetWait () { return m_Wait; }
	void		SetWait (short w) { m_Wait = w; }
	void		AddWait (short w) { m_Wait += w; }

	int			GetPlayed () { return m_Played; }
	void		SetPlayed (int p) { m_Played = p; }
	void		AddPlayed (int p) { m_Played += p; }

	short		GetHp () { return m_Hit; }
	void		SetHp (short h) { m_Hit = h; }
	void		AddHp (short h) { m_Hit += h; }
	short		GetMaxHp () { return m_MaxHit; }
	void		SetMaxHp (short h) { m_MaxHit = h; }
	void		AddMaxHp (short h) { m_MaxHit += h; }

	short		GetMana () { return m_Mana; }
	void		SetMana (short m) { m_Mana = m; }
	void		AddMana (short m) { m_Mana += m; }
	short		GetMaxMana () { return m_MaxMana; }
	void		SetMaxMana (short m) { m_MaxMana = m; }
	void		AddMaxMana (short m) { m_MaxMana += m; }

	short		GetMove () { return m_Move; }
	void		SetMove (short m) { m_Move = m; }
	void		AddMove (short m) { m_Move += m; }
	short		GetMaxMove () { return m_MaxMove; }
	void		SetMaxMove (short m) { m_MaxMove = m; }
	void		AddMaxMove (short m) { m_MaxMove += m; }

	short		GetPractices () { return m_nPractice; }
	void		SetPractices (short n) { m_nPractice = n; }
	void		AddPractices (short n) { m_nPractice += n; }

	short		GetCarryWeight () { return m_CarryWeight; }
	void		SetCarryWeight (short w) { m_CarryWeight = w; }
	void		AddCarryWeight (short w) { m_CarryWeight += w; }

	short		GetAlignment () { return m_Alignment; }
	void		SetAlignment (short a) { m_Alignment = a; }
	void		AddAlignment (short a) { m_Alignment += a; }

	short		GetMentalState () { return m_MentalState; }
	void		SetMentalState (short h) { m_MentalState = h; }
	void		AddMentalState (short h) { m_MentalState += h; }

	short		GetHitroll () { return m_Hitroll; }
	void		SetHitroll (short h) { m_Hitroll = h; }
	void		AddHitroll (short h) { m_Hitroll += h; }

	short		GetDamroll () { return m_Damroll; }
	void		SetDamroll (short d) { m_Damroll = d; }
	void		AddDamroll (short d) { m_Damroll += d; }

	short		GetArmor () { return m_Armor; }
	void		SetArmor (short d) { m_Armor = d; }
	void		AddArmor (short d) { m_Armor += d; }

	short		GetWimpLevel () { return m_Wimpy; }
	void		SetWimpLevel (short d) { m_Wimpy = d; }
	
	int			GetGold () { return m_Gold; }
	void		SetGold (int g) { m_Gold = g; }
	void		AddGold (int g) { m_Gold += g; }

	short		GetHeight () { return m_Height; }
	void		SetHeight (short h) { m_Height = h; }
	void		AddHeight (short h) { m_Height += h; }

	short		GetWeight () { return m_Weight; }
	void		SetWeight (short w) { m_Weight = w; }
	void		AddWeight (short w) { m_Weight += w; }

	int			GetExp () { return m_Exp; }
	void		SetExp (int e) { m_Exp = e; }
	void		AddExp (int e) { m_Exp += e; }

	CActFlags	GetActFlags () { return m_ActionBits; }
	void		SetActFlags (CActFlags a) { m_ActionBits = a; }
	void		ToggleActBit (int bit) { m_ActionBits.ToggleBit (bit); }
	BOOL		IsAction (int b) { return m_ActionBits.IsSet (b); }
	void		SetActBit (int b) { m_ActionBits.SetBit (b); }
	void		ClrActBit (int b) { m_ActionBits.ClrBit (b); }

	BOOL		IsPacifist ()
				{ return IsNpc () && m_ActionBits.IsPacifist (); }
	void		SetPacifist () { if (IsNpc ()) m_ActionBits.SetPacifist (); }
	void		ClrPacifist () { if (IsNpc ()) m_ActionBits.ClrPacifist (); }

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

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

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

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

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

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

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

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

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

	BOOL		IsLitterBug () { return m_ActionBits.IsLitterBug (); }
	void		SetLitterBug () { m_ActionBits.SetLitterBug (); }
	void		ClrLitterBug () { m_ActionBits.ClrLitterBug (); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	BOOL		IsPet () { return m_ActionBits.IsSet (ACT_PET); }
	void		SetPetFlag () { m_ActionBits.SetBit (ACT_PET); }
	void		ClrPetFlag () { m_ActionBits.ClrBit (ACT_PET); }

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

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

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

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

	BOOL		IsAfk () { return m_ActionBits.IsAfk (); }
	void		SetAfk () { m_ActionBits.SetAfk (); }
	void		ClrAfk () { m_ActionBits.ClrAfk (); }

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

	BOOL		IsAutonomous () { return m_ActionBits.IsAutonomous (); }
	void		SetAutonomous () { m_ActionBits.SetAutonomous (); }
	void		ClrAutonomous () { m_ActionBits.ClrAutonomous (); }


	const CAffectFlags&	GetAffectFlags () { return m_AffectBits; }
	const CAffectFlags&	GetNoAffectFlags () { return m_NoAffectBits; }

	void			SetAffectFlags (CAffectFlags a) { m_AffectBits = a; }
	void			SetAffectBits (CAffectFlags f) { m_AffectBits.SetBits (f); }
	void			ClrAffectBits (CAffectFlags f) { m_AffectBits.ClearBits (f); }
	void			ToggleAffect (int b)
					{ if (b >= 0) m_AffectBits.ToggleBit (b); }
	BOOL			IsAffected (int b)
					{ return b < 0 ? FALSE : m_AffectBits.IsSet (b); }
	void			SetAffBit (int b) { if (b >= 0) m_AffectBits.SetBit (b); }
	void			ClrAffBit (int b) { if (b >= 0) m_AffectBits.ClrBit (b); }
	BOOL			IsPermanentAffect (int b);
	CAffectFlags	*GetAffectBitsAddr () { return &m_AffectBits; }
					// (Special for Reset.cpp)

	BOOL		IsCharmed () { return m_AffectBits.IsSet (AFF_CHARM); }
	void		SetCharmed () { m_AffectBits.SetBit (AFF_CHARM); }
	void		ClrCharmed () { m_AffectBits.ClrBit (AFF_CHARM); }

	BOOL		IsInvis () { return m_AffectBits.IsSet (AFF_INVISIBLE); }
	void		SetInvis () { m_AffectBits.SetBit (AFF_INVISIBLE); }
	void		ClrInvis () { m_AffectBits.ClrBit (AFF_INVISIBLE); }

	BOOL		IsHidden () { return m_AffectBits.IsSet (AFF_HIDE); }
	void		SetHide () { m_AffectBits.SetBit (AFF_HIDE); }
	void		ClrHide () { m_AffectBits.ClrBit (AFF_HIDE); }

	BOOL		CanPass () { return m_AffectBits.IsSet (AFF_PASS_DOOR); }
	void		SetPass () { m_AffectBits.SetBit (AFF_PASS_DOOR); }
	void		ClrPass () { m_AffectBits.ClrBit (AFF_PASS_DOOR); }

	BOOL		IsFaerieFire () { return m_AffectBits.IsSet (AFF_FAERIE_FIRE); }
	void		SetFaerieFire () { m_AffectBits.SetBit (AFF_FAERIE_FIRE); }
	void		ClrFaerieFire () { m_AffectBits.ClrBit (AFF_FAERIE_FIRE); }

	BOOL		HasSanctuary () { return m_AffectBits.IsSet (AFF_SANCTUARY); }
	void		SetSanctuary () { m_AffectBits.SetBit (AFF_SANCTUARY); }
	void		ClrSanctuary () { m_AffectBits.ClrBit (AFF_SANCTUARY); }

	BOOL		CanSeeInfra () { return m_AffectBits.IsSet (AFF_INFRARED); }
	void		SetSeeInfra () { m_AffectBits.SetBit (AFF_INFRARED); }
	void		ClrSeeInfra () { m_AffectBits.ClrBit (AFF_INFRARED); }

	BOOL		CanSeeHidden () { return m_AffectBits.IsSet (AFF_DETECT_HIDDEN); }
	void		SetSeeHidden () { m_AffectBits.SetBit (AFF_DETECT_HIDDEN); }
	void		ClrSeeHidden () { m_AffectBits.ClrBit (AFF_DETECT_HIDDEN); }

	BOOL		CanSeeEvil () { return m_AffectBits.IsSet (AFF_DETECT_EVIL); }
	void		SetSeeEvil () { m_AffectBits.SetBit (AFF_DETECT_EVIL); }
	void		ClrSeeEvil () { m_AffectBits.ClrBit (AFF_DETECT_EVIL); }

	BOOL		CanSeeMagic () { return m_AffectBits.IsSet (AFF_DETECT_MAGIC); }
	void		SetSeeMagic () { m_AffectBits.SetBit (AFF_DETECT_MAGIC); }
	void		ClrSeeMagic () { m_AffectBits.ClrBit (AFF_DETECT_MAGIC); }

	BOOL		CanSeeInvis () { return m_AffectBits.IsSet (AFF_DETECT_INVIS); }
	void		SetSeeInvis () { m_AffectBits.SetBit (AFF_DETECT_INVIS); }
	void		ClrSeeInvis () { m_AffectBits.ClrBit (AFF_DETECT_INVIS); }

	BOOL		IsBlind () { return m_AffectBits.IsSet (AFF_BLIND); }
	void		SetBlind () { m_AffectBits.SetBit (AFF_BLIND); }
	void		ClrBlind () { m_AffectBits.ClrBit (AFF_BLIND); }

	BOOL		IsSneaking () { return m_AffectBits.IsSet (AFF_SNEAK); }
	void		SetSneak () { m_AffectBits.SetBit (AFF_SNEAK); }
	void		ClrSneak () { m_AffectBits.ClrBit (AFF_SNEAK); }

	BOOL		IsCursed () { return m_AffectBits.IsSet (AFF_CURSE); }
	void		SetCursed () { m_AffectBits.SetBit (AFF_CURSE); }
	void		ClrCursed () { m_AffectBits.ClrBit (AFF_CURSE); }

	BOOL		IsFlying () { return m_AffectBits.IsSet (AFF_FLYING); }
	void		SetFly () { m_AffectBits.SetBit (AFF_FLYING); }
	void		ClrFly () { m_AffectBits.ClrBit (AFF_FLYING); }

	BOOL		IsFloating () { return m_AffectBits.IsSet (AFF_FLOATING); }
	void		SetFloat () { m_AffectBits.SetBit (AFF_FLOATING); }
	void		ClrFloat () { m_AffectBits.ClrBit (AFF_FLOATING); }

	BOOL		IsProtected () { return m_AffectBits.IsSet (AFF_PROTECT); }
	void		SetProtect () { m_AffectBits.SetBit (AFF_PROTECT); }
	void		ClrProtect () { m_AffectBits.ClrBit (AFF_PROTECT); }

	BOOL		IsSleeping () { return m_AffectBits.IsSet (AFF_SLEEP); }
	void		SetSleeping () { m_AffectBits.SetBit (AFF_SLEEP); }
	void		ClrSleeping () { m_AffectBits.ClrBit (AFF_SLEEP); }

	BOOL		IsPoisoned () { return m_AffectBits.IsSet (AFF_POISON); }
	void		SetPoisoned () { m_AffectBits.SetBit (AFF_POISON); }
	void		ClrPoisoned () { m_AffectBits.ClrBit (AFF_POISON); }

	BOOL		IsPossessed () { return m_AffectBits.IsSet (AFF_POSSESS); }
	void		SetPossessed () { m_AffectBits.SetBit (AFF_POSSESS); }
	void		ClrPossessed () { m_AffectBits.ClrBit (AFF_POSSESS); }

	BOOL		IsParalysed () { return m_AffectBits.IsSet (AFF_PARALYSIS); }
	void		SetParalysed () { m_AffectBits.SetBit (AFF_PARALYSIS); }
	void		ClrParalysed () { m_AffectBits.ClrBit (AFF_PARALYSIS); }

	BOOL		IsBeserk () { return m_AffectBits.IsSet (AFF_BERSERK); }
	void		SetBeserk () { m_AffectBits.SetBit (AFF_BERSERK); }
	void		ClrBeserk () { m_AffectBits.ClrBit (AFF_BERSERK); }

	BOOL		IsFlaming () { return m_AffectBits.IsSet (AFF_FLAMING); }
	BOOL		IsScrying () { return m_AffectBits.IsSet (AFF_SCRYING); }
	BOOL		HasFireShield () { return m_AffectBits.IsSet (AFF_FIRESHIELD); }
	BOOL		HasShockShield () { return m_AffectBits.IsSet (AFF_SHOCKSHIELD); }
	BOOL		HasIceShield () { return m_AffectBits.IsSet (AFF_ICESHIELD); }
	BOOL		HasTrueSight () { return m_AffectBits.IsSet (AFF_TRUESIGHT); }
	BOOL		IsAqua () { return m_AffectBits.IsSet (AFF_AQUA_BREATH); }
	BOOL		IsDetTrap () { return m_AffectBits.IsSet (AFF_DETECTTRAPS); }

	// Styles
	BOOL		IsBeserkStyle () { return m_Style == STYLE_BERSERK; }
	BOOL		IsAggressiveStyle () { return m_Style == STYLE_AGGRESSIVE; }
	BOOL		IsFightingStyle () { return m_Style == STYLE_FIGHTING; }
	BOOL		IsDefensiveStyle () { return m_Style == STYLE_DEFENSIVE; }
	BOOL		IsEvasiveStyle () { return m_Style == STYLE_EVASIVE; }

	// Access functions for defenses
	const CDefenseFlags&	GetDefenseFlags () { return m_defenses; }
	void		SetDefenseFlags (CDefenseFlags f) { m_defenses = f; }
	BOOL		HasDefenses () { return ! m_defenses.IsEmpty (); }
	BOOL		CanDefend (int bit) { return m_defenses.IsSet (bit); }
	void		ToggleDefense (int bit) { m_defenses.ToggleBit (bit); }
	BOOL		CanParry () { return m_defenses.CanParry (); }
	BOOL		CanDodge () { return m_defenses.CanDodge (); }
	BOOL		CanGrip () { return m_defenses.CanGrip (); }
	BOOL		CanDisarm () { return m_defenses.CanDisarm (); }

	// Access functions for attacks
	const CAttackFlags&	GetAttackFlags () { return m_attacks; }
	void		SetAttackFlags (CAttackFlags f) { m_attacks = f; }
	void		ToggleAttack (int bit) { m_attacks.ToggleBit (bit); }
	BOOL		HasAttacks () { return ! m_attacks.IsEmpty (); }
	BOOL		CanAttack (int bit) { return m_attacks.IsSet (bit); }
	BOOL		CanTrip () { return m_attacks.CanTrip (); }
	BOOL		CanBackStab () { return m_attacks.CanBackStab (); }

	// Access functions for immunes
	int			GetImmuneFlags () { return m_Immune; }
	void		SetImmuneFlags (int f) { m_Immune = f; }
	BOOL		IsImmune (int bit) { return (m_Immune & bit) != 0; }
	void		SetImmune (int bit) { m_Immune |= bit; }
	void		ClrImmune (int bit) { m_Immune &= ~bit; }
	void		ToggleImmune (int bit) { m_Immune ^= bit; }

	BOOL		IsImmuneFire () { return (m_Immune & RIS_FIRE) != 0; }
	BOOL		IsImmuneCold () { return (m_Immune & RIS_COLD) != 0; }
	BOOL		IsImmuneElectricity () { return (m_Immune & RIS_ELECTRICITY) != 0; }
	BOOL		IsImmuneEnergy () { return (m_Immune & RIS_ENERGY) != 0; }
	BOOL		IsImmuneAcid () { return (m_Immune & RIS_ACID) != 0; }
	BOOL		IsImmunePoison () { return (m_Immune & RIS_POISON) != 0; }
	BOOL		IsImmuneEnergyDrain () { return (m_Immune & RIS_DRAIN) != 0; }
	BOOL		IsImmuneMagic () { return (m_Immune & RIS_MAGIC) != 0; }
	BOOL		IsImmuneCharm () { return (m_Immune & RIS_CHARM) != 0; }

	// Access functions for resistances
	int			GetResistFlags () { return m_Resist; }
	void		SetResistFlags (int f) { m_Resist = f; }
	void		ToggleResist (int bit) { m_Resist ^= bit; }
	BOOL		CanResist (int bit) { return (m_Resist & bit) != 0; }
	void		SetResist (int bit) { m_Resist |= bit; }
	void		ClrResist (int bit) { m_Resist &= ~bit; }

	// Access functions for susceptibility
	int			GetSusceptFlags () { return m_Suscept; }
	void		SetSusceptFlags (int f) { m_Suscept = f; }
	void		ToggleSuscept (int bit) { m_Suscept ^= bit; }
	BOOL		IsSusceptible (int bit) { return (m_Suscept & bit) != 0; }
	void		SetSusceptible (int bit) { m_Suscept |= bit; }
	void		ClrSusceptible (int bit) { m_Suscept &= ~bit; }

	// Access functions for xflags
	int			GetXFlags () { return m_xflags; }
	void		SetXFlags (int f) { m_xflags = f; }
	void		ToggleXFlag (int bit) { m_xflags ^= bit; }

	// Access functions for Languages
	const CBitVector&	GetSpeaksFlags () { return m_Speaks; }
	void		SetSpeaksFlags (const CBitVector& f) { m_Speaks = f; }
	int			GetSpeaking () { return m_Speaking; }
	void		SetSpeaking (int l) { m_Speaking = l; }
	BOOL		SpeaksLanguage (int l)
				{ return m_Speaks.IsSet (LANG_ALL) || m_Speaks.IsSet (l); }
	BOOL		IsSpeaking (int l)
				{ return m_Speaking == LANG_ALL || m_Speaking == l; }
	void		SetSpeaks (int l) { m_Speaks.SetBit (l); }
	void		ClrSpeaks (int l) { m_Speaks.ClrBit (l); }

	BOOL		IsChannelOn (int c) { return (m_Channels & c) != 0; }
	void		SetChannel (int c) { m_Channels |= c; }
	void		ClrChannel (int c) { m_Channels &= ~c; }
	short		GetAllChannels () { return m_Channels; }
	void		SetAllChannels (int c) { m_Channels = c; }

	BOOL		IsVampire ();
	BOOL		IsEvil () { return m_Alignment <= -350; }
	BOOL		IsGood () { return m_Alignment >= 350; }
	BOOL		IsDevoted () { return ! IsNpc () && GetPcData()->deity; }
	BOOL		IsNeutral () { return ! IsGood () && ! IsEvil (); }
	BOOL		IsStanding () { return m_Position == POS_STANDING; }
	BOOL		IsFighting () { return m_Position == POS_FIGHTING; }
	BOOL		IsStunned () { return m_Position == POS_STUNNED; }
	BOOL		IsSLeeping () { return m_Position == POS_SLEEPING; }
	BOOL		IsDead () { return m_Position == POS_DEAD; }
	BOOL		IsAwake () { return m_Position > POS_SLEEPING; }
	BOOL		IsMounted () { return m_Position == POS_MOUNTED; }
	BOOL		IsImmortal () { return GetTrustLevel() >= LEVEL_IMMORTAL; }
	BOOL		IsMortal () { return GetTrustLevel() < LEVEL_IMMORTAL; }
	BOOL		IsHero () { return GetTrustLevel () >= LEVEL_HERO; }
	BOOL		IsFightPosition ();

	// Access functions for pc_data flags
	int			GetPcFlags () { return m_pPcdata ? m_pPcdata->m_flags : 0; }
	void		SetPcFlag (int bit) { if (m_pPcdata) m_pPcdata->SetFlag (bit); }
	void		ClrPcFlag (int bit) { if (m_pPcdata) m_pPcdata->ClrFlag (bit); }
	void		TogglePcFlag (int bit)
				{ if (m_pPcdata) m_pPcdata->ToggleFlag (bit); }

	BOOL		IsPkiller ()
				{ return m_pPcdata ? m_pPcdata->IsPkiller () : FALSE; }
	void		SetPkiller () { if (m_pPcdata) m_pPcdata->SetPkiller (); }
	void		ClrPkiller () { if (m_pPcdata) m_pPcdata->ClrPkiller (); }

	BOOL		CanPkill ()
				{ return IsPkiller () && m_Level >= 5 && GetAge() >= 18; }
	BOOL		CanCast () { return m_Class != 2 && m_Class != 3; }
	BOOL		IsGuilded ()
				{ return m_pPcdata ? m_pPcdata->IsGuilded () : FALSE; }
	BOOL		IsPagerOn ()
				{ return m_pPcdata ? m_pPcdata->IsPagerOn () : FALSE; }
	BOOL		IsNoTitle ()
				{ return m_pPcdata ? m_pPcdata->IsNoTitle () : TRUE; }
	void		SetNoTitle () { if (m_pPcdata) m_pPcdata->SetNoTitle (); }
	void		ClrNoTitle () { if (m_pPcdata) m_pPcdata->ClrNoTitle (); }
	BOOL		IsNoSummon ()
				{ return m_pPcdata ? m_pPcdata->IsNoSummon () : TRUE; }
	BOOL		IsNoRecall ()
				{ return m_pPcdata ? m_pPcdata->IsNoRecall () : TRUE; }
	void		SetNoRecall () { if (m_pPcdata) m_pPcdata->SetNoRecall (); }
	void		ClrNoRecall () { if (m_pPcdata) m_pPcdata->ClrNoRecall (); }
	BOOL		IsGagged ()
				{ return m_pPcdata ? m_pPcdata->IsGagged () : FALSE; }
	BOOL		IsUnauthed ()
				{ return m_pPcdata ? m_pPcdata->IsUnauthed () : TRUE; }
	void		SetUnauthed () { if (m_pPcdata) m_pPcdata->SetUnauthed (); }
	void		ClrUnauthed () { if (m_pPcdata) m_pPcdata->ClrUnauthed (); }
	BOOL		IsNoIntro ()
				{ return m_pPcdata ? m_pPcdata->IsNoIntro () : TRUE; }
	void		SetNoIntro () { if (m_pPcdata) m_pPcdata->SetNoIntro (); }
	void		ClrNoIntro () { if (m_pPcdata) m_pPcdata->ClrNoIntro (); }


	// Retired and guest imms.
	BOOL		IsRetired ()
				{ return IsNpc () ? FALSE : m_pPcdata->IsRetired (); }
	void		SetRetired () { if (m_pPcdata) m_pPcdata->SetRetired (); }
	void		ClrRetired () { if (m_pPcdata) m_pPcdata->ClrRetired (); }
	BOOL		IsGuest () { return m_pPcdata ? m_pPcdata->IsGuest () : FALSE; }

	int			GetAc ()
				{ return m_Armor + VAMP_AC(this) + (IsAwake () ?
				  dex_app [GetDexterity ()].defensive : 0); }
	int			GetManaCost (int sn);
	BOOL		IsIndoors () { return m_pInRoom->IsIndoors (); }
	BOOL		IsOutside () { return ! IsIndoors (); }
	short		GetSectorType () { return m_pInRoom->sector_type; }

	BOOL		CheckSubrestricted ();
	BOOL		HasBodypart (int part)
				{ return m_xflags == 0 || (m_xflags & part) != 0; }
	BOOL		IsDrunk (int drunk)
				{ if (IsNpc ()) return FALSE;
				  return number_percent () <
				  (m_pPcdata->condition [COND_DRUNK] * 2 / drunk); }
	BOOL		IsClanned ()
				{ if (IsNpc ()) return FALSE;
				  return m_pPcdata->m_pClan
				    && m_pPcdata->m_pClan->GetType () != CLAN_ORDER
				    && m_pPcdata->m_pClan->GetType () != CLAN_GUILD; }

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

	BOOL		IsAuthed ()
				{ if (IsNpc ()) return TRUE;
				  return m_pPcdata->auth_state > 3
				    || ! IS_SET (m_pPcdata->m_flags, PCFLAG_UNAUTHED); }
	BOOL		IsWaitingForAuth ()
				{ if (IsNpc ()) return FALSE;
				  return m_pPcdata->auth_state == 1
				    && IS_SET (m_pPcdata->m_flags, PCFLAG_UNAUTHED); }

	BOOL		HasPet () { return m_pPcdata &&	m_pPcdata->m_pPet; }
	CCharacter	*GetPet () { return m_pPcdata ? m_pPcdata->m_pPet : NULL; }
	void		SetPet (CCharacter* p) { if (m_pPcdata) m_pPcdata->m_pPet = p; }

	BOOL		IsIgnoring (CCharacter* ich);

	BOOL		IsConnectError () { return ! m_ConnectError.IsEmpty (); }
	void		SetConnectError (ConnectErrorTypes e);
	void		ClrConnectError (int b) { m_ConnectError.ClrBit (b); }
	ConnectErrorTypes	GetConnectError ();


	CMobProgActList	*GetMobPact () { return m_pMobPact; }
	void			SetMobPact (CMobProgActList* p) { m_pMobPact = p; }

	SPEC_FUN		*GetSpecialMobFunction () { return m_SpecFun; }
	void			SetSpecialMobFunction (SPEC_FUN* p) { m_SpecFun = p; }
	int				GetMobPactnum () { return m_MobPactnum; }
	void			SetMobPactnum (int n) { m_MobPactnum = n; }
	void			AddMobPactnum (int n) { m_MobPactnum += n; }

	void		AddCarrying (CObjData* pObj, BOOL bLevSort = FALSE)
				{ m_Carrying.AddByLevel (pObj, bLevSort); }
	void		RemoveCarrying (CObjData* pObj) { m_Carrying.Remove (pObj); }
	CObjData	*GetFirstCarrying () { return m_Carrying.GetFirst (); }
	CObjData	*GetLastCarrying () { return m_Carrying.GetLast (); }

	BOOL		IsCarrying () { return ! m_Carrying.IsEmpty (); }
	POSITION	GetHeadCarryPos () { return m_Carrying.GetHeadPosition (); }
	POSITION	GetTailCarryPos () { return m_Carrying.GetTailPosition (); }
	CObjData	*GetNextCarrying (POSITION& pos)
				{ return m_Carrying.GetNext (pos); }
	CObjData	*GetPreviousCarrying (POSITION& pos)
				{ return m_Carrying.GetPrev (pos); }
	CObjectList	&GetCarryList () { return m_Carrying; }

	BOOL		IsStackColors () { return m_Flags.IsSet (0); }
	void		StartColorStack ()
				{ m_ColorStack.RemoveAll (); m_Flags.SetBit (0); }
	void		EndColorStack ()
				{ m_ColorStack.RemoveAll (); m_Flags.ClrBit (0); }

private:
    CSwTime			m_LogTime;
    CSwTime			m_SaveTime;

	CCharacter		*m_pNext;		// Global chain of all char/mob
	CCharacter		*m_pPrev;		// Global chain of all char/mob
    CCharacter		*m_pNextInRoom;	// Chain set by SendToRoom ()
    CCharacter		*m_pPrevInRoom;	// Chain set by SendToRoom ()
    CCharacter		*m_pMaster;		// Who char follows or is charmed by
    CCharacter		*m_pLeader;		// Leader of a group
    CFightData		*m_pFighting;	// Who char is fighting
    CCharacter		*m_Reply;		// Last person who talked to char
    CDescriptor		*m_pDesc;		// Player socket info
    CNoteData		*m_pNote;		// Note writing stuff
    CRoomIndexData	*m_pInRoom;		// Room char is in
    CRoomIndexData	*m_pWasInRoom; 	// Room returned to after 'idle void'
    pc_data			*m_pPcdata;		// Data only PCs have
	CSmaugMenu		*m_pEditMenu;	// Pointer to menu char is editing
	CEditor			*m_pEditor;
	char			*m_pName;
	char			*m_pShortDescr;
	char			*m_pLongDescr;
	char			*m_pDescription;
	short			m_Sex;
	short			m_Class;
	short			m_Race;
	short			m_Level;
	short			m_Trust;
    int				m_Played;
    short			m_Timer;
    short			m_Wait;
    short			m_Hit;
    short			m_MaxHit;
    short			m_Mana;
    short			m_MaxMana;
    short			m_Move;
    short			m_MaxMove;
    int				m_Gold;
    int				m_Exp;
	short			m_Height;
	short			m_Weight;
    CActFlags		m_ActionBits;		// was act
    CAffectFlags	m_AffectBits;		// was affected_by
	CAffectFlags	m_NoAffectBits;		// was no_affected_by
    short			m_Position;
    short			m_nPractice;
    short			m_CarryWeight;
    short			m_Alignment;
    short			m_Hitroll;
    short			m_Damroll;
    short			m_Armor;
    short			m_Wimpy;
    short			m_Channels;
	int				m_xflags;
	int				m_Resist;
	int				m_NoResist;
	int				m_Immune;
	int				m_NoImmune;
	int				m_Suscept;
	int				m_NoSuscept;
	WORD			m_MobInvis;			// Mobinvis level SB
	CAttackFlags	m_attacks;
	CDefenseFlags	m_defenses;
	int				m_Speaking;
	CBitVector		m_Speaks;			// languages spoken
	CIntVector		m_ConnectError;

    SPEC_FUN		*m_SpecFun;			// Mobile special function
    CMobIndexData	*m_pIndexData;		// Mobile class info
    CMobProgActList*    m_pMobPact;		// Used by MOBprogram
    int				m_MobPactnum;		// Used by MOBprogram

public:
	CCharacter		*switched;
	CCharacter		*mount;
	HHF_DATA		*hunting;
	HHF_DATA		*fearing;
	HHF_DATA		*hating;
	short			mpscriptpos;
	CNoteData		*comments;
	DO_FUN			*last_cmd;
	DO_FUN			*prev_cmd;		// mapping
	void			*dest_buf;		// This one is to assign to different things
	char			*alloc_ptr;		// Must str_dup and delete this one
	void			*spare_ptr;
	int				tempnum;
	CTimerData		*first_timer;
	CTimerData		*last_timer;
	short			num_fighting;
	short			numattacks;
	int				carry_number;
	short			saving_poison_death;
	short			saving_wand;
	short			saving_para_petri;
	short			saving_breath;
	short			saving_spell_staff;
	short			barenumdie;
	short			baresizedie;
	short			mobthac0;
	short			hitplus;
	short			damplus;
	short			defposition;
	short			m_Style;
	int				deaf;
	short			perm_str;
	short			perm_int;
	short			perm_wis;
	short			perm_dex;
	short			perm_con;
	short			perm_cha;
	short			perm_lck;
	short			mod_str;
	short			mod_int;
	short			mod_wis;
	short			mod_dex;
	short			mod_con;
	short			mod_cha;
	short			mod_lck;
	short			m_MentalState;		// simplified
	short			emotional_state;	// simplified
	int				retran;
	int				regoto;

	CAffectList		m_AffectList;
	CObjectList		m_Carrying;
	CPtrList		m_ColorStack;
	CIntVector		m_Flags;
};



#endif