public override object Evaluate(
List <string> args,
ExpressionEvaluator evaluator,
Creature player,
Target target,
CastedSpell spell,
RollResults dice = null)
{
ExpectingArguments(args, 0, 1);
WhatSide whatSide = WhatSide.All;
if (args.Count > 0)
{
string whatSideStr = args[0].Trim();
string[] parts = whatSideStr.Split('|'); // Union enum elements, e.g., "Friendly | Neutral"
whatSide = WhatSide.None;
foreach (string part in parts)
{
whatSide |= DndUtils.ToWhatSide(part);
}
}
OnTargetCreaturesInVolumeRequest(player, new WhatSideEventArgs(whatSide));
return(null);
}
private void TriggerEvent(Magic magic, string eventCode, RollResults dice = null)
{
if (string.IsNullOrWhiteSpace(eventCode))
{
return;
}
Expressions.Do(eventCode, magic.Caster as Character, Target.FromMagic(magic), magic.CastedSpell, dice, magic);
}
private static void ExpressionEvaluator_EvaluateFunction(object sender, FunctionEvaluationEventArg e)
{
Creature player = GetPlayer(e.Evaluator.Variables);
CastedSpell castedSpell = GetCastedSpell(e.Evaluator.Variables);
Target target = GetTargetCreature(e.Evaluator.Variables);
RollResults dice = GetDiceStoppedRollingData(e.Evaluator.Variables);
DndFunction function = functions.FirstOrDefault(x => x.Handles(e.Name, player, castedSpell));
if (function != null)
{
try
{
e.Value = function.Evaluate(e.Args, e.Evaluator, player, target, castedSpell, dice);
Log($" {e.Name}({GetArgsStr(e.Args)}) => {GetValueStr(e.Value)}");
}
catch //(Exception ex)
{
e.Value = null;
Log($" Exception thrown trying to evaluate {e.Name}({GetArgsStr(e.Args)})");
}
}
}
public static double GetDouble(string expression, Creature player = null, Target target = null, CastedSpell spell = null, RollResults dice = null, object customData = null)
{
if (string.IsNullOrWhiteSpace(expression))
{
return(0);
}
StartEvaluation(player, $"GetDouble({expression})", target, spell, dice, customData);
try
{
object result = 0.0;
try
{
result = expressionEvaluator.Evaluate(Clean(expression));
Log($" returns {result};");
}
catch (Exception ex)
{
OnExceptionThrown(null, new DndCoreExceptionEventArgs(ex));
return(0);
}
if (result is int)
{
return((int)result);
}
if (result is decimal)
{
return((double)((decimal)result));
}
if (result is double)
{
return((double)result);
}
if (result is string resultStr)
{
if (double.TryParse(resultStr, out double resultDbl))
{
return(resultDbl);
}
else // Support fractions...
{
const string divideSymbol = "/";
if (resultStr.Contains(divideSymbol))
{
string numeratorStr = resultStr.EverythingBefore(divideSymbol).Trim();
string denominatorStr = resultStr.EverythingAfter(divideSymbol).Trim();
if (double.TryParse(numeratorStr, out double numerator) && double.TryParse(denominatorStr, out double denominator) && denominator != 0)
{
return(numerator / denominator);
}
}
}
}
return(double.MinValue);
}
finally
{
FinishEvaluation(player);
}
}
public static bool GetBool(string expression, Creature player = null, Target target = null, CastedSpell spell = null, RollResults dice = null, object customData = null)
{
if (string.IsNullOrWhiteSpace(expression))
{
return(false);
}
StartEvaluation(player, $"GetBool({expression})", target, spell, dice, customData);
try
{
object result = false;
try
{
result = expressionEvaluator.Evaluate(Clean(expression));
}
catch (Exception ex)
{
OnExceptionThrown(null, new DndCoreExceptionEventArgs(ex));
return(false);
}
bool resultBool;
if (result is int)
{
resultBool = (int)result == 1;
}
else if (result is string)
{
string compareStr = ((string)result).Trim().ToLower();
resultBool = compareStr == "x" || compareStr == "true";
}
else if (result is bool)
{
resultBool = (bool)result;
}
else
{
resultBool = false;
}
Log($" returns {resultBool};");
return(resultBool);
}
finally
{
FinishEvaluation(player);
}
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
if (function == null)
{
return(null);
}
return(evaluator.Evaluate(DndUtils.InjectParameters(function.Expression, function.Parameters, args)));
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, RollResults dice = null)
{
ExpectingArguments(args, 1, 3);
if (player != null)
{
int hue = Expressions.GetInt(args[0], player, target, spell);
int saturation = 100;
if (args.Count == 2)
{
saturation = Expressions.GetInt(args[1], player, target, spell);
}
int brightness = 100;
if (args.Count == 3)
{
brightness = Expressions.GetInt(args[2], player, target, spell);
}
player.AddSpellHitEffect(hue: hue, saturation: saturation, brightness: brightness);
}
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, RollResults dice = null)
{
ExpectingArguments(args, 1, 2);
if (player != null)
{
string fileName = Expressions.GetStr(args[0], player, target, spell);
int timeOffsetMs = 0;
if (args.Count > 1)
{
timeOffsetMs = Expressions.GetInt(args[1], player, target, spell);
}
player.AddSpellHitSoundEffect(fileName, timeOffsetMs);
}
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, RollResults dice = null)
{
ExpectingArguments(args, 1, 15);
if (player != null)
{
string effectName;
int hue, saturation, brightness, timeOffset, secondaryHue, secondarySaturation, secondaryBrightness, yOffset, xOffset;
double scale, rotation, autoRotation, velocityX, velocityY;
AddSpellCastEffect.GetVisualEffectParameters(args, player, target, spell, out effectName, out hue, out saturation, out brightness, out scale, out rotation, out autoRotation, out timeOffset, out secondaryHue, out secondarySaturation, out secondaryBrightness, out xOffset, out yOffset, out velocityX, out velocityY);
player.AddSpellHitEffect(effectName, hue, saturation, brightness,
scale, rotation, autoRotation, timeOffset,
secondaryHue, secondarySaturation, secondaryBrightness, xOffset, yOffset, velocityX, velocityY);
}
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, RollResults dice = null)
{
string question = Expressions.GetStr(args[0], player, target, spell);
List <string> answers = args.Skip(1).ToList();
AskEventArgs ea = new AskEventArgs(question, answers);
OnAskQuestion(player, ea);
return(ea.Result);
}
private static void AddPlayerVariables(Creature player, Target target, CastedSpell spell, RollResults dice = null, object customData = null)
{
variableStack.Push(expressionEvaluator.Variables);
expressionEvaluator.Variables = new Dictionary <string, object>()
{
{ STR_Player, player },
{ STR_Target, target },
{ STR_Dice, dice },
{ STR_CastedSpell, spell },
{ STR_CustomData, customData }
};
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 0);
CreaturePlusModId recipient = Expressions.GetCustomData <CreaturePlusModId>(evaluator.Variables);
if (recipient == null)
{
return(null);
}
OnRequestDispelMagic(new DispelMagicEventArgs(recipient));
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
if (player == null)
{
return(null);
}
ExpectingArguments(args, 2);
string variableName = args[0];
object rawValue = Expressions.Get <object>(args[1], player, target, spell);
double valueDouble;
if (rawValue == null)
{
valueDouble = 0;
}
else
{
valueDouble = MathUtils.GetDouble(rawValue.ToString());
}
int valueInt = (int)Math.Round(valueDouble);
// TODO: Wil says Convert.ConvertTo() can simplify this.
FieldInfo field = typeof(Character).GetField(variableName);
if (field != null)
{
if (field.FieldType.FullName == "System.Int32")
{
field.SetValue(player, MathUtils.GetInt(field.GetValue(player).ToString()) + valueInt);
}
else
{
field.SetValue(player, MathUtils.GetDouble(field.GetValue(player).ToString()) + valueDouble);
}
return(null);
}
PropertyInfo property = typeof(Character).GetProperty(variableName);
if (property != null)
{
if (property.PropertyType.FullName == "System.Int32")
{
property.SetValue(player, MathUtils.GetInt(property.GetValue(player).ToString()) + valueInt);
}
else
{
property.SetValue(player, MathUtils.GetDouble(property.GetValue(player).ToString()) + valueDouble);
}
return(null);
}
object existingValueRaw = player.GetState(variableName);
if (existingValueRaw != null)
{
if (existingValueRaw is int)
{
player.SetState(variableName, MathUtils.GetInt(existingValueRaw.ToString()) + valueInt);
}
else
{
player.SetState(variableName, MathUtils.GetDouble(existingValueRaw.ToString()) + valueDouble);
}
return(null);
}
throw new Exception($"Variable \"{variableName}\" not found.");
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 4);
string tableName = evaluator.Evaluate <string>(args[0]);
string fieldLookup = evaluator.Evaluate <string>(args[1]);
string matchColumn = evaluator.Evaluate <string>(args[2]);
object matchValue = evaluator.Evaluate(Expressions.Clean(args[3]));
return(AllTables.GetData(tableName, fieldLookup, matchColumn, matchValue));
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 1);
string diceStr = evaluator.Evaluate <string>(args[0]);
player.AddDice(diceStr);
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, RollResults dice = null)
{
ExpectingArguments(args, 1, 2);
if (args.Count > 1)
{
player = AllPlayers.GetFromName(args[1].Trim());
}
if (player != null)
{
player.SetNextAnswer(Expressions.GetStr(args[0], player, target, spell));
}
return(null);
}
public static string GetStr(string expression, Creature player = null, Target target = null, CastedSpell spell = null, RollResults dice = null, object customData = null)
{
if (string.IsNullOrWhiteSpace(expression))
{
return(string.Empty);
}
StartEvaluation(player, $"GetStr({expression})", target, spell, dice, customData);
try
{
object result = string.Empty;
try
{
result = expressionEvaluator.Evaluate(Clean(expression));
}
catch (Exception ex)
{
OnExceptionThrown(null, new DndCoreExceptionEventArgs(ex));
return(string.Empty);
}
string resultStr = string.Empty;
if (result is string)
{
resultStr = (string)result;
}
else if (result == null)
{
resultStr = string.Empty;
}
else
{
resultStr = result.ToString();
}
Log($" returns \"{resultStr}\";");
return(resultStr);
}
finally
{
FinishEvaluation(player);
}
}
// TODO: Add customData parameter?
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 1, 2);
string shortcutName = evaluator.Evaluate <string>(args[0]);
bool rollImmediately = false;
if (args.Count > 1)
{
rollImmediately = Expressions.GetBool(args[1], player, target, spell, dice);
}
player.AddShortcutToQueue(shortcutName, rollImmediately);
return(null);
}
private static void StartEvaluation(Creature player, string callingProc, Target target = null, CastedSpell spell = null, RollResults dice = null, object customData = null)
{
//historyStack.Push(history);
//history = new List<string>();
LogCallingProc(callingProc);
AddPlayerVariables(player, target, spell, dice, customData);
if (player != null)
{
player.StartingExpressionEvaluation();
}
BeginUpdate();
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 0);
CastedSpell castedSpell = Expressions.GetCastedSpell(evaluator.Variables);
if (castedSpell != null && player != null)
{
player.Dispel(castedSpell);
}
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 2);
string propertyName = Expressions.GetStr(args[0], player, target, spell, dice);
double deltaValue = Expressions.GetDouble(args[1], player, target, spell, dice);
if (target == null)
{
// Make sure this Spell has values in the MinTargetsToCast and MaxTargetsToCast columns.
System.Diagnostics.Debugger.Break();
return(null);
}
foreach (Creature creature in target.Creatures)
{
OnRequestPropertyChange(creature, propertyName, deltaValue);
}
if (player != null)
{
foreach (int playerId in target.PlayerIds)
{
Character playerFromId = player.Game.GetPlayerFromId(playerId);
if (playerFromId != null)
{
OnRequestPropertyChange(playerFromId, propertyName, deltaValue);
}
}
}
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, RollResults dice = null)
{
ExpectingArguments(args, 2);
string reminder = Expressions.GetStr(args[0], player, target, spell);
string fromNowDuration = Expressions.GetStr(args[1], player, target, spell);
AddReminderEventArgs ea = new AddReminderEventArgs(reminder, fromNowDuration);
AddReminder(player, ea);
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, RollResults dice = null)
{
ExpectingArguments(args, 1);
// TODO: Get the condition to set.
// TODO: Set the target's condition.
return(null);
}
public static T Get <T>(string expression, Creature player = null, Target target = null, CastedSpell spell = null, RollResults dice = null, object customData = null)
{
if (string.IsNullOrWhiteSpace(expression))
{
return(default(T));
}
StartEvaluation(player, $"Get<{typeof(T).ToString()}>({expression})", target, spell, dice, customData);
try
{
try
{
T result = (T)expressionEvaluator.Evaluate(Clean(expression));
Log($" returns {result};");
return(result);
}
catch (Exception ex)
{
OnExceptionThrown(null, new DndCoreExceptionEventArgs(ex));
return(default(T));
}
}
finally
{
FinishEvaluation(player);
}
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
CreaturePlusModId recipient = Expressions.GetCustomData <CreaturePlusModId>(evaluator.Variables);
if (recipient == null)
{
throw new Exception($"CreaturePlusModId recipient must be specified before evaluating expressions containing RemovePropertyMod.");
}
ExpectingArguments(args, 0);
recipient.Creature.RemoveVantageMod(recipient.ID);
return(null);
}
public static void Do(string expression, Creature player = null, Target target = null, CastedSpell castedSpell = null, RollResults dice = null, object customData = null)
{
if (string.IsNullOrWhiteSpace(expression))
{
return;
}
StartEvaluation(player, $"Do({expression})", target, castedSpell, dice, customData);
try
{
string script = Clean(expression);
if (!script.EndsWith(";") && !script.EndsWith("}"))
{
script += ";";
}
string compactScript = string.Empty;
string[] splitLines = script.Split('\r', '\n');
foreach (string line in splitLines)
{
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
if (line.Trim().StartsWith("//"))
{
continue;
}
compactScript += line + Environment.NewLine;
}
if (string.IsNullOrWhiteSpace(compactScript))
{
return;
}
try
{
expressionEvaluator.ScriptEvaluate(compactScript);
}
catch (ExpressionEvaluatorSyntaxErrorException ex)
{
OnExceptionThrown(null, new DndCoreExceptionEventArgs(ex));
}
}
finally
{
FinishEvaluation(player);
}
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 1);
string featureName = args[0];
if (featureName.StartsWith("\""))
{
featureName = Expressions.GetStr(featureName);
}
Feature feature = AllFeatures.Get(featureName);
if (feature != null)
{
feature.Deactivate("", player);
}
return(null);
}
public static int GetInt(string expression, Creature player = null, Target target = null, CastedSpell spell = null, RollResults dice = null, object customData = null)
{
if (string.IsNullOrWhiteSpace(expression))
{
return(0);
}
StartEvaluation(player, $"GetInt({expression})", target, spell, dice, customData);
try
{
object result = 0;
try
{
result = expressionEvaluator.Evaluate(Clean(expression));
Log($" returns {result};");
}
catch (Exception ex)
{
OnExceptionThrown(null, new DndCoreExceptionEventArgs(ex));
return(0);
}
if (result is int)
{
return((int)result);
}
if (result is double)
{
return((int)Math.Round((double)result));
}
if (result is decimal)
{
return((int)Math.Round((decimal)result));
}
if (result is Enum)
{
return((int)result);
}
return(int.MinValue);
}
finally
{
FinishEvaluation(player);
}
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 1);
string message = evaluator.Evaluate <string>(args[0]);
player.Game.TellDungeonMaster(message);
return(null);
}
public static float GetFloat(string expression, Creature player = null, Target target = null, CastedSpell spell = null, RollResults dice = null, object customData = null)
{
return((float)GetDouble(expression, player, target, spell, dice, customData));
}
