//public static bool validationFeedback = false; //NOTE: Tynan called the parameter for this method "constraints", but actually it means "constants". //The real constraints are at rule.constantConstraints. Very confusing! private static bool Prefix(GrammarResolver.RuleEntry __instance, ref bool __result, Dictionary <string, string> constraints, ref bool ___constantConstraintsChecked, ref bool ___constantConstraintsValid) { var currentRules = GrammarResolver_RandomPossiblyResolvableEntry.CurrentRules; var constants = constraints; //see note above var actualConstraints = __instance.rule.constantConstraints; if (Current.ProgramState != ProgramState.Playing || actualConstraints.NullOrEmpty() || currentRules.NullOrEmpty()) { return(true); } __result = ValidateRulesConstraints(actualConstraints, currentRules, ref ___constantConstraintsChecked, ref ___constantConstraintsValid); //if (validationFeedback) //{ // string result = __result ? "success" : "failed"; // StringBuilder feedback = new StringBuilder(); // feedback.Append($"{result.ToUpper()} validating constraints for {__instance.rule.keyword}:"); // feedback.AppendInNewLine($"{actualConstraints.Select(x => $"\"{x.key} {x.type.ToString().ToLower()} {x.value}\"").ToStringSafeEnumerable()}"); // feedback.AppendInNewLine($"The rule text is \"{__instance.rule}\"."); // feedback.AppendInNewLine($"\nChecked against {currentRules.Count()} rules:\n" + // $"{(currentRules.EnumerableNullOrEmpty() ? "none" : currentRules.Select(x => $"{x.Key}: {x.Value.ResolveTags()}").ToLineList())}"); // Log.Message(feedback.ToString()); // validationFeedback = false; //} return(false); }
//Ensures the tag/requiredTag functionality works. public static void Prefix(GrammarResolver.RuleEntry entry, List <string> resolvedTags) { if (entry.rule is Rule_String stringRule && !stringRule.tag.NullOrEmpty() && !resolvedTags.Contains(stringRule.tag)) { resolvedTags.Add(stringRule.tag); } }
//Ensures the tag/requiredTag functionality works. public static void Prefix(GrammarResolver.RuleEntry entry, List <string> resolvedTags) { if (entry.rule is Rule_String stringRule && !stringRule.tag.NullOrEmpty() && !resolvedTags.Contains(stringRule.tag)) { //Log.Message($"Adding tag {stringRule.tag} to {entry.rule.keyword} with {entry.uses} uses"); resolvedTags.Add(stringRule.tag); } }
public static void Postfix(GrammarResolver.RuleEntry __result, string keyword, Dictionary <string, string> constants, List <string> extraTags, List <string> resolvedTags) { //reset exposed rules cache if (!CurrentRules.EnumerableNullOrEmpty()) { CurrentRules.Clear(); } }
private static void Postfix(GrammarResolver.RuleEntry __instance, MethodBase __originalMethod, ref bool __result, Dictionary <string, string> constraints, ref bool ___constantConstraintsChecked, bool ___constantConstraintsValid, bool ___knownUnresolvable) { if (!__result) { ___constantConstraintsChecked = false; __result = DoubleCheckConstraints(__instance, GrammarResolver_RandomPossiblyResolvableEntry.CurrentRulesDic); } }
//Prepares a reply if entry carries a tag public static void Postfix(bool __result, GrammarResolver.RuleEntry entry, List <string> resolvedTags) { if (__result && entry.rule.keyword == "r_logentry") { if (!resolvedTags.NullOrEmpty()) { Ensue(resolvedTags); } } }
public static void Prefix(string keyword, Dictionary <string, string> constants, List <string> extraTags, List <string> resolvedTags, Dictionary <string, List <GrammarResolver.RuleEntry> > ___rules, ref GrammarResolver.RuleEntry __result) { //Warning to catch invalid keywords. if (keyword == "r_logentry" && ___rules.TryGetValue(keyword, null).NullOrEmpty()) { Log.Warning($"RandomPossiblyResolvableEntry found bad value for {keyword}.\n" + $"Constants are: {constants.ToStringSafeEnumerable()}\n" + $"Rules are : {___rules.Values.ToStringSafeEnumerable()}\n"); } //Expose current rules to be used later to check constraints. if (keyword == "r_logentry") { CurrentRules = ___rules.Keys.ToList(); foreach (Rule_String rule in ___rules.Values.SelectMany(x => x).Where(x => x.rule is Rule_String).Select(x => x.rule)) { if (!CurrentRulesDic.ContainsKey(keyword)) { CurrentRulesDic.SetOrAdd(rule.keyword, (string)outputInfo.GetValue(rule)); } } //Log.Message($"DEBUG {___rules.Values.SelectMany(x=>x).Select(x => x.rule.keyword).ToStringSafeEnumerable()}"); } }
public static void Prefix(string keyword, Dictionary <string, string> constants, List <string> extraTags, List <string> resolvedTags, Dictionary <string, List <GrammarResolver.RuleEntry> > ___rules, ref GrammarResolver.RuleEntry __result) { //Expose current constants & rules if (!___rules.TryGetValue(keyword, null).NullOrEmpty()) { if (!constants.EnumerableNullOrEmpty()) { foreach (var constant in constants) { CurrentRules.Add(constant); } } foreach (Rule_String rule in ___rules.Values.SelectMany(x => x).Where(x => x.rule is Rule_String).Select(x => x.rule)) { CurrentRules.Add(new KeyValuePair <string, string>(rule.keyword, (string)outputInfo.GetValue(rule))); } return; } //Warning to catch invalid keywords. if (Prefs.LogVerbose && Current.ProgramState == ProgramState.Playing) { Log.Warning($"[SpeakUp] Bad value found for \"{keyword}\". Could be a typo!"); } }