Added MudEngine Project to the Solution. I will slowly be moving the MudDesigner.MudEngine classes out of the Mud Designer Solution and into it's own.

Currently the Mud Designer still contains the old MudEngine classes until migration has been completed.

MudDesigner.sln

@@ -3,6 +3,8 @@ Microsoft Visual Studio Solution File, Format Version 10.00
 # Visual C# Express 2008
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mud Designer", "Mud Designer\Mud Designer.csproj", "{F0C50EA1-80F7-4CE6-93A3-A4E9F34F0434}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MudEngine", "MudEngine\MudEngine.csproj", "{498943A8-DF5A-4DB0-B506-0BFF44788657}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -13,6 +15,10 @@ Global
 		{F0C50EA1-80F7-4CE6-93A3-A4E9F34F0434}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F0C50EA1-80F7-4CE6-93A3-A4E9F34F0434}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F0C50EA1-80F7-4CE6-93A3-A4E9F34F0434}.Release|Any CPU.Build.0 = Release|Any CPU
+		{498943A8-DF5A-4DB0-B506-0BFF44788657}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{498943A8-DF5A-4DB0-B506-0BFF44788657}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{498943A8-DF5A-4DB0-B506-0BFF44788657}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{498943A8-DF5A-4DB0-B506-0BFF44788657}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

MudEngine/Commands/CommandEngine.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MudEngine.Commands
+{
+    class CommandEngine
+    {
+        /// <summary>
+        /// Gets or Sets a Dictionary list of available commands to use.
+        /// </summary>
+        static internal Dictionary<string, IGameCommand> Commands { get; set; }
+
+        public List<string> GetCommands
+        {
+            get
+            {
+                List<string> temp = new List<string>();
+                foreach (string name in Commands.Keys)
+                {
+                    temp.Add(name);
+                }
+
+                return temp;
+            }
+        }
+    }
+}

MudEngine/Commands/CommandResults.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MudEngine.Commands
+{
+    public class CommandResults
+    {
+        /// <summary>
+        /// Result of the command.
+        /// </summary>
+        public object[] Result { get; set; }
+
+        public CommandResults()
+        {
+        }
+
+        public CommandResults(object[] Result)
+        {
+            this.Result = Result;
+        }
+
+        public CommandResults(string message)
+        {
+            this.Result = new object[] { message };
+        }
+    }
+}

MudEngine/Commands/ICommand.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using MudEngine.Commands;
+using MudEngine.GameObjects.Characters;
+using MudEngine.GameManagement;
+using MudEngine.GameObjects.Environment;
+
+namespace MudEngine.Commands
+{
+    public interface IGameCommand
+    {
+        //Name of the command
+        string Name { get; set; }
+        //Used to override commands with the same name
+        bool Override { get; set; }
+        //Executes the command.
+        CommandResults Execute(BaseCharacter player, GameSetup project, Room room, string command);
+    }
+}

MudEngine/FileSystem/FileManager.cs

