/*
....[@@@..[@@@..............[@.................. MUD++ is a written from
....[@..[@..[@..[@..[@..[@@@@@....[@......[@.... scratch multi-user swords and
....[@..[@..[@..[@..[@..[@..[@..[@@@@@..[@@@@@.. sorcery game written in C++.
....[@......[@..[@..[@..[@..[@....[@......[@.... This server is an ongoing
....[@......[@..[@@@@@..[@@@@@.................. development project.  All 
................................................ contributions are welcome. 
....Copyright(C).1995.Melvin.Smith.............. Enjoy. 
------------------------------------------------------------------------------
Melvin Smith (aka Fusion)         msmith@hom.net 
MUD++ development mailing list    mudpp@van.ml.org
------------------------------------------------------------------------------
exit.h
*/

#ifndef _EXIT_H
#define _EXIT_H
#include "nameable.h"
#include "io.h"
#include "streamable.h"
#include "string.h"
#include "index.h"
#include "bit.h"
#include "vmobject.h"

class Affect;
class Room;


const int EXIT_UNDEF		= 0;
const int EXIT_SIMPLE		= 1;
const int EXIT_IS_DOOR		= 2;
const int EXIT_CLOSED		= 3;
const int EXIT_LOCKED		= 4;
const int EXIT_BASHED		= 5;
const int EXIT_NO_PICK		= 6;
const int EXIT_NO_LOCK		= 7;
const int EXIT_NO_BASH		= 8;
const int EXIT_NO_MAGE		= 9;
const int EXIT_NO_CLERIC	= 10;
const int EXIT_NO_THIEF		= 11;
const int EXIT_NO_WARRIOR	= 12;
const int EXIT_NO_5			= 13;
const int EXIT_NO_6			= 14;
const int EXIT_NO_7			= 15;
const int EXIT_NO_8			= 16;
const int EXIT_NO_MORTAL	= 17;
const int EXIT_HIDDEN		= 18;
const int EXIT_TRAP			= 19;
const int EXIT_SLAM			= 20;


const int MAX_EXIT_BIT_FIELDS		= 1;

extern const bitType exit_bits[];

class Exit : public Nameable, public Streamable, public virtual VMObject
{
	public:
		Index room_index;
		Room *room_ptr;
		unsigned long original_flags[ MAX_EXIT_BIT_FIELDS ];
		unsigned long flags[ MAX_EXIT_BIT_FIELDS ];
		Index key;
		String desc;

		Exit()
		:	room_ptr(0)
		{
			memset( (void *)original_flags, 0,
						sizeof( original_flags[0] * MAX_EXIT_BIT_FIELDS ) );
			memset( (void *)flags, 0,
						sizeof( flags[0] * MAX_EXIT_BIT_FIELDS ) );
		}

		Exit( const char * strName, const char * rIndex,
			const char * kIndex, int start_flags, const char *str )
		:	Nameable( strName ),
			room_index( rIndex ),
			room_ptr(0), key( kIndex ),
			desc( str )
		{
			// Temporaryh
			original_flags[0] = start_flags;
			flags[0] = start_flags;
		}

		Exit( const String & strName, const Index & rIndex,
			const Index & kIndex, int start_flags, const String & str )
		:	Nameable( strName ),
			room_index( rIndex ),
			room_ptr(0), key( kIndex ),
			desc( str )
		{
			// Temporary
			original_flags[0] = start_flags;
			flags[0] = start_flags;
		}
		virtual vmtype getVMType() { return VMT_EXIT; }

		int readFrom( StaticInput & ) { return -1; }
		int writeTo( Output & ) const { return -1; }

		void out( const char * ) const {}
		void out( const String & ) const {}
		void addAffect( Affect * ) {}
		void rmAffect( int ) {}
		Affect * getAffect( int ) { return 0; }
		const Index & getIndex() const { return room_index; }
		Room * getRoom() const { return room_ptr; }
		Room * toRoom() const { return room_ptr; }
		void setDesc( const String & x ) { desc = x; }
		const String & getDesc() const { return desc; }
		void reset();
		void hardLink();

		void toggleExitBit( int x ) { TOGGLE_BIT( flags, x ); }
		bool exitBitSet( int x ) { return IS_SET( flags, x ); }
		void setIsDoor() { SET_BIT( flags, EXIT_IS_DOOR ); }
		void setIsClosed() { SET_BIT( flags, EXIT_CLOSED ); }
		void setIsLocked() { SET_BIT( flags, EXIT_LOCKED ); }
		void setIsBashed() { SET_BIT( flags, EXIT_BASHED ); }
		void setIsNoPick() { SET_BIT( flags, EXIT_NO_PICK ); }
		void setIsNoLock() { SET_BIT( flags, EXIT_NO_LOCK ); }
		void setIsNoBash() { SET_BIT( flags, EXIT_NO_BASH ); }

		void rmIsDoor() { CLR_BIT( flags, EXIT_IS_DOOR ); }
		void rmIsClosed() { CLR_BIT( flags, EXIT_CLOSED ); }
		void rmIsLocked() { CLR_BIT( flags, EXIT_LOCKED ); }
		void rmIsBashed() { CLR_BIT( flags, EXIT_BASHED ); }
		void rmIsNoPick() { CLR_BIT( flags, EXIT_NO_PICK ); }
		void rmIsNoLock() { CLR_BIT( flags, EXIT_NO_LOCK ); }
		void rmIsNoBash() { CLR_BIT( flags, EXIT_NO_BASH ); }

		bool isDoor() const { return IS_SET( flags, EXIT_IS_DOOR ); }
		bool isClosed() const { return IS_SET( flags, EXIT_CLOSED ); }
		bool isOpen() const { return ! IS_SET( flags, EXIT_CLOSED ); }
		bool isLocked() const { return IS_SET( flags, EXIT_LOCKED ); }
		bool isBashed() const { return IS_SET( flags, EXIT_BASHED ); }
		bool isNoPick() const { return IS_SET( flags, EXIT_NO_PICK ); }
		bool isNoLock() const { return IS_SET( flags, EXIT_NO_LOCK ); }
		bool isNoBash() const { return IS_SET( flags, EXIT_NO_BASH ); }
};


inline int lookupExitBit( const char * x )
	{	return lookupBit( exit_bits, x );	}

inline const char * lookupExitBitName( int x )
	{	return lookupBitName( exit_bits, x );	}

#endif