private void FinishAction(TimedActionController.Performance defPerformance) { _performanceHasEnded = true; AbilityDetails details = Gm.combatManager.DequeueNextAbility(); details.performance = ((NPCombatant)details.performer).DetermineNPCPerformance(); details.targets[0].overheadHud.inputIndicator.Show(false); foreach (GridObject target in details.targets) { details.RegisterTargetPerformance(target, _defPerformance); } details.performer.PerformAbility(details); foreach (GridObject target in details.targets) { if (target is Combatant combatant) { if (combatant.state == Combatant.State.Blocking) { combatant.state = Combatant.State.Idle; } } } }
protected override void OnApplyEffect(Combatant primaryTarget, AbilityDetails details) { foreach (GridObject target in details.targets) { if (target is Combatant combatant) { if (stat == Stat.End) { combatant.profile.EndLvl += modifier; } else if (stat == Stat.Str) { combatant.profile.StrLvl += modifier; } else if (stat == Stat.Dex) { combatant.profile.DexLvl += modifier; } else if (stat == Stat.Wis) { combatant.profile.WisLvl += modifier; } } } }
public void Start() { this.HumanActiveAbility = this.SetAbilityDetails(AbilityDetails.AbilityType.Active, AbilityDetails.PlayerForm.Human, this.HumanActiveAbilityImage, this.HumanActiveAbilityName, this.HumanActiveAbilityDescription, this.HumanActiveAbilityCooldown); this.HumanPassiveAbility = this.SetAbilityDetails(AbilityDetails.AbilityType.Passive, AbilityDetails.PlayerForm.Human, this.HumanPassiveAbilityImage, this.HumanPassiveAbilityName, this.HumanPassiveAbilityDescription, this.HumanPassiveAbilityCooldown); this.WerebeastActiveAbility = this.SetAbilityDetails(AbilityDetails.AbilityType.Active, AbilityDetails.PlayerForm.Werebeast, this.WerebeastActiveAbilityImage, this.WerebeastActiveAbilityName, this.WerebeastActiveAbilityDescription, this.WerebeastActiveAbilityCooldown); this.WerebeastPassiveAbility = this.SetAbilityDetails(AbilityDetails.AbilityType.Passive, AbilityDetails.PlayerForm.Werebeast, this.WerebeastPassiveAbilityImage, this.WerebeastPassiveAbilityName, this.WerebeastPassiveAbilityDescription, this.WerebeastPassiveAbilityCooldown); }
/// <summary> /// Set the ability details for every form (human vs werebeast) and type (active vs passive) /// </summary> /// <param name="abilityType">Ability type</param> /// <param name="playerForm">Player form</param> /// <param name="abilityImage">Ability image for UI</param> /// <param name="abilityName">Ability name for UI</param> /// <param name="abilityDescription">Ability description for UI</param> /// <param name="abilityCooldown">Ability cooldown for UI</param> public AbilityDetails SetAbilityDetails(AbilityDetails.AbilityType abilityType, AbilityDetails.PlayerForm playerForm, Sprite abilityImage, string abilityName, string abilityDescription, float abilityCooldown) { // Use switch to generate AbilityDetails object for each case switch (playerForm) { case AbilityDetails.PlayerForm.Human: switch (abilityType) { case AbilityDetails.AbilityType.Active: this.humanActiveAbility = new AbilityDetails(abilityType, playerForm, abilityImage, abilityName, abilityDescription, abilityCooldown); return(this.humanActiveAbility); case AbilityDetails.AbilityType.Passive: this.humanPassiveAbility = new AbilityDetails(abilityType, playerForm, abilityImage, abilityName, abilityDescription, abilityCooldown); return(this.humanPassiveAbility); } break; case AbilityDetails.PlayerForm.Werebeast: switch (abilityType) { case AbilityDetails.AbilityType.Active: this.werebeastActiveAbility = new AbilityDetails(abilityType, playerForm, abilityImage, abilityName, abilityDescription, abilityCooldown); return(this.werebeastActiveAbility); case AbilityDetails.AbilityType.Passive: this.werebeastPassiveAbility = new AbilityDetails(abilityType, playerForm, abilityImage, abilityName, abilityDescription, abilityCooldown); return(this.werebeastPassiveAbility); } break; } return(null); }
public override int GetBonusDamage(float baseDamage, AbilityDetails details, Combatant defender) { int missingHP = defender.maxHP - defender.Hitpoints; float netRatio = GetRatio(details.performance); return((int)Mathf.Clamp(missingHP * netRatio, 0, baseDamage * maxBonusToBaseDamageRatio)); }
public override int GetBonusDamage(float baseDamage, AbilityDetails details, Combatant defender) { if (defender.Dir == details.performer.Dir) { return((int)(baseDamage * (damageMultiplier * GetRatio(details.performance) - 1))); } return(0); }
public int GetBonusDamage(float baseDamage, AbilityDetails details, Combatant defender) { int result = 0; if (bonusDamageEffects != null && bonusDamageEffects.Count > 0) { result += bonusDamageEffects.Sum(dEffect => dEffect.GetBonusDamage(baseDamage, details, defender)); } return(result); }
public int CalculateNetDamageOutput(AbilityDetails details) { if (!dealsDamage) { Debug.LogError("Ability [" + details.command.commandName + "] called Ability.GetNetDamage() even" + "though dealsDamage == false."); return(-1); } return(_baseDamageEffect.NetDamage(details)); }
protected override void OnApplyEffect(Combatant primaryTarget, AbilityDetails details) { int missingHP = details.performer.maxHP - details.performer.Hitpoints; foreach (GridObject target in details.targets) { if (target is Combatant combatant) { combatant.Hitpoints += (int)(missingHP * missingHPRatio + details.performer.maxHP * maxHPRatio); } } }
private void SlowDownTime(AbilityDetails details) { Combatant combatantWithHourglass = details.targets.First(target => target is Combatant combatant && combatant.loadout.trinket != null && combatant.loadout.trinket is CrystallineHourglass && combatant.Hitpoints <= combatant.maxHP * 0.25f) as Combatant; if (combatantWithHourglass != null) { Time.timeScale = slowmotionRatio; combatantWithHourglass.loadout.trinket = null; } }
public override void TakeDamageFromAttack(AbilityDetails details) { float damage = details.command.CalculateNetDamageOutput(details); if (damage >= damageToBreak) { GenerateLoot(); gm.combatManager.ClearAbilityQueue(); gm.hudManager.ShakeScreen(2); gm.SwitchState(typeof(State_PlayerTurn_Loot)); OnDisable(); } }
public void OnRemoveFromInventory(GameManager gm) { AbilityDetails details = new AbilityDetails(gm.combatManager.discardItemAbility, gm.combatManager.CurrentActor, new List <GridObject> { gm.combatManager.CurrentActor }); details.command.sprite = sprite; DiscardItemEffect effect = (DiscardItemEffect)details.command.utilityEffects.First(e => e is DiscardItemEffect); effect.item = this; gm.combatManager.EnqueueCommand(details); isQueued = true; }
public void OnApply(AbilityDetails details) { if (uniqueToEquipmentCategories.Count == 0 || uniqueToEquipmentCategories.Count > 0 && details.performer.HasAccessToAbilityPool(uniqueToEquipmentCategories)) { foreach (GridObject gridObject in details.targets) { var target = (Combatant)gridObject; if (SuccessfullyApplied(target, details)) { OnApplyEffect(target, details); } } } }
private float PerformanceMultiplier(AbilityDetails details) { switch (details.performance) { case TimedActionController.Performance.Meh: return(details.command.mehMultiplier); case TimedActionController.Performance.Okay: return(details.command.okayMultiplier); case TimedActionController.Performance.Good: return(details.command.goodMultiplier); case TimedActionController.Performance.Perfect: return(details.command.perfectMultiplier); default: throw new ArgumentOutOfRangeException(); } }
private float GetSuccessRatio(Combatant target, AbilityDetails details) { float result = mehSuccessRatio; if (details.performance == TimedActionController.Performance.Okay) { result = okaySuccessRatio; } else if (details.performance == TimedActionController.Performance.Good) { result = goodSuccessRatio; } else if (details.performance == TimedActionController.Performance.Perfect) { result = perfectSuccessRatio; } float blockPerformanceSuccessMultiplier = 1; if (isBlockable) { if (details.GetDefPerformance(target) == TimedActionController.Performance.Okay) { blockPerformanceSuccessMultiplier = okayBlockMultiplier; } else if (details.GetDefPerformance(target) == TimedActionController.Performance.Good) { blockPerformanceSuccessMultiplier = goodBlockMultiplier; } else if (details.GetDefPerformance(target) == TimedActionController.Performance.Perfect) { blockPerformanceSuccessMultiplier = perfectBlockMultiplier; } } return(result * blockPerformanceSuccessMultiplier); }
private void FinishAction(TimedActionController.Performance performance) { _performanceHasEnded = true; AbilityDetails details = Gm.combatManager.DequeueNextAbility(); if (details.targets.Count > 0) { foreach (GridObject gridObject in details.targets) { if (gridObject is NPCombatant npc) { float rand = Random.Range(0.0f, 1.0f); npc.state = rand <= Mathf.Clamp(npc.chanceToBlock + _idleCounter * 0.6f, 0, 1) ? Combatant.State.Blocking : Combatant.State.Idle; details.RegisterTargetPerformance(npc, npc.state == Combatant.State.Blocking ? npc.DetermineBlockPerformance() : TimedActionController.Performance.Meh); } } } details.performer.PerformAbility(details); }
protected override void OnApplyEffect(Combatant primaryTarget, AbilityDetails details) { if (details.command.diagonal) { Debug.LogWarning("Knockback cannot be applied on abilities with diagonal reach"); return; } GridPos performerPos = details.performer.Point; foreach (GridObject target in details.targets) { int xDelta = 0; int yDelta = 0; GridPos defPos = target.Point; if (defPos.x < performerPos.x) { xDelta = -distance; } else if (defPos.x > performerPos.x) { xDelta = +distance; } else if (defPos.y < performerPos.y) { yDelta = -distance; } else if (defPos.y > performerPos.y) { yDelta = +distance; } KnockBack(target, defPos, xDelta, yDelta); } }
protected override int BaseDamage(AbilityDetails details) { return(15 + details.performer.profile.StrLvl * 5); }
protected override void OnApplyEffect(Combatant primaryTarget, AbilityDetails details) { item.OnUseAsAbility(primaryTarget); }
protected bool SuccessfullyApplied(Combatant target, AbilityDetails details) { float randomNo = Random.Range(0, 1.0f); return(randomNo <= GetSuccessRatio(target, details)); }
protected virtual int BaseDamage(AbilityDetails details) { return(0); }
// a maxBonusToBaseDamageRatio of 1 means that the bonus damage has a cap of 100% of the ability's base damage public abstract int GetBonusDamage(float baseDamage, AbilityDetails details, Combatant defender);
protected abstract void OnApplyEffect(Combatant primaryTarget, AbilityDetails details);
public int RawDamage(AbilityDetails details) { return(BaseDamage(details) + BonusDamage(details)); }
// a maxBonusToBaseDamageRatio of 1 means that the bonus damage has a cap of 100% of the ability's base damage public abstract int ActivateEffect(AbilityDetails details, Combatant defender);
public override int GetBonusDamage(float baseDamage, AbilityDetails details, Combatant defender) { int tilesTravelled = TileManager.DistanceBetween(details.performer.StartingPoint, details.performer.point); return((int)(baseDamage * GetRatio(details.performance) * tilesTravelled)); }
public override int GetBonusDamage(float baseDamage, AbilityDetails details, Combatant defender) { return((int)Mathf.Clamp(defender.Hitpoints * GetRatio(details.performance), 0, baseDamage * maxBonusToBaseDamageRatio)); }
protected override void OnApplyEffect(Combatant primaryTarget, AbilityDetails details) { primaryTarget.ApplyStatusEffect(NewStatusEffect(primaryTarget)); }
public int NetDamage(AbilityDetails details) { return((int)(RawDamage(details) * PerformanceMultiplier(details))); }
protected override void OnApplyEffect(Combatant primaryTarget, AbilityDetails details) { details.performer.AccessInventory(); }