private void Awake()
{
avatar = GetComponent <Avatar>();
waitForSeconds = new WaitForSeconds(1);
panelCombats = GameObject.Find("P_Combats");
combats = panelCombats.GetComponent <Combats>();
}
bool TryPreDodgeProjectile()
{
const int preTicks = 18;
var opp = OpponentWizards
.OrderBy(x => x.GetDistanceTo2(ASelf))
.FirstOrDefault(x =>
Math.Min(x.RemainingActionCooldownTicks, x.RemainingMagicMissileCooldownTicks) <= preTicks &&
x.GetDistanceTo(ASelf) <= x.CastRange + ASelf.Radius + Game.MagicMissileRadius + 7 &&
Math.Abs(x.GetAngleTo(ASelf)) <= Game.StaffSector /* /2*/
);
if (opp == null)
{
return(false);
}
if (Math.Abs(ASelf.GetAngleTo(opp)) < Math.PI / 2 && ASelf.GetDistanceTo(opp) > 500)
{
var obstacles = Combats.Where(x => x.Id != Self.Id && x.GetDistanceTo(ASelf) < 300).ToArray();
var selSign = 0;
double selPriority = int.MaxValue;
var requiredAngle = ASelf.GetDistanceTo(opp) <= opp.CastRange + ASelf.Radius
? Math.PI - 2 * ASelf.MaxTurnAngle - 0.001
: Math.PI / 2;
for (var sign = -1; sign <= 1; sign += 2)
{
var my = new AWizard(ASelf);
var priority = 0.0;
while (Math.Abs(my.GetAngleTo(opp)) < requiredAngle)
{
my.Angle += sign * my.MaxTurnAngle;
priority += 0.1;
}
for (var i = 0; i < 15; i++)
{
if (!my.MoveTo(my + Point.ByAngle(my.Angle), null, w => !CheckIntersectionsAndTress(w, obstacles)))
{
break;
}
priority--;
}
if (priority < selPriority)
{
selPriority = priority;
selSign = sign;
}
}
FinalMove.Turn = selSign * 10;
return(true);
}
return(false);
}
public virtual float ChanceToLand()
{
if (AbilityType == AbilityType.Melee)
{
return(1 - (Combats.GetMeleeMissChance() + Combats.GetToBeDodgedChance() + Combats.GetToBeParriedChance() * _calcOpts.InFront));
}
else if (AbilityType == AbilityType.Range)
{
return(1 - Combats.GetRangedMissChance());
}
else // Spell
{
return(1 - Combats.GetSpellMissChance());
}
}
public static WizardPath[] DijkstraFindPath(AWizard start, DijkstraPointStopFunc stopFunc, DijkstraPointCostFunc costFunc)
{
start = new AWizard(start);
_startState = start;
_obstacles = Combats
.Where(x => !x.IsOpponent && x.Id != start.Id && x.GetDistanceTo2(start) < Geom.Sqr(start.VisionRange)) // (нейтральные включительно)
.ToArray();
var startCell = FindNearestCell(start);
if (startCell == null)
{
return new WizardPath[] {}
}
;
var endCells = new List <Cell>();
DijkstraStart(startCell, cell =>
{
var point = _points[cell.I, cell.J];
var status = stopFunc(point);
if (status == DijkstraStopStatus.Take || status == DijkstraStopStatus.TakeAndStop)
{
endCells.Add(cell);
}
if (status == DijkstraStopStatus.Stop || status == DijkstraStopStatus.TakeAndStop)
{
return(true);
}
return(false);
}, costFunc);
return(endCells.Select(endCell =>
{
var cellsPath = DijkstraGeneratePath(startCell, endCell);
var res = new WizardPath {
start
};
res.AddRange(cellsPath.Select(cell => _points[cell.I, cell.J]));
return res;
}).ToArray());
}
}
List <AProjectile.ProjectilePathSegment> EmulateProjectileWithNearest(AProjectile projectile)
{
return(projectile.Emulate(Combats.Where(x => x.GetDistanceTo(ASelf) - x.Radius < 900).ToArray(), 0.0));
}
MovingInfo _findCastTarget2(AWizard self, Point moveTo, ProjectileType projectileType)
{
var move = new FinalMove(new Move());
if (projectileType == ProjectileType.MagicMissile)
{
AUnit mmSelTarget = null;
Point mmSelFirstMoveTo = null;
var mmMinTicks = int.MaxValue;
double mmMinPriority = int.MaxValue;
foreach (var opp in OpponentCombats)
{
if (self.GetDistanceTo2(opp) > Geom.Sqr(self.CastRange + opp.Radius + 40) || !opp.IsAssailable)
{
continue;
}
var nearest = Combats
.Where(x => self.GetDistanceTo2(x) < Geom.Sqr(Math.Max(x.VisionRange, self.VisionRange) * 1.3))
.Select(Utility.CloneCombat)
.ToArray();
var targetsSelector = new TargetsSelector(nearest)
{
EnableMinionsCache = true
};
var nearstOpponents = nearest
.Where(x => x.IsOpponent)
.ToArray();
var canHitNow = opp.EthalonCanHit(self, checkCooldown: !(opp is AWizard));
var ticks = 0;
var my = nearest.FirstOrDefault(x => x.Id == self.Id) as AWizard;
var his = nearest.FirstOrDefault(x => x.Id == opp.Id);
if (my == null || his == null)
{
continue;
}
Point firstMoveTo = null;
var buildingsHit = false;
while (!my.EthalonCanCastMagicMissile(his, checkCooldown: false))
{
if (ticks > 40)
{
break;
}
var m = moveTo;
var stopIfCannotMove = true;
if (m == null && my.EthalonCanCastMagicMissile(his, checkCooldown: false, checkAngle: false))
{
stopIfCannotMove = false;
m = my + (my - his);
var tmp = new AWizard(my);
tmp.MoveTo(m, his, w => !CheckIntersectionsAndTress(w, nearest));
if (EstimateDanger(my, false) <= EstimateDanger(tmp, false))
{
m = null;
}
}
if (m == null)
{
m = his;
}
if (ticks == 0)
{
firstMoveTo = m;
}
if (!my.MoveTo(m, his, w => !CheckIntersectionsAndTress(w, nearest)) && Utility.PointsEqual(m, his) && stopIfCannotMove)
{
break;
}
foreach (var x in nearest)
{
if (x.Id == my.Id)
{
continue;
}
var tar = targetsSelector.Select(x);
buildingsHit = buildingsHit ||
(x.IsOpponent && x is ABuilding && tar != null && tar.Id == my.Id && x.EthalonCanHit(my));
if (x.IsOpponent)
{
x.EthalonMove(tar ?? my);
}
else if (tar != null)
{
x.EthalonMove(tar);
}
else
{
x.SkipTick();
}
}
ticks++;
}
if (his is AWizard && (his as AWizard).IsBesieded)
{
ticks -= 15; // чтобы дать больше приоритета визарду
}
var priority = GetCombatPriority(self, his);
if (ticks < mmMinTicks || ticks == mmMinTicks && priority < mmMinPriority)
{
if (my.EthalonCanCastMagicMissile(his))
{
if (nearstOpponents.All(x =>
{
if (canHitNow && x.Id == opp.Id) // он и так доставал
{
return(true);
}
if (!x.EthalonCanHit(my) && (!(x is ABuilding) || !buildingsHit))
{
return(true);
}
if (his.Id == x.Id && CanRush(my, x))
{
return(true);
}
var target = targetsSelector.Select(x);
if (target != null && target.Id != my.Id)
{
return(true);
}
return(false);
})
)
{
mmMinTicks = ticks;
mmMinPriority = priority;
mmSelTarget = opp;
mmSelFirstMoveTo = firstMoveTo;
}
}
}
}
if (mmSelTarget != null)
{
mmMinTicks = Math.Max(0, mmMinTicks);
move.MoveTo(moveTo ?? mmSelFirstMoveTo, mmSelTarget);
return(new MovingInfo(mmSelTarget, mmMinTicks, move)
{
TargetId = mmSelTarget.Id
});
}
}
const int walkLimit = 9;
if (projectileType == ProjectileType.Fireball && self.FireballSkillLevel == 5 && Math.Max(self.RemainingActionCooldownTicks, self.RemainingFireballCooldownTicks) <= walkLimit)
{
var fbMaxDamage = 0.0;
Point fbSelTarget = null;
var fbMinTicks = int.MaxValue;
foreach (var ang in Utility.Range(-Game.StaffSector, Game.StaffSector, 10))
{
var nearest = Combats
.Where(x => self.GetDistanceTo2(x) < Geom.Sqr(Math.Max(x.VisionRange, self.VisionRange) * 1.3))
.Select(Utility.CloneCombat)
.ToArray();
var targetsSelector = new TargetsSelector(nearest)
{
EnableMinionsCache = true
};
var ticks = 0;
var my = nearest.FirstOrDefault(x => x.Id == self.Id) as AWizard;
var dir = my + Point.ByAngle(my.Angle + ang) * 1000;
while (ticks <= walkLimit)
{
if (my.CanUseFireball())
{
var proj = new AProjectile(my, 0, ProjectileType.Fireball);
var path = proj.Emulate(nearest, 0.0);
var damage =
path.Where(x => _isFireballGoodSeg(my, x))
.Select(x => x.OpponentDamage)
.DefaultIfEmpty(0)
.Max();
if (damage > fbMaxDamage)
{
fbMaxDamage = damage;
fbSelTarget = dir;
fbMinTicks = ticks;
}
}
foreach (var x in nearest)
{
if (x.Id == my.Id)
{
continue;
}
if (x is AMinion)
{
x.EthalonMove(targetsSelector.Select(x));
}
else
{
x.SkipTick();
}
}
if (!my.MoveTo(dir, dir, w => !CheckIntersectionsAndTress(w, nearest)))
{
break;
}
if (nearest.Any(x => x.IsOpponent && x is ABuilding && x.EthalonCanHit(my) && targetsSelector.Select(x) == my))
{
break;
}
ticks++;
}
}
if (fbSelTarget != null)
{
move.MoveTo(fbSelTarget, fbSelTarget);
return(new MovingInfo(fbSelTarget, fbMinTicks, move)
{
Damage = fbMaxDamage
});
}
}
return(new MovingInfo(null, int.MaxValue, move));
}
MovingInfo _findCastTarget(AWizard self, ProjectileType projectileType)
{
var actionType = Utility.GetActionByProjectileType(projectileType);
var move = new FinalMove(new Move());
if (self.RemainingActionCooldownTicks > 0 ||
self.RemainingCooldownTicksByAction[(int)actionType] > 0 ||
self.Mana < Const.ProjectileInfo[(int)projectileType].ManaCost ||
!self.IsActionAvailable(actionType)
)
{
return(new MovingInfo(null, int.MaxValue, move));
}
var angles = new List <double>();
foreach (var x in OpponentCombats)
{
var distTo = self.GetDistanceTo(x);
if (distTo > self.CastRange + x.Radius + Const.ProjectileInfo[(int)projectileType].DamageRadius + 3)
{
continue;
}
var angleTo = self.GetAngleTo(x);
if (Math.Abs(angleTo) > Math.PI / 3)
{
continue;
}
var deltaAngle = Math.Atan2(x.Radius, distTo);
angles.AddRange(new[] { angleTo, angleTo + deltaAngle, angleTo - deltaAngle }.Where(a => Math.Abs(a) <= Game.StaffSector / 2));
}
if (angles.Count > 0)
{
angles.AddRange(Utility.Range(-Game.StaffSector / 2, Game.StaffSector / 2, 16));
}
ACombatUnit selTarget = null;
double
selMinDist = 0,
selMaxDist = self.CastRange + 20,
selCastAngle = 0,
selMaxDamage = 0;
if (projectileType == ProjectileType.Fireball)
{
var maxDamage = 0.0;
var maxBurned = 0;
foreach (var angle in angles)
{
var proj = new AProjectile(new AWizard(self), angle, projectileType);
var path = EmulateProjectileWithNearest(proj);
for (var i = 0; i < path.Count; i++)
{
var seg = path[i];
if (_isFireballGoodSeg(self, seg))
{
if (seg.OpponentBurned > maxBurned ||
seg.OpponentBurned == maxBurned && seg.OpponentDamage > maxDamage
//|| seg.OpponentBurned == maxBurned && Utility.Equals(seg.OpponentDamage, maxDamage)
//TODO: combare by angle and priority
)
{
maxBurned = seg.OpponentBurned;
maxDamage = seg.OpponentDamage;
selCastAngle = angle;
selMinDist = selMaxDist = seg.StartDistance;
selTarget = seg.Target;
selMaxDamage = seg.OpponentDamage;
}
}
}
}
}
else
{
double
selPriority = int.MaxValue,
selAngleTo = 0;
foreach (var angle in angles)
{
var proj = new AProjectile(new AWizard(self), angle, projectileType);
var path = EmulateProjectileWithNearest(proj);
for (var i = 0; i < path.Count; i++)
{
if (path[i].State == AProjectile.ProjectilePathState.Free)
{
continue;
}
// TODO: если можно убить нескольких, убивать того, у кого больше жизней
var combat = path[i].Target;
if (!combat.IsAssailable)
{
continue;
}
var myAngle = self.Angle + angle;
var hisAngle = self.Angle + self.GetAngleTo(combat);
var angleTo = Geom.GetAngleBetween(myAngle, hisAngle);
var priority = GetCombatPriority(self, combat);
if (combat.IsOpponent &&
(priority < selPriority || Utility.Equals(priority, selPriority) && angleTo < selAngleTo) &&
self.CheckProjectileCantDodge(proj, Combats.FirstOrDefault(x => x.Id == combat.Id))
)
{
selTarget = combat;
selCastAngle = angle;
selAngleTo = angleTo;
selMinDist = i == 0 ||
path[i - 1].State == AProjectile.ProjectilePathState.Free &&
path[i - 1].Length < 40
? path[i].StartDistance - 1
: path[i].StartDistance - 20;
selMaxDist = i >= path.Count - 2
? (self.CastRange + 500)
: (path[i + 1].EndDistance + path[i].EndDistance) / 2;
selPriority = priority;
selMaxDamage = path[i].OpponentDamage;
}
}
}
}
if (selTarget == null)
{
return(new MovingInfo(null, int.MaxValue, move));
}
move.Action = actionType;
move.MinCastDistance = selMinDist;
move.MaxCastDistance = selMaxDist;
move.CastAngle = selCastAngle;
#if DEBUG
_lastProjectileTick = World.TickIndex;
_lastProjectilePoints = new[]
{
self + Point.ByAngle(self.Angle + selCastAngle) * selMinDist,
self + Point.ByAngle(self.Angle + selCastAngle) * Math.Min(Self.CastRange, selMaxDist),
};
#endif
return(new MovingInfo(selTarget, 0, move)
{
Damage = selMaxDamage, TargetId = selTarget.Id
});
}
MovingInfo _findStaffTarget(AWizard self)
{
var potentialColliders = Combats
.Where(x => x.Id != self.Id && self.GetDistanceTo2(x) < Geom.Sqr(Game.StaffRange * 6))
.ToArray();
int minTicks = int.MaxValue;
var move = new FinalMove(new Move());
var attacked = self.GetStaffAttacked(potentialColliders).Cast <ACombatUnit>().ToArray();
ACircularUnit selTarget = attacked.FirstOrDefault(x => x.IsOpponent);
if (selTarget != null) // если уже можно бить
{
move.Action = ActionType.Staff;
return(new MovingInfo(selTarget, 0, move));
}
if (self.MmSkillLevel == 5)
{
// т.к. стрелять можно без задержки
// возможно, нужно сделать исключение, если прокачан посох
return(new MovingInfo(null, int.MaxValue, move));
}
Point selMoveTo = null;
foreach (var opp in OpponentCombats)
{
var dist = self.GetDistanceTo(opp);
if (dist > Game.StaffRange * 5 || !opp.IsAssailable)
{
continue;
}
var range = opp.Radius + Game.StaffRange;
foreach (var delta in new[] { -range, -range / 2, 0, range / 2, range })
{
var angle = Math.Atan2(delta, dist);
var moveTo = self + (opp - self).Normalized().RotateClockwise(angle) * self.VisionRange;
var nearstCombats = Combats
.Where(x => x.GetDistanceTo(self) <= Math.Max(x.VisionRange, self.VisionRange) * 1.2)
.Select(Utility.CloneCombat)
.ToArray();
var targetsSelector = new TargetsSelector(nearstCombats)
{
EnableMinionsCache = true
};
var nearstOpponents = nearstCombats.Where(x => x.IsOpponent).ToArray();
var my = nearstCombats.FirstOrDefault(x => x.Id == self.Id) as AWizard;
var his = nearstCombats.FirstOrDefault(x => x.Id == opp.Id);
var allowRush = opp is AFetish || opp is AWizard;
var canHitNow = opp.EthalonCanHit(self, checkCooldown: !allowRush);
var ticks = 0;
var ok = true;
var buildingsHit = false;
while (ticks < (allowRush ? 65 : 35) && my.GetDistanceTo2(his) > Geom.Sqr(Game.StaffRange + his.Radius))
{
foreach (var x in nearstOpponents) // свои как-бы стоят на месте
{
var tar = targetsSelector.Select(x);
buildingsHit = buildingsHit ||
(x is ABuilding && tar != null && tar.Id == my.Id && x.EthalonCanHit(my));
x.EthalonMove(tar ?? my);
}
if (!my.MoveTo(moveTo, his, w => !CheckIntersectionsAndTress(w, potentialColliders)))
{
ok = false;
break;
}
ticks++;
}
if (ok && !(opp is AOrc))
{
while (Math.Abs(my.GetAngleTo(his)) > Game.StaffSector / 2)
{
my.MoveTo(null, his);
foreach (var x in nearstOpponents)
{
var tar = targetsSelector.Select(x);
buildingsHit = buildingsHit ||
(x is ABuilding && tar != null && tar.Id == my.Id && x.EthalonCanHit(my));
x.EthalonMove(tar ?? my);
}
ticks++;
}
}
Func <ACombatUnit, bool> check = x =>
{
if ((opp is AWizard) && (opp as AWizard).IsBesieded && !(x is ABuilding))
{
return(true);
}
if (canHitNow && x.Id == opp.Id) // он и так доставал
{
return(true);
}
if (!x.EthalonCanHit(my) && (!(x is ABuilding) || !buildingsHit))
{
return(true);
}
if (his.Id == x.Id && my.StaffDamage >= his.Life)
{
return(true);
}
var target = targetsSelector.Select(x);
if (target != null && target.Id != my.Id)
{
return(true);
}
return(false);
};
if (opp is AWizard)
{
ticks -= 5;
if ((opp as AWizard).IsBesieded)
{
ticks -= 10;
}
}
if (ok && ticks < minTicks)
{
if (my.CanStaffAttack(his))
{
if (nearstOpponents.All(check))
{
// успею-ли я вернуться обратно
while (my.GetDistanceTo(self) > my.MaxForwardSpeed)//TODO:HACK
{
my.MoveTo(self, null);
foreach (var x in nearstOpponents)
{
var tar = targetsSelector.Select(x);
buildingsHit = buildingsHit ||
(x is ABuilding && tar != null && tar.Id == my.Id && x.EthalonCanHit(my));
if (tar != null)
{
x.EthalonMove(tar);
}
else
{
x.SkipTick();
}
}
}
if (nearstOpponents.All(check))
{
selTarget = opp;
selMoveTo = moveTo;
minTicks = ticks;
}
}
}
}
}
}
if (selTarget != null)
{
bool angleOk = Math.Abs(self.GetAngleTo(selTarget)) <= Game.StaffSector / 2,
distOk = self.GetDistanceTo2(selTarget) <= Geom.Sqr(Game.StaffRange + selTarget.Radius);
if (!distOk)
{
move.MoveTo(selMoveTo, selTarget);
}
else if (!angleOk)
{
move.MoveTo(null, selTarget);
}
}
return(new MovingInfo(selTarget, Math.Max(0, minTicks), move));
}
MovingInfo FindBonusTarget(AWizard self)
{
var minTime = int.MaxValue;
var selGo = 0;
Point selMoveTo = null;
foreach (var _bonus in BonusesObserver.Bonuses)
{
if (_bonus.GetDistanceTo(self) - self.Radius - _bonus.Radius > Game.StaffRange * 3)
{
continue;
}
if (_bonus.RemainingAppearanceTicks > 60)
{
continue;
}
var nearest = Combats
.Where(x => x.Id != self.Id && self.GetDistanceTo2(x) < Geom.Sqr(self.VisionRange))
.ToArray();
foreach (var angle in Utility.Range(self.Angle, Math.PI * 2 + self.Angle, 24, false))
{
var bonus = new ABonus(_bonus);
var my = new AWizard(self);
var moveTo = my + Point.ByAngle(angle) * self.VisionRange;
int time = 0;
int go = 0;
while (my.GetDistanceTo(bonus) > my.Radius + bonus.Radius && time < 60)
{
if (!my.MoveTo(moveTo, null, w => !CheckIntersectionsAndTress(w, nearest)))
{
break;
}
var wait = !bonus.Exists;
bonus.SkipTick();
time++;
if (my.GetDistanceTo(bonus) <= my.Radius + bonus.Radius)
{
while (!bonus.Exists)
{
bonus.SkipTick();
time++;
}
if (wait)
{
time++;
}
if (time < minTime)
{
minTime = time;
selMoveTo = moveTo;
selGo = go;
}
break;
}
go++;
}
}
}
var moving = new MovingInfo(selMoveTo, minTime, new FinalMove(new Move()));
if (selMoveTo != null)
{
if (minTime == 1 || selGo > 0)
{
moving.Move.MoveTo(selMoveTo, null);
}
else
{
moving.Target = self;
}
}
return(moving);
}
public static bool IsPointVisible(Point point)
{
return(Combats.Any(x => x.IsTeammate && point.GetDistanceTo2(x) <= x.VisionRange * x.VisionRange));
}
bool _tryDodgeProjectile()
{
var obstacles = Combats.Where(x => x.Id != Self.Id && x.GetDistanceTo(ASelf) < 300).ToArray();
var minTicks = int.MaxValue;
var minDamage = 1000.0;
Point selMoveTo = null;
Point selTurnTo = null;
foreach (var doTurn in new[] { false, true })
{
foreach (var angle in Utility.Range(0, Math.PI * 2, 40, false))
{
if (minTicks == 0 && minDamage < Const.Eps) // ничего не грозит
{
break;
}
var ticks = 0;
var my = new AWizard(ASelf);
var bonus = new ABonus(BonusesObserver.Bonuses.ArgMin(b => b.GetDistanceTo(Self)));
var moveTo = my + Point.ByAngle(angle) * 1000;
var turnTo = doTurn ? moveTo : null;
var myStates = new List <AWizard> {
new AWizard(my)
};
while (ticks < ProjectilesCheckTicks)
{
var totalDamage = _getProjectilesDamage(myStates);
if (Utility.Less(totalDamage, minDamage) ||
Utility.Equals(totalDamage, minDamage) && ticks < minTicks)
{
minTicks = ticks;
minDamage = totalDamage;
selMoveTo = moveTo;
selTurnTo = turnTo;
}
bonus.SkipTick();
my.MoveTo(moveTo, turnTo, w =>
{
if (CheckIntersectionsAndTress(w, obstacles))
{
return(false);
}
if (bonus.RemainingAppearanceTicks < 15 && bonus.IntersectsWith(w))
{
return(false);
}
return(true);
});
myStates.Add(new AWizard(my));
ticks++;
}
}
}
if (minTicks == 0 || minTicks == int.MaxValue) // нет необходимости уворачиваться
{
return(false);
}
if (selTurnTo != null || Math.Abs(ASelf.GetAngleTo(selMoveTo)) < Math.PI / 2)
{
FinalMove.Turn = 0;
}
FinalMove.MoveTo(selMoveTo, selTurnTo);
return(true);
}
private bool _TryGoByGradient(Func <AWizard, double> costFunction, Func <AWizard, bool> firstMoveCondition, FinalMove move)
{
var self = new AWizard(ASelf);
var obstacles =
Combats.Where(x => x.Id != Self.Id && !(x is ABuilding)).Cast <ACircularUnit>()
.Concat(BuildingsObserver.Buildings)
.Where(x => self.GetDistanceTo2(x) < Geom.Sqr(x.Radius + 150))
.ToArray();
var danger = costFunction(self); // for debug
List <double> selVec = null;
var minDanger = double.MaxValue;
Point selMoveTo = null;
foreach (var angle in Utility.Range(self.Angle, Math.PI * 2 + self.Angle, 24, false))
{
var moveTo = self + Point.ByAngle(angle) * self.VisionRange;
var nearest = Combats
.Where(x => x.GetDistanceTo(self) < Math.Max(self.VisionRange, x.VisionRange) * 1.3)
.Select(Utility.CloneCombat)
.ToArray();
var tergetsSelector = new TargetsSelector(nearest);
var opponents = nearest.Where(x => x.IsOpponent).ToArray();
var vec = new List <double>();
const int steps = 18;
var my = (AWizard)nearest.FirstOrDefault(x => x.Id == self.Id);
var ok = true;
var canMove = true;
while (vec.Count < steps)
{
if (canMove)
{
canMove = my.MoveTo(moveTo, null, w => w.GetFirstIntersection(obstacles) == null);
if (TreesObserver.GetNearestTrees(my).Any(t => t.IntersectsWith(my)))
{
break;
}
}
else
{
my.SkipTick();
}
var tmp = OpponentCombats;//HACK
OpponentCombats = opponents;
vec.Add(costFunction(my));
OpponentCombats = tmp;
foreach (var x in opponents)
{
var tar = tergetsSelector.Select(x);
if (tar != null || x is AWizard)
{
x.EthalonMove(tar);
}
}
if (vec.Count == 1 && firstMoveCondition != null && !firstMoveCondition(my))
{
ok = false;
break;
}
}
if (!ok || vec.Count == 0)
{
continue;
}
while (vec.Count < steps)
{
vec.Add(CantMoveDanger);
}
var newDanger = 0.0;
for (var k = 0; k < steps; k++)
{
newDanger += vec[k] * Math.Pow(0.87, k);
}
newDanger += 3 * vec[0];
if (newDanger < minDanger)
{
minDanger = newDanger;
selMoveTo = Utility.PointsEqual(my, self) ? null : moveTo;
selVec = vec;
}
}
if (selVec != null)
{
move.Speed = move.StrafeSpeed = 0;
move.MoveTo(selMoveTo, null);
return(true);
}
return(false);
}