/****************************************************************************
 * [S]imulated [M]edieval [A]dventure multi[U]ser [G]ame      |				*
 * -----------------------------------------------------------|   \\._.//	*
 * SmaugWizard (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 System Data Interface file							*
 ****************************************************************************/

#ifndef		SYSDATA_H
#define		SYSDATA_H

#include	"log.h"

extern char	*const SaveFlagNames [];

enum AuthTypes { AU_WAIT, AU_AUTO, AU_IMMEDIATE, AU_DENY };

// Used to keep track of system settings and statistics		-Thoric
class CSystemData {
public:
				CSystemData () { Clear (); }

	void	Clear () { memset (this, 0, sizeof (CSystemData)); }
	void	Empty ();			// Same as Clear but frees strings first
	void	Init ();
	BOOL	Load ();
	BOOL	ReLoad () { m_bLoaded = FALSE; return Load (); }
	void	Read (FILE *fp);
	void	Save ();
	BOOL	IsLoaded () { return m_bLoaded; }
	void	UpdateCounters (int count);

	BOOL	IsSavePasswordOnChange ()
			{ return (m_SaveFlags & SV_PASSCHG) != 0; }
	void	SetSavePasswordOnChange (BOOL f) { SetSave (SV_PASSCHG, f); }
	BOOL    IsSaveOnGet () { return (m_SaveFlags & SV_GET) != 0; }
	void	SetSaveOnGet (BOOL f) { SetSave (SV_GET, f); }
	BOOL    IsSaveOnPut () { return (m_SaveFlags & SV_PUT) != 0; }
	void	SetSaveOnPut (BOOL f) { SetSave (SV_PUT, f); }
	BOOL    IsSaveOnDrop () { return (m_SaveFlags & SV_DROP) != 0; }
	void	SetSaveOnDrop (BOOL f) { SetSave (SV_DROP, f); }
	BOOL    IsSaveOnGive () { return (m_SaveFlags & SV_GIVE) != 0; }
	void	SetSaveOnGive (BOOL f) { SetSave (SV_GIVE, f); }
	BOOL    IsSaveOnReceive () { return (m_SaveFlags & SV_RECEIVE) != 0; }
	void	SetSaveOnReceive (BOOL f) { SetSave (SV_RECEIVE, f); }
	BOOL    IsSaveOnAuction () { return (m_SaveFlags & SV_AUCTION) != 0; }
	void	SetSaveOnAuction (BOOL f) { SetSave (SV_AUCTION, f); }
	BOOL    IsSaveOnKill () { return (m_SaveFlags & SV_KILL) != 0; }
	void	SetSaveOnKill (BOOL f) { SetSave (SV_KILL, f); }
	BOOL    IsSaveOnDeath () { return (m_SaveFlags & SV_DEATH) != 0; }
	void	SetSaveOnDeath (BOOL f) { SetSave (SV_DEATH, f); }
	BOOL	IsSaveOnZapDrop () { return (m_SaveFlags & SV_ZAPDROP) != 0; }
	void	SetSaveOnZapDrop (BOOL f) { SetSave (SV_ZAPDROP, f); }
	BOOL	IsSaveOnIdle () { return (m_SaveFlags & SV_IDLE) != 0; }
	void	SetSaveOnIdle (BOOL f) { SetSave (SV_IDLE, f); }
	BOOL	IsBackup () { return (m_SaveFlags & SV_BACKUP) != 0; }
	void	SetBackup (BOOL f) { SetSave (SV_BACKUP, f); }
	BOOL	IsAutoSave () { return (m_SaveFlags & SV_AUTO) != 0; }
	void	SetAutoSave (BOOL f) { SetSave (SV_AUTO, f); }
	BOOL	IsAutoReboot () { return m_bAutoReboot; }
	void	SetAutoReboot (BOOL f) { m_bAutoReboot = f; }
	int		GetRebootDelay () { return m_RebootDelay; }

	int		GetRebootHour () { return m_RebootHour; }
	void	SetRebootHour (int h) { m_RebootHour = h; }
	int		GetRebootInterval () { return m_RebootDays; }
	void	SetRebootInterval (int i) { m_RebootDays = i; }

	void	SetRebootDelay (int d) { m_RebootDelay = d; }
	BOOL	IsAutoStart () { return m_bAutoStart; }
	void	SetAutoStart (BOOL f) { m_bAutoStart = f; }
	int		GetStartDelay () { return m_StartDelay; }
	void	SetStartDelay (int d) { m_StartDelay = d; }

	void	ToggleSave (int bit) { TOGGLE_BIT (m_SaveFlags, bit); }
	void	SetSave (int bit, BOOL f)
			{ if (f) m_SaveFlags |= bit; else m_SaveFlags &= ~bit; }

