/****************************************************************************
 * [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.    *
 * ------------------------------------------------------------------------ *
 *			    Smaug Exits Interface file									*
 ***************************************************************************/

#ifndef EXITS_H
#define	EXITS_H

// Exit flags.
// Used in #ROOMS.
enum ExitTypes {
	EX_ISDOOR, EX_CLOSED, EX_LOCKED, EX_SECRET, EX_SWIM, EX_PICKPROOF,
	EX_FLY, EX_CLIMB, EX_DIG, EX_RES1, EX_NOPASSDOOR, EX_HIDDEN, EX_PASSAGE,
	EX_PORTAL, EX_RES2, EX_RES3, EX_xCLIMB, EX_xENTER, EX_xLEAVE, EX_xAUTO,
	EX_RES4, EX_xSEARCHABLE, EX_BASHED, EX_BASHPROOF, EX_NOMOB, EX_WINDOW,
	EX_xLOOK, EX_DISABLE, EX_MAX };

#ifdef SMAUGSERVER_CPP
const char*		ExitTypeNames [EX_MAX] = { 
	"isdoor", "closed", "locked", "secret", "swim", "pickproof", "fly",
	"climb", "dig", "r1", "nopassdoor", "hidden", "passage", "portal",
	"r2", "r3", "can_climb", "can_enter", "can_leave", "auto", "r4",
	"searchable", "bashed", "bashproof", "nomob", "window", "can_look"
	"disabled" };
#endif

extern const char*	ExitTypeNames [EX_MAX];



// Exit data.
class CExitData {
public:
				CExitData () { ZeroMemory (this, sizeof (CExitData)); }
	CExitData	*GetNext () { return m_pNext; }
	void		SetNext (CExitData* n) { m_pNext = n; }
	CExitData	*GetPrev () { return m_pPrev; }
	void		SetPrev (CExitData* n) { m_pPrev = n; }

	CIntVector *GetFlags () { return &m_Flags; }
	void	SetFlags (int v) { m_Flags = v; }
	BOOL	IsSet (int b) { return m_Flags.IsSet (b); }
	void	SetBit (int b) { m_Flags.SetBit (b); }
	void	ClrBit (int b) { m_Flags.ClrBit (b); }
	void	Toggle (int b) { m_Flags.ToggleBit (b); }
	CString	PrintFlagVector () { return m_Flags.PrintVector (); }
	BOOL	IsDisabled () { return m_Flags.IsSet (EX_DISABLE); }
	void	SetDisabled () { m_Flags.SetBit (EX_DISABLE); }
	void	ClrDisabled () { m_Flags.ClrBit (EX_DISABLE); }
	BOOL	IsClosed () { return m_Flags.IsSet (EX_CLOSED); }
	void	SetClosed () { m_Flags.SetBit (EX_CLOSED); }
	void	ClrClosed () { m_Flags.ClrBit (EX_CLOSED); }
	BOOL	IsWindow () { return m_Flags.IsSet (EX_WINDOW); }
	void	SetWindow () { m_Flags.SetBit (EX_WINDOW); }
	BOOL	IsDoor () { return m_Flags.IsSet (EX_ISDOOR); }
	void	SetDoor () { m_Flags.SetBit (EX_ISDOOR); }
	BOOL	IsPortal () { return m_Flags.IsSet (EX_PORTAL); }
	void	SetPortal () { m_Flags.SetBit (EX_PORTAL); }
	BOOL	IsNoMob () { return m_Flags.IsSet (EX_NOMOB); }
	void	SetNoMob () { m_Flags.SetBit (EX_NOMOB); }
	BOOL	IsNoPass () { return m_Flags.IsSet (EX_NOPASSDOOR); }
	void	SetNoPass () { m_Flags.SetBit (EX_NOPASSDOOR); }
	BOOL	IsSecret () { return m_Flags.IsSet (EX_SECRET); }
	void	SetSecret () { m_Flags.SetBit (EX_SECRET); }
	void	ClrSecret () { m_Flags.ClrBit (EX_SECRET); }
	BOOL	IsDig () { return m_Flags.IsSet (EX_DIG); }
	void	SetDig () { m_Flags.SetBit (EX_DIG); }
	BOOL	IsFly () { return m_Flags.IsSet (EX_FLY); }
	void	SetFly () { m_Flags.SetBit (EX_FLY); }
	BOOL	IsClimb () { return m_Flags.IsSet (EX_CLIMB); }
	void	SetClimb () { m_Flags.SetBit (EX_CLIMB); }
	BOOL	IsLocked () { return m_Flags.IsSet (EX_LOCKED); }
	void	SetLocked () { m_Flags.SetBit (EX_LOCKED); }
	void	ClrLocked () { m_Flags.ClrBit (EX_LOCKED); }
	BOOL	IsBashProof () { return m_Flags.IsSet (EX_BASHPROOF); }
	void	SetBashProof () { m_Flags.SetBit (EX_BASHPROOF); }
	BOOL	IsBashed () { return m_Flags.IsSet (EX_BASHED); }
	void	SetBashed () { m_Flags.SetBit (EX_BASHED); }
	void	ClrBashed () { m_Flags.ClrBit (EX_BASHED); }
	BOOL	IsHidden () { return m_Flags.IsSet (EX_HIDDEN); }
	void	SetHidden () { m_Flags.SetBit (EX_HIDDEN); }
	BOOL	IsPickProof () { return m_Flags.IsSet (EX_PICKPROOF); }
	void	SetPickProof () { m_Flags.SetBit (EX_PICKPROOF); }
	BOOL	IsPassage () { return m_Flags.IsSet (EX_PASSAGE); }
	void	SetPassage () { m_Flags.SetBit (EX_PASSAGE); }

	BOOL	CanClimb () { return m_Flags.IsSet (EX_xCLIMB); }
	void	SetCanClimb () { m_Flags.SetBit (EX_xCLIMB); }
	BOOL	CanEnter () { return m_Flags.IsSet (EX_xENTER); }
	void	SetCanEnter () { m_Flags.SetBit (EX_xENTER); }
	BOOL	CanLeave () { return m_Flags.IsSet (EX_xLEAVE); }
	void	SetCanLeave () { m_Flags.SetBit (EX_xLEAVE); }
	BOOL	CanLook () { return m_Flags.IsSet (EX_xLOOK); }
	void	SetCanLook () { m_Flags.SetBit (EX_xLOOK); }
	BOOL	CanAuto () { return m_Flags.IsSet (EX_xAUTO); }
	void	SetCanAuto () { m_Flags.SetBit (EX_xAUTO); }
	BOOL	CanSearch () { return m_Flags.IsSet (EX_xSEARCHABLE); }
	void	SetCanSearch () { m_Flags.SetBit (EX_xSEARCHABLE); }

	CRoomIndexData	*GetToRoom () { return m_pToRoom; }
	void	SetToRoom (CRoomIndexData* r) { m_pToRoom = r; }

private:
	CExitData	*m_pNext;		// previous exit in linked list
	CExitData	*m_pPrev;		// next exit in linked list
	CIntVector	m_Flags;		// door states & other flags
	CRoomIndexData	*m_pToRoom;	// Pointer to destination room

public:
	CExitData	*rexit;			// Reverse exit pointer
	char		*keyword;		// Keywords for exit or door
	char		*description;	// Description of exit
	int			vnum;			// Vnum of room exit leads to
	int			rvnum;			// Vnum of room in opposite dir
	int			key;			// Key vnum
	short		vdir;			// Physical "direction"
	short		distance;		// how far to the next room
	short		pull;			// pull of direction (current)
	short		pulltype;		// type of pull (current, wind)
};

#endif