Added more rooms

AdminModule/AdminModule.csproj

@@ -31,6 +31,9 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="SharpRuleEngine">
+      <HintPath>..\packages\SharpRuleEngine.1.0.5\lib\SharpRuleEngine.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -40,8 +43,12 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Cons.cs" />
     <Compile Include="Dump.cs" />
+    <Compile Include="DumpMessages.cs" />
     <Compile Include="Force.cs" />
+    <Compile Include="Properties.cs" />
+    <Compile Include="Set.cs" />
     <Compile Include="Scope.cs" />
     <Compile Include="Inspect.cs" />
     <Compile Include="Instance.cs" />
@@ -57,6 +64,9 @@
     </Compile>
     <Compile Include="Stats.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Core\Core.csproj">
       <Project>{5c29e6ad-54e3-4105-a9f3-2aab48a17c41}</Project>

AdminModule/Cons.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using RMUD;
+
+namespace AdminModule
+{
+	internal class Cons : CommandFactory
+	{
+		public override void Create(CommandParser Parser)
+		{
+            Core.StandardMessage("cons", "Results of consistency check:");
+            Core.StandardMessage("cons no results", "I found nothing wrong.");
+
+            Parser.AddCommand(
+                Sequence(
+                    KeyWord("!CONS"),
+                    Optional(KeyWord("LOCAL"), "LOCAL")))
+                .ID("Meta:Cons")
+                .Manual("Scan all defined commands for ommissions, then scan loaded objects for omissions.")
+                .ProceduralRule((match, actor) =>
+                {
+                    var localScan = false;
+                    if (match.ContainsKey("LOCAL"))
+                        localScan = (match["LOCAL"] as bool?).Value;
+
+                    var resultsFound = 0;
+
+                    MudObject.SendMessage(actor, "@cons");
+
+                    if (!localScan)
+                        foreach (var command in Core.DefaultParser.EnumerateCommands())
+                        {
+                            if (String.IsNullOrEmpty(command.GetID())) 
+                            {
+                                resultsFound += 1;
+                                MudObject.SendMessage(actor, "Command has no ID set: " + command.ManualName + " from " + command.SourceModule);
+                            }
+                        }
+
+                    if (resultsFound == 0)
+                        MudObject.SendMessage(actor, "@cons no results");
+
+
+                    return SharpRuleEngine.PerformResult.Continue;
+                });
+
+		}
+	}
+}

AdminModule/Dump.cs

@@ -25,7 +25,7 @@ public override void Create(CommandParser Parser)
                             MudObject.SendMessage(actor, "Could not display source: " + source.Item2);
                         else
                             MudObject.SendMessage(actor, "Source of " + target + "\n" + source.Item2);
-                    return PerformResult.Continue;
+                        return SharpRuleEngine.PerformResult.Continue;
                 });
         }
     }

Core/Core/Meta/DumpMessages.cs → AdminModule/DumpMessages.cs

@@ -2,8 +2,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using RMUD;
 
-namespace RMUD.Modules.Meta
+namespace AdminModule
 {
 	internal class DumpMessages : CommandFactory
 	{
@@ -18,7 +19,7 @@ public override void Create(CommandParser Parser)
                     Core.DumpMessagesForCustomization(builder);
                     System.IO.File.WriteAllText("messages.txt", builder.ToString());
                     MudObject.SendMessage(actor, "Messages dumped to messages.txt.");
-                    return PerformResult.Continue;
+                    return SharpRuleEngine.PerformResult.Continue;
                 });
 		}
 	}

AdminModule/Force.cs

@@ -28,25 +28,18 @@ public override void Create(CommandParser Parser)
                             if (target == null)
                             {
                                 MudObject.SendMessage(actor, "I can't find whomever it is you want to submit to your foolish whims.");
-                                return PerformResult.Stop;
+                                return SharpRuleEngine.PerformResult.Stop;
                             }
                             match.Upsert("OBJECT", target);
                         }
-                        return PerformResult.Continue;
+                        return SharpRuleEngine.PerformResult.Continue;
                     }, "Convert path to object rule.")
                 .ProceduralRule((match, actor) =>
                 {
                     MudObject target = match["OBJECT"] as MudObject;
 
-                    var targetActor = target as Actor;
-                    if (targetActor == null)
-                    {
-                        MudObject.SendMessage(actor, "You can order inanimate objects about as much as you like, they aren't going to listen.");
-                        return PerformResult.Stop;
-                    }
-
                     var command = match["RAW-COMMAND"].ToString();
-                    var matchedCommand = Core.DefaultParser.ParseCommand(new PendingCommand { RawCommand = command, Actor = targetActor });
+                    var matchedCommand = Core.DefaultParser.ParseCommand(new PendingCommand { RawCommand = command, Actor = target });
 
                     if (matchedCommand != null)
                     {
@@ -55,13 +48,13 @@ public override void Create(CommandParser Parser)
                         else
                         {
                             MudObject.SendMessage(actor, "Enacting your will.");
-                            Core.ProcessPlayerCommand(matchedCommand.Command, matchedCommand.Matches[0], targetActor);
+                            Core.ProcessPlayerCommand(matchedCommand.Command, matchedCommand.Matches[0], target);
                         }
                     }
                     else
                         MudObject.SendMessage(actor, "The command did not match.");
 
-                    return PerformResult.Continue;
+                    return SharpRuleEngine.PerformResult.Continue;
                 });
         }
 	}