	char*	GetFlagString ()
			{ return flag_string (m_SaveFlags, SaveFlagNames); }
	int		GetSaveFlag (const char *name);

	int		GetPort () { return m_Port; }
	void	SetPort (int p) { m_Port = p; }

	char*	GetLongTitle () { return m_pLongTitle; }
	void	SetLongTitle (const char* t) { m_pLongTitle = str_dup (t); }
	char*	GetShortTitle () { return m_pShortTitle; }
	void	SetShortTitle (const char* t) { m_pShortTitle = str_dup (t); }
	CString	GetShortDesc ();
	char	*GetSupremeEntity () { return m_pSupreme; }
	void	SetSupremeEntity (const char* s) { m_pSupreme = str_dup (s); }

	BOOL	IsLoggingToScreen (LogTypes Type);
	BOOL	IsLogBootToScreen () { return (m_LogFlags & 0x1) != 0; }
	BOOL	IsLogResetsToScreen () { return (m_LogFlags & 0x2) != 0; }
	BOOL	IsLogBuildToScreen () { return (m_LogFlags & 0x4) != 0; }
	BOOL	IsLogBugsToScreen () { return (m_LogFlags & 0x8) != 0; }
	BOOL	IsLogPlayersToScreen () { return (m_LogFlags & 0x10) != 0; }
	BOOL	IsLogCommToScreen () { return (m_LogFlags & 0x20) != 0; }
	BOOL	IsLogBootToFile () { return (m_LogFlags & 0x40) != 0; }
	BOOL	IsLogResetsToFile () { return (m_LogFlags & 0x80) != 0; }
	BOOL	IsLogBuildToFile () { return (m_LogFlags & 0x100) != 0; }
	BOOL	IsLogBugsToFile () { return (m_LogFlags & 0x200) != 0; }
	BOOL	IsLogPlayersToFile () { return (m_LogFlags & 0x400) != 0; }
	BOOL	IsLogCommToFile () { return (m_LogFlags & 0x800) != 0; }
	BOOL	IsLogBuildToChannel () { return (m_LogFlags & 0x1000) != 0; }
	BOOL	IsLogBugsToChannel () { return (m_LogFlags & 0x2000) != 0; }
	BOOL	IsLogPlayersToChannel () { return (m_LogFlags & 0x4000) != 0; }
	BOOL	IsLogCommToChannel () { return (m_LogFlags & 0x8000) != 0; }
	BOOL	IsCloseStdErr () { return (m_LogFlags & 0x10000) != 0; }
	int		GetMaxStdErrSize () { return m_MaxStdSize; }

	#define	LSET(f,b)		if(f) m_LogFlags |= b; else m_LogFlags &= ~b

	void	SetLogBootToScreen (BOOL f) { LSET(f,0x1); }
	void	SetLogResetsToScreen (BOOL f) { LSET(f,0x2); }
	void	SetLogBuildToScreen (BOOL f) { LSET(f,0x4); }
	void	SetLogBugsToScreen (BOOL f) { LSET(f,0x8); }
	void	SetLogPlayersToScreen (BOOL f) { LSET(f,0x10); }
	void	SetLogCommToScreen (BOOL f) { LSET(f,0x20); }
	void	SetLogBootToFile (BOOL f) { LSET(f,0x40); }
	void	SetLogResetsToFile (BOOL f) { LSET(f,0x80); }
	void	SetLogBuildToFile (BOOL f) { LSET(f,0x100); }
	void	SetLogBugsToFile (BOOL f) { LSET(f,0x200); }
	void	SetLogPlayersToFile (BOOL f) { LSET(f,0x400); }
	void	SetLogCommToFile (BOOL f) { LSET(f,0x800); }
	void	SetLogBuildToChannel (BOOL f) { LSET(f,0x1000); }
	void	SetLogBugsToChannel (BOOL f) { LSET(f,0x2000); }
	void	SetLogPlayersToChannel (BOOL f) { LSET(f,0x4000); }
	void	SetLogCommToChannel (BOOL f) { LSET(f,0x8000); }
	void	SetCloseStdErr (BOOL f) { LSET(f,0x10000); }
	void	SetMaxStdErrSize (int s) { m_MaxStdSize = s; }

	BOOL	IsWaitForAuth () { return m_Authorization == AU_WAIT; }
	BOOL	IsAutoAuth () { return m_Authorization == AU_AUTO; }
	BOOL	IsImmediateAuth () { return m_Authorization == AU_IMMEDIATE; }
	BOOL	IsDenyNew () { return m_Authorization == AU_DENY; }
	void	SetWaitForAuth () { m_Authorization = AU_WAIT; }
	void	SetAutoAuth () { m_Authorization = AU_AUTO; }
	void	SetImmediateAuth () { m_Authorization = AU_IMMEDIATE; }
	void	SetDenyNew () { m_Authorization = AU_DENY; }

