private bool isRunTire()
{
PCar self = null;
List <PCar> their = new List <PCar>();
List <PCar> enemies = new List <PCar>();
foreach (Car carIter in world.Cars)
{
PCar physicCar = new PCar(carIter, game);
if (carIter.IsTeammate)
{
their.Add(physicCar);
}
else
{
enemies.Add(physicCar);
}
if (carIter.Id == car.Id)
{
self = physicCar;
}
}
return(isRunTire(self, their.ToArray(), enemies.ToArray()));
}
public override List <Tuple <Vector, double> > GetPoints()
{
Tuple <PCar, PCar> hitInfo = hitInformation();
if (null == hitInfo)
{
return(null);
}
PCar self = hitInfo.Item1;
PCar enemy = hitInfo.Item2;
Vector selfPos = new Vector(self.Car.X, self.Car.Y);
Vector enemyPos = new Vector(enemy.Car.X, enemy.Car.Y);
double angle = self.Car.Angle.AngleDeviation((enemy.Pos - selfPos).Angle);
double sign = Math.Sign(angle);
Vector center = selfPos + (enemyPos - selfPos) * 0.5;
Vector dir = new Vector(path[0].DirOut.X, path[0].DirOut.Y);
Vector endPos = center + dir.PerpendicularRight() * sign * car.Height;
return(new List <Tuple <Vector, double> > {
new Tuple <Vector, double>(endPos, car.Height)
});
}
private Tuple <PCar, PCar> hitInformation(PCar self, List <PCar> enemies)
{
//double maxAngle = Math.Atan2(car.Height, car.Width);
double maxAngle = Math.PI / 2.57;//70degrees
self.setEnginePower(1);
MoveToAngleFunction mover = new MoveToAngleFunction(new Vector(path[0].DirOut.X, path[0].DirOut.Y).Angle);
for (int i = 0; i < MaxCheckTicks; i++)
{
foreach (PCar enemy in enemies)
{
Vector distance = enemy.Pos - self.Pos;
double angle = Math.Abs(Math.Acos(distance.Normalize().Dot(self.Dir)));
if (distance.Length < game.CarWidth && angle < maxAngle)
{
return(new Tuple <PCar, PCar>(self, enemy));
}
enemy.Iteration(1);
}
mover.Iteration(self, 1);
}
return(null);
}
public override List <Tuple <Vector, double> > GetPoints()
{
List <Tuple <PCar, PTire> > hitInforamtions = hitInformation();
if (null == hitInforamtions || 0 == hitInforamtions.Count)
{
return(null);
}
List <Tuple <Vector, double> > result = new List <Tuple <Vector, double> >();
foreach (Tuple <PCar, PTire> hitInfo in hitInforamtions)
{
PCar self = hitInfo.Item1;
PTire tire = hitInfo.Item2;
Vector selfPos = new Vector(self.Car.X, self.Car.Y);
Vector tirePos = new Vector(tire.Tire.X, tire.Tire.Y);
double angle = self.Car.Angle.AngleDeviation((tirePos - selfPos).Angle);
double sign = Math.Sign(angle);
Vector center = selfPos + (tire.Pos - selfPos) * 0.5;
Vector dir = new Vector(path[0].DirOut.X, path[0].DirOut.Y);
Vector endPos = center + dir.PerpendicularRight() * sign * car.Height;
result.Add(new Tuple <Vector, double>(endPos, car.Height));
}
return(result);
}
private Bonus findBonus()
{
Vector dir = new Vector(path[0].DirOut.X, path[0].DirOut.Y);
PCar pcar = new PCar(car, game);
if (pcar.Speed.Length < 1)
{
return(null);
}
PCar zeroWheelTurnCar = pcar.GetZeroWheelTurnCar();
Bonus priorityBonus = null;
foreach (Bonus bonus in world.Bonuses)
{
double distance = car.GetDistanceTo(bonus);
if (distance > game.TrackTileSize * 3.0)
{
continue;
}
Vector bonusPos = new Vector(bonus.X, bonus.Y);
if ((bonusPos - pcar.Pos).Dot(dir) < 0)//back
{
continue;
}
if (!isNextTile(new TilePos(bonus.X, bonus.Y)))
{
continue;
}
if (Constant.BonusPriority(bonus, car, false) < 0)
{
continue;
}
double newBonusPriority = Constant.BonusPriority(bonus, car, true);
if (null == priorityBonus || Constant.BonusPriority(priorityBonus, car, true) < newBonusPriority)
{
priorityBonus = bonus;
}
}
return(priorityBonus);
}
private bool tireCollisionWithCar(Vector tirePos, PCar car, out Vector normal, double multR = 1)
{
CollisionCircle collisionTire = new CollisionCircle(tirePos, game.TireRadius * multR);
CollisionRect collisionCar = new CollisionRect(car);
CollisionInfo collision = new CollisionInfo(collisionTire, collisionCar);
if (CollisionDetector.CheckCollision(collision))
{
normal = collision.NormalObj1;
return(true);
}
normal = null;
return(false);
}
private Tuple <PCar, PCar> hitInformation()
{
PCar self = new PCar(car, game);
List <PCar> enemies = new List <PCar>();
foreach (Car iter in world.Cars)
{
Vector distance = new Vector(iter.X, iter.Y) - self.Pos;
if (iter.Id != car.Id && distance.Dot(self.Dir) > 0 && !iter.IsFinishedTrack)
{
enemies.Add(new PCar(iter, game));
}
}
return(hitInformation(self, enemies));
}
private bool isEnemyOnWasherLine(Car enemy, ref int tick)
{
Vector washerPos = new Vector(car.X, car.Y);
Vector washerDir = Vector.sincos(car.Angle);
Vector washerSpd = washerDir * game.WasherInitialSpeed;
if ((new Vector(enemy.X, enemy.Y) - washerPos).Dot(washerDir) < 0)//back car
{
return(false);
}
PCar physicCar = new PCar(enemy, game);
double radius = Math.Min(car.Width, car.Height) * 0.25 + game.WasherRadius;
double maxDistance = Math.Max(car.Width, car.Height) / Math.Sin(game.SideWasherAngle);
int maxTicks = (int)(maxDistance / game.WasherInitialSpeed);
//for one 30 for two 15 other 0.
int ticks = maxTicks - 15 * Math.Max(0, 3 - car.RemainingProjectileCooldownTicks);
ticks = Math.Max((int)(1.5 * game.TrackTileSize / game.WasherInitialSpeed), ticks);
for (int i = 0; i < ticks; i++)
{
physicCar.Iteration(1);
washerPos = washerPos + washerSpd;
double distanceByDir = (physicCar.Pos - washerPos).Dot(washerDir);
double fullDistance = physicCar.Pos.GetDistanceTo(washerPos);
if (distanceByDir < 0 /*over flight*/ && fullDistance > -distanceByDir /*save sqrt*/)
{
double distance = Math.Sqrt(Math.Pow(fullDistance, 2) - Math.Pow(distanceByDir, 2));
if (distance < radius)
{
tick = i;
return(true);
}
return(false);
}
}
return(false);
}
private List <Tuple <PCar, PTire> > hitInformation()
{
List <Tuple <PCar, PTire> > result = new List <Tuple <PCar, PTire> >();
foreach (Projectile iter in world.Projectiles)
{
if (iter.Type == ProjectileType.Tire)
{
PCar self = new PCar(car, game);
PTire tire = new PTire(iter, game);
if (checkHit(self, tire))
{
result.Add(new Tuple <PCar, PTire>(self, tire));
}
}
}
return(result);
}
private bool checkHit(PCar self, PTire tire)
{
double selfRadius = 0.5 * Math.Sqrt(game.CarWidth * game.CarWidth + game.CarHeight * game.CarHeight);
double checkRadius = selfRadius + game.TireRadius;
self.setEnginePower(1);
MoveToAngleFunction mover = new MoveToAngleFunction(new Vector(path[0].DirOut.X, path[0].DirOut.Y).Angle);
for (int i = 0; i < MaxCheckTicks; i++)
{
Vector lastDistance = tire.LastPos - self.LastPos;
Vector distance = tire.Pos - self.Pos;
if (lastDistance.Length > checkRadius && distance.Length < checkRadius)
{
return(true);
}
tire.Iteration(1);
mover.Iteration(self, 1);
}
return(false);
}
public override List <Tuple <Vector, double> > GetPoints()
{
if (car.Durability < 0.25)
{
return(null);
}
Tuple <PCar, PCar> hitInfo = hitInformation();
if (null == hitInfo)
{
return(null);
}
PCar self = hitInfo.Item1;
PCar enemy = hitInfo.Item2;
Vector distance = self.Pos - enemy.Pos;
Vector endPos = enemy.Pos + enemy.Dir * distance.Length;
return(new List <Tuple <Vector, double> > {
new Tuple <Vector, double>(endPos, car.Height * 0.5)
});
}
private bool isRunTire(PCar self, PCar[] their, PCar[] enemies)
{
Logger.instance.Assert(null != self, "Self car is null.");
PCar ignored = self;
PTire tire = new PTire(self.Pos, self.Dir * game.TireInitialSpeed, game);
int tireRebound = maxTireRebound;
for (int i = 0; i < tireCalculateTicks; i++)
{
tire.Iteration(1);
foreach (PCar physicCar in their)
{
physicCar.Iteration(1);
Vector collisionNormal = null;
if (tireCollisionWithCar(tire.Pos, physicCar, out collisionNormal, 2))
{
if (ignored == physicCar)
{
continue;
}
return(false);
}
}
foreach (PCar physicCar in enemies)
{
physicCar.Iteration(1);
Vector collisionNormal = null;
if (tireCollisionWithCar(tire.Pos, physicCar, out collisionNormal, 0.25))
{
if (null == collisionNormal)
{
return(false);
}
double angleDot = Math.Abs(tire.Speed.Normalize().Dot(collisionNormal));
double angleCross = Math.Abs(tire.Speed.Normalize().Cross(collisionNormal));
bool correctFireAngle = (Math.Abs(tire.Speed.Dot(physicCar.Speed)) > 70 && angleDot > 0.5) ||
(Math.Abs(tire.Speed.Cross(physicCar.Speed)) > 70 && angleCross > 0.5);
return(correctFireAngle && physicCar.Car.Durability > 1.0e-9 && !physicCar.Car.IsFinishedTrack);
}
}
Vector collisionNormalWithMap = tireCollisionWithMap(tire.Pos, tire.LastPos);
if (null != collisionNormalWithMap)
{
ignored = null;
tire.HitTireWitMap(collisionNormalWithMap);
tireRebound--;
}
if (!tire.Valid() || tireRebound < 0)
{
return(false);
}
}
return(false);
}