AdminModule/Inspect.cs

@@ -23,72 +23,32 @@ public override void Create(CommandParser Parser)
                     {
                         if (!match.ContainsKey("OBJECT"))
                             match.Upsert("OBJECT", actor.Location);
-                        return PerformResult.Continue;
+                        return SharpRuleEngine.PerformResult.Continue;
                     }, "Convert locale option to standard form rule.")
                 .ProceduralRule((match, actor) =>
                 {
                     var target = match["OBJECT"] as MudObject;
-                    MudObject.SendMessage(actor, target.GetType().Name);
 
-                    foreach (var @interface in target.GetType().GetInterfaces())
-                        MudObject.SendMessage(actor, "Implements " + @interface.Name);
+                    MudObject.SendMessage(actor, "*** INSPECT LISTING ***");
+                    MudObject.SendMessage(actor, "Path: <s0>", target.Path);
+                    MudObject.SendMessage(actor, "Instance: <s0>", target.Instance);
+                    MudObject.SendMessage(actor, "Persistent: <s0>", target.IsPersistent.ToString());
+                    if (target.Location == null)
+                        MudObject.SendMessage(actor, "Location: NOWHERE");
+                    else
+                        MudObject.SendMessage(actor, "Location: <s0>", target.Location.GetFullName());
+                    MudObject.SendMessage(actor, "*** DYNAMIC PROPERTIES ***");
 
-                    foreach (var field in target.GetType().GetFields())
-                        MudObject.SendMessage(actor, "field " + field.FieldType.Name + " " + field.Name + " = " + WriteValue(field.GetValue(target)));
-
-                    foreach (var property in target.GetType().GetProperties())
+                    foreach (var property in target.Properties)
                     {
-                        var s = (property.CanWrite ? "property " : "readonly ") + property.PropertyType.Name + " " + property.Name;
-                        if (property.CanRead)
-                        {
-                            s += " = ";
-                            try
-                            {
-                                s += WriteValue(property.GetValue(target, null));
-                            }
-                            catch (Exception) { s += "[Error reading value]"; }
-                        }
-                        MudObject.SendMessage(actor, s);
+                        var info = PropertyManifest.GetPropertyInformation(property.Key);
+                        MudObject.SendMessage(actor, "<s0>: <s1>", property.Key, info.Converter.ConvertToString(property.Value));
                     }
 
-                    return PerformResult.Continue;
-                }, "List all the damn things rule.");
-        }
+                    MudObject.SendMessage(actor, "*** END OF LISTING ***");
 
-        private static String WriteValue(Object Value, int indent = 1)
-        {
-            if (Value == null)
-                return "NULL";
-            else if (Value is String)
-                return "\"" + Value + "\"";
-            else if (Value is MudObject)
-            {
-                return (Value as MudObject).GetFullName();
-            }
-            else if (Value is KeyValuePair<String, Object>)
-            {
-                var v = (Value as KeyValuePair<String, Object>?).Value;
-                return v.Key + ": " + WriteValue(v.Value, indent + 1);
-            }
-            else if (Value is KeyValuePair<RelativeLocations, List<MudObject>>) //Containers..
-            {
-                var v = (Value as KeyValuePair<RelativeLocations, List<MudObject>>?).Value;
-                return v.Key + ": " + WriteValue(v.Value, indent + 1);
-            }
-            else if (Value is System.Collections.IEnumerable)
-            {
-                var r = "[ ";
-                bool first = true;
-                foreach (var sub in (Value as System.Collections.IEnumerable))
-                {
-                    if (!first) r += "\n" + new String(' ', indent * 2);
-                    first = false;
-                    r += WriteValue(sub, indent + 1);
-                }
-                r += " ] ";
-                return r;
-            }
-            else return Value.ToString();
+                    return SharpRuleEngine.PerformResult.Continue;
+                }, "List all the damn things rule.");
         }
 	}
 }

AdminModule/Instance.cs

@@ -27,7 +27,7 @@ public override void Create(CommandParser Parser)
                         MudObject.Move(newObject, actor);
                         MudObject.SendMessage(actor, "Instanced " + path + ".");
                     }
-                    return PerformResult.Continue;
+                    return SharpRuleEngine.PerformResult.Continue;
                 });
         }
     }

