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