@@ -0,0 +1,96 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+
+namespace MudEngine.FileSystem
+{
+    /// <summary>
+    /// Handles saving and loading of engine objects
+    /// </summary>
+    public static class FileManager
+    {
+        public enum OutputFormats
+        {
+            XML = 0,
+        }
+
+        /// <summary>
+        /// The filetype that the MUDs files will be saved as
+        /// </summary>
+        public static OutputFormats FileType
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Saves the object using the specified output format
+        /// </summary>
+        /// <param name="Filename"></param>
+        /// <param name="o"></param>
+        public static void Save(string Filename, object o)
+        {
+            if (FileType == OutputFormats.XML)
+            {
+                XmlSerialization.Save(Filename, o);
+            }
+        }
+
+        /// <summary>
+        /// Loads the object using the specified FileType format
+        /// </summary>
+        /// <param name="Filename"></param>
+        /// <param name="o"></param>
+        /// <returns></returns>
+        public static object Load(string Filename, object o)
+        {
+            if (FileType == OutputFormats.XML)
+            {
+                return XmlSerialization.Load(Filename, o);
+            }
+            else return null;
+        }
+
+        /// <summary>
+        /// Returns the complete path to the specified data's save folder.
+        /// </summary>
+        /// <param name="DataType"></param>
+        /// <returns></returns>
+        public static string GetDataPath(SaveDataTypes DataType)
+        {
+            string assemblyPath = System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.FullyQualifiedName;
+            string assemblyName = System.IO.Path.GetFileName(assemblyPath);
+            string installBase = assemblyPath.Substring(0, assemblyPath.Length - assemblyName.Length);
+            string rootPath = System.IO.Path.Combine(installBase, "Project");
+
+            if (DataType == SaveDataTypes.Root)
+                return rootPath;
+            else
+                return System.IO.Path.Combine(rootPath, DataType.ToString());
+        }
+
+        public static string GetDataPath(string Realm, string Zone)
+        {
+            string assemblyPath = System.Reflection.Assembly.GetExecutingAssembly().ManifestModule.FullyQualifiedName;
+            string assemblyName = System.IO.Path.GetFileName(assemblyPath);
+            string installBase = assemblyPath.Substring(0, assemblyPath.Length - assemblyName.Length);
+            string rootPath = System.IO.Path.Combine(installBase, "Project");
+            string realmsPath = System.IO.Path.Combine(rootPath, "Realms");
+            string requestRealm = Path.Combine(realmsPath, Realm);
+            string requestedRealmZones = Path.Combine(requestRealm, "Zones");
+            string requestedZone = Path.Combine(requestedRealmZones, Zone);
+
+            return requestedZone;
+        }
+
+        public static string GetDataPath(string Realm, string Zone, string Room)
+        {
+            return System.IO.Path.Combine(GetDataPath(Realm, Zone), Room);
+        }
+
+        //TODO Write CopyDirectory method.
+    }
+}

MudEngine/FileSystem/SaveDataTypes.cs

@@ -0,0 +1,10 @@
+namespace MudEngine.FileSystem
+{
+    public enum SaveDataTypes
+    {
+        Root,
+        Currencies,
+        Realms,
+        Zones,
+    }
+}

MudEngine/FileSystem/XmlSerialization.cs

@@ -0,0 +1,40 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.Xml.Serialization;
+
+namespace MudEngine.FileSystem
+{
+    internal class XmlSerialization
+    {
+        internal static void Save(string Filename, object o)
+        {
+            Stream stream = File.Create(Filename);
+
+            XmlSerializer serializer = new XmlSerializer(o.GetType());
+            serializer.Serialize(stream, o);
+            stream.Close();
+        }
+
+
+        /// <summary>
+        /// Loads an item via Xml Deserialization
+        /// </summary>
+        /// <param name="Filename">The Xml document to deserialize.</param>
+        /// <returns></returns>
+        internal static object Load(string Filename, object o)
+        {
+            Stream stream = File.OpenRead(Filename);
+
+            object obj = new object();
+            XmlSerializer serializer = new XmlSerializer(o.GetType());
+            obj = (object)serializer.Deserialize(stream);
+
+            stream.Close();
+            return obj;
+        }
+    }
+}

MudEngine/GameManagement/GameSetup.cs

