//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); }