/// <summary>
/// Clone this match, but advance the clone to the end of input and give it an additional property.
/// </summary>
/// <param name="ArgumentName"></param>
/// <param name="Value"></param>
/// <returns></returns>
public PossibleMatch EndWith(String ArgumentName, Object Value)
{
var r = new PossibleMatch(this, null, ParseDepth + 1);
r.Upsert(ArgumentName, Value);
return(r);
}
override protected List <PossibleMatch> ImplementMatch(PossibleMatch State, MatchContext Context)
{
var r = new List <PossibleMatch>();
if (State.Next == null)
{
return(r);
}
var word = State.Next.Value.ToUpper();
if (word == "ON")
{
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.ON));
}
else if (word == "IN")
{
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.IN));
}
else if (word == "UNDER")
{
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.UNDER));
}
else if (word == "BEHIND")
{
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.BEHIND));
}
return(r);
}
public List <PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = new List <PossibleMatch>();
if (State.Next == null)
{
return(r);
}
var word = State.Next.Value.ToUpper();
if (word == "ON")
{
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.On));
}
else if (word == "IN")
{
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.In));
}
else if (word == "UNDER")
{
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.Under));
}
else if (word == "BEHIND")
{
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.Behind));
}
return(r);
}
/// <summary>
/// Clone this match, but give the clone an additional argument.
/// </summary>
/// <param name="ArgumentName"></param>
/// <param name="Value"></param>
/// <returns></returns>
public PossibleMatch With(String ArgumentName, Object Value)
{
var r = new PossibleMatch(this, Next);
r.Upsert(ArgumentName, Value);
return(r);
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var R = new List<PossibleMatch>();
R.AddRange(Sub.Match(State, Context));
if (R.Count == 0) throw new CommandParser.MatchAborted(Message);
return R;
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var R = new List<PossibleMatch>();
R.AddRange(Sub.Match(State, Context));
if (R.Count == 0) R.Add(State);
return R;
}
public List<PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var Matches = new List<PossibleMatch>();
foreach (var Matcher in Matchers)
Matches.AddRange(Matcher.Match(State, Context));
return Matches;
}
public List<PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List<PossibleMatch>();
if (State.Next == null) return R;
if ((Settings & ObjectMatcherSettings.UnderstandMe) == ObjectMatcherSettings.UnderstandMe)
{
if (State.Next.Value.ToUpper() == "ME")
{
var possibleMatch = new PossibleMatch(State.Arguments, State.Next.Next);
possibleMatch.Arguments.Upsert(CaptureName, Context.ExecutingActor);
R.Add(possibleMatch);
}
}
foreach (var thing in ObjectSource.GetObjects(State, Context))
{
var possibleMatch = new PossibleMatch(State.Arguments, State.Next);
bool matched = false;
while (possibleMatch.Next != null && thing.Nouns.Contains(possibleMatch.Next.Value.ToUpper()))
{
matched = true;
possibleMatch.Next = possibleMatch.Next.Next;
}
if (matched)
{
possibleMatch.Arguments.Upsert(CaptureName, thing);
R.Add(possibleMatch);
}
}
return R;
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = new List<PossibleMatch>();
if (State.Next != null)
r.Add(State.AdvanceWith(ArgumentName, State.Next.Value));
return r;
}
public List<PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List<PossibleMatch>();
if (Context.ExecutingActor.Rank >= RequiredRank)
R.Add(State);
return R;
}
/// <summary>
/// Clone this match, but advance the clone to the next token and give it an additional property.
/// </summary>
/// <param name="ArgumentName"></param>
/// <param name="Value"></param>
/// <returns></returns>
public PossibleMatch AdvanceWith(String ArgumentName, Object Value)
{
var r = new PossibleMatch(this, Next.Next, ParseDepth + 1);
r.Upsert(ArgumentName, Value);
return(r);
}
public List<PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List<PossibleMatch>();
if (Filter(State, Context))
R.Add(State);
return R;
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
if (Test(State, Context)) throw new CommandParser.MatchAborted(Message);
var r = new List<PossibleMatch>();
r.Add(State);
return r;
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var R = new List<PossibleMatch>();
if (Context.ExecutingActor.Rank >= RequiredRank)
R.Add(State);
//else
// throw new CommandParser.MatchAborted("You do not have sufficient rank to use that command.");
return R;
}
public List<PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List<PossibleMatch>();
if (State.Next != null && State.Next.Value.ToUpper() == Word)
R.Add(new PossibleMatch(State.Arguments, State.Next.Next));
if (Optional)
R.Add(new PossibleMatch(State.Arguments, State.Next));
return R;
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var R = new List<PossibleMatch>();
if (State.Next != null && State.Next.Value.ToUpper() == Word)
R.Add(State.Advance());
else if (Optional) //Greedy match
R.Add(State);
return R;
}
override protected List <PossibleMatch> ImplementMatch(PossibleMatch State, MatchContext Context)
{
var r = new List <PossibleMatch>();
if (State.Next != null)
{
r.Add(State.AdvanceWith(ArgumentName, State.Next.Value));
}
return(r);
}
public List <PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List <PossibleMatch>();
if (Filter(State, Context))
{
R.Add(State);
}
return(R);
}
public List <PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List <PossibleMatch>();
if (Context.ExecutingActor.Rank >= RequiredRank)
{
R.Add(State);
}
return(R);
}
private IEnumerable <RuleSet> EnumerateMatchRules(PossibleMatch Match)
{
foreach (var arg in Match)
{
if (arg.Value is MudObject && (arg.Value as MudObject).Rules != null)
{
yield return((arg.Value as MudObject).Rules);
}
}
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = new List<PossibleMatch>();
if (State.Next == null) return r;
if (Link.IsCardinal(State.Next.Value.ToUpper()))
r.Add(State.AdvanceWith(ArgumentName, Link.ToCardinal(State.Next.Value.ToUpper())));
return r;
}
override protected List <PossibleMatch> ImplementMatch(PossibleMatch State, MatchContext Context)
{
var Matches = new List <PossibleMatch>();
foreach (var Matcher in Matchers)
{
Matches.AddRange(Matcher.Match(State, Context));
}
return(Matches);
}
public List <PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var Matches = new List <PossibleMatch>();
foreach (var Matcher in Matchers)
{
Matches.AddRange(Matcher.Match(State, Context));
}
return(Matches);
}
private static MatchPreference GetScore(PossibleMatch Match, String ScoreArgumentName)
{
if (Match.ContainsKey(ScoreArgumentName + "-SCORE"))
{
var argScore = Match[ScoreArgumentName + "-SCORE"] as MatchPreference?;
if (argScore.HasValue) return argScore.Value;
}
return MatchPreference.Plausible; //If there is no score, the match is neutral.
}
public List <PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = new List <PossibleMatch>();
if (State.Next != null)
{
r.Add(State.AdvanceWith(ArgumentName, State.Next.Value));
}
return(r);
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var Matches = new List<PossibleMatch>();
foreach (var Matcher in Matchers)
{
Matches.AddRange(Matcher.Match(State, Context));
if (Matches.Count > 0) return Matches;
}
return Matches;
}
public MatchedCommand ParseCommand(PendingCommand Command)
{
var tokens = new LinkedList<String>(Command.RawCommand.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries));
var rootMatch = new PossibleMatch(tokens.First);
rootMatch.Upsert("ACTOR", Command.Actor);
rootMatch.Upsert("LOCATION", Command.Actor == null ? null : Command.Actor.Location);
// A pending command can have some properties set when it is queued. For example, the 'go' action
// generates a 'look' command after processing. It will give the 'look' command a property named
// 'auto' to indicate that the look command was generated. Rules can then use this property to
// implement behavior. From the same example, 'look' may emit a brief description if it is generated
// by the 'go' action, but emit a more detailed description if the player enters the command 'look'.
// See StandardActions.Go
if (Command.PreSettings != null)
foreach (var setting in Command.PreSettings)
rootMatch.Upsert(setting.Key.ToUpper(), setting.Value);
var matchContext = new MatchContext { ExecutingActor = Command.Actor };
// Try every single command defined, until one matches.
foreach (var command in Commands)
{
IEnumerable<PossibleMatch> matches;
try
{
matches = command.Matcher.Match(rootMatch, matchContext);
}
catch (MatchAborted ma)
{
// The match didn't fail; it generated an error. These means the match progressed to a point
// where the author of the command felt that the input could not logically match any other
// command, however, the input was still malformed in some way. Abort matching, and dummy up
// a command entry to display the error message to the player.
return new MatchedCommand(
new CommandEntry().ProceduralRule((match, actor) =>
{
MudObject.SendMessage(actor, ma.Message);
return PerformResult.Continue;
}),
// We need a fake match just so it can be passed to the procedural rule.
new PossibleMatch[] { new PossibleMatch(null) });
}
// Only accept matches that consumed all of the input.
matches = matches.Where(m => m.Next == null);
// If we did consume all of the input, we will assume this match is successful. Note it is
// possible for a command to generate multiple matches, but not possible to match multiple commands.
if (matches.Count() > 0)
return new MatchedCommand(command, matches);
}
return null;
}
public List <PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var R = new List <PossibleMatch>();
R.AddRange(Sub.Match(State, Context));
if (R.Count == 0)
{
R.Add(State);
}
return(R);
}
override protected List <PossibleMatch> ImplementMatch(PossibleMatch State, MatchContext Context)
{
var R = new List <PossibleMatch>();
R.AddRange(Sub.Match(State, Context));
if (R.Count == 0)
{
throw new CommandParser.MatchAborted(Message);
}
return(R);
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = Sub.Match(State, Context);
var highestScoreFound = MatchPreference.VeryUnlikely;
foreach (var match in r)
{
var score = GetScore(match, ScoreArgument );
if (score > highestScoreFound) highestScoreFound = score;
}
return new List<PossibleMatch>(r.Where(m => highestScoreFound == GetScore(m, ScoreArgument)));
}
override protected List <PossibleMatch> ImplementMatch(PossibleMatch State, MatchContext Context)
{
if (Test(State, Context))
{
throw new CommandParser.MatchAborted(Message);
}
var r = new List <PossibleMatch>();
r.Add(State);
return(r);
}
public List <PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
if (Test(State, Context))
{
throw new CommandParser.MatchAborted(Message);
}
var r = new List <PossibleMatch>();
r.Add(State);
return(r);
}
public List<PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List<PossibleMatch>();
if (State.Next != null)
{
var possibleMatch = new PossibleMatch(State.Arguments, null);
possibleMatch.Arguments.Upsert(ArgumentName, State.Next);
R.Add(possibleMatch);
}
return R;
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = new List<PossibleMatch>();
if (State.Next == null) return r;
int value = 0;
if (Int32.TryParse(State.Next.Value, out value))
r.Add(State.AdvanceWith(ArgumentName, value));
return r;
}
public static void ProcessPlayerCommand(CommandEntry Command, PossibleMatch Match, Actor Actor)
{
ExecutingCommand = Match;
try
{
ExecuteCommand(Command, Match, Actor);
}
finally
{
ExecutingCommand = null;
}
}
public List <PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var R = new List <PossibleMatch>();
if (Context.ExecutingActor.Rank >= RequiredRank)
{
R.Add(State);
}
//else
// throw new CommandParser.MatchAborted("You do not have sufficient rank to use that command.");
return(R);
}
override protected List <PossibleMatch> ImplementMatch(PossibleMatch State, MatchContext Context)
{
var R = new List <PossibleMatch>();
if (Context.ExecutingActor.GetProperty <int>("rank") >= RequiredRank)
{
R.Add(State);
}
//else
// throw new CommandParser.MatchAborted("You do not have sufficient rank to use that command.");
return(R);
}
public List <PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List <PossibleMatch>();
if (State.Next != null)
{
var match = new PossibleMatch(State.Arguments, State.Next.Next);
match.Arguments.Upsert(ArgumentName, State.Next.Value);
R.Add(match);
}
return(R);
}
public static void ProcessPlayerCommand(CommandEntry Command, PossibleMatch Match, MudObject Actor)
{
ExecutingCommand = Match;
try
{
ExecuteCommand(Command, Match, Actor);
}
finally
{
ExecutingCommand = null;
}
}
public List<PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var r = new List<PossibleMatch>();
if (State.Next == null) return r;
if (Link.IsCardinal(State.Next.Value.ToUpper()))
{
var match = new PossibleMatch(State.Arguments, State.Next.Next);
match.Arguments.Upsert(ArgumentName, Link.ToCardinal(State.Next.Value.ToUpper()));
r.Add(match);
}
return r;
}
/// <summary>
/// Actually carryout the command, following all of it's rules, including the before and after command rules.
/// </summary>
/// <param name="Command"></param>
/// <param name="Match"></param>
/// <param name="Actor"></param>
/// <returns>The result of the command's procedural rules.</returns>
private static PerformResult ExecuteCommand(CommandEntry Command, PossibleMatch Match, MudObject Actor)
{
var result = PerformResult.Stop;
Match.Upsert("COMMAND", Command);
if (GlobalRules.ConsiderMatchBasedPerformRule("before command", Match, Actor) == PerformResult.Continue)
{
result = Command.ProceduralRules.Consider(Match, Actor);
GlobalRules.ConsiderMatchBasedPerformRule("after command", Match, Actor);
}
GlobalRules.ConsiderPerformRule("after every command", Actor);
return(result);
}
private static MatchPreference GetScore(PossibleMatch Match, String ScoreArgumentName)
{
if (Match.ContainsKey(ScoreArgumentName + "-SCORE"))
{
var argScore = Match[ScoreArgumentName + "-SCORE"] as MatchPreference?;
if (argScore.HasValue)
{
return(argScore.Value);
}
}
return(MatchPreference.Plausible); //If there is no score, the match is neutral.
}
public List <PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var R = new List <PossibleMatch>();
if (State.Next != null && State.Next.Value.ToUpper() == Word)
{
R.Add(new PossibleMatch(State.Arguments, State.Next.Next));
}
if (Optional)
{
R.Add(new PossibleMatch(State.Arguments, State.Next));
}
return(R);
}
/// <summary>
/// Try to execute a command immediately. This does not bypass the before and after command rules. This is intended
/// to be used by rules to implement implicit actions. For example, the 'go' command will attempt to open closed
/// doors by calling
/// Core.Try("StandardActions:Open", Core.ExecutingCommand.With("SUBJECT", link), actor);
/// </summary>
/// <param name="CommandID">The ID of the command to try, assigned when the command is created.</param>
/// <param name="Match"></param>
/// <param name="Actor"></param>
/// <returns>The result of the command's proceedural rules.</returns>
public static PerformResult Try(String CommandID, PossibleMatch Match, Actor Actor)
{
var parentCommand = ExecutingCommand;
try
{
var command = Core.DefaultParser.FindCommandWithID(CommandID);
if (command == null) return PerformResult.Stop;
return ExecuteCommand(command, Match, Actor);
}
finally
{
ExecutingCommand = parentCommand;
}
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var Matches = new List<PossibleMatch>();
Matches.Add(State);
foreach (var Matcher in Matchers)
{
var NextMatches = new List<PossibleMatch>();
foreach (var Match in Matches)
NextMatches.AddRange(Matcher.Match(Match, Context));
Matches = NextMatches;
if (Matches.Count == 0) return Matches; //Shortcircuit for when no matches are found.
}
return Matches;
}
override protected List <PossibleMatch> ImplementMatch(PossibleMatch State, MatchContext Context)
{
var R = new List <PossibleMatch>();
if (State.Next != null && State.Next.Value.ToUpper() == Word)
{
R.Add(State.Advance());
}
else if (Optional) //Greedy match
{
R.Add(State);
}
return(R);
}
public List<MudObject> GetObjects(PossibleMatch State, MatchContext Context)
{
NPC source = null;
if (!String.IsNullOrEmpty(LocutorArgument))
source = State[LocutorArgument] as NPC;
else if (Context.ExecutingActor.HasProperty<NPC>("interlocutor"))
source = Context.ExecutingActor.GetProperty<NPC>("interlocutor");
if (source != null)
if (source.HasProperty<List<MudObject>>("conversation-topics"))
return new List<MudObject>(source.GetProperty<List<MudObject>>("conversation-topics").Where(t => Core.GlobalRules.ConsiderCheckRuleSilently("topic available?", Context.ExecutingActor, source, t) == CheckResult.Allow));
return new List<MudObject>();
}
public List <PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = Sub.Match(State, Context);
var highestScoreFound = MatchPreference.VeryUnlikely;
foreach (var match in r)
{
var score = GetScore(match, ScoreArgument);
if (score > highestScoreFound)
{
highestScoreFound = score;
}
}
return(new List <PossibleMatch>(r.Where(m => highestScoreFound == GetScore(m, ScoreArgument))));
}
internal MatchedCommand ParseCommand(String Command, Actor Actor)
{
var tokens = new LinkedList<String>(Command.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries));
var rootMatch = new PossibleMatch(tokens.First);
//Find all objects in scope
var matchContext = new MatchContext { ExecutingActor = Actor };
foreach (var command in Commands)
{
var matches = command.Matcher.Match(rootMatch, matchContext);
var firstGoodMatch = matches.Find(m => m.Next == null);
if (firstGoodMatch != null) return new MatchedCommand(command, firstGoodMatch);
}
return null;
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = new List<PossibleMatch>();
if (State.Next == null) return r;
var word = State.Next.Value.ToUpper();
if (word == "ON")
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.On));
else if (word == "IN")
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.In));
else if (word == "UNDER")
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.Under));
else if (word == "BEHIND")
r.Add(State.AdvanceWith(ArgumentName, RelativeLocations.Behind));
return r;
}
public List <PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = new List <PossibleMatch>();
if (State.Next == null)
{
return(r);
}
if (Link.IsCardinal(State.Next.Value.ToUpper()))
{
r.Add(State.AdvanceWith(ArgumentName, Link.ToCardinal(State.Next.Value.ToUpper())));
}
return(r);
}
public List <PossibleMatch> Match(PossibleMatch State, CommandParser.MatchContext Context)
{
var r = new List <PossibleMatch>();
if (State.Next == null)
{
return(r);
}
if (Link.IsCardinal(State.Next.Value.ToUpper()))
{
var match = new PossibleMatch(State.Arguments, State.Next.Next);
match.Arguments.Upsert(ArgumentName, Link.ToCardinal(State.Next.Value.ToUpper()));
r.Add(match);
}
return(r);
}
public void ParseStage(PossibleMatch Match, String Description)
{
if (CurrentParseCommand.IsNamed("LOOK"))
{
var x = 5;
}
if (BestFailedMatch == null || Match.ParseDepth >= BestFailedMatch.ParseDepth)
{
if (!String.IsNullOrEmpty(Description) || !Object.ReferenceEquals(CurrentParseCommand, BestFailedCommand))
{
BestFailedParseStageDescription = Description;
}
BestFailedCommand = CurrentParseCommand;
BestFailedMatch = Match;
}
}
/// <summary>
/// Try to execute a command immediately. This does not bypass the before and after command rules. This is intended
/// to be used by rules to implement implicit actions. For example, the 'go' command will attempt to open closed
/// doors by calling
/// Core.Try("StandardActions:Open", Core.ExecutingCommand.With("SUBJECT", link), actor);
/// </summary>
/// <param name="CommandID">The ID of the command to try, assigned when the command is created.</param>
/// <param name="Match"></param>
/// <param name="Actor"></param>
/// <returns>The result of the command's proceedural rules.</returns>
public static PerformResult Try(String CommandID, PossibleMatch Match, MudObject Actor)
{
var parentCommand = ExecutingCommand;
try
{
var command = Core.DefaultParser.FindCommandWithID(CommandID);
if (command == null)
{
return(PerformResult.Stop);
}
return(ExecuteCommand(command, Match, Actor));
}
finally
{
ExecutingCommand = parentCommand;
}
}
override protected List <PossibleMatch> ImplementMatch(PossibleMatch State, MatchContext Context)
{
var r = new List <PossibleMatch>();
if (State.Next == null)
{
return(r);
}
int value = 0;
if (Int32.TryParse(State.Next.Value, out value))
{
r.Add(State.AdvanceWith(ArgumentName, value));
}
return(r);
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
var r = new List<PossibleMatch>();
if (State.Next != null)
{
var builder = new StringBuilder();
var node = State.Next;
for (; node != null; node = node.Next)
{
builder.Append(node.Value);
builder.Append(" ");
}
builder.Remove(builder.Length - 1, 1);
r.Add(State.EndWith(ArgumentName, builder.ToString()));
}
return r;
}
public List<MudObject> GetObjects(PossibleMatch State, MatchContext Context)
{
return new List<MudObject>(Context.ObjectsInScope);
}
public List<PossibleMatch> Match(PossibleMatch State, MatchContext Context)
{
return MatchFunc(State, Context);
}
public List<MudObject> GetObjects(PossibleMatch State, MatchContext Context)
{
return new List<MudObject>(ChatChannel.ChatChannels);
}
public MatchedCommand(CommandEntry Command, PossibleMatch Match)
{
this.Command = Command;
this.Match = Match;
}