public static bool ModelMove(ACar car, AMove m, PassedInfo total,
ABonus[] bonusCandidates, AOilSlick[] slickCandidates, AProjectile[][] projCandidates, ACar[][] carCandidates)
{
double prevStateX = 0, prevStateY = 0, prevStateAngle = 0;
if (m.RangesMode)
{
prevStateX = car.X;
prevStateY = car.Y;
prevStateAngle = car.Angle;
}
var turn = m.WheelTurn is Point?MyStrategy.TurnRound(car.GetAngleTo(m.WheelTurn as Point)) : Convert.ToDouble(m.WheelTurn);
var isBreak = m.IsBrake;
// если сдаю назад но кочусь вперед
if (m.EnginePower < 0 && car.EnginePower > 0)
{
isBreak = true;
}
// если еду вперед но кочусь назад
else if (car.EnginePower < 0 && m.EnginePower > 0)
{
turn *= -1;
isBreak = true;
}
var simpleMode = total.Time > 41;
var checking = !simpleMode || (MyStrategy.world.Tick + total.Time) % 4 == 0;
car.Move(m.EnginePower, turn, isBreak, m.IsUseNitro, simpleMode);
if (checking)
{
for (var i = 0; i < bonusCandidates.Length; i++)
{
if (total.Bonuses[i]) // бонус уже взят
{
continue;
}
var bonus = bonusCandidates[i];
if (car.TakeBonus(bonus))
{
total.Importance += bonus.GetImportance(car.Original) * MagicConst.BonusImportanceCoeff;
total.Bonuses[i] = true;
}
}
if (!total.Slicks) // если не въехал ни в одну лужу
{
foreach (var slick in slickCandidates)
{
if (total.Slicks)
{
break;
}
slick.RemainingLifetime -= total.Time;
if (slick.Intersect(car, 9))
{
total.Importance -= slick.GetDanger() * MagicConst.OilSlickDangerCoeff *
(car.RemainingNitroTicks > 0 ? 2 : 1);
total.Slicks = true;
}
slick.RemainingLifetime += total.Time;
}
}
if (projCandidates.Length > 0 && total.Time < projCandidates[0].Length)
{
for (var i = 0; i < projCandidates.Length; i++)
{
if (total.Projectiles[i])
{
continue;
}
var proj = projCandidates[i][total.Time];
if (proj.Intersect(car, 5))
{
total.Importance -= proj.GetDanger() * MagicConst.TireDangerCoeff;
total.Projectiles[i] = true;
}
}
}
if (!total.Cars)
{
for (var i = 0; i < carCandidates.Length; i++)
{
if (total.Time >= carCandidates[i].Length)
{
continue;
}
var opp = carCandidates[i][total.Time];
if (car.IntersectWith(opp, opp.Original.IsTeammate ? 20 : 0))
{
if ((car.Speed.Length > 8 || car.Original.IsTeammate) && MyStrategy.world.Tick > 400)
{
// чтобы не боялся протаранить на маленькой скорости
total.Importance -= car.RemainingNitroTicks > 0
? MagicConst.InactiveCarNitroDangerCoeff
: MagicConst.InactiveCarDangerCoeff;
}
total.Cars = true;
break;
}
}
}
}
total.Time++;
var res = true;
if (checking)
{
// проверка на стены
res = car.GetRectEx().All(p => !MyStrategy.IntersectTail(p, m.SafeMargin));
// проверка что можно проехать точно возле стены
if (!res && car.RemainingNitroTicks == 0 && m.ExactlyMargin < m.SafeMargin &&
car.GetRectEx().All(p => !MyStrategy.IntersectTail(p, m.ExactlyMargin)))
{
if (!total.ExactlyBorder)
{
total.Importance -= MagicConst.ExactlyBorderDangerCoeff;
}
total.ExactlyBorder = true;
res = true;
}
// проверка что можно проскользнуть по стене
if (!m.RangesMode && !res && car.RemainingNitroTicks == 0 && m.ExtraMargin < m.ExactlyMargin &&
car.GetRectEx().All(p => !MyStrategy.IntersectTail(p, total.Time < 20 ? -2 : m.ExtraMargin)))
{
if (!total.OutOfBoreder)
{
total.Importance -= MagicConst.OutOfBorederDangerCoeff;
total.OutOfBoreder = true;
}
res = true;
}
if (!total.WayPoint)
{
total.WayPoint = MyStrategy.GetNextWayPoint(car.Original).Equals(MyStrategy.GetCell(car));
}
if (!res && m.RangesMode)
{
res = true;
// HACK
car.X = prevStateX;
car.Y = prevStateY;
car.Angle = prevStateAngle;
car.Speed = Point.Zero;
car.AngularSpeed = 0;
}
}
return(res);
}
public Moves Do(ACar car, Points pts)
{
// Проверка что данный путь был выбран
if (_selectThisTick + 1 != MyStrategy.world.Tick)
{
_lastSuccessStack = null;
}
Self = car.Clone();
if (_lastCall == LastSuccess)
{
LastSuccess = _lastCall;
}
for (var t = 0; t < MyStrategy.world.Tick - _lastCall && _lastSuccessStack != null && _lastSuccessStack.Count > 0; t++)
{
_lastSuccessStack[0].Times--;
_lastSuccessStack.Normalize();
}
if (_lastSuccessStack != null && (_lastSuccessStack.Count == 0 || _useDist2 && _lastSuccessStack.ComputeTime() < 30))
{
_lastSuccessStack = null;
}
_lastCall = MyStrategy.world.Tick;
/*
* Количество бонусов на расстоянии 0.5t
* Если изменилось - пересчитывать сильно
*/
var bonusesCount05 = MyStrategy.Bonuses
.Count(bonus => Self.GetDistanceTo(bonus) < Const.TileSize / 2);
/*
* Количество бонусов на расстоянии 2t
* Если изменилось - чуть нужно пересчитать
*/
var bonusesCount2 = MyStrategy.Bonuses
.Count(
bonus =>
Self.GetDistanceTo(bonus) < Const.TileSize * 2 &&
MyStrategy.CellDistance(Self, bonus) <= 2);
// Если был success на прошлом тике, то продолжаем. Или каждые _interval тиков.
if (Const.Game.InitialFreezeDurationTicks < MyStrategy.world.Tick &&
bonusesCount05 == _bonusesCount05 &&
LastSuccess < MyStrategy.world.Tick - 1 &&
(MyStrategy.world.Tick - (LastSuccess + 1)) % _interval != 0)
{
_validateLastSuccessStack();
return(_lastSuccessStack);
}
/*
* Смотрим на шины, которые на расстоянии не более 6 тайлов
*/
var prevProj = _projCandidates;
_projCandidates = MyStrategy.Tires
.Where(
proj =>
Self.GetDistanceTo(proj[0]) <= Const.TileSize * 6 &&
MyStrategy.CellDistance(Self, proj[0]) <= 6)
.ToArray();
var extended = MyStrategy.ExtendWaySegments(pts, 50);
_bruteWayPoints = extended.GetRange(0, Math.Min(_waypointsCount, extended.Count)).ToArray();
if (LastStageMove.IsUseNitro && _turnsCount(_bruteWayPoints) > 1)
{
return(null);
}
#if DEBUG
var bruteWayPoints = new Points();
bruteWayPoints.AddRange(_bruteWayPoints);
Visualizer.SegmentsDrawQueue.Add(new object[] { Brushes.Brown, bruteWayPoints, 0.0 });
#endif
_needDist = Const.TileSize * 0.5 - 3;
_needDist2 = Const.TileSize - 3;
_turnTo = _bruteWayPoints[_bruteWayPoints.Length - 1];
_turnTo2 = _bruteWayPoints[Math.Min(_bruteWayPoints.Length - 1, (int)(_bruteWayPoints.Length * 0.83))];
#if DEBUG
Visualizer.CircleFillQueue.Add(new Tuple <Brush, ACircularUnit>(Brushes.OrangeRed, new ACircularUnit {
X = _turnTo.X, Y = _turnTo.Y, Radius = 20
}));
Visualizer.CircleFillQueue.Add(new Tuple <Brush, ACircularUnit>(Brushes.Orange, new ACircularUnit {
X = _turnTo2.X, Y = _turnTo2.Y, Radius = 20
}));
#endif
_patterns = Patterns.Select(pt => new PathPattern
{
From = pt.From,
To = pt.To,
Step = pt.Step,
Move = pt.Move.Clone()
}).ToArray();
foreach (var p in _patterns)
{
if (p.Move.WheelTurn is TurnPattern)
{
var turnPattern = p.Move.WheelTurn as TurnPattern;
if (turnPattern.Pattern == TurnPatternType.ToNext)
{
p.Move.WheelTurn = Self.GetAngleTo(_turnTo) < 0 ? -1 : 1;
}
else if (turnPattern.Pattern == TurnPatternType.FromNext)
{
p.Move.WheelTurn = Self.GetAngleTo(_turnTo) < 0 ? 1 : -1;
}
}
}
_movesStack = new Moves();
_bestMovesStack = new Moves();
_bestTime = MyStrategy.Infinity;
_bestImportance = 0;
/*
* Смотрим на бонусы, которые на расстоянии не более 4t
* TODO: уменьшить приоритет бонусов, которые может быть возьмет другой (в.т.ч тиммейт)
*/
_bonusCandidates = MyStrategy.Bonuses
.Where(
bonus =>
MyStrategy.world.Tick > 270 && // Не смотреть на бонусы при старте!!!
Self.GetDistanceTo(bonus) <= Const.TileSize * 4 &&
MyStrategy.CellDistance(Self, bonus) <= 4
)
.ToArray();
/*
* Смотрим на лужи, которые на расстоянии не более 5 тайлов
*/
var prevSlicks = _slickCandidates;
_slickCandidates = MyStrategy.OilSlicks
.Where(
slick =>
Self.GetDistanceTo(slick) <= Const.TileSize * 5 &&
MyStrategy.CellDistance(Self, slick) <= 5
)
.ToArray();
/*
* Пытаться объехать тех, которые
* - Крашнулись
* - Убиты
* - Двигатель меньше чем на 0.5 мощности
* - Двигаются по встречной
*
* - Если у меня нитро, или будет нитро
*
* - Своих
*/
var prevCars = _carCandidates;
_carCandidates = MyStrategy.Others
.Where(opp => opp[0].GetDistanceTo(Self) < Const.TileSize * 9)
.Where(
opp =>
opp[0].Original.IsTeammate ||
MyStrategy.IsCrashed(opp[0].Original) ||
!DurabilityObserver.IsActive(opp[0].Original) ||
opp[0].EnginePower < 0.5 ||
Self.RemainingNitroTicks > 0 ||
Math.Abs(Geom.GetAngleBetween(Self.Speed, opp[0].Speed)) > Math.PI / 2
)
.Where(opp => MyStrategy.CellDistance(Self, opp[0]) <= 9) // 9 - потому что он может ехать по встречке
.ToArray();
if (_cache != null)
{
for (var k = 0; k < _patterns.Length; k++)
{
var range = (prevSlicks == null || prevCars == null || prevProj == null ||
_bonusesCount2 != bonusesCount2 ||
prevSlicks.Length != _slickCandidates.Length ||
prevCars.Length != _carCandidates.Length ||
prevProj.Length != _projCandidates.Length)
? (k == 0 ? 6 : 4)
: (k == 0 ? 6 : 2);
if (_bonusesCount05 != bonusesCount05 || Special && k == 0)
{
range = 10;
}
_patterns[k].From = Math.Max(0, _cache[k].Times - range);
_patterns[k].To = Math.Min(_patterns[k].To * 9 / 7, _cache[k].Times + range);
_patterns[k].Step = 2;
}
}
_bonusesCount05 = bonusesCount05;
_bonusesCount2 = bonusesCount2;
var wayPointRequired = false;
for (var i = _bruteWayPoints.Length - 1; i >= 0; i--)
{
if (_bruteWayPoints[i].GetDistanceTo2(_turnTo) < _needDist * _needDist)
{
for (var j = 0; j < i; j++)
{
wayPointRequired |=
MyStrategy.GetNextWayPoint(Self.Original).Equals(MyStrategy.GetCell(_bruteWayPoints[j]));
}
break;
}
}
_doRecursive(Self, 0, new PassedInfo {
WayPoint = !wayPointRequired
});
_cache = null;
if (_bestTime == MyStrategy.Infinity)
{
return(_lastSuccessStack);
}
if (_bestMovesStack.ComputeTime() != _bestTime)
{
throw new Exception("ComputeTime != BestTime");
}
LastSuccess = MyStrategy.world.Tick;
_cache = _bestMovesStack.Clone();
if (_maxTicksInfo == null)
{
_maxTicksInfo = new int[_bestMovesStack.Count];
}
for (var i = 0; i < _maxTicksInfo.Length; i++)
{
_maxTicksInfo[i] = Math.Max(_maxTicksInfo[i], _bestMovesStack[i].Times);
}
_bestMovesStack.Normalize();
_lastSuccessStack = _bestMovesStack.Clone();
return(_bestMovesStack);
}
public void Move()
{
if (!Exists)
{
return;
}
if (Type == ProjectileType.Washer)
{
X += Speed.X;
Y += Speed.Y;
if (X < 0 || Y < 0 || X > Const.MapWidth || Y > Const.MapHeight)
{
Exists = false;
}
return;
}
var reflected = false;
for (int it = 0; it < UpdateIterations; it++)
{
X += Speed.X / UpdateIterations;
Y += Speed.Y / UpdateIterations;
// может выйти за пределы если тайлы unknown
if (X < 1 || Y < 1 || X >= Const.MapWidth - 1 || Y >= Const.MapHeight - 1)
{
Exists = false;
break;
}
if (reflected)
{
continue;
}
var currentCell = MyStrategy.GetCell(this);
foreach (var part in MyStrategy.MyTiles[currentCell.I, currentCell.J].Parts)
{
Point e = null, n = null;
// e - направление стены
// n - нормаль от стены
double en = 0, et = 0, d = 0, d1 = 0, d2 = 0;
if (part.Type == TilePartType.Segment)
{
var pts = Geom.LineCircleIntersect(part.Start, part.End, this, this.Radius);
if (pts.Length == 0)
{
continue;
}
e = (part.End - part.Start).Normalized();
n = ~e * -1;
}
else
{
if (GetDistanceTo2(part.Circle) <= Geom.Sqr(Radius + part.Circle.Radius))
{
n = (this - part.Circle).Normalized();
e = ~n;
}
}
if (e == null || n == null)
{
continue;
}
en = Speed * n; // норм.
et = Speed * e; // танг.
en *= -0.5;
d = n.X * e.Y - n.Y * e.X;
d1 = n.X * et - en * e.X;
d2 = en * e.Y - n.Y * et;
Speed.X = d2 / d;
Speed.Y = d1 / d;
reflected = true;
break;
}
}
if (Speed.Length <= Const.Game.TireDisappearSpeedFactor * Const.Game.TireInitialSpeed)
{
Exists = false;
}
}
