public override object VisitAbilityLine([NotNull] classlist_langParser.AbilityLineContext context)
{
//add ability modif
AbilityModifier modif = new AbilityModifier();
var contextValue = context.value().VALUE();
if (contextValue is ErrorNodeImpl)
{
return(base.VisitAbilityLine(context));
}
modif.AbilityName = context.ability().GetText();
modif.Value = int.Parse(context.value().GetText());
if (context.abilityModifier().GetText() == "-")
{
modif.Value = -modif.Value;
}
currentClass.Modifiers.Add(modif);
return(base.VisitAbilityLine(context));
}
public void GivenATotalScore_StringIsReturned(int totalScore, string expected)
{
AbilityModifier ability = new AbilityModifier();
string actual = ability.Calculate(totalScore).ToString();
Assert.AreEqual(expected, actual);
}
public int CalculateTest([PexAssumeUnderTest] AbilityModifier target, int totalScore)
{
int result = target.Calculate(totalScore);
return(result);
// TODO: add assertions to method AbilityModifierTest.CalculateTest(AbilityModifier, Int32)
}
public void AbilityScores_HaveAppropriateModifier(int score, int expectedModifier)
{
AbilityScore abilityScore = new AbilityScore(score, Ability.Strength);
AbilityModifier modifier = new AbilityModifier(abilityScore);
Assert.AreEqual(modifier.Amount, expectedModifier);
}
public void SetAbility(WeaponItem weapon, ScriptableUseableAbility newAbility)
{
ScriptableAbility = newAbility;
Modifiers.Clear();
if (weapon)
{
//override the modifiers to add the attack bonus
var attackModifier = ScriptableObject.CreateInstance <ScriptableStatModifier>();
attackModifier.Type = StatType.ATTACK;
attackModifier.Amount = weapon.attack;
var AbilityModifier = new AbilityModifier();
AbilityModifier.Modifier = attackModifier;
AbilityModifier.Stage = ModifierStage.ACTION;
AbilityModifier.Target = ModifierTarget.CASTER;
Modifiers.Insert(0, AbilityModifier);
}
if (worldGameObject)
{
Destroy(worldGameObject);
}
Initilise();
}
private ModifierRoot ParseAbilityModifier(AbilityModifier abilityModifier)
{
ModifierRoot root = new ModifierRoot(abilityModifier.duration);
if (abilityModifier.OnIntervalThink != null)
{
foreach (var command in abilityModifier.OnIntervalThink)
{
root.AddModifier(new ModifierThinkInterval(ParseCommands(command), command.thinkInterval));
}
}
if (abilityModifier.OnAdd != null)
{
foreach (var command in abilityModifier.OnAdd)
{
root.AddModifier(new ModifierOnAdd(ParseCommands(command)));
}
}
if (abilityModifier.OnRemove != null)
{
foreach (var command in abilityModifier.OnRemove)
{
root.AddModifier(new ModifierOnRemove(ParseCommands(command)));
}
}
return(root);
}
/// <summary>
/// Updates the racial ability modifiers for the selected ability
/// </summary>
/// <param name="characterAbilityType">The character ability type</param>
private void UpdateRacialAbilityModifiers(Type characterAbilityType)
{
AbilityModifier racialAbilityModifier = CharacterCreator.GetRacialAbilityModifier(characterAbilityType);
Text characterAbilityRacialModifier = GetAbilityRacialModifierGameObject(characterAbilityType);
ClearRacialAbilityModifiers();
UpdateRacialAbilityModifier(characterAbilityRacialModifier, racialAbilityModifier.Modifier);
}
public void RemoveAbilityModifier(AbilityModifier mod) //todo maybe by id?
{
for (int i = 0; i < abilities.Count; i++)
{
mod.Remove(abilities[i]);
}
abilityModifiers.Remove(mod);
}
public void AddAbilityModifier(AbilityModifier mod)
{
mod.Initialize();
for (int i = 0; i < abilities.Count; i++)
{
mod.Apply(abilities[i]);
}
abilityModifiers.Add(mod); //todo maybe ref count these as well? or break into stacks
}
public virtual void CalculateAbilityMods()
{
AbilityModifier ability = new AbilityModifier();
StatMods.StrAbilityMod = ability.Calculate(TotalScore.StrTotalScore);
StatMods.DexAbilityMod = ability.Calculate(TotalScore.DexTotalScore);
StatMods.ConAbilityMod = ability.Calculate(TotalScore.ConTotalScore);
StatMods.IntAbilityMod = ability.Calculate(TotalScore.IntTotalScore);
StatMods.WisAbilityMod = ability.Calculate(TotalScore.WisTotalScore);
StatMods.ChaAbilityMod = ability.Calculate(TotalScore.ChaTotalScore);
}
/// <summary>
/// Returns an ability modifier for the specified type and returns its modifier
/// </summary>
/// <typeparam name="T">The type of ability</typeparam>
/// <returns>An integer value representing the ability modifier for the specified type of ability. Returns 0 if the type of ability modifier was not found.</returns>
public int GetModifier <T>()
{
int modifier;
AbilityModifier abilityModifier = FindModifier <T>();
if (abilityModifier != null)
{
modifier = abilityModifier.Modifier;
}
else
{
modifier = 0;
}
return(modifier);
}
private Modifier applyModifier(AbilityModifier abilityModifier, CharacterBase ownerCharacter,
CharacterBase targetCharacter)
{
if (abilityModifier.Modifier == null)
{
return(null);
}
//create a new instance of the modifier
Modifier modifier = new Modifier(abilityModifier.Modifier, ownerCharacter);
modifier.Apply(targetCharacter);
if (abilityModifier.Modifier.ActivePeriod <= 0.0f)
{
appliedInstantModifiers.Add(Tuple.Create(modifier, targetCharacter));
}
return(modifier);
}
public IAddSimpleAbilityActionModifierCommand(List <AbilityModifier> modifierList, AbilityModifier abilityModifier)
{
this.modifierList = modifierList;
this.abilityModifier = abilityModifier;
logInsert = true;
}
public void RemoveAbilityModifier(AbilityModifier mod) { //todo maybe by id?
for (int i = 0; i < abilities.Count; i++) {
mod.Remove(abilities[i]);
}
abilityModifiers.Remove(mod);
}
public void AddAbilityModifier(AbilityModifier mod) {
mod.Initialize();
for (int i = 0; i < abilities.Count; i++) {
mod.Apply(abilities[i]);
}
abilityModifiers.Add(mod); //todo maybe ref count these as well? or break into stacks
}
/// <summary>
/// Returns an ability modifier to support "Your Choice" modifiers
/// </summary>
/// <param name="characterAbilityType">The character ability type</param>
/// <returns>An ability modifier for the specified character ability</returns>
public static AbilityModifier GetRacialAbilityModifier(Type characterAbilityType)
{
AbilityModifier abilityModifier = new AbilityModifier(characterAbilityType, 2);
return(abilityModifier);
}
public IRemoveAbilityActionModifierCommand(IAbility ability, AbilityModifier modifier)
{
this.ability = ability;
this.modifier = modifier;
logInsert = true;
}
public IAddAbilityActionModifierCommand(IAbility ability, AbilityModifier abilityModifier)
{
this.ability = ability;
this.abilityModifier = abilityModifier;
logInsert = true;
}
public override void OnEffectApplied()
{
modifier = new CastSpeedModifier(SlowCastId, power);
target.abilityManager.AddAbilityModifier(modifier);
}
public override void OnEffectApplied() {
modifier = new CastSpeedModifier(SlowCastId, power);
target.abilityManager.AddAbilityModifier(modifier);
}
public IApplyModifierCommand(IAbility ability, AbilityModifier abilityModifier)
{
this.ability = ability;
this.abilityModifier = abilityModifier;
}
public void RemoveModifier(AbilityModifier m)
{
m.GetParent().RemoveModifier(m);
}
