public void DistanceTo_ReturnsValidValue()
{
for (int xt = 0; xt < Constants.MAP_WIDTH; xt++)
{
for (int yt = 0; yt < Constants.MAP_HEIGHT; yt++)
{
for (int x = 0; x < Constants.MAP_WIDTH; x++)
{
for (int y = 0; y < Constants.MAP_HEIGHT; y++)
{
for (int speed = 0; speed <= Constants.MAX_SHIP_SPEED; speed++)
{
for (int orientation = 0; orientation < 6; orientation++)
{
var shipPosition = new ShipPosition(new Coord(x, y), orientation, speed);
var target = new Coord(xt, yt);
var fastShipPosition = FastShipPosition.Create(shipPosition);
FastShipPosition.DistanceTo(fastShipPosition, FastCoord.Create(target)).Should().Be(shipPosition.DistanceTo(target), $"shipPosition: {shipPosition}; target: {target}");
}
}
}
}
}
}
}
protected Entity(int id, EntityType type, int x, int y)
{
this.id = id;
this.type = type;
coord = new Coord(x, y);
fcoord = FastCoord.Create(x, y);
}
public void NearMap_GoOut_ReturnsValidFastCoord(int x, int y, int orientation)
{
var coord = new Coord(x, y);
var fastCoord = FastCoord.Create(coord);
var neighbor = FastCoord.Neighbor(fastCoord, orientation);
neighbor.Should().Be(-1);
}
public void NearMap_GoIn_ReturnsValidFastCoord(int x, int y, int orientation)
{
var coord = new Coord(x, y);
var fastCoord = FastCoord.Create(coord);
var neighbor = FastCoord.Neighbor(fastCoord, orientation);
var actual = FastCoord.ToCoord(neighbor);
actual.Should().Be(coord.Neighbor(orientation));
}
public void DistanceTo_StrangeCase_ReturnsValidValue()
{
//coord: 23, 5, orientation: 0, speed: 0 23, 5
var shipPosition = new ShipPosition(new Coord(23, 5), 0, 0);
var target = new Coord(20, 5);
var fastShipPosition = FastShipPosition.Create(shipPosition);
var fastTarget = FastCoord.Create(target);
FastShipPosition.DistanceTo(fastShipPosition, fastTarget).Should().Be(1000);
}
public void FarFromMap_ReturnsValidFastCoord(int x, int y)
{
var coord = new Coord(x, y);
var fastCoord = FastCoord.Create(coord);
fastCoord.Should().Be(-1);
var actual = FastCoord.ToCoord(fastCoord);
actual.Should().Be(new Coord(-1000, -1000));
}
public void ReturnsValidValue()
{
for (int x = -10; x < Constants.MAP_WIDTH + 10; x++)
{
for (int y = -10; y < Constants.MAP_HEIGHT + 10; y++)
{
var coord = new Coord(x, y);
var fastCoord = FastCoord.Create(coord);
FastCoord.IsInsideMap(fastCoord).Should().Be(coord.IsInsideMap(), coord.ToString());
}
}
}
public void InsideMap_ReturnsValidFastCoord()
{
for (int x = 0; x < Constants.MAP_WIDTH; x++)
{
for (int y = 0; y < Constants.MAP_HEIGHT; y++)
{
var coord = new Coord(x, y);
var fastCoord = FastCoord.Create(coord);
var actual = FastCoord.ToCoord(fastCoord);
actual.Should().Be(coord);
}
}
}
public void InsideMap_ReturnsValidFastCoord(int orientation)
{
for (int x = 0; x < Constants.MAP_WIDTH; x++)
{
for (int y = 0; y < Constants.MAP_HEIGHT; y++)
{
var coord = new Coord(x, y);
var fastCoord = FastCoord.Create(coord);
var neighbor = FastCoord.Neighbor(fastCoord, orientation);
var actual = FastCoord.ToCoord(neighbor);
actual.Should().Be(coord.Neighbor(orientation));
}
}
}
public void NearMap_ReturnsValidFastCoord()
{
for (int x = -1; x < Constants.MAP_WIDTH + 1; x++)
{
{
var coord = new Coord(x, -1);
var fastCoord = FastCoord.Create(coord);
fastCoord.Should().BeGreaterOrEqualTo(0);
var actual = FastCoord.ToCoord(fastCoord);
actual.Should().Be(coord);
}
{
var coord = new Coord(x, Constants.MAP_HEIGHT);
var fastCoord = FastCoord.Create(coord);
fastCoord.Should().BeGreaterOrEqualTo(0);
var actual = FastCoord.ToCoord(fastCoord);
actual.Should().Be(coord);
}
}
for (int y = -1; y < Constants.MAP_HEIGHT + 1; y++)
{
{
var coord = new Coord(-1, y);
var fastCoord = FastCoord.Create(coord);
fastCoord.Should().BeGreaterOrEqualTo(0);
var actual = FastCoord.ToCoord(fastCoord);
actual.Should().Be(coord);
}
{
var coord = new Coord(Constants.MAP_WIDTH, y);
var fastCoord = FastCoord.Create(coord);
fastCoord.Should().BeGreaterOrEqualTo(0);
var actual = FastCoord.ToCoord(fastCoord);
actual.Should().Be(coord);
}
}
}
public static int CalcCost(int startCoord, int endCoord, int enemyCoord)
{
if (FastCoord.Distance(startCoord, endCoord) < FastCoord.Distance(enemyCoord, endCoord))
{
return(0);
}
var startX = FastCoord.GetX(startCoord);
var startY = FastCoord.GetY(startCoord);
var endX = FastCoord.GetX(endCoord);
var endY = FastCoord.GetY(endCoord);
var deltaX = endX - startX;
var deltaY = endY - startY;
var enemyDist = int.MaxValue;
for (int i = 1; i < 10; i++)
{
var x = startX + deltaX * i / 10;
var y = startY + deltaY * i / 10;
var dist = FastCoord.Distance(enemyCoord, FastCoord.Create(x, y));
if (dist < enemyDist)
{
enemyDist = dist;
}
}
if (enemyDist >= costs.Length)
{
return(0);
}
return(costs[enemyDist]);
}
private void RunOrSuicide(TurnState turnState)
{
if (turnState.myShips.Max(s => s.rum) > turnState.enemyShips.Max(s => s.rum) || turnState.myShips.Min(s => s.rum) > 50)
{
foreach (var ship in turnState.myShips)
{
StrategicDecision prevDecision;
strateg.decisions.TryGetValue(ship.id, out prevDecision);
strateg.decisions[ship.id] = strateg.RunAway(turnState, ship, prevDecision);
}
return;
}
if (turnState.myShips.Count == 1)
{
var ship = turnState.myShips[0];
StrategicDecision prevDecision;
strateg.decisions.TryGetValue(ship.id, out prevDecision);
strateg.decisions[ship.id] = strateg.RunAway(turnState, ship, prevDecision);
return;
}
var ship1 = turnState.myShips[0];
var ship2 = turnState.myShips[1];
if (ship1.rum > ship2.rum)
{
var tmp = ship1;
ship1 = ship2;
ship2 = tmp;
}
if (FastCoord.Distance(ship1.fbow, ship2.fbow) <= 4)
{
StrategicDecision prevDecision;
strateg.decisions.TryGetValue(ship1.id, out prevDecision);
if (prevDecision?.role == StrategicRole.Fire || prevDecision?.role == StrategicRole.Explicit)
{
strateg.decisions[ship1.id] = new StrategicDecision {
role = StrategicRole.Explicit, explicitCommand = ShipMoveCommand.Slower
};
strateg.decisions[ship2.id] = new StrategicDecision {
role = StrategicRole.Approach, targetCoord = prevDecision.fireToCoord
};
}
else
{
var nextShip1Position = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship1.fposition, ShipMoveCommand.Wait));
nextShip1Position = FastShipPosition.GetFinalPosition(FastShipPosition.Move(nextShip1Position, ShipMoveCommand.Slower));
strateg.decisions[ship1.id] = new StrategicDecision {
role = StrategicRole.Fire, fireToCoord = FastShipPosition.Coord(nextShip1Position)
};
strateg.decisions[ship2.id] = new StrategicDecision {
role = StrategicRole.Approach, targetCoord = FastShipPosition.Coord(nextShip1Position)
};
}
}
else
{
var x = (FastCoord.GetX(ship1.fcoord) + FastCoord.GetX(ship2.fcoord)) / 2;
var y = (FastCoord.GetY(ship1.fcoord) + FastCoord.GetY(ship2.fcoord)) / 2;
if (x < 5)
{
x = 5;
}
if (x > Constants.MAP_WIDTH - 6)
{
x = Constants.MAP_WIDTH - 6;
}
if (y < 5)
{
y = 5;
}
if (y > Constants.MAP_HEIGHT - 6)
{
x = Constants.MAP_HEIGHT - 6;
}
strateg.decisions[ship1.id] = new StrategicDecision {
role = StrategicRole.Approach, targetCoord = FastCoord.Create(x, y)
};
strateg.decisions[ship2.id] = new StrategicDecision {
role = StrategicRole.Approach, targetCoord = FastCoord.Create(x, y)
};
}
}
public void Test()
{
Console.Out.WriteLine(WayEvaluator.CalcCost(FastCoord.Create(19, 16), FastCoord.Create(13, 5), FastCoord.Create(17, 8)));
Console.Out.WriteLine(WayEvaluator.CalcCost(FastCoord.Create(19, 16), FastCoord.Create(13, 5), FastCoord.Create(16, 8)));
Console.Out.WriteLine(WayEvaluator.CalcCost(FastCoord.Create(19, 16), FastCoord.Create(13, 5), FastCoord.Create(18, 8)));
}
public void MakeStrategicDecisions(TurnState turnState)
{
if (turnState.barrels.Any())
{
strateg.MakeStandardStrategicDecisions(turnState);
return;
}
if (turnState.myShips.Max(s => s.rum) > turnState.enemyShips.Max(s => s.rum) || turnState.myShips.Min(s => s.rum) > 50)
{
foreach (var ship in turnState.myShips)
{
StrategicDecision prevDecision;
strateg.decisions.TryGetValue(ship.id, out prevDecision);
strateg.decisions[ship.id] = strateg.RunAway(turnState, ship, prevDecision);
}
return;
}
if (turnState.myShips.Count == 1)
{
var ship = turnState.myShips[0];
StrategicDecision prevDecision;
strateg.decisions.TryGetValue(ship.id, out prevDecision);
strateg.decisions[ship.id] = strateg.RunAway(turnState, ship, prevDecision);
return;
}
var maxRum = turnState.myShips.Max(s => s.rum);
var minRum = turnState.myShips.Min(s => s.rum);
var ship1 = turnState.myShips.First(s => s.rum == minRum);
var ship2 = turnState.myShips.Last(s => s.rum == maxRum);
var last = turnState.myShips.FirstOrDefault(s => s != ship1 && s != ship2);
if (last != null)
{
StrategicDecision prevDecision;
strateg.decisions.TryGetValue(last.id, out prevDecision);
strateg.decisions[last.id] = strateg.RunAway(turnState, last, prevDecision);
}
if (FastCoord.Distance(ship1.fbow, ship2.fbow) <= 4)
{
StrategicDecision prevDecision;
strateg.decisions.TryGetValue(ship1.id, out prevDecision);
if (prevDecision?.role == StrategicRole.Fire || prevDecision?.role == StrategicRole.Explicit)
{
strateg.decisions[ship1.id] = new StrategicDecision {
role = StrategicRole.Explicit, explicitCommand = ShipMoveCommand.Slower
};
strateg.decisions[ship2.id] = new StrategicDecision {
role = StrategicRole.Approach, targetCoord = prevDecision.fireToCoord
};
}
else
{
var nextShip1Position = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship1.fposition, ShipMoveCommand.Wait));
nextShip1Position = FastShipPosition.GetFinalPosition(FastShipPosition.Move(nextShip1Position, ShipMoveCommand.Slower));
strateg.decisions[ship1.id] = new StrategicDecision {
role = StrategicRole.Fire, fireToCoord = FastShipPosition.Coord(nextShip1Position)
};
strateg.decisions[ship2.id] = new StrategicDecision {
role = StrategicRole.Approach, targetCoord = FastShipPosition.Coord(nextShip1Position)
};
}
}
else
{
var x = (FastCoord.GetX(ship1.fcoord) + FastCoord.GetX(ship2.fcoord)) / 2;
var y = (FastCoord.GetY(ship1.fcoord) + FastCoord.GetY(ship2.fcoord)) / 2;
if (x < 5)
{
x = 5;
}
if (x > Constants.MAP_WIDTH - 6)
{
x = Constants.MAP_WIDTH - 6;
}
if (y < 5)
{
y = 5;
}
if (y > Constants.MAP_HEIGHT - 6)
{
x = Constants.MAP_HEIGHT - 6;
}
strateg.decisions[ship1.id] = new StrategicDecision {
role = StrategicRole.Approach, targetCoord = FastCoord.Create(x, y)
};
strateg.decisions[ship2.id] = new StrategicDecision {
role = StrategicRole.Approach, targetCoord = FastCoord.Create(x, y)
};
}
}
private static void Main22(string[] args)
{
FastCoord.Init();
var coordsX = new List <Coord>();
for (int x = -1; x < Constants.MAP_WIDTH + 1; x++)
{
for (int y = -1; y < Constants.MAP_HEIGHT + 1; y++)
{
var coord = new Coord(x, y);
coordsX.Add(coord);
}
}
var indexes = Enumerable.Range(0, coordsX.Count).ToArray();
var seed = new Random().Next();
Console.Out.WriteLine($"Seed: {seed}");
var random = new Random(seed);
for (int i = 0; i < indexes.Length; i++)
{
var r = random.Next(i, indexes.Length);
var tmp = indexes[r];
indexes[r] = indexes[i];
indexes[i] = tmp;
}
var coords = indexes.Select(i => coordsX[i]).ToArray();
var fastCoords = indexes.Select(i => FastCoord.Create(coords[i])).ToArray();
var ships = coords.Select(c => new ShipPosition(c, random.Next(6), random.Next(3))).ToArray();
var fastShips = ships.Select(FastShipPosition.Create).ToArray();
var stopwatch = Stopwatch.StartNew();
Console.Out.WriteLine("IsInsideMap");
stopwatch.Restart();
int ind = 0;
for (int i = 0; i < 10000000; i++)
{
coords[ind++].IsInsideMap();
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
FastCoord.IsInsideMap(fastCoords[ind++]);
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
Console.Out.WriteLine("DistanceTo");
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
coords[ind++].DistanceTo(coords[0]);
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
FastCoord.Distance(fastCoords[ind++], fastCoords[0]);
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
Console.Out.WriteLine("Neighbor");
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
coords[ind].Neighbor(0);
coords[ind].Neighbor(1);
coords[ind].Neighbor(2);
coords[ind].Neighbor(3);
coords[ind].Neighbor(4);
coords[ind].Neighbor(5);
if (++ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
FastCoord.Neighbor(fastCoords[ind], 0);
FastCoord.Neighbor(fastCoords[ind], 1);
FastCoord.Neighbor(fastCoords[ind], 2);
FastCoord.Neighbor(fastCoords[ind], 3);
FastCoord.Neighbor(fastCoords[ind], 4);
FastCoord.Neighbor(fastCoords[ind], 5);
if (++ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
Console.Out.WriteLine("ShipDistanceTo");
var shipPosition = new ShipPosition(coords[0], 0, 0);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
shipPosition.DistanceTo(coords[ind]);
if (++ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
var fastShipPosition = FastShipPosition.Create(shipPosition);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
FastShipPosition.DistanceTo(fastShipPosition, fastCoords[ind++]);
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
Console.Out.WriteLine("Collides");
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
shipPosition.Collides(coords[ind++]);
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
FastShipPosition.Collides(fastShipPosition, fastCoords[ind++]);
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
Console.Out.WriteLine("CollidesShip");
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
shipPosition.CollidesShip(ships[ind++]);
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 10000000; i++)
{
FastShipPosition.CollidesShip(fastShipPosition, fastShips[ind++]);
if (ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
Console.Out.WriteLine("Move");
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 1_000_000; i++)
{
foreach (var moveCommand in ShipMoveCommands.all)
{
ships[ind].Apply(moveCommand);
}
if (++ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 1_000_000; i++)
{
foreach (var moveCommand in ShipMoveCommands.all)
{
var moved = FastShipPosition.Move(fastShips[ind], moveCommand);
FastShipPosition.GetMovedPosition(moved);
FastShipPosition.GetFinalPosition(moved);
}
if (++ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
stopwatch.Restart();
ind = 0;
for (int i = 0; i < 1_000_000; i++)
{
foreach (var moveCommand in ShipMoveCommands.all)
{
uint myMovement;
uint otherMovement;
CollisionChecker.Move(fastShips[ind], moveCommand, fastShips[(ind + 1) % indexes.Length], moveCommand, out myMovement, out otherMovement);
FastShipPosition.GetMovedPosition(myMovement);
FastShipPosition.GetFinalPosition(myMovement);
}
if (++ind >= indexes.Length)
{
ind = 0;
}
}
stopwatch.Stop();
Console.Out.WriteLine(stopwatch.ElapsedMilliseconds);
}