public void UpdateStats()
{
Hunger--;
ReproduceTimer--;
ageTimer--;
EatingCooldown--;
if (ageTimer <= 0)
{
Age++;
ageTimer = 3;
if (Age > 70)
{
var diff = Age - 70;
var percentage = 4 * diff;
if (UnityEngine.Random.Range(0, 100) < percentage)
{
owner.Die(false);
}
}
}
if (Hunger <= 0)
{
owner.Die(false);
}
OnStatChanged?.Invoke(this);
}
// manually sets the Extra stat (used for scoring)
public void ExtraSet(string extra, double value)
{
switch (extra)
{
case "EHP":
EffectiveHP = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.EffectiveHP, value));
break;
case "EHPDB":
EffectiveHPDefenseBreak = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.EffectiveHPDefenseBreak, value));
break;
case "DPS":
DamagePerSpeed = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.DamagePerSpeed, value));
break;
case "AvD":
AverageDamage = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.AverageDamage, value));
break;
case "MxD":
MaxDamage = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.MaxDamage, value));
break;
default:
throw new NotImplementedException();
}
}
public void RemoveModifier(int modifier)
{
if (modifier != 0)
{
_modifiers.Remove(modifier);
OnStatChanged?.Invoke(GetValue());
}
}
public void AddModifier(int modifier)
{
if (modifier != 0)
{
_modifiers.Add(modifier);
OnStatChanged?.Invoke(GetValue());
}
}
public void RemoveStat(StatController stat, StatModifierType addType)
{
/*if (stat.statModel != statController.statModel)
{
Debug.Log("Les deux stats n'ont pas le même modèle, l'opération n'est pas optimisé");
// faire l'opération pas optimisé
}*/
statController.Remove(stat, addType);
if (OnStatChanged != null) OnStatChanged.Invoke(this);
}
public bool TryModifyStat(StatType stat, int value)
{
if (stats.TryModifyStat(stat, value))
{
int newValue = GetStatValue(stat);
OnStatChanged?.Invoke(stat, newValue);
return(true);
}
return(false);
}
/// <summary>
/// Sets the movementspeed to a new value.
/// </summary>
/// <param name="value">The new movementspeed to set.</param>
/// <returns>True if the movementspeed is greater than 0.</returns>
public bool ModifyMovementSpeed(float value)
{
MovementSpeed = value;
OnStatChanged?.Invoke(StatType.MovementSpeed, value, MovementSpeed);
if (movementSpeed <= 0)
{
movementSpeed = 0;
return(false);
}
return(true);
}
/// <summary>
/// Negative values does damage to the shield only, positive values adds shield.
/// </summary>
/// <param name="value">The value which will be added or subtracted.</param>
/// <returns>Any potential damage exceeding the shield</returns>
public int ModifyShield(int value)
{
int dmg = 0; //Return damage if it exceeds the shield limit
Shield += value;
OnStatChanged?.Invoke(StatType.Shield, value, Shield);
if (Shield <= 0)
{
dmg = shield;
shield = 0;
}
return(dmg);
}
/// <summary>
/// Positive values add currency, negative values subtract currency..
/// </summary>
/// <param name="value">The value wich will be added or subtracted.</param>
/// <returns>True if currency is less than 0.</returns>
public bool ModifyCurrency(int value)
{
Currency += value;
OnStatChanged?.Invoke(StatType.Currency, value, Currency);
if (Currency < 0)
{
Currency = 0;
return(true);
}
else if (Currency > 9999)
{
Currency = 9999;
}
return(false);
}
public Stats SetTo(Stats rhs)
{
foreach (var a in Build.StatAll)
{
this[a] = rhs[a];
}
for (int i = 0; i < 4; i++)
{
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.Skill1 + i, GetSkillDamage(Attr.AverageDamage, i, this)));
}
for (int i = 0; i < 8; i++)
{
DamageSkillups[i] = rhs.DamageSkillups[i];
}
return(this);
}
/// <summary>
/// Negative values does damage, positive values heals.
/// Damage is dealth to active shields first.
/// </summary>
/// <param name="value">The value which will be added or subtracted.</param>
/// <returns>Returns true if object has died.</returns>
public bool ModifyHealth(int value)
{
if (value < 0)
{
Health += ModifyShield(value); //If we are taking damage, reduce the shield first, then deal any leftover damage
}
else
{
Health += value; //otherwise increase our health
}
OnStatChanged?.Invoke(StatType.Health, value, Health);
if (Health <= 0)
{
return(true);
}
return(false);
}
private void Level()
{
if (currentXP >= XPToLvl)
{
value++;
value = Mathf.Clamp(value, 0, 20);
currentXP -= XPToLvl;
SetXpToLevel();
}
else if (currentXP <= 0)
{
value--;
value = Mathf.Clamp(value, 0, 20);
SetXpToLevel();
currentXP += XPToLvl;
}
OnStatChanged?.Invoke(this, new StatChangedEventArgs {
stat = this
});
}
// manually sets the Extra stat (used for scoring)
public void ExtraSet(Attr extra, double value)
{
switch (extra)
{
case Attr.EffectiveHP:
EffectiveHP = value;
break;
case Attr.EffectiveHPDefenseBreak:
EffectiveHPDefenseBreak = value;
break;
case Attr.DamagePerSpeed:
DamagePerSpeed = value;
break;
case Attr.AverageDamage:
AverageDamage = value;
break;
case Attr.MaxDamage:
MaxDamage = value;
break;
case Attr.Skill1:
case Attr.Skill2:
case Attr.Skill3:
case Attr.Skill4:
DamageSkillups[extra - Attr.Skill1] = value;
break;
default:
throw new NotImplementedException();
}
OnStatChanged?.Invoke(this, new StatModEventArgs(extra, value));
}
public void unsubscribe(OnStatChanged callback)
{
onStatChanged -= callback;
}
public void subscribe(OnStatChanged callback)
{
onStatChanged += callback;
}
public void RemoveStat(string statName, float statValue, StatModifierType addType)
{
statController.RemoveStat(new Stat(statName, statValue), addType);
if (OnStatChanged != null) OnStatChanged.Invoke(this);
}
public void AttributeModified(Attribute attribute)
{
Debug.Log(string.Concat(attribute.type, " was updated! Value is now: ", attribute.value.ModifiedValue));
OnStatChanged?.Invoke(this, EventArgs.Empty);
}
// Allows speedy iteration through the entity
public double this[string stat] {
get {
// TODO: switch from using [string] to [Attr]
switch (stat)
{
case "HP":
return(Health);
case "ATK":
return(Attack);
case "DEF":
return(Defense);
case "SPD":
return(Speed);
case "CD":
return(CritDamage);
case "CR":
return(CritRate);
case "ACC":
return(Accuracy);
case "RES":
return(Resistance);
case "WaterATK":
return(DamageSkillups[(int)Element.Water - 1]);
case "FireATK":
return(DamageSkillups[(int)Element.Fire - 1]);
case "WindATK":
return(DamageSkillups[(int)Element.Wind - 1]);
case "LightATK":
return(DamageSkillups[(int)Element.Light - 1]);
case "DarkATK":
return(DamageSkillups[(int)Element.Dark - 1]);
default:
return(0);
//throw new NotImplementedException();
}
}
set {
switch (stat)
{
case "HP":
Health = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.HealthFlat, value));
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.HealthPercent, value));
break;
case "ATK":
Attack = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.AttackFlat, value));
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.AttackPercent, value));
break;
case "DEF":
Defense = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.DefenseFlat, value));
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.DefensePercent, value));
break;
case "SPD":
Speed = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.Speed, value));
break;
case "CD":
CritDamage = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.CritDamage, value));
break;
case "CR":
CritRate = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.CritRate, value));
break;
case "ACC":
Accuracy = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.Accuracy, value));
break;
case "RES":
Resistance = value;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.Resistance, value));
break;
case "WaterATK":
DamageSkillups[0] = value;
break;
case "FireATK":
DamageSkillups[1] = value;
break;
case "WindATK":
DamageSkillups[2] = value;
break;
case "LightATK":
DamageSkillups[3] = value;
break;
case "DarkATK":
DamageSkillups[4] = value;
break;
default:
#if DEBUG
throw new NotImplementedException();
#else
break;
#endif
}
}
}
public void DamageSkillupsSet(int ind, double val)
{
DamageSkillups[ind] = val;
OnStatChanged?.Invoke(this, new StatModEventArgs(Attr.Skill1 + ind, val));
}
public double this[Attr stat] {
get {
switch (stat)
{
case Attr.HealthFlat:
case Attr.HealthPercent:
return(Health);
case Attr.AttackFlat:
case Attr.AttackPercent:
return(Attack);
case Attr.DefenseFlat:
case Attr.DefensePercent:
return(Defense);
case Attr.Speed:
case Attr.SpeedPercent:
return(Speed);
case Attr.CritDamage:
return(CritDamage);
case Attr.CritRate:
return(CritRate);
case Attr.Accuracy:
return(Accuracy);
case Attr.Resistance:
return(Resistance);
case Attr.EffectiveHP:
return(EffectiveHP);
case Attr.EffectiveHPDefenseBreak:
return(EffectiveHPDefenseBreak);
case Attr.DamagePerSpeed:
return(DamagePerSpeed);
case Attr.AverageDamage:
return(AverageDamage);
case Attr.MaxDamage:
return(MaxDamage);
}
throw new NotImplementedException();
}
set {
switch (stat)
{
case Attr.HealthFlat:
case Attr.HealthPercent:
Health = value;
break;
case Attr.AttackFlat:
case Attr.AttackPercent:
Attack = value;
break;
case Attr.DefenseFlat:
case Attr.DefensePercent:
Defense = value;
break;
case Attr.Speed:
case Attr.SpeedPercent:
Speed = value;
break;
case Attr.CritDamage:
CritDamage = value;
break;
case Attr.CritRate:
CritRate = value;
break;
case Attr.Accuracy:
Accuracy = value;
break;
case Attr.Resistance:
Resistance = value;
break;
case Attr.EffectiveHP:
EffectiveHP = value;
break;
case Attr.EffectiveHPDefenseBreak:
EffectiveHPDefenseBreak = value;
break;
case Attr.DamagePerSpeed:
DamagePerSpeed = value;
break;
case Attr.AverageDamage:
AverageDamage = value;
break;
case Attr.MaxDamage:
MaxDamage = value;
break;
default:
throw new NotImplementedException();
}
OnStatChanged?.Invoke(this, new StatModEventArgs(stat, value));
}
}