@@ -0,0 +1,167 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ComponentModel;
+using System.Xml.Serialization;
+using System.Xml;
+using System.IO;
+
+//MUD Engine
+using MudEngine.FileSystem;
+using MudEngine.GameObjects;
+using MudEngine.GameObjects.Environment;
+
+namespace MudEngine.GameManagement
+{
+    /// <summary>
+    /// Manages all of the projects settings.
+    /// </summary>
+    [XmlInclude(typeof(StartingLocation))]
+    [XmlInclude(typeof(Currency))]
+    public class GameSetup
+    {
+        public enum TimeOfDayOptions
+        {
+            AlwaysDay,
+            AlwaysNight,
+            Transition,
+        }
+
+        [Category("Company Settings")]
+        [Description("The name of the Company or Author building the game.")]
+        /// <summary>
+        /// Gets or Sets the name of the company
+        /// </summary>
+        public string CompanyName { get; set; }
+
+        [Category("Company Settings")]
+        [Description("The website URL that a player can visit to view additional information related to the game")]
+        /// <summary>
+        /// Gets or Sets the companies website for this project
+        /// </summary>
+        public string Website { get; set; }
+
+        [Category("Project Settings")]
+        [Description("The name of the game displayed to the users, and title bar of the runtime.")]
+        public string GameTitle { get; set; }
+
+        [Category("Project Settings")]
+        [Description("Enable or Disable Auto-saving of players when the player travels")]
+        /// <summary>
+        /// Gets or Sets if the game autosaves when the player changes locations.
+        /// </summary>
+        public bool AutoSave { get; set; }
+
+        [Category("Project Settings")]
+        [Description("Hide Room names from being outputted to the console.")]
+        /// <summary>
+        /// Gets or Sets if room names are hidden during console output.
+        /// </summary>
+        public bool HideRoomNames { get; set; }
+
+        [Category("Day Management")]
+        [Description("Set what time of day the world will take place in.")]
+        public TimeOfDayOptions TimeOfDay
+        {
+            get;
+            set;
+        }
+
+        [Category("Day Management")]
+        [Description("Set how long in minutes it takes to transition from day to night.")]
+        public int TimeOfDayTransition
+        {
+            get;
+            set;
+        }
+
+        [Category("Day Management")]
+        [Description("Sets how long in minutes a day lasts in the game world.")]
+        public int DayLength
+        {
+            get;
+            set;
+        }
+
+        [Category("Project Settings")]
+        [Description("The current working version of the game.")]
+        public string Version { get; set; }
+
+        [Category("Game Currency")]
+        [DefaultValue(1)]
+        [Description("Sets the amount that the base currency is valued at.")]
+        public uint BaseCurrencyAmount { get; set; }
+
+
+        [Category("Game Currency")]
+        [DefaultValue("Copper")]
+        public string BaseCurrencyName { get; set; }
+
+
+
+        //TODO: Add Party support.
+        [Category("Project Settings")]
+        [Description("If enabled, all objects will be loaded during server startup resulting in a slower server start time, but faster load time during gameplay")]
+        public bool PreCacheObjects { get; set; }
+
+        [Browsable(false)]
+        public List<Currency> CurrencyList { get; set; }
+
+        [Browsable(false)]
+        public string ProjectPath { get; set; }
+
+        [Category("Environment Settings")]
+        [ReadOnly(true)]
+        public StartingLocation InitialLocation { get; set; }
+
+        [Browsable(false)]
+        public string Story
+        {
+            get;
+            set;
+        }
+
+        [Category("Object Setup")]
+        public string Filename
+        {
+            get
+            {
+                return _Filename;
+            }
+        }
+        private string _Filename;
+
+        public GameSetup()
+        {
+            CurrencyList = new List<Currency>();
+            GameTitle = "New Game";
+            _Filename = "Game.xml";
+            BaseCurrencyAmount = 1;
+            BaseCurrencyName = "Copper";
+            InitialLocation = new StartingLocation();
+        }
+
+        public void Save(string filename)
+        {
+            string directory = Path.GetDirectoryName(filename);
+
+            if (!Directory.Exists(directory))
+                Directory.CreateDirectory(directory);
+
+            FileManager.Save(filename, this);
+        }
+
+        public object Load(string path)
+        {
+            string fileName = Path.Combine(path, _Filename);
+            if (!File.Exists(fileName))
+            {
+                return null;
+            }
+
+            return FileManager.Load(fileName, this);
+        }
+    }
+}

MudEngine/GameObjects/Bag.cs

@@ -0,0 +1,36 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+//MUD Engine
+using MudEngine.GameObjects.Items;
+
+namespace MudEngine.GameObjects
+{
+    public class Bag : BaseObject
+    {
+        /// <summary>
+        /// Gets or Sets the size of the bag.
+        /// </summary>
+        public int Size
+        {
+            get;
+            set;
+        }
+
+        private List<Items.BaseItem> Items { get; set; }
+
+        public void Add(BaseItem item)
+        {
+            if (Items.Count < Size)
+                Items.Add(item);
+        }
+
+        public int GetSlotsRemaining()
+        {
+            return Size - Items.Count;
+        }
+    }
+}

MudEngine/GameObjects/BaseObject.cs

