protected override double ScoreSubBuff_IV(AIProcessor AI, Spells.EffectInfos Effect, List <Fighter> Targets, bool Reverse = false, bool notUseJet = false)
{
var Score = 0;
var BaseScore = 18;
if (!notUseJet)
{
BaseScore *= Effect.RandomJet;
}
foreach (var Target in Targets)
{
int currScore = BaseScore;
var PercentLife = Math.Ceiling((double)(Target.Life / Target.MaxLife) * 100);
if (PercentLife < 20)
{
currScore *= 2;
}
else if (PercentLife < 30)
{
currScore *= 3;
}
else if (PercentLife < 50)
{
currScore *= 5;
}
else if (PercentLife < 75)
{
currScore *= 8;
}
if (Effect.Duration > 0)
{
currScore *= Effect.Duration;
}
if (Reverse)
{
if (Target.Team != AI.myFighter.Team)
{
Score -= currScore * 2;
}
else
{
Score += currScore;
}
}
else
{
if (Target.Team == AI.myFighter.Team)
{
Score -= currScore * 2;
}
else
{
Score += currScore;
}
}
}
return(Score);
}
protected override double ScoreBuff_I(AIProcessor AI, Spells.EffectInfos Effect, List <Fighter> Targets, bool Reverse = false, bool notUseJet = false)
{
var Score = 0;
var BaseScore = 10;
if (!notUseJet)
{
BaseScore *= Effect.RandomJet;
}
foreach (var Target in Targets)
{
int currScore = BaseScore;
if (Target.States.HasState(FighterStateEnum.STATE_INVISIBLE) && Effect.EffectType == EffectEnum.Invisible)
{
Score -= currScore;
continue;
}
var PercentLife = Math.Ceiling((double)(Target.Life / Target.MaxLife) * 100);
if (PercentLife < 20)
{
currScore *= 8;
}
else if (PercentLife < 30)
{
currScore *= 5;
}
else if (PercentLife < 50)
{
currScore *= 3;
}
else if (PercentLife < 75)
{
currScore *= 2;
}
if (Effect.Duration > 0)
{
currScore *= Effect.Duration;
}
if (Reverse)
{
if (Target.Team == AI.myFighter.Team)
{
Score -= currScore * 2;
}
else
{
Score += currScore;
}
}
else
{
if (Target.Team != AI.myFighter.Team)
{
Score -= currScore * 2;
}
else
{
Score += currScore;
}
}
}
return(Score);
}
protected override double ScoreInvocation(AIProcessor AI, Spells.EffectInfos Effect, List <Fighter> Targets, bool Reverse = false, bool InvokPreview = false)
{
if (Reverse)//On evite la boucle infinie
{
return(0);
}
var BaseScore = 11;
var Score = BaseScore;
var InvocationId = Effect.Value1;
var InvocationLevel = Effect.Value2;
if (InvokPreview)
{
return(BaseScore * InvocationLevel);
}
if (!AI.myNeuron.myScoreInvocations.ContainsKey(InvocationId))
{
var Monster = MonsterTable.GetMonster(InvocationId);
// Template de monstre existante
if (Monster != null)
{
Monster.Initialize();
var MonsterLevel = Monster.GetLevelOrNear(InvocationLevel);
// Level de monstre existant
if (MonsterLevel != null)
{
List <Fighter> possibleTargets = AI.myFight.GetAllyTeam(AI.myFighter.Team).GetFighters().FindAll(x => !x.Dead && !x.Left);
foreach (var Spell in MonsterLevel.Spells.GetSpells())
{
foreach (var spellEffect in Spell.Effects)
{
int currScore = (int)this.GetEffectScore(AI, -1, -1, spellEffect, possibleTargets, InvokPreview: true);
if (currScore > 0)
{
Score += currScore;
}
}
}
possibleTargets = AI.myFight.GetEnnemyTeam(AI.myFighter.Team).GetFighters().FindAll(x => !x.Dead && !x.Left);
foreach (var Spell in MonsterLevel.Spells.GetSpells())
{
foreach (var spellEffect in Spell.Effects)
{
int currScore = (int)this.GetEffectScore(AI, -1, -1, spellEffect, possibleTargets, InvokPreview: true);
if (currScore > 0)
{
Score += currScore;
}
}
}
foreach (var State in MonsterLevel.Stats.GetEffects().Values)
{
var total = State.Total;
if (total > 0)
{
Score += total;
}
}
Score *= MonsterLevel.Level;
AI.myNeuron.myScoreInvocations.Add(InvocationId, Score);
return(Score);
}
}
}
else
{
return(AI.myNeuron.myScoreInvocations[InvocationId]);
}
return(0);
}
private int ScorePush(AIProcessor AI, Fighter Target, int Direction, int Length, bool Fear)
{
bool isAlly = Target.Team == AI.myFighter.Team;
List <Fighter> TargetList = new List <Fighter>()
{
Target
};
var LastCell = Target.Cell;
int Score = 0;
foreach (var Layer in Target.Cell.GetObjects <FightGroundLayer>())//On cherche à savoir si décaller de cette cellule est utile
{
int LayerScore = 0;
foreach (var Effect in Layer.CastSpell.Effects)
{
LayerScore = (int)Math.Floor(AIAction.AIActions[AIActionEnum.SELF_ACTING].GetEffectScore(AI, -1, -1, Effect, TargetList, true, true));
}
if (Layer is FightBlypheLayer)
{
LayerScore *= 2;
}
Score += LayerScore;
}
int PathScore = 4;
int FinalLength = 0;
for (int i = 0; i < Length; i++)
{
var NextCell = Target.Fight.GetCell(Pathfinder.NextCell(Target.Fight.Map, LastCell.Id, Direction));
if (NextCell != null)
{
LastCell = NextCell;
}
if (NextCell != null && NextCell.IsWalkable())
{
if (NextCell.HasGameObject(FightObjectType.OBJECT_FIGHTER) || NextCell.HasGameObject(FightObjectType.OBJECT_STATIC) || Target.States.HasState(FighterStateEnum.STATE_ENRACINER))
{
if (!Fear)
{
PathScore *= EffectPush.RANDOM_PUSHDAMAGE.Next(4, 7);
if (isAlly)
{
PathScore *= -1;
}
}
break;
}
else if (NextCell.HasGameObject(FightObjectType.OBJECT_TRAP))
{//On Stop seulement : ce genre de calcul se fera a la fin.
break;
}
}
else
{
if (!Fear)
{
PathScore *= EffectPush.RANDOM_PUSHDAMAGE.Next(4, 7);
if (isAlly)
{
PathScore *= -1;
}
}
break;
}
FinalLength += 1;
}
Score += FinalLength * PathScore;
if (LastCell != Target.Cell)
{
foreach (var Layer in LastCell.GetObjects <FightGroundLayer>())
{
int LayerScore = 0;
foreach (var Effect in Layer.CastSpell.Effects)
{
LayerScore += (int)Math.Floor(AIAction.AIActions[AIActionEnum.SELF_ACTING].GetEffectScore(AI, -1, -1, Effect, TargetList, false, true));
}
if (Layer is FightTrapLayer) // TODO : Calculate if traplayer others targets
{
LayerScore *= 4; //Immediat
}
else if (Layer is FightBlypheLayer)
{
LayerScore *= 2;//Debut de tour
}
Score += LayerScore;
}
}
return(Score);
}
protected abstract double ScoreUseLayer(AIProcessor AI, int CastCell, EffectInfos Effect, List <Fighter> Targets, bool Reverse = false, bool notUseJet = false);
public double GetEffectScore(AIProcessor AI, int CasterCell, int CastCell, EffectInfos Effect, List <Fighter> Targets, bool Reverse = false, bool InvokPreview = false)
{
switch (Effect.EffectType)
{
/* HEAL */
case EffectEnum.RenderedPDV:
case EffectEnum.Heal:
case EffectEnum.DamageDropLife:
return(ScoreHeal(AI, Effect, Targets, Reverse));
/* BUFFS LEVEL 1*/
case EffectEnum.ChanceEcaflip:
return(Targets.Contains(AI.myFighter) ? (ScoreBuff_I(AI, Effect, Targets, Reverse)) : (-ScoreBuff_I(AI, Effect, Targets, Reverse)));
case EffectEnum.AddDamagePhysic:
case EffectEnum.AddDamageMagic:
case EffectEnum.AddDamagePercent:
case EffectEnum.AddForce:
case EffectEnum.AddIntelligence:
case EffectEnum.AddChance:
case EffectEnum.AddSagesse:
case EffectEnum.AddAgilite:
case EffectEnum.AddEsquivePA:
case EffectEnum.AddEsquivePM:
return(ScoreBuff_I(AI, Effect, Targets, Reverse));
/* BUFFS LEVEL 2*/
case EffectEnum.Invisible:
return(ScoreBuff_II(AI, Effect, Targets, Reverse, true));
case EffectEnum.BonusPM:
case EffectEnum.AddPA:
case EffectEnum.AddPABis:
case EffectEnum.AddPO:
case EffectEnum.AddPM:
case EffectEnum.AddVitalite:
case EffectEnum.DoubleDamageOrRendPDV:
case EffectEnum.AddVie:
case EffectEnum.AddDamage:
case EffectEnum.AddCC:
case EffectEnum.AddSoins:
case EffectEnum.MultiplyDamage:
case EffectEnum.AddReduceDamageMagic:
case EffectEnum.AddReduceDamagePhysic:
return(ScoreBuff_II(AI, Effect, Targets, Reverse));
/* BUFFS LEVEL 3*/
case EffectEnum.IncreaseSpellDamage:
case EffectEnum.AddArmorBis:
case EffectEnum.ReflectSpell:
case EffectEnum.AddArmorNeutre:
case EffectEnum.AddArmorTerre:
case EffectEnum.AddArmorFeu:
case EffectEnum.AddArmorEau:
case EffectEnum.AddArmorAir:
case EffectEnum.AddReduceDamagePourcentAir:
case EffectEnum.AddReduceDamagePourcentEau:
case EffectEnum.AddReduceDamagePourcentFeu:
case EffectEnum.AddReduceDamagePourcentTerre:
case EffectEnum.AddReduceDamagePourcentNeutre:
case EffectEnum.AddReduceDamageAir:
case EffectEnum.AddReduceDamageEau:
case EffectEnum.AddReduceDamageFeu:
case EffectEnum.AddReduceDamageTerre:
case EffectEnum.AddReduceDamageNeutre:
case EffectEnum.AddArmor:
case EffectEnum.AddRenvoiDamage:
case EffectEnum.Sacrifice:
return(ScoreBuff_III(AI, Effect, Targets, Reverse));
/* DAMAGE LEVEL 3*/
case EffectEnum.VolEau:
case EffectEnum.VolTerre:
case EffectEnum.VolAir:
case EffectEnum.VolFeu:
case EffectEnum.VolNeutre:
case EffectEnum.Punition:
return(ScoreDamage_III(AI, Effect, Targets, Reverse));
/* DAMAGE LEVEL 2*/
case EffectEnum.VolVie:
case EffectEnum.DamageLifeAir:
case EffectEnum.DamageLifeEau:
case EffectEnum.DamageLifeFeu:
case EffectEnum.DamageLifeNeutre:
case EffectEnum.DamageLifeTerre:
return(ScoreDamage_II(AI, Effect, Targets, Reverse));
/* DAMAGE LEVEL 1*/
case EffectEnum.DamageEau:
case EffectEnum.DamageTerre:
case EffectEnum.DamageAir:
case EffectEnum.DamageFeu:
case EffectEnum.DamageNeutre:
return(ScoreDamage_I(AI, Effect, Targets, Reverse));
/* DAMAGE LEVEL 0*/
case EffectEnum.DamageLanceur:
return(ScoreDamage_0(AI, Effect, Targets, Reverse));
/* SUBBUFF LEVEL 4*/
case EffectEnum.TurnPass:
case EffectEnum.DieFighter:
return(ScoreSubBuff_IV(AI, Effect, Targets, Reverse, true));
/* SUBBUFF LEVEL 3*/
case EffectEnum.VolPA:
case EffectEnum.VolPO:
case EffectEnum.VolPM:
case EffectEnum.SubPA:
case EffectEnum.SubPM:
case EffectEnum.SubPO:
case EffectEnum.SubDamage:
case EffectEnum.SubVitalite:
case EffectEnum.SubReduceDamagePourcentNeutre:
case EffectEnum.SubReduceDamagePourcentFeu:
case EffectEnum.SubReduceDamagePourcentEau:
case EffectEnum.SubReduceDamagePourcentAir:
case EffectEnum.SubReduceDamagePourcentTerre:
return(ScoreSubBuff_III(AI, Effect, Targets, Reverse));
/* SUBBUFF LEVEL 2*/
case EffectEnum.DamagePerPA:
return(ScoreDamagesPerPA(AI, Effect, Targets, Reverse));
case EffectEnum.SubSoins:
case EffectEnum.SubSagesse:
case EffectEnum.SubForce:
case EffectEnum.SubAgilite:
case EffectEnum.SubChance:
case EffectEnum.SubIntelligence:
case EffectEnum.SubDamagePercent:
case EffectEnum.SubDamagePhysic:
case EffectEnum.SubDamageMagic:
case EffectEnum.SubCC:
case EffectEnum.AddEchecCritic:
return(ScoreSubBuff_II(AI, Effect, Targets, Reverse));
/* SUBBUFF LEVEL 1*/
case EffectEnum.SubReduceDamageAir:
case EffectEnum.SubReduceDamageEau:
case EffectEnum.SubReduceDamageFeu:
case EffectEnum.SubReduceDamageNeutre:
case EffectEnum.SubReduceDamageTerre:
case EffectEnum.SubPAEsquivable:
case EffectEnum.SubPMEsquivable:
return(ScoreSubBuff_I(AI, Effect, Targets, Reverse));
/* ADDSTATE */
case EffectEnum.AddState:
{
if (isGoodState(Effect))
{
return(ScoreAddStateGood(AI, Effect, Targets, Reverse));
}
else
{
return(ScoreAddStateBad(AI, Effect, Targets, Reverse));
}
}
/* REMSTATE */
case EffectEnum.LostState:
{
if (isGoodState(Effect))
{
return(ScoreRemStateGood(AI, Effect, Targets, Reverse));
}
else
{
return(ScoreRemStateBad(AI, Effect, Targets, Reverse));
}
}
/* REPULSE */
case EffectEnum.PushBack:
return(ScoreRepulse(AI, CastCell, Effect, Targets, InvokPreview, false));
case EffectEnum.PushFear:
return(ScoreRepulse(AI, CastCell, Effect, Targets, InvokPreview, true));
/* ATTRACT */
case EffectEnum.PushFront:
return(ScoreAttract(AI, CastCell, Effect, Targets, InvokPreview));
/* DEPLACE */
case EffectEnum.Porter:
return(ScoreDeplace(AI, CastCell, Effect, Targets, InvokPreview, false));
case EffectEnum.Lancer:
return(ScoreDeplace(AI, CastCell, Effect, Targets, InvokPreview, true));
/* EXCHANGE PLACE */
case EffectEnum.Transpose:
return(ScoreExchangePlace(AI, CasterCell, CastCell, Effect, Targets, InvokPreview));
/* DEBUFF */
case EffectEnum.DeleteAllBonus:
return(ScoreDebuff(AI, Effect, Targets, Reverse));
/* INVOCATION */
case EffectEnum.InvocationStatic:
return(ScoreInvocationStatic(AI, Effect, Targets, Reverse, InvokPreview));
case EffectEnum.Invocation:
return(ScoreInvocation(AI, Effect, Targets, Reverse, InvokPreview));
case EffectEnum.DieFighterReplaceInvocation:
return(ScoreSubBuff_IV(AI, Effect, Targets, Reverse, true) + ScoreInvocation(AI, Effect, Targets, Reverse, InvokPreview));
case EffectEnum.UseGlyph:
case EffectEnum.UseBlyph:
case EffectEnum.UseTrap:
return(ScoreUseLayer(AI, CastCell, Effect, Targets, Reverse));
/* NADA */
case EffectEnum.DoNothing:
return(0);
default:
{
Logger.Info("Effect[" + Effect.EffectType + "] non defini pour l'IA");
return(ScoreDamage_I(AI, Effect, Targets, Reverse));
}
}
}
protected abstract double ScoreDeplace(AIProcessor AI, int CastCell, EffectInfos Effect, List <Fighter> Targets, bool InvokPreview, bool isThrow);
protected abstract double ScoreExchangePlace(AIProcessor AI, int CasterCell, int CastCell, EffectInfos Effect, List <Fighter> Targets, bool InvokPreview);
protected abstract double ScoreRepulse(AIProcessor AI, int CastCell, EffectInfos Effect, List <Fighter> Targets, bool InvokPreview, bool isFear);
protected abstract double ScoreInvocationStatic(AIProcessor AI, EffectInfos Effect, List <Fighter> Targets, bool Reverse = false, bool InvokPreview = false);
protected abstract double ScoreDebuff(AIProcessor AI, EffectInfos Effect, List <Fighter> Targets, bool Reverse = false);
protected abstract double ScoreSubBuff_IV(AIProcessor AI, EffectInfos Effect, List <Fighter> Targets, bool Reverse = false, bool notUseJet = false);
public void Play(AIProcessor IA)
{
this.Invoke("Play", IA);
}