public Tupotrof() { Name = "Tupotrof"; Image = Graphics.resources.Res.Tupotrof; SetMaxHp(765); SetAttackDamage(45); SetAttackSpeed(2); SetMovementSpeed(11); Growth = new Perk { Name = "Growth", Number = (h) => h.Level, LevelUp = (a) => (d) => { AddAttackDamage(GetAttackDamage() * GrowthADPercentBuff); AddMovementSpeed(GrowthMSBuff); return(a(d)); }, }; Cutter = new Skill { Name = "Cutter", Explanation = () => "Deales " + CutterDamage + " + " + CutterADScale * 100 + "% AD (" + (CutterDamage + CutterADScale * GetAttackDamage()) + ") phyc damage" + " to all enemies within AA range (" + GetAttackRange() + ").", CoolDown = CutterCooldown, Job = (h) => { var damage = new Damage(h, h.P, phys: CutterDamage + CutterADScale * h.GetAttackDamage()); var targets = GetEnemiesInRange(h, h.GetAttackRange()); foreach (var target in targets) { target.GetDamage(damage); } return(true); }, }; Cutter.SkillTypes.Add(SkillType.Special); Skills.Add(Cutter); Perks.Add(Growth); }
public Immortal() { Name = "Immortal"; Image = Graphics.resources.Res.Immortal; SetMaxHp(333); SetEnergyRegen(5); SetMaxEnergy(333); SetArmor(10); SetResist(10); SetMovementSpeed(9); SetAttackDamage(50); SetAttackRange(8); Shield = new Perk { Name = "Shield", Number = (h) => Math.Floor(ShieldEnergyRegen * (h.GetMaxEnergy() - h.GetEnergy())), Explanation = (h) => "When taking damage up to " + ShieldMaxDamage + " of it goes in to HP, others goes energy;" + " And in end of turn restore " + ShieldEnergyRegen * 100 + "% of lost energy", GetDamage = (a) => (d) => { var h = d.HeroValue; var damage = d.DamageValue; var arm = h.GetArmor(); var res = h.GetResist(); var armored = damage.Phys > arm ? arm : damage.Phys; var resisted = damage.Magic > arm ? arm : damage.Magic; var resDamage = new Damage(h, h.P, damage.Phys - armored, damage.Magic - resisted, damage.Pure); var damageShould = resDamage.Sum(); if (damageShould > ShieldMaxDamage) { var over = damageShould - ShieldMaxDamage; var energyLeft = h.GetEnergy(); var absorbed = energyLeft >= over ? over : energyLeft; var damageLeft = over - absorbed + ShieldMaxDamage; var coeff = damageLeft / damageShould; resDamage.Phys *= coeff; resDamage.Magic *= coeff; resDamage.Pure *= coeff; h.AddEnergy(-absorbed); d.PlayerValue.AllDamage += absorbed * ShieldEnergyExpCoeff; } resDamage.Phys += armored; resDamage.Magic += resisted; d.DamageValue = resDamage; return(a(d)); }, EndTurn = (a) => (d) => { var h = d.HeroValue; h.AddEnergy(ShieldEnergyRegen * (h.GetMaxEnergy() - h.GetEnergy())); return(a(d)); } }; Perks.Add(Shield); Reflection = new Perk { Name = "Reflection", Number = (h) => Math.Floor(StormMaxEnergyScale * h.GetMaxEnergy() + StormAPScale * h.GetAbilityPower()), Explanation = (h) => "Everybody who attacks you or stay within " + StormRange + " radius at the end of your turn gets" + (StormMaxEnergyScale * h.GetMaxEnergy() + StormAPScale * h.GetAbilityPower()) + " spell damage", GetDamage = (a) => (d) => { var h = d.HeroValue; if (h.P.Heroes.Contains(d.DamageValue.Creator)) { return(a(d)); } var maxEnergy = h.GetMaxEnergy(); var ap = h.GetAbilityPower(); d.DamageValue.Creator .GetDamage(new Damage(h, h.P, magic: maxEnergy * StormMaxEnergyScale + ap * StormAPScale)); return(a(d)); }, EndTurn = (a) => (d) => { var h = d.HeroValue; var maxEnergy = h.GetMaxEnergy(); var ap = h.GetAbilityPower(); var damage = new Damage(h, h.P, magic: maxEnergy * StormMaxEnergyScale + ap * StormAPScale); var targets = GetEnemiesInRange(h, StormRange); foreach (var target in targets) { target.GetDamage(damage); } return(a(d)); }, }; Storm = new Skill { Name = "Storm", Explanation = () => "For next " + StormDuration + " turns all enemies in " + StormRange + " units from you and each time they do damage to" + " this hero they take " + StormMaxEnergyScale * 100 + "% MaxEnergy + " + StormAPScale * 100 + "%AP (" + (StormMaxEnergyScale * GetMaxEnergy() + StormAPScale * GetAbilityPower()) + ") magic damage. Cost " + StormCost + "%Energy. CD " + StormCD, CoolDown = StormCD, Job = (h) => { var ef = new Effect(h, StormDuration - 1) { Activate = (eh) => eh.Perks.Add(Reflection), Disactivate = (eh) => eh.Perks.Remove(Reflection), }; h.M.Effects.Add(ef); ef.Activate(h); h.SetEnergy(h.GetEnergy() * (1 - StormCost)); return(true); } }; Storm.SkillTypes.Add(SkillType.Special); Skills.Add(Storm); }
public Geneva() { Name = "Geneva"; Image = Graphics.resources.Res.Geneva; SetMaxHp(808); SetMaxEnergy(300); SetMovementSpeed(8); SetArmor(15); SetAttackRange(5); SetEnergyRegen(15); Keeping = false; Impulse = new Skill() { Name = "Impulse", Explanation = () => "Creates an impulse, centered " + ImpulseRange + " units from you, that explodes in " + ImpulseRadius + " units radius dealing " + ImpulseDamage + " + " + ImpulseApScale * 100 + "%AP (" + (ImpulseDamage + ImpulseApScale * GetAbilityPower()) + ") " + "magic damage to enemies and slowing them by " + ImpulseSlow * 100 + "% MS for " + ImpulseSlowTime + " turns. CD " + ImpulseCD + ". Cost " + ImpulseCost + ".", EnergyCost = ImpulseCost, CoolDown = ImpulseCD, Job = (h) => { var points = h.GetPosition().GetPointsInDistance(0, ImpulseRange).Select(p => p.Key).ToList(); if (points.Count == 0) { return(false); } var center = ChoosePoint(points, h.P); if (center == null) { return(false); } var targets = h.M.GetHeroPositions().Where(u => u.Value.GetStepsTo(center) <= ImpulseRadius) .Select(p => p.Key) .Where(u => h.P != u.P) .ToList(); var damage = new Damage(h, h.P, magic: ImpulseDamage + ImpulseApScale * GetAbilityPower()); foreach (var t in targets) { h.Targets.Add(t); t.GetDamage(damage); } var slowPerk = new Perk { GetMovementSpeed = (g) => () => g() * (1 - ImpulseSlow), SetMovementSpeed = (g) => (v) => g(v / (1 - ImpulseSlow)), }; foreach (var t in targets) { t.Perks.Add(slowPerk); } var slowEffect = new Effect(h) { Activate = (he) => { }, Disactivate = (he) => { foreach (var t in targets) { t.Perks.Remove(slowPerk); } }, Timer = (int)ImpulseSlowTime, }; h.M.Effects.Add(slowEffect); slowEffect.Activate(h); (h as Geneva).Keeping = false; return(true); }, }; Impulse.SkillTypes.Add(SkillType.Special); Impulse.SkillTypes.Add(SkillType.Mag); Skills.Add(Impulse); BeamPerk = new Perk { Name = "Beam", EndTurn = (f) => (d) => { var me = d.HeroValue as Geneva; if (me.Keeping) { if (me.BeamTarget != null && me.M.GetHeroes().Contains(me.BeamTarget) && me.BeamTarget.GetPosition().GetStepsTo(me.GetPosition()) <= BeamRadius) { me.BeamTarget.GetHeal(BeamRegen + BeamRegenApScale * me.GetAbilityPower()); } else { me.Keeping = false; } } return(f(d)); }, SkillFix = (s) => { var prev = s.Job; if (s.Name == "Beam" || s.Name == "Impulse") { return(s); } var newSkill = new Skill { Name = s.Name, Explanation = s.Explanation, CoolDown = s.CoolDown, EnergyCost = s.EnergyCost, SkillTypes = s.SkillTypes, Job = (h) => { var res = prev(h); if (res) { (h as Geneva).Keeping = false; } return(res); }, Timer = s.CoolDown, }; return(newSkill); } }; Perks.Add(BeamPerk); Beam = new Skill { Name = "Beam", Explanation = () => "Heales chosen hero in " + BeamRadius + " units from you for " + BeamHeal + " + " + BeamHealApScale * 100 + "%AP (" + (BeamHeal + BeamHealApScale * GetAbilityPower()) + ") HP and " + " continues healing him at the end of every your turn fro " + +BeamRegen + " + " + BeamRegenApScale * 100 + "%AP (" + (BeamRegen + BeamRegenApScale * GetAbilityPower()) + ") HP" + " while you dont use any other skills and target stays in range of skill. CD " + BeamCD + ". Cost " + BeamCost + ".", EnergyCost = BeamCost, CoolDown = BeamCD, Job = (h) => { var allys = GetAlliesInRange(h, BeamRadius); if (allys.Count == 0) { return(false); } var target = ChooseTarget(allys, h.P); if (target == null) { return(false); } h.Targets.Add(target); target.GetHeal(BeamHeal + BeamHealApScale * h.GetAbilityPower()); (h as Geneva).Keeping = true; (h as Geneva).BeamTarget = target; return(true); } }; Beam.SkillTypes.Add(SkillType.Special); Skills.Add(Beam); }
public Banker() { Name = "Banker"; Image = Graphics.resources.Res.Banker; SetMaxHp(950); SetArmor(15); SetResist(20); SetMaxEnergy(300); SetEnergyRegen(15); SetMovementSpeed(10); InterestRate = new Perk { Name = "Interest Rate", Number = (h) => ((InteresRateHeal + InterestRateHealAPScale * h.GetAbilityPower()) * 100), Explanation = (h) => "When level up, gives all allies " + InterestRateHpBuffAPScale * 100 + "% AP (" + h.GetAbilityPower() * InterestRateHpBuffAPScale + ") HP; At the end of turn, heals allies in " + InterestRateHealRange + " range for " + InteresRateHeal * 100 + " + " + InterestRateHealAPScale * 100 + "% AP (" + (InteresRateHeal + InterestRateHealAPScale * h.GetAbilityPower()) + ")% target's lost HP", LevelUp = (a) => (d) => { var h = d.HeroValue; var hpBuff = GetAbilityPower() * InterestRateHpBuffAPScale; var allies = h.P.Heroes.Where(hh => hh != h); foreach (var ally in allies) { ally.AddMaxHp(hpBuff); ally.AddHp(hpBuff); } return(a(d)); }, EndTurn = (a) => (d) => { var h = d.HeroValue; var targets = GetAlliesInRange(h, InterestRateHealRange); //heal for % of lost HP var percent = h.GetAbilityPower() * InterestRateHealAPScale + InteresRateHeal; foreach (var ally in targets) { ally.GetHeal((ally.GetMaxHp() - ally.GetHp()) * percent); } return(a(d)); }, }; Perks.Add(InterestRate); Investment = new Skill { Name = "Investment", Explanation = () => "Give chosen ally " + InvestmentMoney + " + " + InvestmentAPScale * 100 + "%AP(" + +(InvestmentMoney + InvestmentAPScale * GetAbilityPower()) + ") of your Money.CD " + InvestmentCD + ". Cost " + InvestmentCost + ".", CoolDown = InvestmentCD, EnergyCost = InvestmentCost, Job = (h) => { var moneySent = Math.Min(InvestmentMoney + h.GetAbilityPower() * InvestmentAPScale, h.GetMoney()); var allies = h.P.Heroes.Where(hh => hh != h).ToList(); if (allies.Count == 0) { return(false); } var target = ChooseTarget(allies, h.P); if (target == null) { return(false); } h.Targets.Add(target); foreach (var t in h.Targets) { t.AddMoney(moneySent); } h.AddMoney(-moneySent); return(true); }, }; Investment.SkillTypes.Add(SkillType.Special); Skills.Add(Investment); CurrencyExchange = new Skill { Name = "Exchange", Explanation = () => "Damage yourself by (" + ExchangeHP + " + " + ExchangeAPScale * 100 + "% AP)% of MaxHp (" + (ExchangeHP + ExchangeAPScale * GetAbilityPower()) * GetMaxHp() + "). Earns " + ExchangeExpCoeff * 100 + "% (" + (ExchangeHP + ExchangeAPScale * GetAbilityPower()) * ExchangeExpCoeff * GetMaxHp() + ") of it as EXP. CD " + ExchangeCD + ". Cost " + ExchangeCost + ".", CoolDown = ExchangeCD, EnergyCost = ExchangeCost, Job = (h) => { var hpCost = h.GetMaxHp() * (ExchangeHP + ExchangeAPScale * h.GetAbilityPower()); if (hpCost >= h.GetHp()) { hpCost = h.GetHp() - 1; } h.AddHp(-hpCost); h.P.NotifyAboutDamage(new Damage(h, h.P, 0, 0, hpCost * ExchangeExpCoeff)); return(true); }, }; CurrencyExchange.SkillTypes.Add(SkillType.Special); Skills.Add(CurrencyExchange); }
public Gaina() { Name = "Gaina"; Image = Graphics.resources.Res.Gaina; SetMaxHp(777); SetMaxEnergy(200); SetEnergyRegen(20); SetAbilityPower(50); SetAttackRange(7); Blasts = new List <Specials.Pyroblast>(); Collider = new Perk { StartTurn = (s) => (d) => { var list = new List <Pyroblast>(Blasts); foreach (var pyro in list) { pyro.Boom(); } return(s(d)); }, SkillFix = (s) => { var newSkill = new Skill() { Name = s.Name, CoolDown = s.CoolDown, SkillTypes = s.SkillTypes, Explanation = s.Explanation, }; newSkill.Job = (he) => { var res = s.Job(he); if (res) { var list = new List <Pyroblast>(Blasts); foreach (var pyro in list) { pyro.Boom(); } return(true); } return(false); }; return(newSkill); }, EndTurn = (v) => (d) => { foreach (var pyro in Blasts) { pyro.Tick(); } var list = new List <Pyroblast>(Blasts); foreach (var pyro in list) { pyro.Boom(); } return(v(d)); } }; Perks.Add(new Perk { StartTurn = (f) => (d) => { foreach (var h in d.HeroValue.M.GetHeroes()) { if (!h.Perks.Contains(Collider)) { h.Perks.Add(Collider); } } return(f(d)); }, }); Pyroblast = new Skill { Name = "Pyroblast", Explanation = () => "Shoots pyroblast that moves diagonally and bounce off of stones and deales " + PyroblastAPScale * 100 + "%AP (" + GetAbilityPower() * PyroblastAPScale + ") spell damage to all enemies in " + PyroblastRadius + " range when fly on them. Cost " + PyroblastCost + ". CD " + PyroblastCd, EnergyCost = PyroblastCost, CoolDown = PyroblastCd, Job = (h) => { var directions = new List <Point> { new Point(1, 1), new Point(-1, 1), new Point(-1, -1), new Point(1, -1) }; var positions = directions.Select(d => d + h.GetPosition()).Where(p => h.M.CellIsFree(p)).ToList(); var point = ChoosePoint(positions, h.P); if (point == null) { return(false); } var pyro = new Pyroblast(h) { Direction = new Point(point.X - h.GetPosition().X, point.Y - h.GetPosition().Y) }; pyro.Boom = () => { var place = h.M.UnitPositions[pyro]; var targets = h.M.GetHeroPositions().Where(a => a.Key.P != h.P && place.GetStepsTo(a.Value) <= PyroblasTriggerRadius) .Select(a => a.Key); if (targets.Count() == 0) { return(false); } var damage = new Damage(h, h.P, magic: GetAbilityPower() * PyroblastAPScale); targets = h.M.GetHeroPositions().Where(a => a.Key.P != h.P && place.GetStepsTo(a.Value) <= PyroblastRadius).Select(a => a.Key); foreach (var tg in targets) { tg.GetDamage(damage); } Blasts.Remove(pyro); h.M.UnitPositions.Remove(pyro); return(true); }; pyro.Tick = () => { var curretPoint = h.M.UnitPositions[pyro]; var nextPoint = curretPoint + pyro.Direction; if (h.M.IsInBounds(nextPoint) && h.M.MapTiles[nextPoint.X, nextPoint.Y].Type == TileType.Empty) { h.M.UnitPositions[pyro] = nextPoint; return; } var one = curretPoint + new Point(pyro.Direction.X, 0); var another = curretPoint + new Point(0, pyro.Direction.Y); var oneCool = h.M.IsInBounds(one) && h.M.MapTiles[one.X, one.Y].Type == TileType.Empty; var anotherCool = h.M.IsInBounds(another) && h.M.MapTiles[another.X, another.Y].Type == TileType.Empty; if (oneCool == anotherCool) { pyro.Direction = new Point(-pyro.Direction.X, -pyro.Direction.Y); h.M.UnitPositions[pyro] = curretPoint + pyro.Direction; return; } if (oneCool) { var newDirection = new Point(pyro.Direction.X, -pyro.Direction.Y); var newPosition = curretPoint + newDirection; if (h.M.IsInBounds(newPosition) && h.M.MapTiles[newPosition.X, newPosition.Y].Type == TileType.Empty) { pyro.Direction = newDirection; h.M.UnitPositions[pyro] = curretPoint + pyro.Direction; return; } } if (anotherCool) { var newDirection = new Point(-pyro.Direction.X, pyro.Direction.Y); var newPosition = curretPoint + newDirection; if (h.M.IsInBounds(newPosition) && h.M.MapTiles[newPosition.X, newPosition.Y].Type == TileType.Empty) { pyro.Direction = new Point(-pyro.Direction.X, pyro.Direction.Y); h.M.UnitPositions[pyro] = curretPoint + pyro.Direction; return; } } pyro.Direction = new Point(-pyro.Direction.X, -pyro.Direction.Y); h.M.UnitPositions[pyro] = curretPoint + pyro.Direction; }; Blasts.Add(pyro); h.M.UnitPositions[pyro] = point; return(true); } }; Pyroblast.SkillTypes.Add(SkillType.Special); Skills.Add(Pyroblast); }
public Fe11() { Name = "Fe11"; Image = Graphics.resources.Res.Fe11; SetMaxHp(900); SetAttackDamage(30); SetResist(5); SetMovementSpeed(11); SetAttackRange(4); SetAttackSpeed(2); SetMaxEnergy(120); SetEnergyRegen(6); Stacks = 0; WallStacks = 0; Rage = new Perk { Name = "Rage", Explanation = (h) => "AD increased by " + RageADBuff * Stacks + " and armor by " + RageArmorBuff * Stacks + ".", Number = (h) => (h as Fe11).Stacks, GetArmor = (g) => () => g() + Stacks * RageArmorBuff, SetArmor = (s) => (v) => s(v - Stacks * RageArmorBuff), GetAttackDamage = (g) => () => g() + Stacks * RageADBuff, SetAttackDamage = (s) => (v) => s(v - Stacks * RageADBuff), SkillFix = (sf) => { if (sf.SkillTypes.Contains(SkillType.Attack)) { var newSkill = new Skill() { SkillTypes = sf.SkillTypes, Job = (h) => { var prev = sf.Job(h); if (prev) { (h as Fe11).Stacks++; } return(prev); } }; return(newSkill); } return(sf); }, //Stuff from Wall skill EndTurn = (i) => (d) => { var h = (d.HeroValue as Fe11); var a = i(d); if (h.WallOn) { var wallCost = (WallBaseManaPerTurnCost * Math.Pow(WallTurnManaMultiplier, h.WallStacks)); if (h.GetEnergy() < wallCost) { WallControl.Disactivate(h); h.M.Effects.Remove(WallControl); h.WallStacks--; } else { h.AddEnergy(-wallCost); h.WallStacks++; } } else { if (h.WallStacks > 0) { h.WallStacks--; } } return(a); }, }; Perks.Add(Rage); Skills.Remove(Attack); BuffedAttack = new Skill { Name = Attack.Name, Explanation = () => Attack.Explanation() + "On attack increases you AD by " + RageADBuff + " and armor by " + RageArmorBuff + ".", Job = Attack.Job }; BuffedAttack.SkillTypes.Add(SkillType.Attack); Skills.Add(BuffedAttack); WallControl = new Effect(this, int.MaxValue) { Activate = (h) => { (h as Fe11).BuildWall(h); }, Disactivate = (h) => { (h as Fe11).DestroyWall(h.M); }, }; Wall = new Skill { Name = "YouShallNotPass", Explanation = () => WallOn ? "Destroyes the wall builded by this skill. (current cost " + WallBaseManaPerTurnCost * Math.Pow(WallTurnManaMultiplier, WallStacks) + ")" : "Builds a wall in " + WallMinDist + "-" + WallMaxDist + " range around you. On next use destroyes it. At the end of turn eats " + WallBaseManaPerTurnCost * Math.Pow(WallTurnManaMultiplier, WallStacks) + " energy and increase its next cost by " + WallTurnManaMultiplier * 100 + "% (when disactivated - decrease). energy at the end of turn (if not enough - turnes off).", Job = (h) => { if (WallOn) { WallControl.Disactivate(h); h.M.Effects.Remove(WallControl); } else { h.M.Effects.Add(WallControl); WallControl.Activate(h); } return(WallOn); }, }; Wall.SkillTypes.Add(SkillType.Special); Skills.Add(Wall); }
public Micro() { Name = "Micro"; Image = Graphics.resources.Res.Micro; SetAttackDamage(60); SetMaxHp(1100); SetMaxEnergy(350); SetEnergyRegen(10); SetMovementSpeed(10); SetRegen(15); Defence = new Perk { Name = "Defence", Number = (h) => (h as Micro).GetEnemiesInRange(h, DefenceRadius).Count, Explanation = (h) => "Gets " + (DefenceADScale * 100) + "% AD (" + DefenceADScale * h.GetAttackDamage() + ") armor and resist from every enemy in " + DefenceRadius + "units (" + (h as Micro).GetEnemiesInRange(h, DefenceRadius).Count + " enemies), total " + (h.GetAttackDamage() * DefenceADScale * GetEnemiesInRange(this, DefenceRadius).Count), GetArmor = (g) => () => g() + GetAttackDamage() * DefenceADScale * GetEnemiesInRange(this, DefenceRadius).Count, SetArmor = (s) => (v) => s(v - GetAttackDamage() * DefenceADScale * GetEnemiesInRange(this, DefenceRadius).Count), GetResist = (g) => () => g() + GetAttackDamage() * DefenceADScale * GetEnemiesInRange(this, DefenceRadius).Count, SetResist = (s) => (v) => s(v - GetAttackDamage() * DefenceADScale * GetEnemiesInRange(this, DefenceRadius).Count), }; Perks.Add(Defence); Drop = new Skill { Name = "Drop", Explanation = () => "Get any hero in " + DropCatchRadius + " units and throw in any free place in " + DropRaduis + " units from you." + " CD " + DropCD + ". Cost " + DropCost + ".", CoolDown = DropCD, EnergyCost = DropCost, Job = (h) => { var targets = GetHeroesInRange(h, DropCatchRadius).Where(t => t != h).ToList(); if (targets.Count == 0) { return(false); } var target = ChooseTarget(targets, h.P); if (target == null) { return(false); } h.Targets.Add(target); var points = h.GetPosition().GetPointsInDistance(0, DropRaduis).Keys .Where(p => h.M.CellIsFree(p)).ToList(); if (points.Count == 0) { return(false); } var point = ChoosePoint(points, h.P); if (point == null) { return(false); } h.M.UnitPositions[Targets[0]] = point; return(true); } }; Drop.SkillTypes.Add(SkillType.Special); Skills.Add(Drop); RestoreRegenBuff = new Perk { Name = "Restore", Number = (h) => Math.Floor(RestoreRegen * h.GetMaxHp()), GetRegen = (g) => () => g() + RestoreRegen * GetMaxHp(), SetRegen = (s) => (v) => s(v - RestoreRegen * GetMaxHp()), }; Restore = new Skill { Name = "Restore", Explanation = () => "Heal you for " + RestoreHeal + "% MaxHp (" + RestoreHeal * GetMaxHp() + ") and give " + RestoreRegen + "% MaxHp (" + RestoreRegen * GetMaxHp() + ") Regen for " + RestoreRegenDuration + " turns. CD" + RestoreCooldown + ". Cost " + RestoreCost + ".", CoolDown = RestoreCooldown, EnergyCost = RestoreCost, Job = (h) => { var effect = new Effect(h, RestoreRegenDuration) { Activate = (eh) => { eh.Perks.Add(RestoreRegenBuff); }, Disactivate = (eh) => { eh.Perks.Remove(RestoreRegenBuff); } }; effect.Activate(h); h.M.Effects.Add(effect); h.GetHeal(RestoreHeal * h.GetMaxHp()); return(true); } }; Restore.SkillTypes.Add(SkillType.Special); Skills.Add(Restore); }
public void AddPerk(Perk perk) { perk.Owner = this; Perks.Add(perk); }