/// <summary>
/// Increments the number of turns the StatusEffect has been active and removes it from the entity afflicted when finished
/// </summary>
private void IncrementTurns()
{
//Handle problems with this method occurring after the status has ended
if (Ended == true)
{
string entityName = EntityAfflicted?.Name ?? "N/A";
Debug.LogError($"Attempting to increment turns for {StatusType} on {entityName} after it has ended!");
//If the entity has already been cleared, return since there's no way to remove the status without the reference
if (EntityAfflicted == null)
{
return;
}
}
//Print this message if we somehow reached this method when the StatusEffect was already done
//Don't return because we still want to remove it
if (IsFinished == true)
{
Debug.LogError($"Attempting to increment turns for {StatusType} on entity {EntityAfflicted.Name} when it's already finished!");
}
//Increment the number of turns passed, unless this StatusEffect doesn't go away
if (IsInfinite == false)
{
TurnsPassed++;
}
//When the StatusEffect is finished, remove it
if (IsFinished == true)
{
EntityAfflicted.RemoveStatus(StatusType, true, ShouldQueueEndEvent);
}
}
protected override void OnEnd()
{
EntityAfflicted.SetMaxTurns(EntityAfflicted.BaseTurns);
Debug.Log($"{StatusType} set MaxTurns to {EntityAfflicted.BaseTurns} for {EntityAfflicted.Name}");
base.OnEnd();
}
protected override void OnUnsuppress(Enumerations.StatusSuppressionTypes statusSuppressionType)
{
if (statusSuppressionType == Enumerations.StatusSuppressionTypes.Effects)
{
EntityAfflicted.LowerAttack(AttackValue);
}
}
protected override void OnAfflict()
{
//On affliction end the entity's turn
EntityAfflicted.SetMaxTurns(0);
EntityAfflicted.SetTurnsUsed(EntityAfflicted.MaxTurns);
Debug.Log($"{StatusType} set MaxTurns to 0 for {EntityAfflicted.Name}");
}
protected override void OnUnsuppress(Enumerations.StatusSuppressionTypes statusSuppressionType)
{
if (statusSuppressionType == Enumerations.StatusSuppressionTypes.Effects)
{
EntityAfflicted.AddIntAdditionalProperty(Enumerations.AdditionalProperty.ConfusionPercent, ConfusionPercent);
}
}
protected override void OnUnsuppress(Enumerations.StatusSuppressionTypes statusSuppressionType)
{
if (statusSuppressionType == Enumerations.StatusSuppressionTypes.Effects)
{
EntityAfflicted.SetMaxTurns(EntityAfflicted.BaseTurns + AdditionalTurns);
}
}
protected override void OnUnsuppress(Enumerations.StatusSuppressionTypes statusSuppressionType)
{
if (statusSuppressionType == Enumerations.StatusSuppressionTypes.Effects)
{
EntityAfflicted.RaiseDefense(DefenseValue);
}
}
protected override void OnPhaseCycleStart()
{
if (IsSuppressed(Enumerations.StatusSuppressionTypes.Effects) == false)
{
EntityAfflicted.TakeDamage(Enumerations.Elements.Poison, PoisonDamage, true);
}
ProgressTurnCount();
}
protected override void OnPhaseCycleStart()
{
if (IsSuppressed(Enumerations.StatusSuppressionTypes.Effects) == false)
{
EntityAfflicted.HealHP(AmountHealed);
}
ProgressTurnCount();
}
protected override void OnAfflict()
{
EntityAfflicted.AddEvasionMod(EvasionValue);
EntityAfflicted.TintColor = EntityAfflicted.TintColor.CeilingMult(AlphaValue);
base.OnAfflict();
}
protected override void OnResume()
{
if (PreventMovement == true)
{
EntityAfflicted.SetMaxTurns(0);
EntityAfflicted.SetTurnsUsed(EntityAfflicted.MaxTurns);
}
}
protected override void OnPhaseCycleStart()
{
if (EntityAfflicted.MaxTurns > 0)
{
Debug.Log($"{StatusType} set MaxTurns to {EntityAfflicted.BaseTurns + AdditionalTurns} for {EntityAfflicted.Name}");
EntityAfflicted.SetMaxTurns(EntityAfflicted.BaseTurns + AdditionalTurns);
}
ProgressTurnCount();
}
/// <summary>
/// Handles adding/removing Stone's Status Effect immunities.
/// </summary>
/// <param name="immune">Whether to add or remove the immunities.</param>
private void HandleStatusImmunities(bool immune)
{
EntityAfflicted.AddRemoveStatusImmunity(StatusTypes.Poison, immune);
EntityAfflicted.AddRemoveStatusImmunity(StatusTypes.Dizzy, immune);
EntityAfflicted.AddRemoveStatusImmunity(StatusTypes.Sleep, immune);
EntityAfflicted.AddRemoveStatusImmunity(StatusTypes.Tiny, immune);
EntityAfflicted.AddRemoveStatusImmunity(StatusTypes.Frozen, immune);
EntityAfflicted.AddRemoveStatusImmunity(StatusTypes.NoSkills, immune);
}
protected sealed override void OnSuspend()
{
base.OnSuspend();
//Remove Invincibility and don't do anything else to avoid Suspending/Resuming conflicts with other StatusEffects
EntityAfflicted.EntityProperties.RemoveAdditionalProperty(Enumerations.AdditionalProperty.Invincible);
EntityAfflicted.AnimManager.PlayAnimation(EntityAfflicted.GetIdleAnim());
}
protected override void OnPhaseCycleStart()
{
IncrementTurns();
if (IsFinished == false)
{
EntityAfflicted.SetMaxTurns(0);
Debug.Log($"{StatusType} set MaxTurns to 0 for {EntityAfflicted.Name}");
}
}
protected override void OnEnd()
{
EntityAfflicted.RemoveEvasionMod(EvasionValue);
Color color = EntityAfflicted.TintColor;
float val = (1 / AlphaValue);
EntityAfflicted.TintColor *= val;
}
protected override void OnResume()
{
EntityAfflicted.SetMaxTurns(0);
//Re-add the Immobile property
int immobile = EntityAfflicted.EntityProperties.GetAdditionalProperty <int>(Enumerations.AdditionalProperty.Immobile) + 1;
EntityAfflicted.EntityProperties.AddAdditionalProperty(Enumerations.AdditionalProperty.Immobile, immobile);
}
protected override void OnSuppress(Enumerations.StatusSuppressionTypes statusSuppressionType)
{
if (statusSuppressionType == Enumerations.StatusSuppressionTypes.Effects)
{
EntityAfflicted.SetMaxTurns(EntityAfflicted.BaseTurns);
//Remove the Immobile property
EntityAfflicted.SubtractIntAdditionalProperty(Enumerations.AdditionalProperty.Immobile, 1);
}
}
/// <summary>
/// Handles adding/removing Allergic's Status Effect immunities.
/// Allergic makes the entity immune to every Status Effect.
/// </summary>
/// <param name="immune">Whether to add or remove the immunity.</param>
private void HandleStatusImmunities(bool immune)
{
//Get all statuses and add or remove the immunity
StatusTypes[] allStatusTypes = EnumUtility.GetValues <StatusTypes> .EnumValues;
for (int i = 0; i < allStatusTypes.Length; i++)
{
EntityAfflicted.AddRemoveStatusImmunity(allStatusTypes[i], immune);
}
}
protected override void OnPhaseCycleStart()
{
//Don't damage the BattleEntity if it's Invincible
//NOTE: Find a way to route this damage through the damage calculation
if (EntityAfflicted.EntityProperties.GetAdditionalProperty <bool>(Enumerations.AdditionalProperty.Invincible) == false)
{
EntityAfflicted.TakeDamage(Enumerations.Elements.Poison, PoisonDamage, true);
}
IncrementTurns();
}
protected override void OnAfflict()
{
//Set this on affliction as well, as the entity could have not used its turn yet if it's in the same phase
//First check if the max turn count is greater than 0, as a turn count of 0 indicates the entity was not able to move this turn
if (EntityAfflicted.MaxTurns > 0)
{
EntityAfflicted.SetMaxTurns(EntityAfflicted.BaseTurns + AdditionalTurns);
Debug.Log($"{StatusType} set MaxTurns to {EntityAfflicted.BaseTurns + AdditionalTurns} for {EntityAfflicted.Name}");
}
}
protected override void OnUnsuppress(Enumerations.StatusSuppressionTypes statusSuppressionType)
{
if (statusSuppressionType == Enumerations.StatusSuppressionTypes.Effects)
{
EntityAfflicted.SetMaxTurns(0);
//Re-add the Immobile property
EntityAfflicted.AddIntAdditionalProperty(Enumerations.AdditionalProperty.Immobile, 1);
}
}
protected override void OnEnd()
{
if (EntityAfflicted.MaxTurns > 0 && EntityAfflicted.MaxTurns < EntityAfflicted.BaseTurns)
{
EntityAfflicted.SetMaxTurns(EntityAfflicted.BaseTurns);
Debug.Log($"{StatusType} set MaxTurns to {EntityAfflicted.BaseTurns} for {EntityAfflicted.Name}");
}
//Remove the Immobile property after getting its count
EntityAfflicted.SubtractIntAdditionalProperty(Enumerations.AdditionalProperty.Immobile, 1);
}
protected override void OnUnsuppress(Enumerations.StatusSuppressionTypes statusSuppressionType)
{
if (statusSuppressionType == Enumerations.StatusSuppressionTypes.Effects)
{
if (PreventMovement == true)
{
EntityAfflicted.SetMaxTurns(0);
EntityAfflicted.SetTurnsUsed(EntityAfflicted.MaxTurns);
}
}
}
protected override void OnAfflict()
{
//Prevent the entity from moving on affliction and mark it as using up all of its turns
EntityAfflicted.SetMaxTurns(0);
EntityAfflicted.SetTurnsUsed(EntityAfflicted.MaxTurns);
//Specify that this status makes the entity Immobile
EntityAfflicted.AddIntAdditionalProperty(Enumerations.AdditionalProperty.Immobile, 1);
Debug.Log($"{StatusType} set MaxTurns to 0 for {EntityAfflicted.Name}");
}
protected sealed override void OnEnd()
{
base.OnEnd();
//The entity takes 1 Ice damage when Frozen ends
//Don't damage the BattleEntity if it's Invincible
//NOTE: Find a way to route this damage through the damage calculation
if (EntityAfflicted.EntityProperties.GetAdditionalProperty <bool>(Enumerations.AdditionalProperty.Invincible) == false)
{
EntityAfflicted.TakeDamage(Enumerations.Elements.Ice, IceDamage, true);
}
}
protected override void OnAfflict()
{
//Remove the Frozen status if the entity was afflicted with Burn
if (EntityAfflicted.EntityProperties.HasStatus(Enumerations.StatusTypes.Frozen) == true)
{
Debug.Log($"{StatusType} was inflicted on an entity afflicted with {Enumerations.StatusTypes.Frozen}, negating both effects!");
EntityAfflicted.RemoveStatus(Enumerations.StatusTypes.Frozen, true, false);
//Also remove Burn, as these two statuses negate each other
EntityAfflicted.RemoveStatus(Enumerations.StatusTypes.Burn, true, false);
}
}
protected override void OnPhaseCycleStart()
{
ProgressTurnCount();
if (IsSuppressed(Enumerations.StatusSuppressionTypes.Effects) == false)
{
if (IsFinished == false)
{
EntityAfflicted.SetMaxTurns(0);
Debug.Log($"{StatusType} set MaxTurns to 0 for {EntityAfflicted.Name}");
}
}
}
protected sealed override void OnResume()
{
base.OnResume();
//Suspend all entity's Negative StatusEffects once again
EntityAfflicted.SuspendOrResumeAlignmentStatuses(true, StatusAlignments.Negative, StatusType);
//Add back the NegativeStatusImmune and Invincible MiscProperties
EntityAfflicted.EntityProperties.AddAdditionalProperty(Enumerations.AdditionalProperty.NegativeStatusImmune, true);
EntityAfflicted.EntityProperties.AddAdditionalProperty(Enumerations.AdditionalProperty.Invincible, true);
EntityAfflicted.AnimManager.PlayAnimation(AnimationGlobals.StatusBattleAnimations.StoneName);
}
protected override void OnSuspend()
{
EntityAfflicted.SetMaxTurns(EntityAfflicted.BaseTurns);
//Remove the Immobile property
int immobile = EntityAfflicted.EntityProperties.GetAdditionalProperty <int>(Enumerations.AdditionalProperty.Immobile) - 1;
EntityAfflicted.EntityProperties.RemoveAdditionalProperty(Enumerations.AdditionalProperty.Immobile);
if (immobile > 0)
{
EntityAfflicted.EntityProperties.AddAdditionalProperty(Enumerations.AdditionalProperty.Immobile, immobile);
}
}
