void _rushTo(AWizard self, AWizard opp)
{
// TODO: check angle
if (self.CanUseFrostBolt() &&
self.GetDistanceTo(opp) <= Game.WizardCastRange + opp.Radius)
{
opp.ApplyMagicalDamage(self.FrostBoltDamage);
opp.RemainingFrozen = Game.FrozenDurationTicks;
self.RemainingFrostBoltCooldownTicks = Game.FrostBoltCooldownTicks;
self.RemainingActionCooldownTicks = Game.WizardActionCooldownTicks;
}
if (self.CanUseStaff() &&
self.GetDistanceTo(opp) <= Game.StaffRange + opp.Radius)
{
opp.ApplyDamage(self.StaffDamage);
self.RemainingStaffCooldownTicks = Game.StaffCooldownTicks;
self.RemainingActionCooldownTicks = Game.WizardActionCooldownTicks;
}
if (self.CanUseMagicMissile() &&
self.GetDistanceTo(opp) <= Game.WizardCastRange + opp.Radius)
{
opp.ApplyMagicalDamage(self.MagicMissileDamage);
self.RemainingMagicMissileCooldownTicks = self.MmSkillLevel == 5 ? 0 : Game.MagicMissileCooldownTicks;
self.RemainingActionCooldownTicks = Game.WizardActionCooldownTicks;
}
if (self.GetDistanceTo(opp) > Game.StaffRange + opp.Radius)
{
self.MoveTo(opp, opp);
}
self.SkipTick();
}
MovingInfo FindTreeTarget(AWizard self)
{
var res = new MovingInfo(null, int.MaxValue, new FinalMove(new Move()));
var trees = TreesObserver.Trees.Where(t => self.GetDistanceTo(t) <= Game.StaffRange + t.Radius).ToArray();
var minTicks = int.MaxValue;
ATree selTarget = null;
foreach (var tree in trees)
{
var my = new AWizard(self);
var ticks = 0;
while (Math.Abs(my.GetAngleTo(tree)) > Game.StaffSector / 2)
{
my.MoveTo(null, tree);
ticks++;
}
if (ticks < minTicks && my.CanStaffAttack(tree))
{
minTicks = ticks;
selTarget = tree;
}
}
if (selTarget == null)
{
return(res);
}
res.Time = minTicks;
res.Target = selTarget;
res.TargetId = selTarget.Id;
if (minTicks == 0)
{
res.Move.Action = ActionType.Staff;
}
else
{
res.Move.MoveTo(null, selTarget);
}
return(res);
}
bool TryCutTrees(bool cutNearest, FinalMove move)
{
var self = new AWizard(ASelf);
var nearestTrees = TreesObserver.Trees.Where(
t => self.GetDistanceTo(t) < self.CastRange + t.Radius + Game.MagicMissileRadius
).ToArray();
if (nearestTrees.Length == 0)
{
return(false);
}
if (self.RemainingActionCooldownTicks == 0)
{
if (self.GetStaffAttacked(nearestTrees).Length > 0)
{
move.Action = ActionType.Staff;
return(true);
}
if (self.RemainingMagicMissileCooldownTicks == 0)
{
var proj = new AProjectile(self, 0, ProjectileType.MagicMissile);
var path = EmulateProjectileWithNearest(proj);
if (path.Count == 0 || path[path.Count - 1].EndDistance < self.CastRange - Const.Eps)
{
move.MinCastDistance = path[path.Count - 1].EndDistance;
move.Action = ActionType.MagicMissile;
return(true);
}
}
}
if (cutNearest)
{
var nearest = nearestTrees.OrderBy(t => self.GetDistanceTo2(t)).FirstOrDefault();
move.MoveTo(null, nearest);
}
return(false);
}
static double GetCombatPriority(AWizard self, ACombatUnit unit)
{
// чем меньше - тем важнее стрелять в него первого
var res = unit.Life;
if (unit is AWizard)
{
res /= 4;
if ((unit as AWizard).IsBesieded)
{
res /= 4;
}
res -= 50;
}
var dist = self.GetDistanceTo(unit);
if (dist <= Game.StaffRange + unit.Radius + 10)
{
res -= 60;
res += Math.Log(dist);
}
return(res);
}
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);
}
MovingInfo FindUltimateTarget(AWizard self)
{
var ret = new MovingInfo(null, int.MaxValue, new FinalMove(new Move()));
const int threshold = 29;
var minTicks = int.MaxValue;
AWizard selTarget = null;
var selAction = ActionType.None;
foreach (var action in new[] { ActionType.Haste, ActionType.Shield })
{
if (action == ActionType.Haste && self.HasteSkillLevel < 5 ||
action == ActionType.Shield && self.ShieldSkillLevel < 5
)
{
continue;
}
var teammates = MyWizards
.Where(x => x.Id != self.Id &&
self.GetDistanceTo(x) <= self.CastRange &&
x.RemainingStatusByAction(action) <= threshold
).
ToArray();
foreach (var teammate in teammates)
{
var ticks = 0;
var my = new AWizard(self);
while (Math.Abs(my.GetAngleTo(teammate)) > Game.StaffSector / 2)
{
ticks++;
my.MoveTo(null, teammate);
}
if (ticks < minTicks && my.CanCastUltimate(action, teammate))
{
minTicks = ticks;
selTarget = teammate;
selAction = action;
}
}
if (selTarget == null &&
teammates.Length == 0 &&
self.RemainingStatusByAction(action) <= threshold &&
self.CanUseUltimate(action)
)
{
minTicks = 100;
selTarget = self;
selAction = action;
}
}
if (selTarget == null)
{
return(ret);
}
ret.Target = selTarget;
ret.TargetId = selTarget.Id;
ret.Time = minTicks;
if (self.CanCastUltimate(selAction, selTarget))
{
ret.Move.Action = selAction;
ret.Move.StatusTargetId = selTarget.Id;
}
else
{
ret.Move.MoveTo(null, selTarget);
}
return(ret);
}
private bool HasAnyTarget(AWizard self, bool skipBuildings)
{
var my = new AWizard(self);
foreach (var opp in OpponentCombats)
{
if (!opp.IsAssailable)
{
continue;
}
var prevCastRange = my.CastRange;
var bld = opp as ABuilding;
if (opp is AWizard)
{
if (my.CastRange <= opp.CastRange)
{
if (GoAwayCond(my, opp as AWizard))
{
my.CastRange = opp.CastRange + GoAwaySafeDist;
}
else if (my.CastRange < opp.CastRange)
{
my.CastRange = my.CastRange + 25; // HACK: чтобы не бояться подходить к тем у кого прокачан range
}
}
}
if (bld != null && (skipBuildings || bld.IsBase))
{
if (!bld.IsBase && bld.Lane != MessagesObserver.GetLane())
{
continue;
}
if (!bld.IsBesieded)
{
// чтобы не подходить близко к одиноким башням
if (my.GetDistanceTo(bld) < bld.CastRange + 6)
{
return(true);
}
}
}
if (my.GetDistanceTo(opp) <= my.CastRange + opp.Radius + Game.MagicMissileRadius)
{
var tmp = opp.RemainingFrozen;
opp.RemainingFrozen = 100500;
var canCast = my.EthalonCanCastMagicMissile(opp, checkCooldown: false, checkAngle: false);
opp.RemainingFrozen = tmp;
if (canCast)
{
return(true);
}
}
my.CastRange = prevCastRange;
}
return(false);
}
WizardPath _goAround(ACombatUnit target, bool goAgainst)
{
var my = new AWizard(ASelf);
var selLane = Utility.IsBase(target) ? MessagesObserver.GetLane() : RoadsHelper.GetLane(target);
var nearestBuilding = OpponentBuildings.ArgMin(b => b.GetDistanceTo2(my));
var buildings = new List <ABuilding>();
if (nearestBuilding.GetDistanceTo(my) > nearestBuilding.VisionRange)
{
buildings.Add(nearestBuilding);
}
if (target.IsOpponent && target.Id != nearestBuilding.Id && target is ABuilding)
{
buildings.Add((ABuilding)target);
}
var threshold = Self.CastRange - 200;
if (ASelf.GetDistanceTo(target) < Self.CastRange || !goAgainst)
{
threshold = 0;
}
var path = DijkstraFindPath(ASelf, pos =>
{
// точка ОК, если с неё можно стрелять
var dist2 = pos.GetDistanceTo2(target);
if (dist2 < Geom.Sqr(Self.CastRange) && dist2 > Geom.Sqr(threshold))
{
var distToLine = RoadsHelper.Roads.Where(seg => seg.LaneType == selLane).Min(seg => seg.GetDistanceTo(pos));
if (distToLine < 200 &&
(!goAgainst || BuildingsObserver.MyBase.GetDistanceTo2(pos) < BuildingsObserver.MyBase.GetDistanceTo2(target)) &&
TreesObserver.Trees
.Where(x => x.GetDistanceTo2(pos) < Geom.Sqr(Self.CastRange))
.All(x => !Geom.SegmentCircleIntersects(pos, target, x, x.Radius + Game.MagicMissileRadius))
)
{
return(DijkstraStopStatus.TakeAndStop);
}
}
return(DijkstraStopStatus.Continue);
}, MoveCostFunc(buildings, selLane)).FirstOrDefault();
if (path == null && my.GetDistanceTo(target) - my.Radius - target.Radius <= 1)
{
path = new WizardPath {
my
}
}
; // из-за эпсилон, если стою близко у цели, то он как бы с ней пересекается, но это не так
if (path == null || path.Count == 0)
{
return(null);
}
if (path.Count == 1)
{
FinalMove.Turn = my.GetAngleTo(target);
return(null);
}
var obstacles =
Combats.Where(x => x.Id != Self.Id).Cast <ACircularUnit>()
.Where(x => my.GetDistanceTo2(x) < Geom.Sqr(my.VisionRange)) //???
.ToArray();
path.Simplify(obstacles, MagicConst.SimplifyMaxLength);
var nextPoint = path[1];
var nextNextPoint = path.Count > 2 ? path[2] : target;
FinalMove.MoveTo(nextPoint, my.GetDistanceTo(nextNextPoint) < Self.VisionRange * 1.2 ? nextNextPoint : nextPoint);
var nextTree = path.GetNearestTree();
CutTreesInPath(nextTree, FinalMove);
#if DEBUG
Visualizer.Visualizer.SegmentsDrawQueue.Add(new object[] { path, Pens.Blue, 3 });
#endif
return(path);
}
void CutTreesInPath(ATree nextTree, FinalMove move)
{
if (nextTree == null)
{
return;
}
var my = new AWizard(ASelf);
var angleTo = my.GetAngleTo(nextTree);
if (my.GetDistanceTo(nextTree) < my.VisionRange && Math.Abs(angleTo) > Game.StaffSector / 2)
{
move.MoveTo(null, nextTree);
}
if (my.RemainingActionCooldownTicks == 0 && Math.Abs(angleTo) <= Game.StaffSector / 2)
{
if (my.GetDistanceTo(nextTree) <= Game.StaffRange + nextTree.Radius && my.RemainingStaffCooldownTicks == 0)
{
move.Action = ActionType.Staff;
}
else if (my.GetDistanceTo(nextTree) <= my.CastRange + nextTree.Radius && my.RemainingMagicMissileCooldownTicks == 0)
{
move.Action = ActionType.MagicMissile;
move.CastAngle = angleTo;
move.MinCastDistance = Math.Min(my.CastRange - 1, my.GetDistanceTo(nextTree));
}
}
}
MovingInfo GoToBonus()
{
TimerStart();
var ret = _goToBonus();
TimerEndLog("GoToBonus", 1);
return(ret);
}
bool _skipBonusCond(ABonus bonus)
{
var oppFirst = BuildingsObserver.Buildings.FirstOrDefault(x => x.IsOpponent && x.Lane == MessagesObserver.GetLane() && x.Order == 0);
if (oppFirst == null || ASelf.GetDistanceTo(oppFirst) <= oppFirst.CastRange)
{
return(true);
}
var myFirst = BuildingsObserver.Buildings.FirstOrDefault(x => x.IsTeammate && x.Lane == MessagesObserver.GetLane() && x.Order == 0);
if (myFirst == null || OpponentWizards.Any(x => x.GetDistanceTo(myFirst) <= myFirst.Radius))
{
return(true);
}
// TODO
return(false);
}
ABonus SelectBonus(AWizard self)
{
var bonus = BonusesObserver.Bonuses.ArgMin(b => b.GetDistanceTo2(self));
if (bonus.RemainingAppearanceTicks > MagicConst.GoToBonusMaxTicks + MagicConst.BonusTimeReserve)
{
return(null);
}
if (self.GetDistanceTo(BuildingsObserver.OpponentBase) < BuildingsObserver.OpponentBase.CastRange * 1.4)
{
return(null);
}
if (Game.IsSkillsEnabled && _skipBonusCond(bonus))
{
return(null);
}
return(bonus);
}
MovingInfo _goToBonus()
{
var bonus = SelectBonus(ASelf);
var selMovingInfo = new MovingInfo(null, int.MaxValue, new FinalMove(new Move()));
if (bonus == null)
{
return(selMovingInfo);
}
if (Const.IsFinal)
{
var teammates = MyWizards
.Where(x => x.Id != ASelf.Id)
.Where(x =>
{
var b = SelectBonus(x);
return(b != null && b.Id == bonus.Id);
})
.ToArray();
if (teammates.Any(x => ASelf.GetDistanceTo(bonus) > x.GetDistanceTo(bonus)))
{
return(selMovingInfo);
}
}
var my = new AWizard(ASelf);
var nearestBuilding = OpponentBuildings.ArgMin(b => b.GetDistanceTo2(my));
var path = DijkstraFindPath(ASelf, pos =>
{
// точка ОК, если бонус совсем близко
if (pos.GetDistanceTo2(bonus) < Geom.Sqr(bonus.Radius + Self.Radius + 35))
{
return(DijkstraStopStatus.TakeAndStop);
}
return(DijkstraStopStatus.Continue);
}, MoveCostFunc(new [] { nearestBuilding }, MessagesObserver.GetLane())).FirstOrDefault();
if (path == null)
{
GoDirect(bonus, selMovingInfo.Move);
selMovingInfo.Target = bonus;
return(selMovingInfo);
}
var obstacles =
Combats.Where(x => x.Id != Self.Id).Cast <ACircularUnit>()
.Where(x => my.GetDistanceTo2(x) < Geom.Sqr(my.VisionRange))
.ToArray();
path.Add(bonus);
path.Simplify(obstacles, MagicConst.SimplifyMaxLength);
var time = (int)(path.GetLength() / my.MaxForwardSpeed);
if (time < MagicConst.GoToBonusMaxTicks)
{
selMovingInfo.Time = time;
var nextPoint = path[1];
var nextNextPoint = path.Count > 2 ? path[2] : nextPoint;
selMovingInfo.Move = new FinalMove(new Move());
selMovingInfo.Move.MoveTo(nextPoint, my.GetDistanceTo(nextNextPoint) < my.Radius + 20 ? nextNextPoint : nextPoint);
selMovingInfo.Target = nextPoint;
var nextTree = path.GetNearestTree();
CutTreesInPath(nextTree, selMovingInfo.Move);
}
if (selMovingInfo.Time <= bonus.RemainingAppearanceTicks - MagicConst.BonusTimeReserve)
{
selMovingInfo.Target = null;
}
#if DEBUG
if (selMovingInfo.Target != null)
{
Visualizer.Visualizer.SegmentsDrawQueue.Add(new object[] { path, Pens.Red, 3 });
}
#endif
return(selMovingInfo);
}
private void _move(Wizard self, World world, Game game, Move move)
{
World = world;
Game = game;
Self = self;
FinalMove = new FinalMove(move);
Const.Initialize();
MagicConst.TreeObstacleWeight = Const.IsFinal ? 25 : 35;
Wizards = world.Wizards
.Select(x => new AWizard(x))
.ToArray();
foreach (var wizard in Wizards)
{
foreach (var other in Wizards)
{
if (wizard.Faction != other.Faction)
{
continue;
}
if (wizard.GetDistanceTo2(other) > Geom.Sqr(Game.AuraSkillRange))
{
continue;
}
for (var i = 0; i < 5; i++)
{
wizard.AurasFactorsArr[i] = Math.Max(wizard.AurasFactorsArr[i], other.SkillsLearnedArr[i] / 2);
}
}
var orig = World.Wizards.FirstOrDefault(w => w.Id == wizard.Id);
var player = World.Players.FirstOrDefault(p => orig != null && p.Id == orig.OwnerPlayerId);
if (player != null && player.IsStrategyCrashed)
{
wizard.RemainingFrozen = 100500;
}
}
OpponentWizards = Wizards
.Where(x => x.IsOpponent)
.ToArray();
MyWizards = Wizards
.Where(x => x.IsTeammate)
.ToArray();
Minions = world.Minions
.Select(x => x.Type == MinionType.OrcWoodcutter ? (AMinion) new AOrc(x) : new AFetish(x))
.ToArray();
NeutralMinions = Minions
.Where(x => x.Faction == Faction.Neutral)
.ToArray();
Combats =
Minions.Cast <ACombatUnit>()
.Concat(Wizards)
.Concat(BuildingsObserver.Buildings)//TODO перед BuildingsObserver.Update????
.ToArray();
MyCombats = Combats
.Where(x => x.IsTeammate)
.ToArray();
NeutralMinionsObserver.Update();
OpponentMinions = Minions
.Where(x => x.IsOpponent)
.ToArray();
OpponentCombats = Combats
.Where(x => x.IsOpponent)
.ToArray();
RoadsHelper.Initialize();
BuildingsObserver.Update();
OpponentBuildings = BuildingsObserver.Buildings
.Where(x => x.IsOpponent)
.ToArray();
TreesObserver.Update();
ProjectilesObserver.Update();
BonusesObserver.Update();
MessagesObserver.Update();
InitializeProjectiles();
InitializeDijkstra();
ASelf = Wizards.FirstOrDefault(x => x.Id == Self.Id);
if (ASelf == null)
{
throw new Exception("Self not found in wizards list");
}
InitializeDangerEstimation();
SupportObserver.Update();
if (Self.IsMaster && World.TickIndex == 0)
{
MasterSendMessages();
}
if (Self.IsMaster)
{
MasterCheckRearrange();
}
var nearestBonus = BonusesObserver.Bonuses.ArgMin(b => b.GetDistanceTo(ASelf));
var opponentsAroundBonus = OpponentWizards.Where(w => nearestBonus.GetDistanceTo(w) < ASelf.VisionRange * 1.5).ToArray();
var teammatesAroundBonus = MyWizards.Where(w => ASelf.GetDistanceTo(w) < ASelf.VisionRange * 1.5).ToArray();
WizardPath path = null;
AUnit pathTarget = null;
var goAway = GoAwayDetect();
var bonusMoving = goAway ? new MovingInfo(null, int.MaxValue, null) : GoToBonus();
var target = FindTarget(new AWizard(ASelf), bonusMoving.Target);
if (target == null && bonusMoving.Target == null && !goAway)
{
var nearest = OpponentCombats
.Where(
x =>
Utility.IsBase(x) || RoadsHelper.GetLane(x) == MessagesObserver.GetLane() ||
RoadsHelper.GetLaneEx(ASelf) == ALaneType.Middle &&
RoadsHelper.GetLaneEx(x) == ALaneType.Middle && CanRush(ASelf, x))
.Where(x => x.IsAssailable && x.Faction != Faction.Neutral)
.OrderBy(
x =>
x.GetDistanceTo(self) +
(x is AWizard ? -40 : (x is ABuilding && !((ABuilding)x).IsBesieded) ? 1500 : 0))
.ToArray();
foreach (var n in nearest)
{
path = GoAgainst(n);
if (path != null)
{
pathTarget = n;
break;
}
}
if (nearest.Length > 0 && path == null)
{
GoDirect(nearest[0], FinalMove);
}
}
TimerStart();
if (!TryDodgeProjectile())
{
if (target == null)
{
TryPreDodgeProjectile();
}
if (goAway)
{
GoAway();
}
else if (target == null || target.Type == TargetType.Teammate ||
(FinalMove.Action == ActionType.Staff ||
FinalMove.Action == ActionType.MagicMissile ||
FinalMove.Action == ActionType.Fireball ||
FinalMove.Action == ActionType.FrostBolt) && target.Type == TargetType.Opponent)
{
if (bonusMoving.Target != null)
{
NextBonusWaypoint = bonusMoving.Target;
FinalMove.Turn = bonusMoving.Move.Turn;
if (bonusMoving.Move.Action != ActionType.None && bonusMoving.Move.Action != null)
{
FinalMove.Action = bonusMoving.Move.Action;
FinalMove.MinCastDistance = bonusMoving.Move.MinCastDistance;
FinalMove.MaxCastDistance = bonusMoving.Move.MaxCastDistance;
FinalMove.CastAngle = bonusMoving.Move.CastAngle;
}
NextBonusWaypoint = ASelf + (NextBonusWaypoint - ASelf).Normalized() * (Self.Radius + 30);
if (nearestBonus.GetDistanceTo(ASelf) < ASelf.VisionRange * 1.5 &&
nearestBonus.GetDistanceTo(ASelf) > 100 &&
opponentsAroundBonus.Length <= 1 &&
ASelf.Life + 10 >= (opponentsAroundBonus.FirstOrDefault() ?? ASelf).Life &&
OpponentMinions.Count(x => x.GetDistanceTo(ASelf) < Game.FetishBlowdartAttackRange) == 0
)
{
FinalMove.MoveTo(NextBonusWaypoint, null);
}
else
{
TryGoByGradient(x => EstimateDanger(x), null, FinalMove);
}
}
else
{
var all = Combats.Select(Utility.CloneCombat).ToArray();
var my = all.FirstOrDefault(x => x.Id == ASelf.Id) as AWizard;
my?.Move(FinalMove.Speed, FinalMove.StrafeSpeed);
var ts = new TargetsSelector(all);
var skipBuildings = path == null ||
path.GetLength() < 300 ||
path.GetLength() < 600 && OpponentBuildings.Any(x =>
{
var tar = ts.Select(x);
return(tar != null && tar.Id == ASelf.Id);
});
if (TryGoByGradient(x => EstimateDanger(x), x => HasAnyTarget(x, skipBuildings), FinalMove))
{
var cutTreeMovingInfo = FindTreeTarget(ASelf);
if (cutTreeMovingInfo.Target != null)
{
FinalMove.Turn = cutTreeMovingInfo.Move.Turn;
if (cutTreeMovingInfo.Move.Action != null && FinalMove.Action == null)
{
FinalMove.Action = cutTreeMovingInfo.Move.Action;
}
// не будет мешать TryPreDodgeProjectile?
}
}
}
}
PostDodgeProjectile();
}
TimerEndLog("Go", 1);
if (ASelf.CanLearnSkill)
{
move.SkillToLearn = MessagesObserver.GetSkill();
}
}
double EstimateDanger(AWizard my, bool considerWizardBesieded = true)
{
double res = 0;
var nearestTower = OpponentCombats.FirstOrDefault(x => x is ABuilding && x.GetDistanceTo2(my) <= Geom.Sqr(x.CastRange));
foreach (var opp in OpponentCombats)
{
var dist = opp.GetDistanceTo(my);
if (dist > 2 * my.VisionRange)
{
continue;
}
if (opp is AWizard)
{
var wizard = opp as AWizard;
var inner = (Game.StaffRange + my.Radius) + 1; // (куда достаёт посохом) + запас
var outer = (opp.CastRange + my.Radius + Game.MagicMissileRadius) + 1; // (куда достанет MagicMissile) + запас
if (GoAwayCond(my, wizard))
{
outer += GoAwaySafeDist - Game.MagicMissileRadius;
}
var coeff = 45;
if (!wizard.IsBesieded ||
!considerWizardBesieded ||
(nearestTower != null &&
!Utility.IsBase(nearestTower) &&
BuildingsObserver.MyBase.GetDistanceTo2(my) > BuildingsObserver.MyBase.GetDistanceTo2(nearestTower) &&
BuildingsObserver.MyBase.GetDistanceTo2(wizard) > BuildingsObserver.MyBase.GetDistanceTo2(nearestTower)
)
)
{
if (dist < inner)
{
res += (wizard.StaffDamage + wizard.MagicMissileDamage) * 2;
}
else if (dist < outer)
{
res += (wizard.MagicMissileDamage + coeff - (dist - inner) / (outer - inner) * coeff) * 2;
}
}
else
{
var otr = my.VisionRange * 1.3;
if (dist < otr)
{
res -= 10 + 60 - dist / otr * 60;
}
}
}
else if (opp is ABuilding)
{
var building = opp as ABuilding;
if (building.IsBase && !Game.IsSkillsEnabled)
{
var outer = building.CastRange;
if (dist <= outer)
{
res += 90 - dist / outer * 90 + building.Damage;
}
}
else if (building.IsBesieded)
{
var inner = my.Radius + building.Radius + 2 * Game.DartRadius + 3; // свои фетиши могут стрелять
var outer = building.VisionRange * 1.2;
if (dist < inner)
{
res += 20 - dist / inner * 20;
}
else if (dist < outer)
{
res -= 2 - dist / outer * 2;
}
}
else
{
var inner = Game.StaffRange + building.Radius; // откуда можно достать посохом
var outer = building.CastRange; // куда достреливает башня
double delta = -80;
if (dist < inner)
{
res += building.Damage - delta;
}
else if (dist <= outer)
{
res += (dist - inner) / (outer - inner) * delta + building.Damage - delta;
}
}
}
else if (opp is AOrc)
{
var inner = Game.OrcWoodcutterAttackRange + my.Radius + Game.MinionSpeed + 20 /*запас*/;
var outer = 800;
if (dist < inner)
{
res += Game.OrcWoodcutterDamage + 15 - dist / inner * 15;
}
else if (dist < outer && my.MmSkillLevel < 5)
{
res -= 3 - (dist - inner) / (outer - inner) * 3;
}
}
else if (opp is AFetish)
{
var inner = opp.CastRange + my.Radius + Game.DartRadius + 10;
if (dist < inner)
{
var fetishTarget = MinionsTargetsSelector.Select(opp);
if (fetishTarget == null || Geom.Sqr(dist - 5) < opp.GetDistanceTo2(fetishTarget))
{
res += 15 - dist / inner * 15 + Game.DartDirectDamage;
}
}
}
}
// не прижиматься к своим
foreach (var co in MyCombats)
{
var dist = my.GetDistanceTo(co) - co.Radius - my.Radius;
if (my.Id != co.Id && dist < 15)
{
res += 1 - dist / 15 * 1;
}
}
if (Game.IsSkillsEnabled)
{
// прижиматься за главную башню
var cr = new Point(World.Width - 258, 258);
var cornerMaxDist = 800;
var distToCorner = my.GetDistanceTo(cr);
if (distToCorner < cornerMaxDist)
{
res -= 10 - (distToCorner / cornerMaxDist) * 10;
}
}
// держаться подальше от места появления минионов
var spawnDelta = Game.FactionMinionAppearanceIntervalTicks * 0.33;
var spawnRemains = World.TickIndex % Game.FactionMinionAppearanceIntervalTicks;
if (spawnRemains < spawnDelta)
{
foreach (var pt in MagicConst.MinionAppearencePoints)
{
var dist = pt.GetDistanceTo(my);
var inner = 450;
if (dist < inner)
{
res += 14 - dist / inner * 14;
}
}
}
// двигаться по пути к бонусу
if (NextBonusWaypoint != null)
{
var dist = my.GetDistanceTo(NextBonusWaypoint);
var outer = 100.0;
if (dist < outer)
{
res -= GoToBonusDanger - dist / outer * GoToBonusDanger;
}
}
var nearestRoad = RoadsHelper.Roads.ArgMin(seg => seg.GetDistanceTo(my));
var linePadding = nearestRoad.LaneType == ALaneType.Middle || nearestRoad.LaneType == ALaneType.Middle2 ? 250.0 : 160.0;
// не прижиматься к лесу
if (MagicConst.TreesFreeCircles.All(x => x.GetDistanceTo(my) > x.Radius))
{
var distToLine = nearestRoad.GetDistanceTo(my);
var outerPadding = 500;
if (distToLine > linePadding && distToLine < outerPadding)
{
res += (distToLine - linePadding) / (outerPadding - linePadding) * 10;
}
else if (distToLine >= outerPadding)
{
res += 10;
}
}
{
// прижиматься к центру дорожки
var distToLine = RoadsHelper.Roads.Where(seg => seg.LaneType != ALaneType.Middle2).Min(seg => seg.GetDistanceTo(my));
var outerPadding = 500;
if (distToLine > linePadding && distToLine < outerPadding)
{
res -= 1 - (distToLine - linePadding) / (outerPadding - linePadding) * 1;
}
else if (distToLine <= linePadding)
{
res -= 1;
}
}
// не прижиматься к стене
var distToBorders = Math.Min(Math.Min(my.X, my.Y), Math.Min(Const.MapSize - my.X, Const.MapSize - my.Y));
var bordersPadding = 45;
if (distToBorders < bordersPadding)
{
res += 4 - distToBorders / bordersPadding * 4;
}
// не перекрывать бонус
foreach (var bonus in BonusesObserver.Bonuses)
{
var inner = bonus.Radius + my.Radius;
var dist = my.GetDistanceTo(bonus);
if (dist <= inner && !bonus.Exists && bonus.RemainingAppearanceTicks < 100)
{
res += 30 + 20 - dist / inner * 20;
}
}
// не прижиматься к углам
for (var i = 0; i <= 3; i += 3)
{
var corner = Const.MapCorners[i];
var dist = my.GetDistanceTo(corner);
var outer = 500;
if (dist < outer)
{
res += 7 - dist / outer * 7;
}
}
foreach (var tr in BuildingsDangerTriangles)
{
if (Geom.ContainPoint(tr, my))
{
res += new Segment(tr[0], tr[1]).GetDistanceTo(my) / 100 * 10;
}
}
return(res);
}
