public IEnumerable <float> GetAdditiveModifier(StatsEnum stat)
{
if (stat == StatsEnum.Damage)
{
yield return(_currentWeaponConfig.GetWeaponDamage());
}
}
public ValueHolder(float maxValue, float missingValue, StatsEnum type)
{
this.maxValue = maxValue;
this.missingValue = missingValue;
this.type = type;
currentValue = maxValue - missingValue;//Calculated this way to grant some resources on levelup but not go through a full-reset method
}
public int GetLevels(StatsEnum stat, CharacterClassEnum characterClass)
{
BuildLookup();
float[] levels = _lookupTable[characterClass][stat];
return(levels.Length);
}
public IEnumerable <float> GetPercentageModifier(StatsEnum stat)
{
if (stat == StatsEnum.Damage)
{
yield return(_currentWeaponConfig.GetPercentageBonus());
}
}
public static DoubleStatSuffix GenerateDoubleStatSuffix(StatsEnum stat1, StatsEnum stat2)
{
SingleStatSuffix suffix1 = GeneratedSingleStatSuffix(stat1);
SingleStatSuffix suffix2 = GeneratedSingleStatSuffix(stat2);
string doubleSuffixName = suffix1.SuffixString + " and " + suffix2.SuffixString;
return(new DoubleStatSuffix(suffix1, suffix2, doubleSuffixName));
}
public static ACharacterStat GetStat(StatsEnum targetStat)
{
if (!initialized)
{
Initialize();
}
return(characterStats[targetStat]);
}
void Strike_1()
{
if (currentAttackEnum != StatsEnum.Strike_1)
{
AttackCoroutine = StartCoroutine(DoAttack(Hero.AudioClips.Strike_1.ToString(), 0.6f));
}
currentAttackEnum = StatsEnum.Strike_1;
_anima.SetInteger("Attack Index", (int)currentAttackEnum);
_anima.SetBool("Attack", true);
}
public void SetValue(StatsEnum stat, int value)
{
var statInfo = _currentValues[stat];
statInfo.Value = value;
if (statInfo.NotifyChange)
{
this.GetPubSub().PublishMessageInContext(new StatChangedMessage(statInfo.Stat, value));
}
}
void Strike_3()
{
if (currentAttackEnum != StatsEnum.Strike_3)
{
StopCoroutine(AttackCoroutine);
AttackCoroutine = StartCoroutine(DoAttack(Hero.AudioClips.Strike_3.ToString(), .4f));
}
currentAttackEnum = StatsEnum.Strike_3;
_anima.SetInteger("Attack Index", (int)currentAttackEnum);
_anima.SetBool("Attack", true);
}
void Shield_Attack()
{
if (currentAttackEnum != StatsEnum.Shield_Attack)
{
_fsm.FinishAllStates();
StartCoroutine(DoShield_Attack(1.06f, transform.position));
}
currentAttackEnum = StatsEnum.Shield_Attack;
_anima.SetInteger("Attack Index", (int)currentAttackEnum);
_anima.SetBool("Attack", true);
}
void DoUppercut()
{
_attacks = true;
if (currentAttackEnum != StatsEnum.Uppercut)
{
_anima.SetFloat("Speed", 0);
Hero.instance.audioManager.Play(Hero.AudioClips.Uppercut.ToString());
}
currentAttackEnum = StatsEnum.Uppercut;
_anima.SetInteger("Attack Index", (int)currentAttackEnum);
_anima.SetBool("Attack", true);
}
public void AddRegen(StatsEnum stat, int addPerSec, float timeInSeconds = -1)
{
var regen = new RegenInfo {
Stat = stat, AddPerSec = addPerSec
};
_regens.Add(regen);
if (timeInSeconds > 0)
{
StartCoroutine(DisableRegen(regen, timeInSeconds));
}
}
private void SetStat(StatsEnum stat, int value)
{
if (value < 1)
{
Stats[stat] = 1;
}
else if (value > 20)
{
Stats[stat] = 20;
}
else
{
Stats[stat] = value;
}
}
public bool HasEnough(StatsEnum stat, int required)
{
if (required == 0)
{
return(true);
}
if (!_currentValues.ContainsKey(stat))
{
Debug.LogErrorFormat("Following stat is not defined for this object: {0}", stat.ToString());
return(false);
}
return(_currentValues[stat].Value >= required);
}
public float GetStat(StatsEnum stat, CharacterClassEnum characterClass, int level)
{
BuildLookup();
Dictionary <StatsEnum, float[]> levelInfos = _lookupTable[characterClass];
float[] levels = levelInfos[stat];
if (levels.Length < level)
{
return(0f);
}
return(levels[level - 1]);
}
public IEnumerator Idle(float _time)
{
StopCoroutine(Sleep(0));
m_CatEnum = StatsEnum.Idle;
m_IsMove = false;
yield return(new WaitForSeconds(_time));
///Aplicação das Rotas das Animações
{
m_Animator.SetBool("idle", false);
}
m_IsMove = true;
m_CatEnum = StatsEnum.Move;
}
public SingleStatSuffix
(
StatsEnum statEnum,
float minValue,
float maxValue,
string suffixString,
bool roundValues = false,
bool roundValuesToHalf = false,
bool percentage = false
) : base()
{
valueIsPercentage = percentage;
StatEnum = statEnum;
TrueValue = Random.Range(minValue, maxValue);
if (roundValues)
{
TrueValue = Mathf.Round(TrueValue);
}
else if (roundValuesToHalf)
{
float roundTemp = Mathf.Round(TrueValue);
float roundTempHalf;
if (roundTemp < TrueValue)
{
roundTempHalf = roundTemp + 0.5f;
}
else
{
roundTempHalf = roundTemp - 0.5f;
}
float distanceToRound = Mathf.Abs(TrueValue - roundTemp);
float distanceToHalf = Mathf.Abs(TrueValue - roundTempHalf);
if (distanceToRound < distanceToHalf)
{
TrueValue = roundTemp;
}
else
{
TrueValue = roundTempHalf;
}
}
if (percentage)
{
TrueValue /= 100f;
}
SuffixString = suffixString;
}
public bool tryUpgrade(StatsEnum s, int c, string id)
{
inventoryUIScript.updateLootDisplay(playerManagerScript.money, playerManagerScript.loot);
unitStatesDisplayScript.updateStates();
if (playerManagerScript.removeLoot(c, id))
{
UnitScript currentUnit = unitStatesDisplayScript.currentUnit;
switch (s)
{
case (StatsEnum.HP):
currentUnit.Upgrade_HP();
break;
case (StatsEnum.AC):
currentUnit.Upgrade_AC();
break;
case (StatsEnum.SPEED):
currentUnit.Upgrade_Movement();
break;
case (StatsEnum.TOHIT):
currentUnit.Upgrade_AttackBonus();
break;
case (StatsEnum.WEAPONDAMAGE):
currentUnit.Upgrade_WeaponDamage();
break;
case (StatsEnum.ABILITY):
currentUnit.Upgrade_Ability();
break;
}
inventoryUIScript.updateLootDisplay(playerManagerScript.money, playerManagerScript.loot);
unitStatesDisplayScript.updateStates();
return(true);
}
else
{
return(false);
}
}
public float this[StatsEnum statsEnum] {
get{
if (stats.ContainsKey(statsEnum))
{
return(stats[statsEnum]);
}
return(0);
}
set{
if (stats.ContainsKey(statsEnum))
{
stats[statsEnum] = value;
}
else
{
stats.Add(statsEnum, value);
}
}
}
public void Add(StatsEnum _stat, float _amount)
{
switch (_stat)
{
case StatsEnum.HP:
break;
case StatsEnum.MP:
break;
case StatsEnum.Attack:
attack += _amount;
break;
case StatsEnum.Defence:
defence += _amount;
break;
case StatsEnum.MagAttack:
magAttack += _amount;
break;
case StatsEnum.MagDefence:
magDefence += _amount;
break;
case StatsEnum.Accuracy:
accuracy += _amount;
break;
case StatsEnum.Evade:
evade += _amount;
break;
case StatsEnum.Speed:
attack += _amount;
break;
default:
break;
}
}
public IEnumerator Sleep(float _time)
{
m_IsMove = false;
///Aplicação das Rotas das Animações
{
m_Animator.SetTrigger("sleep");
m_Animator.SetBool("down", false);
m_Animator.SetBool("up", false);
m_Animator.SetBool("idle", false);
}
StopCoroutine(m_CoroutineIdle);
m_CatEnum = StatsEnum.Sleep;
yield return(new WaitForSeconds(_time));
m_IsMove = true;
m_CatEnum = StatsEnum.Move;
}
private float GetPercentageModifier(StatsEnum stat)
{
if (!shouldUseModifiers)
{
return(0f);
}
float total = 0f;
var components = GetComponents <IModifierProvider>();
foreach (IModifierProvider provider in components)
{
var modifiers = provider.GetPercentageModifier(stat);
foreach (float modifier in modifiers)
{
total += modifier;
}
}
return(total);
}
void Moves()
{
comboCount = 0;
_attacks = false;
_anima.SetInteger("Attack Index", 0);
_anima.SetBool("Attack", false);
currentAttackEnum = StatsEnum.None;
if (_blocking || _isDodging || Hero.instance.Manager._TakeDamage)
{
return;
}
if (m_Grounded && _jump)
{
_jump = false;
m_Grounded = false;
Hero.instance.audioManager.Stop(Hero.AudioClips.Run.ToString());
Hero.instance.audioManager.Play(Hero.AudioClips.Jump.ToString());
_rigidbody.velocity = new Vector2(_rigidbody.velocity.x, 0);
_rigidbody.AddForce(new Vector2(_rigidbody.velocity.x, _JumpForce), ForceMode2D.Impulse);
_anima.SetTrigger("Jump");
return;
}
if (m_Grounded && _dodge)
{
_dodge = false;
if (!_isDodging)
{
StartCoroutine(DoDodge(_dodgingTime, transform.position));
_anima.SetTrigger("Dodge");
return;
}
}
Move();
}
public void AddAmount(StatsEnum stat, int amount)
{
if (!_currentValues.ContainsKey(stat))
{
Debug.LogErrorFormat("Following stat is not defined for this object: {0}", stat.ToString());
return;
}
var statInfo = _currentValues[stat];
var newValue = statInfo.Value + amount;
var capedValue = Math.Min(statInfo.MaxValue, newValue);
capedValue = Math.Max(capedValue, statInfo.MinValue);
if (capedValue != statInfo.Value)
{
statInfo.Value = capedValue;
if (statInfo.NotifyChange)
{
this.GetPubSub().PublishMessageInContext(new StatChangedMessage(statInfo.Stat, capedValue));
}
}
}
public void ModifySkill(StatsEnum _enum, int _value)
{
switch (_enum)
{
case StatsEnum.Agility:
ModifiedStats.Agility += _value;
break;
case StatsEnum.Combat:
ModifiedStats.Combat += _value;
break;
case StatsEnum.Corruption:
ModifiedStats.Corruption += _value;
break;
case StatsEnum.Cunning:
ModifiedStats.Cunning += _value;
break;
case StatsEnum.CurHealth:
ModifiedStats.CurHealth += _value;
break;
case StatsEnum.CurSanity:
ModifiedStats.CurSanity += _value;
break;
case StatsEnum.Defense:
ModifiedStats.Defense += _value;
break;
case StatsEnum.Grit:
ModifiedStats.Grit += _value;
break;
case StatsEnum.Health:
ModifiedStats.Health += _value;
break;
case StatsEnum.Initiative:
ModifiedStats.Initiative += _value;
break;
case StatsEnum.Lore:
ModifiedStats.Lore += _value;
break;
case StatsEnum.Luck:
ModifiedStats.Luck += _value;
break;
case StatsEnum.Melee:
ModifiedStats.Melee += _value;
break;
case StatsEnum.Ranged:
ModifiedStats.Ranged += _value;
break;
case StatsEnum.Resistance:
ModifiedStats.Resistance += _value;
break;
case StatsEnum.Sanity:
ModifiedStats.Sanity += _value;
break;
case StatsEnum.Spirit:
ModifiedStats.Spirit += _value;
break;
case StatsEnum.Strength:
ModifiedStats.Strength += _value;
break;
case StatsEnum.Willpower:
ModifiedStats.Willpower += _value;
break;
}
UpdateDisplay();
}
public void SetSkill(StatsEnum _enum, int _value)
{
switch (_enum)
{
case StatsEnum.Agility:
BaseStats.Agility = _value;
break;
case StatsEnum.Combat:
BaseStats.Combat = _value;
break;
case StatsEnum.Corruption:
BaseStats.Corruption = _value;
break;
case StatsEnum.Cunning:
BaseStats.Cunning = _value;
break;
case StatsEnum.CurHealth:
BaseStats.CurHealth = _value;
break;
case StatsEnum.CurSanity:
BaseStats.CurSanity = _value;
break;
case StatsEnum.Defense:
BaseStats.Defense = _value;
break;
case StatsEnum.Grit:
BaseStats.Grit = _value;
break;
case StatsEnum.Health:
BaseStats.Health = _value;
break;
case StatsEnum.Initiative:
BaseStats.Initiative = _value;
break;
case StatsEnum.Lore:
BaseStats.Lore = _value;
break;
case StatsEnum.Luck:
BaseStats.Luck = _value;
break;
case StatsEnum.Melee:
BaseStats.Melee = _value;
break;
case StatsEnum.Ranged:
BaseStats.Ranged = _value;
break;
case StatsEnum.Resistance:
BaseStats.Resistance = _value;
break;
case StatsEnum.Sanity:
BaseStats.Sanity = _value;
break;
case StatsEnum.Spirit:
BaseStats.Spirit = _value;
break;
case StatsEnum.Strength:
BaseStats.Strength = _value;
break;
case StatsEnum.Willpower:
BaseStats.Willpower = _value;
break;
}
UpdateDisplay();
SaveStats();
}
public bool ContainsKey(StatsEnum key)
{
return(stats.ContainsKey(key));
}
private Stats(StatsEnum @enum)
{
Value = @enum;
}
public static string StatsEnumToString(StatsEnum target)
{
return(CharacterStatProcessor.GetStat(target).GetStatName());
}
public StatChangedMessage(StatsEnum stat, int newValue)
{
Stat = stat;
NewValue = newValue;
}