@@ -0,0 +1,194 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ComponentModel;
+using System.Xml.Serialization;
+using System.IO;
+
+//MUD Engine
+using MudEngine.FileSystem;
+
+namespace MudEngine.GameObjects
+{
+    public class BaseObject
+    {
+        [Category("Object Setup")]
+        [Description("The Display Name assigned to this object.")]
+        //Required to refresh Filename property in the editors propertygrid
+        [RefreshProperties(RefreshProperties.All)]
+        public string Name
+        {
+            get
+            {
+                return this._Name;
+            }
+            set
+            {
+                this._Name = value;
+                this.Filename = value + "." + this.GetType().Name;
+            }
+        }
+
+        [Category("Object Setup")]
+        [Description("A brief description of this object. The description is displayed to users when they use a command for investigating an object")]
+        public string Description
+        {
+            get;
+            set;
+        }
+
+        [Category("Object Setup")]
+        [Description("The object script that can manipulate the object during the games life.")]
+        //[EditorAttribute(typeof(UIScriptEditor), typeof(System.Drawing.Design.UITypeEditor))]
+        public string Script { get; set; }
+
+        [Category("Object Setup")]
+        [ReadOnly(true)]
+        [Description("The filename of the current object. This is assigned by the engine and not editable.")]
+        public string Filename
+        {
+            //Returns the name of the object + the objects Type as it's extension.
+            //Filenames are generated by the class itself, users can not assign it.
+            get
+            {
+                return this._Filename;
+            }
+            set
+            {
+                string extension = "." + this.GetType().Name;
+                if (!value.EndsWith(extension))
+                    value += extension;
+
+                this._Filename = value;
+            }
+        }
+
+        [Category("Environment Information")]
+        [Description("If a user asks to use his/her senses to investigate an area, this is one of the results that will be displayed. Senses can be used to assist blind characters.")]
+        [DefaultValue("You don't smell anything unsual.")]
+        public string Smell
+        {
+            get;
+            set;
+        }
+
+        [Category("Environment Information")]
+        [Description("If a user asks to use his/her senses to investigate an area, this is one of the results that will be displayed. Senses can be used to assist blind characters.")]
+        [DefaultValue("You hear nothing of interest.")]
+        public string Listen
+        {
+            get;
+            set;
+        }
+
+        [Category("Environment Information")]
+        [Description("If a user asks to use his/her senses to investigate an area, this is one of the results that will be displayed. Senses can be used to assist blind characters.")]
+        [DefaultValue("You feel nothing.")]
+        public string Feel
+        {
+            get;
+            set;
+        }
+
+        private string _Filename = "";
+        private string _Name = "";
+
+        /// <summary>
+        /// Initializes the base object
+        /// </summary>
+        public BaseObject()
+        {
+            Script = "";
+            _Name = "New " + this.GetType().Name;
+            _Filename = _Name + "." + this.GetType().Name;
+
+            this.Feel = "You feel nothing.";
+            this.Listen = "You hear nothing of interest.";
+            this.Smell = "You don't smell anything unsual.";
+            this.Name = DefaultName();
+        }
+
+        private bool ShouldSerializeName()
+        {
+            return this.Name != DefaultName();
+        }
+
+        private void ResetName()
+        {
+            this.Name = DefaultName();
+        }
+
+        private string DefaultName()
+        {
+            return "New " + this.GetType().Name;
+        }
+
+        #region Public Methods
+        /// <summary>
+        /// Loads the supplied filename and returns it.
+        /// </summary>
+        /// <param name="filename"></param>
+        /// <returns></returns>
+        public virtual object Load(string filename)
+        {
+            if (!File.Exists(filename))
+            {
+                return null;
+            }
+
+            return FileManager.Load(filename, this);
+        }
+
+        /// <summary>
+        /// Saves the current object with the supplied filename
+        /// </summary>
+        /// <param name="filename"></param>
+        public void Save(string filename)
+        {
+            string directory = Path.GetDirectoryName(filename);
+            if (!Directory.Exists(directory))
+                Directory.CreateDirectory(directory);
+            FileManager.Save(filename, this);
+        }
+
+        public override string ToString()
+        {
+            return this.Name;
+        }
+
+        public virtual void OnEnter()
+        {
+        }
+
+        public virtual void OnExit()
+        {
+        }
+
+        public virtual void OnCreate()
+        {
+        }
+
+        public virtual void OnDestroy()
+        {
+        }
+
+        public virtual void OnEquip()
+        {
+        }
+
+        public virtual void OnUnequip()
+        {
+        }
+
+        public virtual void OnMount()
+        {
+        }
+
+        public virtual void OnDismount()
+        {
+        }
+        #endregion
+    }
+}

MudEngine/GameObjects/Characters/BaseCharacter.cs

