public void ApplyTo(EngineCalculationValues calculationValues)
{
for (int i = 0; i < Properties.Count(); i++)
{
var value = GetGene(i).Value;
var property = Properties.ElementAt(i);
property.SetValue(calculationValues, value);
}
}
public override IEnumerable <EngineTick> Effect(IFighterStats fighter, EngineCalculationValues calculationValues)
{
var powerBuff = new PowerSkillBuff(fighter);
fighter.States.Add(powerBuff);
yield return(new FighterBuffAppliedTick()
{
Buff = powerBuff.AsStruct(),
Fighter = fighter.AsStruct(),
Target = fighter.AsStruct(),
});
}
public IEnumerable <EnemyIntel> GetIntels(
FighterBase fighter,
IEnumerable <EngineRoundTick> roundTicks,
EngineCalculationValues calculationValues,
IEnumerable <IFighterStats> enemies)
{
foreach (var enemy in enemies)
{
var intel = new EnemyIntel()
{
Id = enemy.Id,
HealthPercent = enemy.HealthRemaining(calculationValues) / enemy.Health(calculationValues),
};
intel.DamageDealt = DamageDone(roundTicks, fighter.Id, enemy.Id);
intel.DamageTaken = DamageDone(roundTicks, enemy.Id, fighter.Id);
intel.LastTarget = roundTicks
.GetLastRounds(2)
.OfType <FighterAttackTick>()
.Where(o => o.Fighter.Id == fighter.Id)
.OrderByDescending(o => o.DateTime)
.FirstOrDefault()
?.Target.Id;
intel.IsInRange = fighter.SkillFinder
.GetMaxRangeSkill(fighter, fighter.SkillFinder.ExcludeSkillsOnCooldown(fighter, fighter.Skills, roundTicks), calculationValues)?.Range >= fighter.GetDistance(enemy);
intel.LastRoundHealSkillUsed = roundTicks
.Where(o => o.Ticks.OfType <FighterHealTick>().Any(t => t.Target.Id == enemy.Id))
.GetLastRound()
?.Round;
intel.IsStunned = enemy.States.OfType <ISkillCondition>().Any(o => o.PreventsPerformingActions);
intel.IsHealingReduced = enemy.States.OfType <ISkillCondition>().Any(o => o.HealingReduced != null);
intel.OtherFightersNearby = enemies
.Where(o => o.Id != enemy.Id)
.Where(o => o.GetDistanceAbs(enemy) <= 10)
.Count();
intel.LastAttackers = roundTicks
.GetLastRounds(2)
.OfType <FighterAttackTick>()
.Where(o => o.Target.Id == enemy.Id)
.Select(o => o.Fighter.Id)
.Distinct();
yield return(intel);
}
}
public void ShouldCalculateBestEngineCalculationValues()
{
var population = new Population(50, 100, new EngineCalculationChromosome());
var fitness = new EngineCalculationFitness()
{
MatchCount = 25,
SinglePowerLevelMin = 25,
SinglePowerLevelMax = 25,
};
var ga = RunGeneticAlgorithm(population, fitness, 150);
var values = new EngineCalculationValues();
(ga.BestChromosome as EngineCalculationChromosome).ApplyTo(values);
fitness.Evaluate(ga.BestChromosome);
}
public static IEnumerable <EngineTick> Handle(
this IHeal heal,
Dictionary <Guid, IFighterStats> fighters,
IEnumerable <EngineRoundTick> roundTicks,
EngineCalculationValues calculationValues)
{
var ticks = new List <EngineTick>();
var healTick = heal.GetFighterHealTick();
ticks.Add(healTick);
if (heal.IsOnCooldown(roundTicks))
{
healTick.OnCooldown = true;
return(ticks);
}
if (!heal.IsInRange())
{
healTick.OutOfRange = true;
return(ticks);
}
healTick.PotentialHealing = heal.GetHealValue(calculationValues);
var target = fighters[heal.Target.Id];
healTick.AppliedHealing = target.Heal(healTick.PotentialHealing);
target.DamageTaken -= healTick.AppliedHealing;
var additionalTicks = heal.Skill.Perform(heal.Actor, heal.Target, calculationValues);
foreach (var tick in additionalTicks.OfType <FighterTick>())
{
tick.Handle(fighters);
}
ticks.AddRange(additionalTicks);
return(ticks);
}
public virtual IFighterAction GetFighterAction(
IEnumerable <IFighterStats> visibleFighters,
IBattlefield battlefield,
IEnumerable <EngineRoundTick> roundTicks,
EngineCalculationValues calculationValues)
{
var roam = new Move()
{
Actor = this,
NextPosition = PathFinder.GetRoamingPath(this, battlefield),
};
// Better not attack team members
var visibleEnemies = visibleFighters
.Where(o => o.Team == null || o.Team != Team);
if (!visibleEnemies.Any())
{
// if this fighter can't see any enemy he roams
return(roam);
}
var target = TargetFinder.GetTarget(visibleEnemies, this);
var skill = SkillFinder.GetSkill(this, target, SkillFinder.ExcludeSkillsOnCooldown(this, Skills, roundTicks), calculationValues);
if (skill == null)
{
return(GetSkillMove(battlefield, target, roundTicks, calculationValues));
}
return(new Attack()
{
Actor = this,
Skill = skill,
Target = target,
});
}
public virtual IEnumerable <EngineTick> Effect(IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(Enumerable.Empty <EngineTick>());
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
if (25F.Chance())
{
return(Enumerable.Empty <EngineTick>());
}
var condition = new CrippleSkillCondition(actor);
target.States.Add(condition);
return(new FighterConditionAppliedTick()
{
Condition = condition,
Fighter = actor.AsStruct(),
Target = target.AsStruct(),
}.Yield());
}
public IEnumerable <EngineTick> Apply(IFighterStats target, IFighterStats source, EngineCalculationValues calculationValues)
{
throw new NotImplementedException();
}
public virtual IEnumerable <EngineTick> Apply(IFighterStats target, IFighterStats source, EngineCalculationValues calculationValues)
{
return(Enumerable.Empty <EngineTick>());
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new EngineTick[]
{
target.ApplyCharge(actor, Range),
actor.ApplyBuff(actor, 75, new ReflectSkillBuff(actor)
{
Remaining = 1
}),
});
}
public IDamageSkill GetMaxRangeSkill(IFighterStats actor, IEnumerable <ISkill> skills, EngineCalculationValues calculationValues)
{
return(skills
.OfType <IDamageSkill>()
.OrderByDescending(o => o.Range)
.FirstOrDefault());
}
/// <summary>
/// Returns all other fighters within sight.
/// </summary>
public static IEnumerable <IFighterStats> GetVisibleFightersFor(this IEnumerable <IFighterStats> fighters, IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(fighters
.Where(o => o.HealthRemaining(calculationValues) > 0)
.Where(o => o.Id != fighter.Id && o.GetDistance(fighter) <= fighter.VisualRange(calculationValues)));
}
public static float DodgeChance(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(fighter.GetAdjustedStats().Agility *calculationValues.AgilityFactor);
}
public static float CriticalHitChance(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(fighter.GetAdjustedStats().Precision *calculationValues.PrecisionFactor);
}
/// <summary>
/// The fighter's range of sight
/// </summary>
public static float VisualRange(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(fighter.GetAdjustedStats().Vision *calculationValues.VisionFactor);
}
public IDamageSkill GetSkill(IFighterStats actor, IFighterStats target, IEnumerable <ISkill> skills, EngineCalculationValues calculationValues)
{
return(skills
.OfType <IDamageSkill>()
.Where(o => o.Range >= actor.GetDistanceAbs(target))
.OrderByDescending(o => o.Damage)
.FirstOrDefault());
}
public static float HitChance(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(100 + (fighter.GetAdjustedStats().Accuracy *calculationValues.AccuracyFactor));
}
public IHealSkill GetHealSkill(IFighterStats actor, IEnumerable <ISkill> skills, IEnumerable <EngineRoundTick> roundTicks, EngineCalculationValues calculationValues)
{
return(ExcludeSkillsOnCooldown(actor, skills, roundTicks)
.OfType <IHealSkill>()
.OrderByDescending(o => o.Heal)
.FirstOrDefault());
}
/// <summary>
/// Indicates if the fighter is alive.
/// </summary>
public static bool IsAlive(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(fighter.HealthRemaining(calculationValues) > 0);
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
var movedBySkill = new FighterMovedByAttackTick()
{
Current = target.AsStruct(),
Fighter = actor.AsStruct(),
Target = target.AsStruct(),
};
target.Set(actor.CalculatePullPosition(target, 14));
movedBySkill.Next = target.AsStruct();
return(movedBySkill.Yield());
}
/// <summary>
/// The Fighter's health points
/// </summary>
public static int Health(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return((int)(fighter.GetAdjustedStats().Vitality *calculationValues.VitalityFactor));
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new EngineTick[]
{
target.ApplyCondition(actor, 100, new VulnerabilitySkillCondition(actor)
{
Remaining = 2
}),
target.ApplyCondition(actor, 80, new VulnerabilitySkillCondition(actor)
{
Remaining = 1
}),
target.ApplyCondition(actor, 90, new BleedSkillCondition(actor)
{
Remaining = 1
}),
});
}
public static float PotentialDefense(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(fighter.GetAdjustedStats().Armor *calculationValues.ArmorFactor);
}
public override IEnumerable <EngineTick> Apply(IFighterStats target, IFighterStats source, EngineCalculationValues calculationValues)
{
return(base.Apply(target, source, calculationValues));
}
public static float PotentialHealingPower(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(fighter.GetAdjustedStats().HealingPower *calculationValues.HealingPowerFactor);
}
public virtual IEnumerable <EngineTick> Attack(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(Enumerable.Empty <EngineTick>());
}
public static float PotentialFerocity(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(1 + (fighter.GetAdjustedStats().Ferocity *calculationValues.FerocityFactor));
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new EngineTick[]
{
target.ApplyKnockback(actor, 4),
actor.ApplyBuff(actor, 100, new ReflectSkillBuff(actor)
{
Remaining = 2
}),
});
}
public static int HealthRemaining(this IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(fighter.Health(calculationValues) - fighter.DamageTaken);
}