	BOOL	IsShowLevel () const { return m_bShowLevel; }
	void	SetShowLevel (BOOL f) { m_bShowLevel = f; }
	BOOL	IsLevelMsg () const { return m_bRestoreOnLevel; }
	void	SetLevelMsg (BOOL f) { m_bRestoreOnLevel = f; }

	void	AddSentBytes (ULONG b);
	ULONG	GetSentHourBytes () { return m_SHourBytes; }
	ULONG	GetSentDayKb () { return m_SDayKbytes; }
	CTime	GetByteTime () { return m_ByteTime; }
	void	LogBytes ();

	int		MaxPlayers;			// Maximum players this boot
	int		AlltimeMax;			// Maximum players ever
	char	*pTimeOfMax;		// Time of max ever
	BOOL	bNameResolving;		// Hostnames are resolved if TRUE
	short	m_Authorization;	// New players authorization method
	short	m_AuthDelay;		// New players authorization delay
	short	ReadAllMailLev;		// Read all player mail (was 54)
	short	ReadMailFreeLev;	// Read mail for free (was 51)
	short	WriteMailFreeLev;	// Write mail for free (was 51)
	short	TakeOthersMailLev;	// Take others mail (was 54)
	short	MuseLevel;			// Level of muse channel
	short	ThinkLevel;			// Level of think channel LEVEL_HIGOD
	short	BuildLevel;			// Level of build channel LEVEL_BUILD
	short	LogLevel;			// Level of log channel LEVEL LOG
	short	ModifyProtoLevel;	// Level to modify prototype stuff LEVEL_LESSER
	short	OverridePrivateLev; // override private flag
	short	MsetPlayerLevel;	// Level to mset a player
	short	StunPlayerLev;		// Stun mod player vs. player
	short	StunRegularLev;		// Stun difficult
	short	PlrPlrDamage;		// Damage mod player vs. player
	short	PlrMobDamage;		// Damage mod player vs. mobile
	short	MobPlrDamage;		// Damage mod mobile vs. player
	short	MobMobDamage;		// Damage mod mobile vs. mobile
	short	GetObjNoTakeLevel;	// Get objects without take flag
	short	ForcePcLevel;		// The level at which you can use force on players.
	char	*pGuildOverseer;	// NC, Pointer to char containing the name of the
	char	*pGuildAdvisor;		// NC, guild overseer and advisor.
	short	SaveFrequency;		// How old to autosave someone
	int	    m_RoomAuthStart;
	int	    m_RoomSchool;
	int	    m_RoomHell;
	int	    m_RoomTemple;
	int	    m_RoomAltar;
	int		m_RoomHallOfFallen;
	int	    m_RoomVoid;
	int	    m_RoomChat;
	int	    m_RoomLimbo;
	int	    m_RoomPoly;
	int	    m_ObjMace;
	int	    m_ObjDagger;
	int	    m_ObjSword;
	int	    m_ObjVest;
	int	    m_ObjShield;
	int	    m_ObjBanner;
	int	    m_ObjGuide;


private:
	int		m_SaveFlags;		// Toggles for saving conditions
	int		m_LogFlags;			// Bit Flags for Logging
	int		m_Port;				// Communications port.
	BOOL	m_bLoaded;
	BOOL	m_bAutoReboot;
	int		m_RebootDelay;
	int		m_RebootHour;
	int		m_RebootDays;
	BOOL	m_bAutoStart;
	int		m_StartDelay;
	char	*m_pLongTitle;
	char	*m_pShortTitle;
	char	*m_pSupreme;
	int		m_MaxStdSize;		// in megabytes (1 - 100)
	ULONG	m_SHourBytes;
	ULONG	m_SDayKbytes;
	BOOL	m_bShowLevel;		// flag for showing a leveling msg to all players
	BOOL	m_bRestoreOnLevel;	// flag to restore players when they level
	CTime	m_ByteTime;
};


#ifdef	SYSDATA_CPP
char	*const SaveFlagNames [] =
	{ "death", "kill", "passwd", "drop", "put", "give", "auto", "zap",
	  "auction", "get", "receive", "idle", "backup", "r13", "r14", "r15",
	  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23", "r24", "r25",
	  "r26", "r27", "r28", "r29", "r30", "r31" };
#endif

extern	CSystemData		SysData;

#ifdef	SMAUGSERVER_CPP
	CSystemData		SysData;
#endif

#endif