private void AddModifiers(AffectedStat stat, UnitBase unit, bool isBuff)
{
switch (stat)
{
case AffectedStat.MaxHP: break;
case AffectedStat.Strength: modifier = isBuff?
new StatModifier(BuffMultiplier, StatModType.PercentAdd, this) :
new StatModifier(DebuffMultiplier, StatModType.PercentAdd, this);
unit.strength.AddModifier(modifier); break;
case AffectedStat.Magic: modifier = isBuff?
new StatModifier(BuffMultiplier, StatModType.PercentAdd, this) :
new StatModifier(DebuffMultiplier, StatModType.PercentAdd, this);
unit.magic.AddModifier(modifier); break;
case AffectedStat.Accuracy: modifier = isBuff?
new StatModifier(BuffMultiplier, StatModType.PercentAdd, this) :
new StatModifier(DebuffMultiplier, StatModType.PercentAdd, this);
unit.accuracy.AddModifier(modifier); break;
case AffectedStat.Initiative: modifier = isBuff?
new StatModifier(BuffMultiplier, StatModType.PercentAdd, this) :
new StatModifier(DebuffMultiplier, StatModType.PercentAdd, this);
unit.initiative.AddModifier(modifier); break;
case AffectedStat.CriticalChance: modifier = isBuff?
new StatModifier(BuffMultiplier, StatModType.PercentAdd, this) :
new StatModifier(DebuffMultiplier, StatModType.PercentAdd, this);
unit.criticalChance.AddModifier(modifier); break;
case AffectedStat.Defense: modifier = isBuff?
new StatModifier(BuffMultiplier, StatModType.PercentAdd, this) :
new StatModifier(DebuffMultiplier, StatModType.PercentAdd, this);
unit.defense.AddModifier(modifier); break;
case AffectedStat.Resistance: modifier = isBuff?
new StatModifier(BuffMultiplier, StatModType.PercentAdd, this) :
new StatModifier(DebuffMultiplier, StatModType.PercentAdd, this);
unit.resistance.AddModifier(modifier); break;
case AffectedStat.None: break;
default: Logging.Log("Could not find the stat to modify"); break;
}
}
private void AddModifiers(UnitBase target)
{
target.strength.AddModifier(new StatModifier
(GlobalVariables.Instance.moderateDebuff, StatModType.PercentAdd, this));
target.magic.AddModifier(new StatModifier
(GlobalVariables.Instance.moderateDebuff, StatModType.PercentAdd, this));
target.accuracy.AddModifier(new StatModifier
(GlobalVariables.Instance.moderateDebuff, StatModType.PercentAdd, this));
target.initiative.AddModifier(new StatModifier
(GlobalVariables.Instance.moderateDebuff, StatModType.PercentAdd, this));
target.criticalChance.AddModifier(new StatModifier
(GlobalVariables.Instance.moderateDebuff, StatModType.PercentAdd, this));
target.defense.AddModifier(new StatModifier
(GlobalVariables.Instance.moderateDebuff, StatModType.PercentAdd, this));
target.resistance.AddModifier(new StatModifier
(GlobalVariables.Instance.moderateDebuff, StatModType.PercentAdd, this));
}
public void SetTimer(StatusEffect effect, UnitBase unit)
{
targetUnit = unit;
statusEffect = effect;
timer = statusEffect.turnDuration;
removeEffectAtCharacterTurn = effect.removeEffectAtStartOfTurn;
removeEffectAfterCharacterTurn = effect.removeEffectAfterNextTurn;
if (effect.removeEffectAtStartOfTurn)
{
targetUnit.onStatusEvaluation += RemoveEffectAtStartOfTurn;
}
battleEvent.AddListener(this);
BattleEvents.SkipTurnEvent.AddListener(this);
targetUnit.onDeath += RemoveTimerAndEffect;
targetUnit.Unit.recoveredFromOverexertion += RemoveTimerAndEffect;
}
public override void InflictStatus(UnitBase unitBase)
{
var random = Random.value;
if (random > chanceOfInfliction)
{
return;
}
DamagePrefabManager.Instance.DamageTextColor = color;
var modifier = StatusEffectModifier(unitBase);
var dmg = (int)(damagePercentage * modifier * unitBase.Unit.maxHealthRef);
dmg = Random.Range((int)(0.98f * dmg), (int)(1.02f * dmg));
unitBase.TakeDamage(dmg);
// show shocked visual effect
Battle.Engine.canGiveCommand = false;
}
private void RemoveModifier(AffectedStat stat, UnitBase unit)
{
switch (stat)
{
case AffectedStat.MaxHP: break;
case AffectedStat.Strength: unit.strength.RemoveModifier(modifier); break;
case AffectedStat.Magic: unit.magic.RemoveModifier(modifier); break;
case AffectedStat.Accuracy: unit.accuracy.RemoveModifier(modifier); break;
case AffectedStat.Initiative: unit.initiative.RemoveModifier(modifier); break;
case AffectedStat.CriticalChance: unit.criticalChance.RemoveModifier(modifier); break;
case AffectedStat.Defense: unit.defense.RemoveModifier(modifier); break;
case AffectedStat.Resistance: unit.resistance.RemoveModifier(modifier); break;
case AffectedStat.None: break;
}
}
public void OnEventRaised(UnitBase value1, CharacterGameEvent value2)
{
if (value1 == currentSummon && ((Enemy)value1).isSummon)
{
elias.Unit.anim.Play($"Ability {summonAbility.attackState}", 0);
}
if (value1 == elias && value2 == BattleEvents.CharacterAttackEvent &&
elias.CurrentAbility == analyzeAbility && !elias.CurrentTarget.Unit.isCountered)
{
notificationHandler.ShowNotification($"Beginning analysis of {value1.characterName}");
BeginAnalyze((Enemy)elias.CurrentTarget);
}
if (value1 == elias && value2 == BattleEvents.EndOfTurnEvent && isAnalyzing)
{
SetListenerForHpLowered();
}
if (value1 == elias && value2 == BattleEvents.CharacterTurnEvent && isAnalyzing)
{
EndAnalyze();
}
}
public static IEnumerator <float> InflictOnTargets(this UnitBase attacker, Rate rate, float delay, bool delayAfterInfliction)
{
if (attacker.Unit.isAbility && attacker.Unit.currentAbility.isMultiTarget)
{
foreach (var target in attacker.Unit.multiHitTargets.
Where(target => !target.Unit.attackerHasMissed && !target.IsDead))
{
foreach (var statusEffect in from statusEffect in target.StatusEffects
where statusEffect.rateOfInfliction.Contains(rate) select statusEffect)
{
if (attacker.IsDead)
{
break;
}
if (!delayAfterInfliction)
{
yield return(Timing.WaitForSeconds(delay));
}
statusEffect.InflictStatus(target);
if (delayAfterInfliction)
{
yield return(Timing.WaitForSeconds(delay));
}
if (attacker.IsDead)
{
break;
}
}
}
yield break;
}
if (attacker.Unit.currentTarget.Unit.attackerHasMissed || attacker.Unit.currentTarget.IsDead)
{
yield break;
}
foreach (var statusEffect in from statusEffect in attacker.Unit.currentTarget.StatusEffects
where statusEffect.rateOfInfliction.Contains(rate) select statusEffect)
{
if (attacker.Unit.currentTarget.IsDead)
{
break;
}
if (!delayAfterInfliction)
{
yield return(Timing.WaitForSeconds(delay));
}
statusEffect.InflictStatus(attacker.Unit.currentTarget);
if (delayAfterInfliction)
{
yield return(Timing.WaitForSeconds(delay));
}
if (attacker.Unit.currentTarget.IsDead)
{
break;
}
}
}
public override void OnRemoval(UnitBase unitBase)
{
base.OnRemoval(unitBase);
unitBase.Unit.statuses.Remove(Status.UnableToPerformAction);
}
private void ResetTargets()
{
currentTarget = null;
multiHitTargets.Clear();
damageValueList.Clear();
}
public override void OnAdded(UnitBase target)
{
base.OnAdded(target);
target.Unit.overrideElemental = true;
}
public override void OnRemoval(UnitBase unitBase)
{
base.OnRemoval(unitBase);
unitBase.Unit.overrideElemental = false;
}
public void Init(UnitBase unit)
{
unitBase = unit;
unitBase.Unit.onSelect += UpdateIcons;
}
public override void OnAdded(UnitBase target, bool showText = true)
{
base.OnAdded(target, showText);
target.Unit.overrideElemental = true;
}