@@ -0,0 +1,30 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+//MUD Engine
+using MudEngine.FileSystem;
+using MudEngine.Commands;
+using MudEngine.GameManagement;
+using MudEngine.GameObjects;
+using MudEngine.GameObjects.Environment;
+using MudEngine.GameObjects.Items;
+
+namespace MudEngine.GameObjects.Characters
+{
+    public class BaseCharacter : BaseObject
+    {
+        public Room CurrentRoom { get; set; }
+
+        public virtual void OnTravel(AvailableTravelDirections travelDirection)
+        {
+            if (CurrentRoom.DoorwayExist(travelDirection.ToString()))
+            {
+                string connectedRoom = CurrentRoom.GetDoor(travelDirection).ConnectedRoom;
+                CurrentRoom = (Room)CurrentRoom.Load(connectedRoom);
+            }
+        }
+    }
+}

MudEngine/GameObjects/Currency.cs

@@ -0,0 +1,30 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ComponentModel;
+
+namespace MudEngine.GameObjects
+{
+    public class Currency : BaseObject
+    {
+        [Category("Currency Settings")]
+        [Description("The value of the currency is based off the BaseCurrencyValue set in the Project Information. If BaseCurrencyValue is 1, and a new Currency is 10, then it will take 10 BaseCurrency to equal 1 of the new Currencies.")]
+        [DefaultValue(100)]
+        /// <summary>
+        /// The value of this currency. It should be how many 'base currency' it takes to equal 1 of this currency
+        /// </summary>
+        public int Value
+        {
+            get;
+            set;
+        }
+
+        public Currency()
+        {
+            this.Name = "New Currency";
+            this.Value = 100;
+        }
+    }
+}

MudEngine/GameObjects/Environment/Door.cs

@@ -0,0 +1,65 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Serialization;
+using System.ComponentModel;
+
+//MUD Engine
+using MudEngine.GameObjects.Items;
+
+namespace MudEngine.GameObjects.Environment
+{
+    [XmlInclude(typeof(BaseItem))]
+    [Serializable]
+    public class Door
+    {
+        [Category("Door Settings")]
+        [DefaultValue(false)]
+        public bool IsLocked
+        {
+            get;
+            set;
+        }
+
+        [Category("Door Settings")]
+        [Browsable(false)]
+        public BaseItem RequiredKey
+        {
+            get;
+            set;
+        }
+
+        [Category("Door Settings")]
+        [DefaultValue(0)]
+        public int LevelRequirement
+        {
+            get;
+            set;
+        }
+
+        [Category("Door Settings")]
+        public AvailableTravelDirections TravelDirection { get; set; }
+
+        public string ConnectedRoom { get; set; }
+
+        [Category("Environment Information")]
+        [Description("The description displayed to the user when a 'Look' command is used.")]
+        public string Description { get; set; }
+
+        public Door()
+        {
+            LevelRequirement = 0;
+            IsLocked = false;
+            RequiredKey = new BaseItem();
+        }
+
+        public Door(AvailableTravelDirections travelDirection, string connectedRoom)
+            : this()
+        {
+            ConnectedRoom = connectedRoom;
+            TravelDirection = travelDirection;
+        }
+    }
+}

MudEngine/GameObjects/Environment/Realm.cs

@@ -0,0 +1,47 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.IO;
+using System.ComponentModel;
+
+//MUD Engine
+using MudEngine.FileSystem;
+using MudEngine.GameObjects;
+
+namespace MudEngine.GameObjects.Environment
+{
+    public class Realm : BaseObject
+    {
+
+        [Category("Environment Information")]
+        [Description("A collection of Zones that are contained within this Realm. Players can traverse the world be traveling through Rooms that are contained within Zones. Note that it is not required to place a Zone into a Realm.")]
+        //[EditorAttribute(typeof(UIRealmEditor), typeof(System.Drawing.Design.UITypeEditor))]
+        public List<string> Zones { get; set; }
+
+        public Realm()
+        {
+            Zones = new List<string>();
+        }
+
+        /// <summary>
+        /// Returns the requested Zone if the Zone exists within this Realm.
+        /// </summary>
+        /// <param name="zoneName"></param>
+        /// <returns></returns>
+        public Zone GetZone(string filename)
+        {
+            var filterQuery =
+                from zone in Zones
+                where zone == filename
+                select zone;
+
+            Zone z = new Zone();
+            foreach (var zone in filterQuery)
+                return (Zone)z.Load(zone); ;
+
+            return null;
+        }
+    }
+}

MudEngine/GameObjects/Environment/Room.cs