AdminModule/Move.cs

@@ -34,7 +34,7 @@ public override void Create(CommandParser Parser)
                     }
                     else
                         MudObject.SendMessage(actor, "I could not find the destination.");
-                    return PerformResult.Continue;
+                    return SharpRuleEngine.PerformResult.Continue;
                 });
         }
     }

AdminModule/Properties.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using RMUD;
+using SharpRuleEngine;
+
+namespace AdminModule
+{
+    internal class Properties : CommandFactory
+    {
+        public override void Create(CommandParser Parser)
+        {
+            Parser.AddCommand(
+                Sequence(
+                    RequiredRank(500),
+                    KeyWord("!PROPERTIES")))
+                .Manual("List all properties that have been registered.")
+                .ProceduralRule((match, actor) =>
+                {
+                    foreach (var prop in PropertyManifest.GetAllPropertyInformation())
+                    {
+                        MudObject.SendMessage(actor, "<s0> (<s1>) : <s2>", prop.Key, prop.Value.Type.ToString(), prop.Value.Converter.ConvertToString(prop.Value.DefaultValue));
+                    }
+
+                    return PerformResult.Continue;
+                });
+        }
+
+    }
+}

AdminModule/ReadLog.cs

@@ -28,7 +28,7 @@ public override void Create(CommandParser Parser)
                     }
                     else
                         MudObject.SendMessage(actor, "I could not find that log file.");
-                    return PerformResult.Continue;
+                    return SharpRuleEngine.PerformResult.Continue;
                 });
         }
     }

AdminModule/Reload.cs

@@ -23,7 +23,7 @@ public override void Create(CommandParser Parser)
                     var newObject = Core.Database.ReloadObject(target);
                     if (newObject == null) MudObject.SendMessage(actor, "Failed to reload " + target);
                     else MudObject.SendMessage(actor, "Reloaded " + target);
-                    return PerformResult.Continue;
+                    return SharpRuleEngine.PerformResult.Continue;
                 });
 
             Parser.AddCommand(
@@ -39,7 +39,7 @@ public override void Create(CommandParser Parser)
                      if (Core.Database.ResetObject(target) == null) 
                          MudObject.SendMessage(actor, "Failed to reset " + target);
                      else MudObject.SendMessage(actor, "Reset " + target);
-                     return PerformResult.Continue;
+                     return SharpRuleEngine.PerformResult.Continue;
                  });
 
         }

AdminModule/Rules.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Text;
 using RMUD;
+using SharpRuleEngine;
 
 namespace AdminModule
 {
@@ -34,7 +35,7 @@ public override void Create(CommandParser Parser)
                 });
         }
 
-        private static void DisplaySingleBook(Actor Actor, RuleSet From, String BookName)
+        private static void DisplaySingleBook(MudObject Actor, RuleSet From, String BookName)
         {
             if (From == null || From.FindRuleBook(BookName) == null)
                 MudObject.SendMessage(Actor, "[no rules]");
@@ -47,12 +48,12 @@ private static void DisplaySingleBook(Actor Actor, RuleSet From, String BookName
             }
         }
 
-        private static void DisplayBookHeader(Actor Actor, RuleBook Book)
+        private static void DisplayBookHeader(MudObject Actor, RuleBook Book)
         {
             MudObject.SendMessage(Actor, Book.Name + " -> " + Book.ResultType.Name + " : " + Book.Description);
         }
 
-        private static void DisplayBookList(Actor Actor, RuleSet Rules)
+        private static void DisplayBookList(MudObject Actor, RuleSet Rules)
         {
             if (Rules == null || Rules.RuleBooks.Count == 0)
                 MudObject.SendMessage(Actor, "[no rules]");

AdminModule/Save.cs

@@ -26,7 +26,7 @@ public override void Create(CommandParser Parser)
 
                     //TODO MudObject.SendGlobalMessage("The database has been saved.");
                     MudObject.SendMessage(actor, String.Format("I saved {0} persistent objects.", saved));
-                    return PerformResult.Continue;
+                    return SharpRuleEngine.PerformResult.Continue;
                 });
 		}
 	}

AdminModule/Scope.cs

@@ -18,8 +18,8 @@ public override void Create(CommandParser Parser)
                 .ProceduralRule((match, actor) =>
                 {
                     foreach (var thing in MudObject.EnumerateVisibleTree(MudObject.FindLocale(actor)))
-                        MudObject.SendMessage(actor, thing.Short + " - " + thing.GetType().Name);
-                    return PerformResult.Continue;
+                        MudObject.SendMessage(actor, thing.GetProperty<String>("short") + " - " + thing.GetType().Name);
+                    return SharpRuleEngine.PerformResult.Continue;
                 }, "List all the damn things in scope rule.");
         }
     }