public void PiercingArrowPropsTest(AbilityKind kind)
{
var game = CreateGame();
var hero = game.GameManager.Hero;
var ab = game.GameManager.Hero.GetActiveAbility(kind);
Assert.AreEqual(ab.PrimaryStat.Unit, EntityStatUnit.Percentage);
Assert.AreEqual(ab.AuxStat.Unit, EntityStatUnit.Absolute);
Assert.AreEqual(ab.PrimaryStat.Factor, 0);
ab.IncreaseLevel(game.Hero);
Assert.AreEqual(ab.PrimaryStat.Kind, EntityStatKind.ChanceForPiercing);
Assert.AreEqual(ab.PrimaryStat.Factor, 80);
Assert.AreEqual(ab.AuxStat.Kind, EntityStatKind.NumberOfPiercedVictims);
var numberOfPiercedVictims = 2;
Assert.AreEqual(ab.AuxStat.Factor, numberOfPiercedVictims);
numberOfPiercedVictims++;
ab.IncreaseLevel(game.Hero);
Assert.AreEqual(ab.PrimaryStat.Factor, 85);
Assert.AreEqual(ab.AuxStat.Factor, numberOfPiercedVictims);
}
public void AddAbility(AbilityKind kind)
{
kinds |= kind;
c.stat.AddAbility(kind);
Log.to.I($"[Ability] Get - {kind}");
if (kind == AbilityKind.Healing_1 || kind == AbilityKind.Healing_2 || kind == AbilityKind.Healing_3)
{
heal.Activate();
}
if (kind == AbilityKind.AroundBall)
{
orbit.Activate();
}
if (kind == AbilityKind.Divine)
{
divine.Activate();
}
if (kind == AbilityKind.Flame)
{
flame.Activate();
}
AudioController.Play("AbilitySelect");
}
public void MagicProjectileEnemyHitTest(AbilityKind ak)
{
var game = CreateGame();
var ab = game.GameManager.Hero.GetPassiveAbility(ak);
var enemy = PlainEnemies.First();
var enemyBeginHealth = enemy.Stats.Health;
UseSpellSource(game.Hero, enemy, true, AbilityKind2SpellKind[ak]);
Assert.Less(enemy.Stats.Health, enemyBeginHealth);
var diff1 = enemyBeginHealth - enemy.Stats.Health;
enemyBeginHealth = enemy.Stats.Health;
for (int i = 0; i < ab.MaxLevel; i++)
{
ab.IncreaseLevel(game.Hero);
}
GotoNextHeroTurn();
UseSpellSource(game.Hero, enemy, true, AbilityKind2SpellKind[ak]);
Assert.Less(enemy.Stats.Health, enemyBeginHealth);
var diff2 = enemyBeginHealth - enemy.Stats.Health;
Assert.Greater(diff2, diff1);
}
//[TestCase(AbilityKind.SkeletonMastering)]
public void MagicProjectilePropTest(AbilityKind ak)
{
var game = CreateGame();
var ab = game.GameManager.Hero.GetPassiveAbility(ak);
if (ak == AbilityKind.FireBallMastering)
{
Assert.AreEqual(ab.PrimaryStat.Kind, EntityStatKind.FireBallExtraDamage);
}
else if (ak == AbilityKind.PoisonBallMastering)
{
Assert.AreEqual(ab.PrimaryStat.Kind, EntityStatKind.PoisonBallExtraDamage);
}
else if (ak == AbilityKind.IceBallMastering)
{
Assert.AreEqual(ab.PrimaryStat.Kind, EntityStatKind.IceBallExtraDamage);
}
else if (ak == AbilityKind.SkeletonMastering)
{
Assert.AreEqual(ab.PrimaryStat.Kind, EntityStatKind.MeleeAttack);
}
Assert.AreEqual(ab.PrimaryStat.Unit, EntityStatUnit.Percentage);
Assert.AreEqual(ab.PrimaryStat.Factor, 0);
for (int i = 0; i < MaxAbilityInc; i++)
{
ab.IncreaseLevel(game.Hero);
}
Assert.Greater(ab.PrimaryStat.Factor, 10);
Assert.Less(ab.PrimaryStat.Factor, 60);
}
public bool HasAbility(AbilityKind kind)
{
if ((kinds & kind) > 0)
{
return(true);
}
return(false);
}
public static bool IsPercFromKind(AbilityKind kind)
{
if (kind == AbilityKind.RestoreHealth ||
kind == AbilityKind.RestoreMana)
{
return(true);
}
return(false);
}
public static FightItemKind GetFightItemKind(AbilityKind kind)
{
if (Ab2Fi.ContainsKey(kind))
{
return(Ab2Fi[kind]);
}
return(FightItemKind.Unset);
}
public Ability GetAbility(AbilityKind kind)
{
Ability ab = passiveAbilities.Where(i => i.Kind == kind).FirstOrDefault();
if (ab == null)
{
ab = activeAbilities.Where(i => i.Kind == kind).FirstOrDefault();
}
return(ab);
}
private static void IncreaseAbility(Hero hero, AbilityKind kind)
{
var ab = hero.GetActiveAbility(kind);
hero.AbilityPoints = ab.MaxLevel;
hero.Level = 11;
for (int i = 0; i < ab.MaxLevel; i++)
{
var inc = hero.IncreaseAbility(kind);
Assert.IsTrue(inc);
}
}
void AddAllAbility()
{
var abilites = System.Enum.GetValues(typeof(AbilityKind));
foreach (var item in abilites)
{
AbilityKind abil = (AbilityKind)item;
if (abil == AbilityKind.None)
{
continue;
}
AddAbility(abil);
}
}
public void GenerateStates()
{
var abilites = System.Enum.GetValues(typeof(AbilityKind));
foreach (var item in abilites)
{
AbilityKind abil = (AbilityKind)item;
if (abil == AbilityKind.None)
{
continue;
}
var obj = Instantiate(pfAbility, holder).GetComponent <UIAbility>();
obj.Init(abil, StageMan.In.player);
}
}
public override bool IsPercentageFromKind => kind == AbilityKind.Stride;//|| kind == AbilityKind.CauseBleeding;
public override float CalcFactor(bool primary, int level)
{
AbilityKind kind = Kind;
float factor = 0;
switch (kind)
{
case AbilityKind.Stride:
float fac = CalcFightItemFactor(level);
factor = fac;
if (!primary)
{
if (kind == AbilityKind.ExplosiveCocktail ||
kind == AbilityKind.PoisonCocktail)
{
factor *= 3;
}
else
{
factor *= 4;
}
}
factor = (int)Math.Ceiling(factor);
if (primary)
{
if (kind == AbilityKind.ExplosiveCocktail ||
kind == AbilityKind.PoisonCocktail)
{
factor *= 2f;
}
if (kind == AbilityKind.Stride)
{
factor *= 6f;
}
}
break;
case AbilityKind.HunterTrap:
case AbilityKind.ExplosiveCocktail:
case AbilityKind.PoisonCocktail:
case AbilityKind.ThrowingStone:
case AbilityKind.ThrowingKnife:
var multsHunt = new int[] { 0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
factor = multsHunt[level] * 2;
break;
case AbilityKind.PiercingArrow:
if (primary)
{
var percentToDo = new int[] { 0, 80, 85, 90, 95, 100 };
factor = percentToDo[level];
}
else
{
var victims = new int[] { 0, 2, 3, 4, 5, 6 };
factor = victims[level];
}
break;
case AbilityKind.ArrowVolley:
if (primary)
{
var victims = new int[] { 0, 2, 3, 4, 5, 6 };
factor = victims[level];
}
break;
case AbilityKind.OpenWound:
if (primary)
{
//duration
var durations = new int[] { 0, 3, 3, 4, 4, 5 };
factor = durations[level];
}
else
{
var extraDamages = new int[] { 0, 5, 10, 15, 20, 25 };
factor = extraDamages[level];
}
break;
case AbilityKind.Rage:
if (primary)
{
var perc = new int[] { 0, 25, 30, 40, 55, 70 };
factor = perc[level];
}
break;
case AbilityKind.WeightedNet:
var vals = new int[] { 0, 1, 2, 3, 4, 5 };
factor = vals[level];
break;
case AbilityKind.PerfectHit:
if (primary)
{
var victims = new int[] { 0, 10, 15, 35, 50, 70 };//PerfectHitDamage %
factor = victims[level];
}
else
{
var extraDamages = new int[] { 0, 5, 10, 15, 20, 25 };//PerfectHitChanceToHit %
factor = extraDamages[level];
}
break;
default:
break;
}
return(factor);
}
public static string GetExplain(AbilityKind kind)
{
switch (kind)
{
case AbilityKind.None:
break;
case AbilityKind.Double:
return("미사일이 두개");
case AbilityKind.Triple:
return("3갈래 탄");
case AbilityKind.BulletBonus_1:
return("총알 추가 Lv1");
case AbilityKind.BulletBonus_2:
return("총알 추가 Lv2");
case AbilityKind.BulletBonus_3:
return("총알 추가 Lv3");
case AbilityKind.Divine:
return("간헐적 무적");
case AbilityKind.BulletSpdUp_1:
return("총알 속도증가 Lv1");
case AbilityKind.BulletSpdUp_2:
return("총알 속도증가 Lv2");
case AbilityKind.BulletSpdUp_3:
return("총알 속도증가 Lv3");
case AbilityKind.PowerUp_1:
return("공격력 증가 Lv1");
case AbilityKind.PowerUp_2:
return("공격력 증가 Lv2");
case AbilityKind.PowerUp_3:
return("공격력 증가 Lv3");
case AbilityKind.HpUp_1:
return("체력 증가 Lv1");
case AbilityKind.HpUp_2:
return("체력 증가 Lv2");
case AbilityKind.HpUp_3:
return("체력 증가 Lv3");
case AbilityKind.MovSpdUp_1:
return("이동속도증가 Lv1");
case AbilityKind.MovSpdUp_2:
return("이동속도증가 Lv2");
case AbilityKind.MovSpdUp_3:
return("이동속도증가 Lv3");
case AbilityKind.AroundBall:
return("빙빙돌이");
case AbilityKind.Penetrate:
return("관통");
case AbilityKind.Flame:
return("불길생성");
case AbilityKind.Healing_1:
return("체력 재생 Lv1");
case AbilityKind.Healing_2:
return("체력 재생 Lv2");
case AbilityKind.Healing_3:
return("체력 재생 Lv3");
default:
break;
}
return(string.Empty);
}
public override float CalcFactor(bool primary, int level)
{
AbilityKind kind = Kind;
float factor = 0;
switch (kind)
{
case AbilityKind.RestoreHealth:
case AbilityKind.RestoreMana:
try
{
var mults = new float[] { 0, .3f, .75f, 1f, 1.5f, 2.5f };
factor = mults[level];
}
catch (Exception)
{
throw;
}
break;
case AbilityKind.AxesMastering:
case AbilityKind.BashingMastering:
case AbilityKind.DaggersMastering:
case AbilityKind.SwordsMastering:
case AbilityKind.WandsMastering:
case AbilityKind.SceptersMastering:
case AbilityKind.StaffsMastering:
case AbilityKind.BowsMastering:
case AbilityKind.CrossBowsMastering:
case AbilityKind.FireBallMastering:
case AbilityKind.IceBallMastering:
case AbilityKind.PoisonBallMastering:
if (primary)
{
factor = level;
if (kind == AbilityKind.WandsMastering || //ChanceToElementalProjectileBulkAttack
kind == AbilityKind.SceptersMastering ||//ChanceToCauseElementalAilment
kind == AbilityKind.StaffsMastering//ChanceToRepeatElementalAttack
)
{
var multsDef = new int[] { 0, 5, 10, 20, 30, 40, 50, 65, 80, 85, 100 };
factor = multsDef[level];
}
if (kind == AbilityKind.FireBallMastering ||
kind == AbilityKind.IceBallMastering ||
kind == AbilityKind.PoisonBallMastering
)
{
//damage in %
var multsDef = new int[] { 0, 10, 20, 30, 40, 50 };
factor = multsDef[level];
}
}
else
{
factor = level * 5;
if (kind == AbilityKind.WandsMastering)
{
var multsDef = new int[] { 0, 2, 4, 6, 8, 11, 15, 18, 25, 30, 35 };
factor = multsDef[level];
}
}
break;
case AbilityKind.SkeletonMastering:
if (primary)
{
//PrimaryAttributes %
var multsDef = new int[] { 0, 10, 15, 20, 25, 30 };
factor = multsDef[level];
}
else
{
//MaxSkeletonsCount
var maxSkeletonsCount = new int[] { 0, 2, 2, 3, 3, 4 };
factor = maxSkeletonsCount[level];
}
break;
case AbilityKind.StrikeBack:
var multsDefSB = new int[] { 0, 2, 4, 7, 10, 15 };
factor = multsDefSB[level];
break;
case AbilityKind.BulkAttack:
var multsDefSB1 = new int[] { 0, 4, 7, 10, 15, 20 };
factor = multsDefSB1[level];
break;
default:
break;
}
return(factor);
}
public override float CalcFactor(bool primary, int level)
{
AbilityKind kind = Kind;
float factor = 0;
switch (kind)
{
case AbilityKind.ExplosiveMastering:
case AbilityKind.PoisonMastering:
case AbilityKind.ThrowingStoneMastering:
case AbilityKind.ThrowingKnifeMastering:
float fac = CalcFightItemFactor(level);
//List<float> facs = new List<float>();
//for (int i = 0; i < 5; i++)
//{
// facs.Add(CalcExplFactor(i));
//}
factor = fac;
if (!primary)
{
//if (kind == AbilityKind.HuntingMastering)
// factor = level;
if (kind == AbilityKind.ExplosiveMastering ||
kind == AbilityKind.PoisonMastering)
{
factor *= 3;
}
else
{
factor *= 4;
}
}
factor = (int)Math.Ceiling(factor);
if (primary)
{
if (kind == AbilityKind.ExplosiveMastering ||
kind == AbilityKind.PoisonMastering)
{
factor *= 2f;
}
//else if (kind == PassiveAbilityKind.ThrowingWeaponsMastering)
//{
// factor *= 23f;
//}
//else if (kind == AbilityKind.HuntingMastering)
// factor *= 18f;
}
break;
case AbilityKind.HunterTrapMastering:
var multsHunt = new int[] { 0, 10, 20, 30, 40, 50 };
factor = multsHunt[level];
break;
default:
break;
}
return(factor);
}
public void AddAbility(AbilityKind kind)
{
switch (kind)
{
case AbilityKind.None:
break;
case AbilityKind.Double:
break;
case AbilityKind.Triple:
break;
case AbilityKind.BulletBonus_1:
maxBulletCount += Balance.BULLET_BONUS_1;
break;
case AbilityKind.BulletBonus_2:
maxBulletCount += Balance.BULLET_BONUS_2;
break;
case AbilityKind.BulletBonus_3:
maxBulletCount += Balance.BULLET_BONUS_3;
break;
case AbilityKind.Divine:
break;
case AbilityKind.BulletSpdUp_1:
bulletSpd += Balance.BULLET_SPD_1;
break;
case AbilityKind.BulletSpdUp_2:
bulletSpd += Balance.BULLET_SPD_2;
break;
case AbilityKind.BulletSpdUp_3:
bulletSpd += Balance.BULLET_SPD_3;
break;
case AbilityKind.PowerUp_1:
atk += Balance.DAMAGE_INC_1;
break;
case AbilityKind.PowerUp_2:
atk += Balance.DAMAGE_INC_2;
break;
case AbilityKind.PowerUp_3:
atk += Balance.DAMAGE_INC_3;
break;
case AbilityKind.HpUp_1:
maxHp += Balance.MAX_HP_INC_1;
break;
case AbilityKind.HpUp_2:
maxHp += Balance.MAX_HP_INC_2;
break;
case AbilityKind.HpUp_3:
maxHp += Balance.MAX_HP_INC_3;
break;
case AbilityKind.MovSpdUp_1:
movSpd += Balance.MOV_SPD_INC_1;
break;
case AbilityKind.MovSpdUp_2:
movSpd += Balance.MOV_SPD_INC_2;
break;
case AbilityKind.MovSpdUp_3:
movSpd += Balance.MOV_SPD_INC_3;
break;
case AbilityKind.AroundBall:
break;
case AbilityKind.Penetrate:
break;
case AbilityKind.Flame:
break;
case AbilityKind.Healing_1:
healing += Balance.HEALING_INC_1;
break;
case AbilityKind.Healing_2:
healing += Balance.HEALING_INC_2;
break;
case AbilityKind.Healing_3:
healing += Balance.HEALING_INC_3;
break;
default:
break;
}
}
public void Init(AbilityKind kind, Character c)
{
this.kind = kind;
this.c = c;
txtName.text = kind.ToString();
}
public bool IsActive(AbilityKind kind)
{
return(activeAbilities.Where(i => i.Kind == kind).Any());
}
public override float CalcFactor(bool primary, int level)
{
AbilityKind kind = Kind;
float factor = 0;
switch (kind)
{
case AbilityKind.RestoreHealth:
case AbilityKind.RestoreMana:
try
{
var mults = new float[] { 0, .3f, .75f, 1f, 1.5f, 2.5f };
factor = mults[level];
}
catch (Exception)
{
throw;
}
break;
case AbilityKind.AxesMastering:
case AbilityKind.BashingMastering:
case AbilityKind.DaggersMastering:
case AbilityKind.SwordsMastering:
case AbilityKind.WandsMastering:
case AbilityKind.SceptersMastering:
case AbilityKind.StaffsMastering:
case AbilityKind.BowsMastering:
case AbilityKind.CrossBowsMastering:
if (primary)
{
factor = level;
if (kind == AbilityKind.WandsMastering || //ChanceToElementalBulkAttack
kind == AbilityKind.SceptersMastering ||//ChanceToCauseElementalAilment
kind == AbilityKind.StaffsMastering//ChanceToRepeatElementalAttack
)
{
var multsDef = new int[] { 0, 4, 7, 10, 15, 20 };
factor = multsDef[level];
}
}
else
{
factor = level * 5;
if (kind == AbilityKind.WandsMastering)
{
var multsDef = new int[] { 0, 4, 7, 10, 15, 20 };
factor = multsDef[level];
}
}
break;
case AbilityKind.StrikeBack:
var multsDefSB = new int[] { 0, 2, 4, 7, 10, 15 };
factor = multsDefSB[level];
break;
case AbilityKind.BulkAttack:
var multsDefSB1 = new int[] { 0, 4, 7, 10, 15, 20 };
factor = multsDefSB1[level];
break;
default:
break;
}
return(factor);
}
private float TestWeaponKindMastering(AbilityKind kind)
{
var abVal = 0.0f;
var abValAux = 0.0f;
var hero = game.Hero;
hero.UseAttackVariation = false;
float auxStatValue;
var destStat = SetWeapon(kind, hero, out auxStatValue);
var en = PlainEnemies.First();
en.Stats.SetNominal(EntityStatKind.Health, 100);
en.AddImmunity(Roguelike.Effects.EffectType.Bleeding);//not to mix test results
var wpn = hero.GetActiveWeapon();
wpn.StableDamage = true;
Assert.Greater(wpn.LevelIndex, 0);
Func <float> hitEnemy = () =>
{
var health = en.Stats.Health;
if (!wpn.IsBowLike)
{
en.OnMelleeHitBy(hero);
}
else
{
en.OnHitBy(hero.ActiveFightItem as ProjectileFightItem);
}
var health1 = en.Stats.Health;
return(health - health1);
};
if (wpn.IsBowLike)
{
ProjectileFightItem pfi = null;
if (wpn.Kind == Weapon.WeaponKind.Bow)
{
pfi = new ProjectileFightItem(FightItemKind.PlainArrow)
{
Count = 2
};
}
else if (wpn.Kind == Weapon.WeaponKind.Crossbow)
{
pfi = new ProjectileFightItem(FightItemKind.PlainBolt)
{
Count = 2
};
}
pfi.Caller = hero;
hero.Inventory.Add(pfi);
hero.ActiveFightItem = pfi;
}
var damage = hitEnemy();
Assert.Greater(damage, 0);
var heroAttack = hero.GetAttackValue(AttackKind.Unset).CurrentTotal;
for (int i = 0; i < MaxAbilityInc + 1; i++)
{
hero.IncreaseAbility(kind);
var ab = hero.GetPassiveAbility(kind);
Assert.AreNotEqual(ab.PrimaryStat.Kind, EntityStatKind.Unset);
AssertNextValue(i, ab, abVal, abValAux);
abVal = GetFactor(ab, true);
abValAux = GetFactor(ab, false);
Assert.Less(abVal, 21);
Assert.Less(abValAux, 26);
abVal = ab.PrimaryStat.Factor;
//Debug.WriteLine(kind + " Level: " + ab.Level + ", value :" + ab.PrimaryStat.Factor);
}
var statValueWithAbility = hero.Stats.GetCurrentValue(destStat);
Assert.Greater(statValueWithAbility, auxStatValue);
var heroAttackWithAbility = hero.GetAttackValue(AttackKind.Unset).CurrentTotal;
Assert.Greater(heroAttackWithAbility, heroAttack);
var damageWithAbility = hitEnemy();
if (damageWithAbility < damage)
{
int k = 0;
k++;
}
Assert.Greater(damageWithAbility, damage);
return(abVal);
}
public void TestMagicProjectileMasteringStats(EntityStatKind esk, AbilityKind ak)
{
var game = CreateGame();
float originalStatValue = 0;
SetWeapon(ak, game.Hero, out originalStatValue);
var weapon = game.Hero.GetActiveWeapon();
var en = PlainEnemies.First();
float enHealthBase = PrepareEnemyToBeBeaten(en);
var damageComparer1 = new OuaDDamageComparer(en, this);
var spell = weapon.SpellSource.CreateSpell(game.Hero);
Assert.AreEqual(game.GameManager.SpellManager.ApplyAttackPolicy(game.Hero, en, weapon.SpellSource), Roguelike.Managers.ApplyAttackPolicyResult.OK);
GotoNextHeroTurn();
damageComparer1.RegisterHealth(en);
Assert.Greater(damageComparer1.HealthDifference, 0);
var stat1Value = game.Hero.Stats.GetStat(EntityStatKind.ChanceToRepeatElementalProjectileAttack).Value;
Assert.AreEqual(stat1Value.Factor, 0);
Assert.AreEqual(game.Hero.Stats.GetStat(EntityStatKind.StaffExtraElementalProjectileDamage).Value.Factor, 0);
var ab = game.Hero.GetPassiveAbility(ak);
//do not call MaximizeAbility as it's not possible to distinguish what cause greater damage ChanceToRepeat or StaffExtraDamage
//MaximizeAbility(ab, game.Hero);
var factor = 50;//%
game.Hero.Stats.SetFactor(esk, factor);
Assert.Greater(game.Hero.Stats.GetStat(esk).Value.Factor, 0);
bool works = false;
for (int i = 0; i < 20; i++)
{
var damageComparer2 = new OuaDDamageComparer(en, this);
spell = weapon.SpellSource.CreateSpell(game.Hero);
Assert.AreEqual(game.GameManager.SpellManager.ApplyAttackPolicy(game.Hero, en, weapon.SpellSource), Roguelike.Managers.ApplyAttackPolicyResult.OK);
GotoNextHeroTurn();
damageComparer2.RegisterHealth(en);
if (damageComparer2.HealthDifference > damageComparer1.HealthDifference)
{
if (esk == EntityStatKind.StaffExtraElementalProjectileDamage)
{
AssertHealthDiffPercentageInRange(damageComparer1, damageComparer2, 140, 175);//+factor%
}
works = true;
break;
}
}
Assert.True(works);
////SumPercentageFactorAndValue of EnityStat depends on Factor, so check it
//var scroll = PrepareScroll(game.Hero, SpellKind.Skeleton);
//scroll.Count = 10;
//var gm = game.GameManager;
//var spellSk = gm.SpellManager.ApplySpell(game.Hero, scroll) as SkeletonSpell;
//Assert.NotNull(spellSk.Ally);
//Assert.AreEqual(spellSk.Ally.Stats.GetStat(EntityStatKind.StaffExtraElementalProjectileDamage).Value.Factor, 0);
//Assert.AreEqual(spellSk.Ally.Stats.GetStat(EntityStatKind.ChanceToRepeatElementalProjectileAttack).Value.Factor, 0);
//MaximizeAbility(ab, spellSk.Ally);
//Assert.Greater(spellSk.Ally.Stats.GetStat(EntityStatKind.StaffExtraElementalProjectileDamage).Value.Factor, 0);
//Assert.Greater(spellSk.Ally.Stats.GetStat(EntityStatKind.ChanceToRepeatElementalProjectileAttack).Value.Factor, 0);
}
public void Clear()
{
kinds = AbilityKind.None;
}
