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());
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new EngineTick[]
{
actor.ApplyBuff(actor, 100, new ReflectSkillBuff()),
});
}
public IDamageSkill GetMaxRangeSkill(IFighterStats actor, IEnumerable <ISkill> skills, EngineCalculationValues calculationValues)
{
return(skills
.OfType <IDamageSkill>()
.OrderByDescending(o => o.Range)
.FirstOrDefault());
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new EngineTick[]
{
target.ApplyCharge(actor, 9),
});
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new EngineTick[]
{
target.ApplyCondition(actor, 80, new VulnerabilitySkillCondition(actor)),
});
}
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 void SetFighterPosition(IFighterStats fighter, IBattlefield battlefield)
{
fighter.Set(new Vector3()
{
X = random.Next((int)battlefield.CurrentBounds.Low.X, (int)battlefield.CurrentBounds.High.X),
Y = random.Next((int)battlefield.CurrentBounds.Low.Y, (int)battlefield.CurrentBounds.High.Y),
Z = random.Next((int)battlefield.CurrentBounds.Low.Z, (int)battlefield.CurrentBounds.High.Z),
});
}
private static bool IsOnCooldown(IFighterStats actor, IEnumerable <EngineRoundTick> roundTicks, ISkill o)
{
var isOnCooldown = roundTicks
.GetLastRounds(o.Cooldown)
.OfType <FighterSkillTick>()
.Any(t => t.Fighter.Id == actor.Id && t.Skill.Id == o.Id);
return(isOnCooldown);
}
public override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new EngineTick[]
{
target.ApplyCondition(actor, 80, new BleedSkillCondition(actor)
{
Remaining = 0
}),
});
}
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 override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new List <EngineTick>
{
target.ApplyCondition(actor, 50, new StunSkillCondition(actor)
{
Remaining = 0
}),
target.ApplyBleeding(actor, 100)
});
}
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 override IEnumerable <EngineTick> Perform(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(new EngineTick[]
{
target.ApplyCripple(actor, 80),
target.ApplyBleeding(actor, 18),
target.ApplyCondition(actor, 5, new PoisonSkillCondition(actor)
{
Remaining = 3
}),
});
}
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(),
});
}
/// <summary>
/// Converts the fighter into a struct
/// </summary>
public static IFighter AsStruct(this IFighterStats fighter)
{
var fighterStruct = new Fighter()
{
Id = fighter.Id,
Team = fighter.Team,
Health = fighter.Health,
X = fighter.X,
Y = fighter.Y,
Z = fighter.Z,
DamageTaken = fighter.DamageTaken,
};
return(fighterStruct);
}
protected IFighterAction GetSkillMove(IBattlefield battlefield, IFighterStats target, IEnumerable <EngineRoundTick> roundTicks, EngineCalculationValues calculationValues)
{
var desiredSkill = 50F.Chance() ?
SkillFinder.GetMaxDamageSkill(this, SkillFinder.ExcludeSkillsOnCooldown(this, Skills, roundTicks), calculationValues) :
SkillFinder.GetMaxRangeSkill(this, SkillFinder.ExcludeSkillsOnCooldown(this, Skills, roundTicks), calculationValues);
// reduce skill distance by 0.15F to compensate rounding differences
var distance = (desiredSkill?.Range ?? 1.5F) - 0.15F;
return(new Move()
{
Actor = this,
NextPosition = PathFinder.GetPathToEnemy(this, target, distance, battlefield),
});
}
private SharpFightingEngine.Engines.Engine GetEngine(IFighterStats fighterA, IFighterStats fighterB)
{
fighterA.DamageTaken = 0;
fighterB.DamageTaken = 0;
fighterA.States.Clear();
fighterB.States.Clear();
return(EngineFactory.GetEngine(
new IFighterStats[]
{
fighterA,
fighterB,
}, MatchOptions));
}
public static FighterMovedByAttackTick ApplyMove(this IFighterStats target, IFighterStats actor, IPosition newPosition)
{
var movedBySkill = new FighterMovedByAttackTick()
{
Current = target.AsStruct(),
Fighter = actor.AsStruct(),
Target = target.AsStruct(),
};
target.Set(newPosition);
movedBySkill.Next = target.AsStruct();
return(movedBySkill);
}
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());
}
public static FighterBuffAppliedTick ApplyBuff(this IFighterStats target, IFighterStats actor, float chance, ISkillBuff buff)
{
if (!chance.Chance())
{
return(null);
}
target.States.Add(buff);
return(new FighterBuffAppliedTick()
{
Buff = buff.AsStruct(),
Fighter = actor.AsStruct(),
Target = actor.AsStruct(),
});
}
public static FighterConditionAppliedTick ApplyCondition(this IFighterStats target, IFighterStats actor, float chance, SkillConditionBase condition)
{
if (!chance.Chance())
{
return(null);
}
target.States.Add(condition);
return(new FighterConditionAppliedTick()
{
Condition = condition.AsStruct(),
Fighter = actor.AsStruct(),
Target = target.AsStruct(),
});
}
protected IEnumerable <TestResult> CalculateBalance(IFighterStats fighterA, IFighterStats fighterB, int fightsCount)
{
var resultFighterA = new TestResult()
{
Fighter = fighterA,
TotalMatches = fightsCount,
};
var resultFighterB = new TestResult()
{
Fighter = fighterB,
TotalMatches = fightsCount,
};
for (int i = 0; i < fightsCount; i++)
{
var result = GetEngine(fighterA, fighterB).StartMatch();
var contributionA = result.Contributions.First(o => o.FighterId == fighterA.Id);
var contributionB = result.Contributions.First(o => o.FighterId == fighterB.Id);
if (!contributionA.HasWon && !contributionB.HasWon)
{
resultFighterA.Draws++;
resultFighterB.Draws++;
continue;
}
if (contributionA.HasWon)
{
resultFighterA.Wins++;
resultFighterB.Loses++;
}
if (contributionB.HasWon)
{
resultFighterA.Loses++;
resultFighterB.Wins++;
}
}
return(new TestResult[]
{
resultFighterA,
resultFighterB
});
}
private static double GetFitness(IFighterStats geneticFighter, IMatchResult result)
{
var contribution = result.Contributions.First(o => o.FighterId == geneticFighter.Id);
var fitness = 0D;
if (contribution.HasWon)
{
fitness += 200;
}
fitness += contribution.Kills.Count() * 50;
fitness += 25 * contribution.PercentageOfRoundsAlive;
fitness += 15 * contribution.MatchParticipation;
return(fitness);
}
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 override IEnumerable <EngineTick> Apply(IFighterStats target, IFighterStats source, EngineCalculationValues calculationValues)
{
var potentialHeal = Heal * (1 + (source.GetAdjustedStats().HealingPower *calculationValues.HealingPowerFactor));
var actualHeal = target.Heal((int)potentialHeal);
if (actualHeal == 0)
{
yield break;
}
target.DamageTaken -= actualHeal;
yield return(new FighterRegenerateHealthTick()
{
Fighter = target.AsStruct(),
HealthPointsRegenerated = actualHeal,
});
}
public virtual IEnumerable <EngineTick> Apply(IFighterStats target, IFighterStats source, EngineCalculationValues calculationValues)
{
if (!target.IsAlive(calculationValues))
{
return(Enumerable.Empty <EngineTick>());
}
var damage = source.GetConditionDamage(calculationValues, this);
target.DamageTaken += damage;
return(new FighterConditionDamageTick()
{
Condition = this.AsStruct(),
Damage = damage,
Fighter = target.AsStruct(),
Source = source.AsStruct(),
}.Yield());
}
public override IEnumerable <EngineTick> Attack(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
if (90F.Chance())
{
yield break;
}
var burnCondition = new BurnSkillCondition(actor)
{
Remaining = 1
};
target.States.Add(burnCondition);
yield return(new FighterConditionAppliedTick()
{
Fighter = actor.AsStruct(),
Condition = burnCondition.AsStruct(),
Target = target.AsStruct(),
});
}
public static int Heal(this IFighterStats fighter, int potentialHeal)
{
if (fighter.DamageTaken == 0)
{
return(0);
}
var reducedHealing = fighter.States
.OfType <ISkillCondition>()
.Where(o => o.HealingReduced != null)
.Max(o => o.HealingReduced);
var actualHeal = potentialHeal;
if (reducedHealing != null)
{
actualHeal -= (int)(potentialHeal * reducedHealing);
}
return(Math.Min(fighter.DamageTaken, actualHeal));
}
public virtual IEnumerable <EngineTick> Effect(IFighterStats fighter, EngineCalculationValues calculationValues)
{
return(Enumerable.Empty <EngineTick>());
}
public virtual IEnumerable <EngineTick> Attack(IFighterStats actor, IFighterStats target, EngineCalculationValues calculationValues)
{
return(Enumerable.Empty <EngineTick>());
}
