public void SetAmmunitionParameters(string ammoParameters, Character player)
{
Name = "";
DamageBonusStr = "";
HueShift = "";
if (string.IsNullOrEmpty(ammoParameters))
{
return;
}
string[] parameters = ammoParameters.Split(',');
if (parameters.Length == 0)
{
return;
}
Name = Expressions.GetStr(parameters[0], player);
EffectName = Name;
if (parameters.Length > 1)
{
DamageBonusStr = parameters[1].Trim();
if (parameters.Length > 2)
{
HueShift = parameters[2].Trim();
}
if (parameters.Length > 3)
{
EffectName = parameters[3].Trim();
}
}
}
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, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 2, 4);
CardModType modType = DndUtils.ToCardModType(args[0].Trim());
int valueOffset;
double multiplier = 1;
int.TryParse(args[1], out valueOffset);
string userName = "";
if (args.Count > 2)
{
double.TryParse(args[2], out multiplier);
if (args.Count > 3)
{
userName = Expressions.GetStr(args[3].Trim());
}
}
//CreaturePlusModId recipient = Expressions.GetCustomData<CreaturePlusModId>(evaluator.Variables);
if (SystemVariables.DiceRoll != null)
{
SystemVariables.DiceRoll.CardModifiers.Add(new CardModifier(player.SafeId, userName, valueOffset, multiplier));
}
return(null);
}
public void Activate(string arguments, Character player, bool forceActivation = false)
{
if (IsActive && !forceActivation)
{
return;
}
string activationMessage;
if (!string.IsNullOrWhiteSpace(ActivationMessage))
{
activationMessage = Expressions.GetStr(DndUtils.InjectParameters(ActivationMessage, Parameters, arguments), player);
}
else if (player != null)
{
activationMessage = $"Activating {player.name}'s {Name}.";
}
else
{
activationMessage = $"Activating {Name}.";
}
IsActive = true;
if (Duration.HasValue())
{
string alarmName = $"{player.name}.{Name}";
History.TimeClock.CreateAlarm(Duration.GetTimeSpan(), alarmName, player).AlarmFired += Feature_Expired;
}
if (!string.IsNullOrWhiteSpace(OnActivate))
{
Expressions.Do(DndUtils.InjectParameters(OnActivate, Parameters, arguments), player);
}
OnRequestMessageToDungeonMaster(this, activationMessage);
OnFeatureActivated(player, new FeatureEventArgs(this));
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Creature target = null, CastedSpell spell = null)
{
AddReminderEventArgs ea = new AddReminderEventArgs(Expressions.GetStr(args[0], player, target, spell), Expressions.GetStr(args[1], player, target, spell));
AddReminder(player, ea);
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Creature target = null, CastedSpell spell = null)
{
AskEventArgs ea = new AskEventArgs(Expressions.GetStr(args[0], player, target, spell), args.Skip(1).ToList());
OnAskQuestion(player, ea);
return(ea.Result);
}
public void Deactivate(string arguments, Character player, bool forceDeactivation = false)
{
if (!IsActive && !forceDeactivation)
{
return;
}
string deactivationMessage;
if (!string.IsNullOrWhiteSpace(DeactivationMessage))
{
deactivationMessage = Expressions.GetStr(DndUtils.InjectParameters(DeactivationMessage, Parameters, arguments), player);
}
else if (player != null)
{
deactivationMessage = $"Deactivating {player.name}'s {Name}.";
}
else
{
deactivationMessage = $"Deactivating {Name}.";
}
IsActive = false;
TriggerDeactivate(arguments, player);
OnRequestMessageToDungeonMaster(this, deactivationMessage);
OnFeatureDeactivated(player, new FeatureEventArgs(this));
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Creature target = null, CastedSpell spell = null)
{
ExpectingArguments(args, 1);
if (player != null)
{
player.AddSpellsFrom(Expressions.GetStr(args[0], player, target, spell));
}
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);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 3);
string dungeonMasterMessage = Expressions.GetStr(args[0], player, target, spell, dice);
string floatText = Expressions.GetStr(args[1], player, target, spell, dice);
ValidationAction validationAction = Expressions.Get <ValidationAction>(args[2].Trim(), player, target, spell, dice);
Validation.OnValidationFailed(dungeonMasterMessage, floatText, validationAction);
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, DiceStoppedRollingData 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, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 3);
string userName = Expressions.GetStr(args[0], player, target, spell);
string chargeName = Expressions.GetStr(args[1], player, target, spell);
int chargeCount = Expressions.GetInt(args[2], player, target, spell);
OnRequestAddViewerCharge(new RequestAddViewerChargeEventArgs(userName, chargeName, chargeCount));
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Target target = null, CastedSpell spell = null, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 1);
if (player != null)
{
string spellList = Expressions.GetStr(args[0], player, target, spell);
player.AddSpellsFrom(spellList);
}
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);
if (player != null)
{
string spellList = Expressions.GetStr(args[0], player, target, spell);
player.AddSpellsFrom(spellList);
}
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 1);
if (player != null)
{
string languageStr = Expressions.GetStr(args[0], player, target, spell);
player.AddLanguages(languageStr);
}
return(null);
}
static string GetSpellDescription(CastedSpell castedSpell)
{
if (castedSpell.Spell.Description.IndexOf('{') < 0)
{
return(castedSpell.Spell.Description);
}
string result = Expressions.GetStr("$\"" + EmphasizeCalculatedProperties(castedSpell) + "\"", castedSpell.SpellCaster, castedSpell.TargetCreature, castedSpell);
return(result);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 1, 6);
string spellId = null;
if (spell != null)
{
spellId = spell.ID;
}
else
{
CreaturePlusModId creaturePlusModId = Expressions.GetCustomData <CreaturePlusModId>(evaluator.Variables);
if (creaturePlusModId != null)
{
spellId = creaturePlusModId.Guid;
}
}
float lifeTime = 0;
float shrinkTime = 0;
float rotationDegrees = 0;
if (player != null && spellId != null)
{
string effectName = Expressions.GetStr(args[0]);
float secondsDelayStart = 0;
float enlargeTime = 0;
if (args.Count > 1)
{
float.TryParse(args[1], out secondsDelayStart);
if (args.Count > 2)
{
float.TryParse(args[2], out enlargeTime);
if (args.Count > 3)
{
float.TryParse(args[3], out lifeTime);
if (args.Count > 4)
{
float.TryParse(args[4], out shrinkTime);
if (args.Count > 5)
{
float.TryParse(args[5], out rotationDegrees);
}
}
}
}
}
OnAttachChargingEffect(effectName, spellId, player.taleSpireId, secondsDelayStart, enlargeTime, lifeTime, shrinkTime, rotationDegrees);
}
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Target target, CastedSpell spell, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 4);
string rechargeableName = Expressions.GetStr(args[0], player, target, spell);
string variableName = Expressions.GetStr(args[1], player, target, spell);
int maxValue = Expressions.GetInt(args[2], player, target, spell);
string cycle = Expressions.GetStr(args[3], player, target, spell);
player.AddRechargeable(rechargeableName, variableName, maxValue, cycle);
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 override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, RollResults dice = null)
{
ExpectingArguments(args, 2, 10);
string cardEventName = Expressions.GetStr(args[0]);
string cardUserName = Expressions.GetStr(args[1]);
object data1 = null;
object data2 = null;
object data3 = null;
object data4 = null;
object data5 = null;
object data6 = null;
object data7 = null;
object data8 = null;
if (args.Count > 2)
{
data1 = GiveMagicFunction.GetData(args[2], player, target, spell);
}
if (args.Count > 3)
{
data2 = GiveMagicFunction.GetData(args[3], player, target, spell);
}
if (args.Count > 4)
{
data3 = GiveMagicFunction.GetData(args[4], player, target, spell);
}
if (args.Count > 5)
{
data4 = GiveMagicFunction.GetData(args[5], player, target, spell);
}
if (args.Count > 6)
{
data5 = GiveMagicFunction.GetData(args[6], player, target, spell);
}
if (args.Count > 7)
{
data6 = GiveMagicFunction.GetData(args[7], player, target, spell);
}
if (args.Count > 8)
{
data7 = GiveMagicFunction.GetData(args[8], player, target, spell);
}
if (args.Count > 9)
{
data8 = GiveMagicFunction.GetData(args[9], player, target, spell);
}
OnRequestCardEventQueuing(new QueueEffectEventArgs(cardEventName, cardUserName, data1, data2, data3, data4, data5, data6, data7, data8));
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Target target = null, CastedSpell spell = null, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 1);
string nextWord = Expressions.GetStr(args[0], player, target, spell).ToLower();
if (nextWord.StartsWith("a") || nextWord.StartsWith("e") || nextWord.StartsWith("i") || nextWord.StartsWith("o") || nextWord.StartsWith("u"))
{
return("an");
}
else
{
return("a");
}
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Target target, CastedSpell spell, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 3);
int value = Expressions.GetInt(args[0], player, target, spell);
if (value == 1)
{
return(Expressions.GetStr(args[1], player, target, spell)); // singular.
}
else
{
return(Expressions.GetStr(args[2], player, target, spell)); // plural
}
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Target target, CastedSpell spell, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 1);
string timerName = Expressions.GetStr(args[0], player, target, spell);
if (player == null)
{
return(null);
}
if (player.Game == null)
{
return(null);
}
player.Game.Clock.RemoveAlarm(timerName);
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
Creature modOwner = Expressions.GetCustomData <Creature>(evaluator.Variables);
if (modOwner == null)
{
throw new Exception($"Creature mod owner must be specified before evaluating expressions containing RemovePropertyMod.");
}
ExpectingArguments(args, 2);
string propertyName = Expressions.GetStr(args[0], player, target, spell);
string id = Expressions.GetStr(args[1], player, target, spell);
modOwner.RemovePropertyMod(propertyName, id);
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 3, 4);
string sourceName = Expressions.GetStr(args[0], player);
string filterName = Expressions.GetStr(args[1]);
bool filterEnabled = Expressions.GetBool(args[2]);
int delayMs = 0;
if (args.Count > 3)
{
delayMs = Expressions.GetInt(args[3]);
}
OnRequestSetObsSceneFilterVisibility(null, new ObsSceneFilterEventArgs(sourceName, filterName, filterEnabled, delayMs));
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature player, Target target = null, CastedSpell spell = null, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 0, 1);
string weaponFilter = null;
if (args.Count > 0)
{
weaponFilter = Expressions.GetStr(args[0], player, target, spell);
}
if (player != null)
{
return(player.ChooseWeapon(weaponFilter));
}
return(null);
}
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 override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Target target = null, CastedSpell spell = null, DiceStoppedRollingData 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.AddSpellCastSoundEffect(fileName, timeOffsetMs);
}
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Creature creature, Target target, CastedSpell spell, RollResults dice = null)
{
ExpectingArguments(args, 3);
string timerName = Expressions.GetStr(args[0], creature, target, spell);
int durationSeconds = Expressions.GetInt(args[1], creature, target, spell);
string functionToCall = Expressions.GetStr(args[2], creature, target, spell);
if (creature == null)
{
return(null);
}
if (creature.Game == null)
{
return(null);
}
DndAlarm dndAlarm = creature.Game.Clock.CreateAlarm(TimeSpan.FromSeconds(durationSeconds), timerName, creature, functionToCall);
dndAlarm.AlarmFired += DndAlarm_AlarmFired;
return(null);
}
public override object Evaluate(List <string> args, ExpressionEvaluator evaluator, Character player, Target target, CastedSpell spell, DiceStoppedRollingData dice = null)
{
ExpectingArguments(args, 3);
string timerName = Expressions.GetStr(args[0], player, target, spell);
int durationSeconds = Expressions.GetInt(args[1], player, target, spell);
string functionToCall = Expressions.GetStr(args[2], player, target, spell);
if (player == null)
{
return(null);
}
if (player.Game == null)
{
return(null);
}
DndAlarm dndAlarm = player.Game.Clock.CreateAlarm(TimeSpan.FromSeconds(durationSeconds), timerName, player, functionToCall);
dndAlarm.AlarmFired += DndAlarm_AlarmFired;
return(null);
}