@@ -0,0 +1,187 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections;
+using System.ComponentModel;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml.Serialization;
+using System.IO;
+
+//MUD Engine
+using MudEngine.FileSystem;
+
+namespace MudEngine.GameObjects.Environment
+{
+    [XmlInclude(typeof(Door))]
+    public class Room : BaseObject
+    {
+        [Category("Environment Information")]
+        [Description("Shows what rooms are currently created and linked to within this Room.")]
+        [ReadOnly(true)]
+        public string InstalledDoorways
+        {
+            get
+            {
+                string installed = "";
+                if (this.Doorways.Count != 0)
+                {
+                    foreach (Door d in Doorways)
+                    {
+                        installed += d.TravelDirection.ToString() + ",";
+                    }
+                    if (Doorways.Count >= 2)
+                    {
+                        installed = installed.Substring(0, installed.Length - 1);
+                    }
+                    return installed;
+                }
+                else
+                    return "None Installed.";
+            }
+        }
+
+        [Category("Environment Information")]
+        [Description("Allows for linking of Rooms together via Doorways")]
+        //[EditorAttribute(typeof(UIDoorwayEditor), typeof(UITypeEditor))]
+        [RefreshProperties(RefreshProperties.All)]
+        public List<Door> Doorways
+        {
+            get;
+            set;
+        }
+
+        [ReadOnly(true)]
+        [Description("This is the Zone that the Room is currently assigned to.")]
+        [Category("Environment Information")]
+        public string Zone
+        {
+            get;
+            set;
+        }
+
+        [ReadOnly(true)]
+        [Description("This is the Realm that the Room belongs to.")]
+        [Category("Environment Information")]
+        public string Realm
+        {
+            get;
+            set;
+        }
+
+        [Category("Environment Information")]
+        [DefaultValue(false)]
+        [Description("Determins if the Player can be attacked within this Room or not.")]
+        public bool IsSafe
+        {
+            get;
+            set;
+        }
+
+        [Browsable(false)]
+        public string InstallPath
+        {
+            get
+            {
+                string zonePath = "";
+                if (this.Realm == null || this.Realm == "No Realm Associated.")
+                {
+                    zonePath = FileManager.GetDataPath(SaveDataTypes.Zones);
+                    zonePath = Path.Combine(zonePath, this.Zone);
+                }
+                else
+                    zonePath = FileManager.GetDataPath(this.Realm, this.Zone);
+
+                string roomPath = Path.Combine(zonePath, "Rooms");
+                string filename = Path.Combine(roomPath, this.Filename);
+                return filename;
+            }
+        }
+
+        public Room()
+        {
+            Doorways = new List<Door>();
+
+            IsSafe = false;
+        }
+
+        public bool DoorwayExist(string travelDirection)
+        {
+            foreach (Door door in Doorways)
+            {
+                if (door.TravelDirection.ToString().ToLower() == travelDirection.ToLower())
+                    return true;
+            }
+
+            return false;
+        }
+
+        public Door GetDoor(AvailableTravelDirections travelDirection)
+        {
+            foreach (Door door in this.Doorways)
+            {
+                if (door.TravelDirection == travelDirection)
+                    return door;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Load a Room that exists within the same Zone as the current Room
+        /// </summary>
+        /// <param name="roomName"></param>
+        /// <returns></returns>
+        public override object Load(string roomName)
+        {
+            //Correct the roomname incase it doesnt contain a file extension
+            if (!roomName.ToLower().EndsWith(".room"))
+                roomName += ".room";
+
+            //If the current room does not belong within a Realm, then load it from the
+            //Zones root directory
+            if (this.Realm != null || this.Realm != "No Realm Associated.")
+            {
+                return this.Load(roomName, this.Zone);
+            }
+            //This Zone is contained within a Realm so we have to load it from within the
+            //Realm and not from within the Zones root directory
+            else
+                return this.Load(roomName, this.Zone, this.Realm);
+        }
+
+        public object Load(string roomName, string zoneName)
+        {
+            string filename = "";
+            if (!roomName.ToLower().EndsWith(".room"))
+                roomName += ".room";
+
+            if (this.Realm != null && this.Realm != "No Realm Associated.")
+            {
+                return this.Load(roomName, zoneName, this.Realm);
+            }
+            else
+                filename = FileManager.GetDataPath(SaveDataTypes.Zones);
+
+            filename = Path.Combine(filename, zoneName);
+            filename = Path.Combine(filename, "Rooms");
+            filename = Path.Combine(filename, roomName);
+
+            return base.Load(filename);
+        }
+
+        public object Load(string roomName, string zoneName, string realmName)
+        {
+            if (!roomName.ToLower().EndsWith(".room"))
+                roomName += ".room";
+
+            string filename = FileManager.GetDataPath(realmName, zoneName);
+            filename = Path.Combine(filename, "Rooms");
+            filename = Path.Combine(filename, roomName);
+
+            if (realmName == null || realmName == "No Realm Associated.")
+                return this.Load(roomName, zoneName);
+
+            return base.Load(filename);
+        }
+    }
+}

MudEngine/GameObjects/Environment/StartingLocation.cs

@@ -0,0 +1,32 @@
+//MUD Engine
+using MudEngine.FileSystem;
+using MudEngine.GameObjects;
+using MudEngine.GameObjects.Environment;
+
+namespace MudEngine.GameObjects.Environment
+{
+    public struct StartingLocation
+    {
+        public string Room;
+        public string Zone;
+        public string Realm;
+
+        public override string ToString()
+        {
+            if (string.IsNullOrEmpty(Room))
+                return "No initial location defined.";
+            else
+            {
+                if (Realm == "No Realm Associated.")
+                {
+                    return Zone + "->" + Room;
+                }
+                else
+                {
+                    return Realm + "->" + Zone + "->" + Room;
+                }
+            }
+
+        }
+    }
+}

MudEngine/GameObjects/Environment/TravelDirections.cs

@@ -0,0 +1,57 @@
+//Microsoft .NET Framework
+using System;
+
+namespace MudEngine.GameObjects
+{
+    public enum AvailableTravelDirections
+    {
+        None = 0,
+        North,
+        South,
+        East,
+        West,
+        Up,
+        Down,
+    }
+
+    public static class TravelDirections
+    {
+        public static AvailableTravelDirections GetReverseDirection(AvailableTravelDirections Direction)
+        {
+            switch (Direction)
+            {
+                case AvailableTravelDirections.Down:
+                    return AvailableTravelDirections.Up;
+                case AvailableTravelDirections.East:
+                    return AvailableTravelDirections.West;
+                case AvailableTravelDirections.None:
+                    return AvailableTravelDirections.None;
+                case AvailableTravelDirections.North:
+                    return AvailableTravelDirections.South;
+                case AvailableTravelDirections.South:
+                    return AvailableTravelDirections.North;
+                case AvailableTravelDirections.Up:
+                    return AvailableTravelDirections.Down;
+                case AvailableTravelDirections.West:
+                    return AvailableTravelDirections.East;
+                default:
+                    return AvailableTravelDirections.None;
+            }
+        }
+
+        public static AvailableTravelDirections GetTravelDirectionValue(string Direction)
+        {
+            Array values = Enum.GetValues(typeof(AvailableTravelDirections));
+
+            foreach (int value in values)
+            {
+                string displayName = Enum.GetName(typeof(AvailableTravelDirections), value);
+
+                if (displayName.ToLower() == Direction.ToLower())
+                    return (AvailableTravelDirections)Enum.Parse(typeof(AvailableTravelDirections), displayName);
+            }
+
+            return AvailableTravelDirections.None;
+        }
+    }
+}

MudEngine/GameObjects/Environment/Zone.cs

@@ -0,0 +1,124 @@
+//Microsoft .NET Framework
+using System;
+using System.IO;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.ComponentModel;
+using System.Xml.Serialization;
+
+//MUD Engine
+using MudEngine.FileSystem;
+using MudEngine.GameObjects;
+
+namespace MudEngine.GameObjects.Environment
+{
+    [XmlInclude(typeof(Room))]
+    public class Zone : BaseObject
+    {
+        [Category("Environment Information")]
+        [DefaultValue(0)]
+        [Description("The amount to drain each stat by if StatDrain is enabled.")]
+        public int StatDrainAmount
+        {
+            get;
+            set;
+        }
+
+        [Category("Environment Information")]
+        [Description("Enable or Disable the ability for draining stats while traversing.")]
+        [DefaultValue(false)]
+        public bool StatDrain
+        {
+            get;
+            set;
+        }
+
+        [ReadOnly(true)]
+        [Category("Environment Information")]
+        [Description("The Realm that this Zone is assigned to. It is not required to be contained within a Realm.")]
+        public string Realm
+        {
+            get;
+            set;
+        }
+
+        [Category("Environment Information")]
+        [Description("Determins if the Player can be attacked within this Room or not.")]
+        [DefaultValue(false)]
+        public bool IsSafe
+        {
+            get;
+            set;
+        }
+
+        [Category("Environment Information")]
+        //[EditorAttribute(typeof(UIRoomEditor), typeof(UITypeEditor))]
+        [Description("Collection of Rooms that have been created. Editing the Rooms Collection lets you manage the Zones rooms.")]
+        public List<string> Rooms { get; set; }
+
+        [Category("Environment Information")]
+        public string EntranceRoom { get; set; }
+
+        public Zone()
+        {
+            Rooms = new List<string>();
+            IsSafe = false;
+            Realm = "No Realm Associated.";
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="RoomName"></param>
+        /// <returns></returns>
+        public Room GetRoomByName(string name)
+        {
+            var filterQuery =
+                from room in Rooms
+                where room == name
+                select room;
+
+            foreach (string room in filterQuery)
+            {
+                Room r = new Room();
+                return (Room)r.Load(room, this.Name);
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Clears out the Zones room collection and re-builds it.
+        /// This is a time consuming process if there are a large amount of
+        /// of rooms, use sparingly.
+        /// </summary>
+        public void RebuildRoomCollection()
+        {
+            Rooms = new List<string>();
+            //Create our collection of Rooms.
+            string realmPath = Path.Combine(FileManager.GetDataPath(SaveDataTypes.Realms), this.Realm);
+            string zonePath = Path.Combine(realmPath, this.Name);
+
+            //incase the zone hasn't been saved yet.
+            if (!Directory.Exists(zonePath))
+                return;
+
+            //Zone exists, so it's already been saved.
+            string[] rooms = Directory.GetFiles(zonePath, "*.room");
+
+            //Clear the existing collection of Rooms
+            this.Rooms.Clear();
+            //Build a new one based off of the files 
+            foreach (string file in rooms)
+            {
+                Room r = new Room();
+                r = (Room)r.Load(Path.GetFileNameWithoutExtension(file));
+                //r = (Room)FileManager.Load(file, r);
+                this.Rooms.Add(r.Name);
+            }
+
+            //Save the re-built Room collection
+            this.Save(Path.Combine(zonePath, this.Filename));
+        }
+    }
+}

MudEngine/GameObjects/Items/BaseItem.cs

@@ -0,0 +1,13 @@
+//Microsoft .NET Framework
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MudEngine.GameObjects.Items
+{
+    public class BaseItem : BaseObject
+    {
+
+    }
+}

MudEngine/MudEngine.csproj

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{498943A8-DF5A-4DB0-B506-0BFF44788657}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>MudEngine</RootNamespace>
+    <AssemblyName>MudEngine</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Commands\CommandEngine.cs" />
+    <Compile Include="Commands\CommandResults.cs" />
+    <Compile Include="Commands\ICommand.cs" />
+    <Compile Include="FileSystem\FileManager.cs" />
+    <Compile Include="FileSystem\SaveDataTypes.cs" />
+    <Compile Include="FileSystem\XmlSerialization.cs" />
+    <Compile Include="GameManagement\GameSetup.cs" />
+    <Compile Include="GameObjects\Bag.cs" />
+    <Compile Include="GameObjects\BaseObject.cs" />
+    <Compile Include="GameObjects\Characters\BaseCharacter.cs" />
+    <Compile Include="GameObjects\Environment\Door.cs" />
+    <Compile Include="GameObjects\Environment\Realm.cs" />
+    <Compile Include="GameObjects\Environment\Room.cs" />
+    <Compile Include="GameObjects\Environment\StartingLocation.cs" />
+    <Compile Include="GameObjects\Environment\TravelDirections.cs" />
+    <Compile Include="GameObjects\Environment\Zone.cs" />
+    <Compile Include="GameObjects\Items\BaseItem.cs" />
+    <Compile Include="GameObjects\Currency.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Folder Include="GameObjects\Characters\Controlled\" />
+    <Folder Include="GameObjects\Characters\NPC\" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

MudEngine/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("MudEngine")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("MudEngine")]
+[assembly: AssemblyCopyright("Copyright ©  2010")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7e3ecd0a-9fef-4389-8b5e-cb7a77cd0501")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]