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);
}
