public static void AtStartup(RMUD.RuleEngine GlobalRules)
{
Core.StandardMessage("you drop", "You drop <the0>.");
Core.StandardMessage("they drop", "^<the0> drops <a1>.");
GlobalRules.DeclareCheckRuleBook <MudObject, MudObject>("can drop?", "[Actor, Item] : Determine if the item can be dropped.", "actor", "item");
GlobalRules.DeclarePerformRuleBook <MudObject, MudObject>("drop", "[Actor, Item] : Handle an item being dropped.", "actor", "item");
GlobalRules.Check <MudObject, MudObject>("can drop?")
.First
.When((actor, item) => !Core.ObjectContainsObject(actor, item))
.Do((actor, item) =>
{
Core.SendMessage(actor, "@dont have that");
return(CheckResult.Disallow);
})
.Name("Must be holding it to drop it rule.");
GlobalRules.Check <MudObject, MudObject>("can drop?")
.First
.When((actor, item) => actor.Contains(item, RelativeLocations.WORN))
.Do((actor, item) =>
{
if (GlobalRules.ConsiderCheckRule("can remove?", actor, item) == CheckResult.Allow)
{
GlobalRules.ConsiderPerformRule("remove", actor, item);
return(CheckResult.Continue);
}
return(CheckResult.Disallow);
})
.Name("Dropping worn items follows remove rules rule.");
GlobalRules.Check <MudObject, MudObject>("can drop?").Do((a, b) => CheckResult.Allow).Name("Default can drop anything rule.");
GlobalRules.Perform <MudObject, MudObject>("drop").Do((actor, target) =>
{
Core.SendMessage(actor, "@you drop", target);
Core.SendExternalMessage(actor, "@they drop", actor, target);
if (actor.Location.HasValue(out var loc))
{
Core.Move(target, loc);
}
return(PerformResult.Continue);
}).Name("Default drop handler rule.");
}
public static void AtStartup(RMUD.RuleEngine GlobalRules)
{
PropertyManifest.RegisterProperty("interlocutor", typeof(MudObject), null, new DefaultSerializer());
PropertyManifest.RegisterProperty("conversation-topics", typeof(List <MudObject>), new List <MudObject>(), new DefaultSerializer());
PropertyManifest.RegisterProperty("topic-discussed", typeof(bool), false, new BoolSerializer());
Core.StandardMessage("convo topic prompt", "Suggested topics: <l0>");
Core.StandardMessage("convo cant converse", "You can't converse with that.");
Core.StandardMessage("convo greet whom", "Whom did you want to greet?");
Core.StandardMessage("convo nobody", "You aren't talking to anybody.");
Core.StandardMessage("convo no response", "There doesn't seem to be a response defined for that topic.");
Core.StandardMessage("convo no topics", "There is nothing obvious to discuss.");
GlobalRules.DeclareCheckRuleBook <MudObject, MudObject>("can converse?", "[Actor, Item] : Can the actor converse with the item?", "actor", "item");
GlobalRules.Check <MudObject, MudObject>("can converse?")
.When((actor, item) => !item.GetProperty <bool>("actor?"))
.Do((actor, item) =>
{
Core.SendMessage(actor, "@convo cant converse");
return(CheckResult.Disallow);
})
.Name("Can only converse with NPCs rule.");
GlobalRules.Check <MudObject, MudObject>("can converse?")
.Do((actor, item) => Core.CheckIsVisibleTo(actor, item))
.Name("Locutor must be visible rule.");
GlobalRules.Check <MudObject, MudObject>("can converse?")
.Last
.Do((actor, item) => CheckResult.Allow)
.Name("Let them chat rule.");
GlobalRules.DeclarePerformRuleBook <MudObject, MudObject>("greet", "[Actor, NPC] : Handle an actor greeting an NPC.", "actor", "npc");
GlobalRules.DeclarePerformRuleBook <MudObject>("list topics", "[Actor] : List conversation topics available to the actor.", "actor");
GlobalRules.Perform <MudObject>("list topics")
.When(actor => actor.GetProperty <MudObject>("interlocutor") == null)
.Do(actor =>
{
Core.SendMessage(actor, "@convo nobody");
return(PerformResult.Stop);
})
.Name("Need interlocutor to list topics rule.");
GlobalRules.Perform <MudObject>("list topics")
.Do(actor =>
{
var npc = actor.GetProperty <MudObject>("interlocutor");
if (npc != null)
{
var suggestedTopics = npc.GetProperty <List <MudObject> >("conversation-topics").AsEnumerable();
if (!ConversationSettings.ListDiscussedTopics)
{
suggestedTopics = suggestedTopics.Where(obj => !obj.GetProperty <bool>("topic-discussed"));
}
suggestedTopics = suggestedTopics.Where(topic => GlobalRules.ConsiderCheckRule("topic available?", actor, npc, topic) == CheckResult.Allow);
var enumeratedSuggestedTopics = new List <MudObject>(suggestedTopics);
if (enumeratedSuggestedTopics.Count != 0)
{
Core.SendMessage(actor, "@convo topic prompt", enumeratedSuggestedTopics);
}
else
{
GlobalRules.ConsiderPerformRule("no topics to discuss", actor, npc);
}
}
return(PerformResult.Continue);
})
.Name("List un-discussed available topics rule.");
GlobalRules.DeclarePerformRuleBook <MudObject, MudObject>("no topics to discuss", "[Actor, NPC] : Handle there being no topics to list.");
GlobalRules.Perform <MudObject, MudObject>("no topics to discuss")
.Do((actor, npc) =>
{
Core.SendMessage(actor, "@convo no topics");
return(PerformResult.Continue);
})
.Name("Default report no topics to discuss rule.");
GlobalRules.DeclarePerformRuleBook <MudObject, MudObject, MudObject>("discuss topic", "[Actor, NPC, Topic] : Handle the actor discussing the topic with the npc.");
GlobalRules.Perform <MudObject, MudObject, MudObject>("discuss topic")
.Do((actor, npc, topic) =>
{
GlobalRules.ConsiderPerformRule("topic response", actor, npc, topic);
if (topic != null)
{
topic.SetProperty("topic-discussed", true);
}
return(PerformResult.Continue);
})
.Name("Show topic response when discussing topic rule.");
GlobalRules.Perform <MudObject, MudObject, MudObject>("topic response")
.Do((actor, npc, topic) =>
{
Core.SendMessage(actor, "@convo no response");
return(PerformResult.Stop);
})
.Name("No response rule for the topic rule.");
GlobalRules.DeclareCheckRuleBook <MudObject, MudObject, MudObject>("topic available?", "[Actor, NPC, Topic -> bool] : Is the topic available for discussion with the NPC to the actor?", "actor", "npc", "topic");
GlobalRules.DeclarePerformRuleBook <MudObject, MudObject, MudObject>("topic response", "[Actor, NPC, Topic] : Display the response of the topic.", "actor", "npc", "topic");
GlobalRules.Check <MudObject, MudObject, MudObject>("topic available?")
.First
.When((actor, npc, topic) => (topic != null) && (ConversationSettings.AllowRepeats == false) && topic.GetProperty <bool>("topic-discussed"))
.Do((actor, npc, topic) => CheckResult.Disallow)
.Name("Already discussed topics unavailable when repeats disabled rule.");
GlobalRules.Check <MudObject, MudObject, MudObject>("topic available?")
.Last
.Do((actor, npc, topic) => CheckResult.Allow)
.Name("Topics available by default rule.");
}
public static void AtStartup(RMUD.RuleEngine GlobalRules)
{
Core.StandardMessage("cant put relloc", "You can't put things <s0> that.");
Core.StandardMessage("you put", "You put <the0> <s1> <the2>.");
Core.StandardMessage("they put", "^<the0> puts <the1> <s2> <the3>.");
GlobalRules.DeclareCheckRuleBook <MudObject, MudObject, MudObject, RelativeLocations>("can put?", "[Actor, Item, Container, Location] : Determine if the actor can put the item in or on or under the container.", "actor", "item", "container", "relloc");
GlobalRules.DeclarePerformRuleBook <MudObject, MudObject, MudObject, RelativeLocations>("put", "[Actor, Item, Container, Location] : Handle an actor putting the item in or on or under the container.", "actor", "item", "container", "relloc");
GlobalRules.Check <MudObject, MudObject, MudObject, RelativeLocations>("can put?")
.Last
.Do((a, b, c, d) => CheckResult.Allow)
.Name("Allow putting as default rule.");
GlobalRules.Check <MudObject, MudObject, MudObject, RelativeLocations>("can put?")
.Do((actor, item, container, relloc) =>
{
if (!(container.GetProperty <bool>("container?")))
{
Core.SendMessage(actor, "@cant put relloc", Relloc.GetRelativeLocationName(relloc));
return(CheckResult.Disallow);
}
return(CheckResult.Continue);
})
.Name("Can't put things in things that aren't containers rule.");
GlobalRules.Check <MudObject, MudObject, MudObject, RelativeLocations>("can put?")
.Do((actor, item, container, relloc) =>
{
if (GlobalRules.ConsiderCheckRule("can drop?", actor, item) != CheckResult.Allow)
{
return(CheckResult.Disallow);
}
return(CheckResult.Continue);
})
.Name("Putting is dropping rule.");
GlobalRules.Perform <MudObject, MudObject, MudObject, RelativeLocations>("put")
.Do((actor, item, container, relloc) =>
{
Core.SendMessage(actor, "@you put", item, Relloc.GetRelativeLocationName(relloc), container);
Core.SendExternalMessage(actor, "@they put", actor, item, Relloc.GetRelativeLocationName(relloc), container);
Core.Move(item, container, relloc);
return(PerformResult.Continue);
})
.Name("Default putting things in things handler.");
GlobalRules.Check <MudObject, MudObject, MudObject, RelativeLocations>("can put?")
.Do((actor, item, container, relloc) =>
{
if ((container.ContentLocationsAllowed & relloc) != relloc)
{
Core.SendMessage(actor, "@cant put relloc", Relloc.GetRelativeLocationName(relloc));
return(CheckResult.Disallow);
}
return(CheckResult.Continue);
})
.Name("Check supported locations before putting rule.");
GlobalRules.Check <MudObject, MudObject, MudObject, RelativeLocations>("can put?")
.Do((actor, item, container, relloc) =>
{
if (relloc == RelativeLocations.IN && !container.GetProperty <bool>("open?"))
{
Core.SendMessage(actor, "@is closed error", container);
return(CheckResult.Disallow);
}
return(CheckResult.Continue);
})
.Name("Can't put things in closed container rule.");
GlobalRules.Check <MudObject, MudObject, MudObject, RelativeLocations>("can put?")
.First
.Do((actor, item, container, relloc) => Core.CheckIsVisibleTo(actor, container))
.Name("Container must be visible rule.");
GlobalRules.Check <MudObject, MudObject, MudObject, RelativeLocations>("can put?")
.First
.Do((actor, item, container, relloc) => Core.CheckIsHolding(actor, item))
.Name("Must be holding item rule.");
}
