//apply damage, dot, buffs, etc.
public virtual void ApplyEffect(Unit actor, Unit target, ref AbilityResultList results)
{
DelayedResult result = DelayedResult.hit;
if (actor.UnitTeam.isAlly != target.UnitTeam.isAlly)
{
if (ResistType.ContainsKey(Type)) //resistable effect
{
int resist = target.stats.GetStat(ResistType[Type]);
int roll = Random.Range(0, 100);
if (roll < resist)
{
result = DelayedResult.resist;
}
}
}
DelayedAbilityResult r = new DelayedAbilityResult()
{
target = target,
delayedEffect = this,
result = result,
};
results.delayedEffects.Add(r);
}
public override void ModifyAttack(Ability_Attack a, Unit actor, Unit target, ref AbilityResultList results)
{
if (actor.stats.Defense().x > 0)
{
a.ApplyCounter(actor, target, ref results);
}
}
public virtual void ApplyAbility(Unit actor, Unit target, ref AbilityResultList results)
{
if (cancelDisplay)
{
results.display = false;
}
if (isAOE)
{
foreach (Unit u in target.UnitTeam.GetUnits())
{
if (u.targetedState == TargetedState.Targeted)
{
foreach (Effect e in targetBuffs)
{
e.ApplyEffect(actor, u, ref results);
}
}
}
}
else
{
foreach (Effect e in targetBuffs)
{
e.ApplyEffect(actor, target, ref results);
}
}
foreach (Effect e in selfBuffs)
{
e.ApplyEffect(actor, actor, ref results);
}
}
public void AttackModifiers(Ability_Attack a, Unit actor, Unit target, ref AbilityResultList results)
{
foreach (Traits t in traits)
{
t.ModifyAttack(a, actor, target, ref results);
}
}
public void ShowAbilityTargets(AbilityResultList results)
{
results.actor.SetTargetState(TargetedState.Current);
foreach (AbilityResult a in results.targets)
{
a.target.SetTargetState(TargetedState.Targeted);
}
}
public void DisplayCounter(AbilityResultList results)
{
//results.counter.
foreach (AbilityResult r in results.counter)
{
r.Display();
r.actor.SetSprite(r.actor.stats.GetSpriteHeader() + "_Counter");
}
}
public override void ApplyEffect(Unit actor, Unit target, ref AbilityResultList results)
{
DelayedAbilityResult r = new DelayedAbilityResult()
{
target = target,
delayedEffect = this,
result = DelayedResult.hit,
};
results.stress.Add(r);
}
public void PlayEvent(Ability_Event ability, Unit trap)
{
AbilityResultList results = new AbilityResultList
{
actor = trap,
ability = ability,
display = !ability.cancelDisplay,
};
ability.ApplyAbility(trap, currentUnit, ref results);
StartCoroutine(ExecuteAbilityTurn(results));
}
public override void ApplyEffect(Unit actor, Unit target, ref AbilityResultList results)
{
AbilityResult r = new AbilityResult()
{
actor = actor,
target = target,
amount = amount,
result = Result.Heal
};
results.targets.Add(r);
}
public override void Counterattack(Unit actor, Unit target, ref AbilityResultList results)
{
//TODO roll for miss
AbilityResult r = new AbilityResult()
{
target = target,
amount = (int)(target.stats.GetStat(StatType.damage) * multiplier),
result = Result.Hit
};
actor.stats.TakeDamage(r.amount);
results.counter.Add(r);
}
public void ApplyCounter(Unit actor, Unit target, ref AbilityResultList results)
{
Result counterResult = RollCrit(target, 0);
float crit = counterResult == Result.Crit ? 1.5f: 1f;
results.counter.Add(new AbilityResult()
{
actor = target,
target = actor,
amount = (int)(target.stats.GetStat(StatType.damage, actor) * countermod * crit),
result = counterResult
});
}
public override void ApplyEffect(Unit actor, Unit target, ref AbilityResultList results)
{
//TODO: roll for crit def
Vector2Int def = actor.stats.Defense();
AbilityResult r = new AbilityResult()
{
actor = actor,
target = target,
amount = Mathf.Min(amount, def.y - def.x),
result = Result.Def
};
results.targets.Add(r);
}
public void DisplayActor(AbilityResultList results, float time)
{
if (!results.display)
{
return;
}
gameObject.SetActive(true);
results.actor.transform.SetParent(transform);
results.actor.SetLight(Unit.UnitLight.attack, true);
//set up effects sprites
results.actor.SetEffectSprite(string.Format("{0}_{1}", results.actor.stats.GetClassName(), results.ability.abilityName));
if (results.ability.actorParticles)
{
results.actor.SetParticleEffect(results.ability.actorParticles);
}
//check correct position to place in.
if (results.actor.UnitTeam.isAlly)
{
if (results.ability.IsAttack)
{
results.actor.MoveUnit(results.ability.isRanged?
allyRanged.localPosition : allyMelee.localPosition, displayScale, time);
//results.actor.SetPosScale(results.ability.isRanged? allyRanged.localPosition : allyMelee.localPosition, displayScale);
}
else
{
results.actor.MoveUnit(allyTargets[results.actor.Location].localPosition, displayScale, time);
//results.actor.SetPosScale(allyTargets[results.actor.Location].localPosition, displayScale);
}
}
else
{
if (results.ability.IsAttack)
{
results.actor.MoveUnit(results.ability.isRanged?
enemyRanged.localPosition : enemyMelee.localPosition, displayScale, time);
//results.actor.SetPosScale(results.ability.isRanged? enemyRanged.localPosition : enemyMelee.localPosition, displayScale);
}
else
{
results.actor.MoveUnit(enemyTargets[results.actor.Location].localPosition, displayScale, time);
//results.actor.SetPosScale(enemyTargets[results.actor.Location].localPosition, displayScale);
}
}
results.actor.SetSprite(string.Format("{0}_{1}", results.actor.stats.GetSpriteHeader(), results.ability.abilityName));
results.actor.TurnOffUIElemenets();
//add self abilities?
}
public void PlayAction(Ability ability, Unit target)
{
AbilityResultList results = new AbilityResultList
{
actor = currentUnit,
ability = ability,
display = !ability.cancelDisplay,
};
ability.ApplyAbility(currentUnit, target, ref results);
if (ability.metalCost > 0)
{
GameState.Instance.metal.UpdateMetal(-ability.metalCost);
}
StartCoroutine(ExecuteAbilityTurn(results));
}
protected void ApplyDamage(Unit actor, Unit target, int roll, ref AbilityResultList results)
{
if (target.stats.modifiers.IsGuard)
{
target = target.stats.modifiers.Guard.GetTarget();
}
Result r = RollAccuracy(actor, target, roll);
if (r == Result.Miss || r == Result.Dodge || r == Result.Block)
{
//miss/block
results.targets.Add(new AbilityResult()
{
actor = actor,
target = target,
amount = 0,
result = r
});
//apply counter due to miss/block
ApplyCounter(actor, target, ref results);
}
else
{
//apply damage
float multiplier = r == Result.Crit ? 2 : 1;
results.targets.Add(new AbilityResult()
{
actor = actor,
target = target,
amount = (int)(GetDamage(actor, target) * dmgmod * multiplier),
result = r,
});
//apply debuffs
foreach (Effect e in TargetBuffs)
{
e.ApplyEffect(actor, target, ref results);
}
}
actor.stats.modifiers.UpdateOnAction(EffectType.attack, target);
}
public override void ApplyAbility(Unit actor, Unit target, ref AbilityResultList results)
{
int roll = Random.Range(0, 100);
if (isAOE)
{
foreach (Unit u in target.UnitTeam.GetUnits())
{
if (u.targetedState == TargetedState.Targeted)
{
ApplyDamage(actor, u, roll, ref results);
}
}
}
else
{
ApplyDamage(actor, target, roll, ref results);
}
foreach (Effect e in SelfBuffs)
{
e.ApplyEffect(actor, actor, ref results);
}
}
public void ApplyAbility(Unit actor, ref AbilityResultList results)
{
if (effects == null)
{
Init();
}
if (isAOE)
{
foreach (Unit u in actor.UnitTeam.GetUnits())
{
foreach (Effect e in effects)
{
e.ApplyEffect(u, u, ref results);
}
}
}
else
{
foreach (Effect e in effects)
{
e.ApplyEffect(actor, actor, ref results);
}
}
}
public override void ApplyAbility(Unit actor, Unit target, ref AbilityResultList results)
{
if (dmgmod > 0)
{
int roll = Random.Range(0, 100);
if (isAOE)
{
foreach (Unit u in target.UnitTeam.GetUnits())
{
ApplyDamage(actor, u, roll, ref results);
}
}
else
{
ApplyDamage(actor, target, roll, ref results);
}
}
if (isAOE)
{
foreach (Unit u in target.UnitTeam.GetUnits())
{
foreach (Effect e in TargetBuffs)
{
e.ApplyEffect(actor, u, ref results);
}
}
}
else
{
foreach (Effect e in TargetBuffs)
{
e.ApplyEffect(actor, target, ref results);
}
}
results.counter.Clear();
}
public override void UseItem(Unit actor)
{
AbilityResultList temp = new AbilityResultList();
effect.ApplyAbility(actor, ref temp);
}
public void DisplayAbilityName(AbilityResultList results)
{
abilityTitle.text = results.ability.abilityName;
abilityTitleParent.SetActive(true);
}
public IEnumerator ExecuteAbilityTurn(AbilityResultList results)
{
//lock player input
GameState.Instance.ic.SetBlock(true);
//turn lighting teams off
GameState.Instance.ally.TurnLightingOn(false);
GameState.Instance.enemy.TurnLightingOn(false);
//turn off alarm visibilty;
GameState.Instance.am.SetAlarmVisible(false);
//play animation
if (results.display)
{
if (!results.actor.UnitTeam.isAlly)
{
GameState.Instance.uic.action.DisplayAbilityName(results);
GameState.Instance.uic.action.ShowAbilityTargets(results);
yield return(new WaitForSeconds(0.75f));
GameState.Instance.uic.action.HideAbilityName();
}
GameState.Instance.uic.action.DisplayActor(results, 0.1f);
GameState.Instance.uic.ScaleBackground(1.5f, 0.5f);
yield return(new WaitForSeconds(0.1f));
GameState.Instance.uic.action.DisplayTargets(results, 1.0f);
yield return(new WaitForSeconds(0.5f));
GameState.Instance.uic.action.DisplayCounter(results);
yield return(new WaitForSeconds(1.0f));
//update unit uis
GameState.Instance.uic.action.HideAciton();
GameState.Instance.uic.ScaleBackground(1.0f, 0.5f);
}
//turn lighting back on
GameState.Instance.ally.TurnLightingOn(true);
GameState.Instance.enemy.TurnLightingOn(true);
GameState.Instance.am.SetAlarmVisible(true);
//applies delayed effects like bleed or buffs
List <Unit> targets = new List <Unit>();
foreach (DelayedAbilityResult d in results.delayedEffects)
{
d.ApplyEffect(results.actor);
d.Display();
if (!targets.Contains(d.target))
{
targets.Add(d.target);
}
}
//waits for all effects to be played out
bool doneDisplay = false;
while (!doneDisplay)
{
doneDisplay = true;
foreach (Unit u in targets)
{
if (!u.IsFinishedPopupText())
{
doneDisplay = false;
}
}
yield return(new WaitForFixedUpdate());
}
//applies stress
foreach (DelayedAbilityResult d in results.stress)
{
d.ApplyEffect(results.actor);
d.Display();
while (playAffliction)
{
yield return(new WaitForSeconds(GameState.Instance.uic.affliction.GetDuration()));
}
yield return(new WaitForSeconds(0.75f));
}
//unlock player input
GameState.Instance.ic.SetBlock(false);
NextTurn(); //after finished
yield return(null);
}
public void DisplayTargets(AbilityResultList results, float duration)
{
int direction = results.actor.UnitTeam.isAlly ? 1: -1;
results.actor.UpdateUnitPosition(results.ability.isRanged? (forward * -1 * direction) : forward * direction, duration);
moved.Add(results.actor);
bool hit = false;
float crit = 1.0f;
bool hasSprite = results.ability.spriteType == AbilitySpriteType.single ? true : false;
if (results.ability.spriteType == AbilitySpriteType.aoe)
{
hasSprite = false;
if (results.targets.Count > 0)
{
if (results.targets[0].target.UnitTeam.isAlly)
{
allyProjectile.sprite = SpriteLibrary.GetAbilityEffectSprite(results.ability.abilityName);
allyProjectile.enabled = true;
}
else
{
enemyProjectile.sprite = SpriteLibrary.GetAbilityEffectSprite(results.ability.abilityName);
enemyProjectile.enabled = true;
}
}
}
foreach (AbilityResult r in results.targets)
{
r.target.transform.SetParent(transform);
if (hasSprite)
{
r.target.SetEffectSprite(results.ability.abilityName);
}
r.target.SetParticleEffect(results.ability.targetPartcles);
if (r.target.UnitTeam.isAlly)
{
r.target.MoveUnit(allyTargets[r.target.Location].localPosition, displayScale);
}
else
{
r.target.MoveUnit(enemyTargets[r.target.Location].localPosition, displayScale);
}
if (results.ability.IsAttack)
{
r.target.SetSprite(string.Format("{0}_Hurt", r.target.stats.GetSpriteHeader()));
r.target.SetLight(Unit.UnitLight.hurt, true);
}
else
{
r.target.SetLight(Unit.UnitLight.attack, true);
}
r.target.TurnOffUIElemenets();
moved.Add(r.target);
if (r.result == Result.Hit || r.result == Result.Crit)
{
hit = true;
if (r.result == Result.Crit)
{
crit = 2.0f;
}
}
r.Display();
//TODO check for death icons, etc.
}
enemyProjectile.transform.SetAsLastSibling();
allyProjectile.transform.SetAsFirstSibling();
if (hit)
{
shake.StartShake(shakeIntensity * crit, shakeDuration);
}
}
public virtual void ModifyAttack(Ability_Attack a, Unit actor, Unit target, ref AbilityResultList results)
{
}
public virtual void Counterattack(Unit actor, Unit Target, ref AbilityResultList results)
{
}
public override void ApplyEffect(Unit actor, Unit target, ref AbilityResultList results)
{
GameState.Instance.metal.UpdateMetal(amount);
}
