public StrategicDecision RunAway_FreeWay(TurnState turnState, Ship ship, StrategicDecision prevDecision) { var finalCoords = new List <int>(); foreach (var enemyShip in turnState.enemyShips) { var move = FastShipPosition.Move(enemyShip.fposition, ShipMoveCommand.Faster); move = FastShipPosition.Move(FastShipPosition.GetFinalPosition(move), ShipMoveCommand.Faster); move = FastShipPosition.Move(FastShipPosition.GetFinalPosition(move), ShipMoveCommand.Faster); var finalCoord = FastShipPosition.Coord(FastShipPosition.GetFinalPosition(move)); finalCoords.Add(finalCoord); } var candidates = runTargets.OrderByDescending(t => (int)finalCoords.Average(fc => FastCoord.Distance(t, fc) * FastCoord.Distance(t, fc))).Take(3).ToArray(); var runTarget = candidates.OrderBy( t => { var cost = 0; foreach (var enemyShip in turnState.enemyShips) { cost += WayEvaluator.CalcCost(ship.fcoord, t, enemyShip.fcoord); } return(cost); }).First(); return(new StrategicDecision { role = StrategicRole.RunAway, targetCoord = runTarget }); }
public CollectableBarrel FindNearestBarrelToCollect(TurnState turnState, Ship ship, HashSet <int> used = null) { var barrelsHitTurns = new Dictionary <int, int>(); foreach (var barrel in turnState.barrels) { foreach (var cannonball in turnState.cannonballs) { if (cannonball.fcoord == barrel.fcoord) { int prevTurns; if (!barrelsHitTurns.TryGetValue(barrel.id, out prevTurns) || prevTurns > cannonball.turns) { barrelsHitTurns[barrel.id] = cannonball.turns; } } } } var nextShipPosition1 = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship.fposition, ShipMoveCommand.Faster)); var nextShipPosition2 = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship.fposition, ShipMoveCommand.Wait)); var bestDist = int.MaxValue; Barrel bestBarrel = null; foreach (var barrel in turnState.barrels) { if (used == null || !used.Contains(barrel.id)) { var dist = FastShipPosition.DistanceTo(nextShipPosition1, barrel.fcoord); if (dist < bestDist) { var enemyTravelTime = dist / 2 + 1; int hitTurns; if (barrelsHitTurns.TryGetValue(barrel.id, out hitTurns) && hitTurns <= enemyTravelTime) { continue; } bestBarrel = barrel; bestDist = dist; } dist = FastShipPosition.DistanceTo(nextShipPosition2, barrel.fcoord); if (dist < bestDist) { var enemyTravelTime = dist / 2 + 1; int hitTurns; if (barrelsHitTurns.TryGetValue(barrel.id, out hitTurns) && hitTurns <= enemyTravelTime) { continue; } bestBarrel = barrel; bestDist = dist; } } } return(bestBarrel == null ? null : new CollectableBarrel { barrel = bestBarrel, dist = bestDist }); }
public void ApplyPath(Ship ship, List <PathItem> path) { var index = ship.index; var movedShip = ship.fposition; for (var i = 0; i < path.Count; i++) { var pathItem = path[i]; GetTurnForecast(i).myShipsSourcePositions[index] = pathItem.sourcePosition; GetTurnForecast(i).myShipsPositions[index] = pathItem.targetPosition; GetTurnForecast(i).myShipsMoveCommands[index] = pathItem.command; movedShip = pathItem.targetPosition; } for (var i = path.Count; i < Settings.NAVIGATION_PATH_DEPTH; i++) { movedShip = FastShipPosition.GetFinalPosition(FastShipPosition.Move(movedShip, ShipMoveCommand.Wait)); GetTurnForecast(i).myShipsPositions[index] = movedShip; } }
public StrategicDecision MakeStrategicDecision(TurnState turnState, StrategicDecision prevDecision, Ship ship, Ship enemyShip) { var barrels = CollectableBarrels(turnState, enemyShip); var nextShipPosition1 = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship.fposition, ShipMoveCommand.Faster)); var nextShipPosition2 = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship.fposition, ShipMoveCommand.Wait)); var target = barrels.FirstOrDefault( b => FastShipPosition.DistanceTo(nextShipPosition1, b.barrel.fcoord) < b.dist - 1 || FastShipPosition.DistanceTo(nextShipPosition2, b.barrel.fcoord) < b.dist - 1); if (target == null) { return(strateg.RunAway(turnState, ship, prevDecision)); } var barrelToFire = barrels.TakeWhile(b => b != target).LastOrDefault(); return(strateg.Collect(target.barrel).FireTo(barrelToFire?.barrel.fcoord)); }
private void BuildMyShipsForecast(TurnState turnState) { var prevPositions = new int[turnState.myShips.Count]; for (var i = 0; i < turnState.myShips.Count; i++) { prevPositions[i] = turnState.myShips[i].fposition; } for (int depth = 0; depth < Settings.NAVIGATION_PATH_DEPTH; depth++) { turnForecasts[depth].myShipsSourcePositions = prevPositions; var commands = new ShipMoveCommand[prevPositions.Length]; turnForecasts[depth].myShipsMoveCommands = commands; var nextPositions = new int[prevPositions.Length]; for (var i = 0; i < prevPositions.Length; i++) { var position = prevPositions[i]; var movement = FastShipPosition.Move(position, ShipMoveCommand.Wait); nextPositions[i] = FastShipPosition.GetFinalPosition(movement); } prevPositions = turnForecasts[depth].myShipsPositions = nextPositions; } }
private void BuildEnemyShipsForecast(TurnState turnState) { var prevPositions = new int[turnState.enemyShips.Count]; for (var i = 0; i < turnState.enemyShips.Count; i++) { prevPositions[i] = turnState.enemyShips[i].fposition; } for (var depth = 0; depth < Settings.NAVIGATION_PATH_DEPTH; depth++) { var nextMovedPositions = new int[prevPositions.Length]; var nextFinalPositions = new int[prevPositions.Length]; for (var i = 0; i < prevPositions.Length; i++) { var position = prevPositions[i]; var movement = FastShipPosition.Move(position, ShipMoveCommand.Wait); nextMovedPositions[i] = FastShipPosition.GetMovedPosition(movement); nextFinalPositions[i] = FastShipPosition.GetFinalPosition(movement); } turnForecasts[depth].enemyShipsMovedPositions = nextMovedPositions; prevPositions = turnForecasts[depth].enemyShipsFinalPositions = nextFinalPositions; } }
public void CollectEnemyBarrels(TurnState turnState, Ship enemyShip1, Ship enemyShip2) { var barrels1 = strateg.strategy1vs1.CollectableBarrels(turnState, enemyShip1); var barrels2 = strateg.strategy1vs1.CollectableBarrels(turnState, enemyShip2); var ship1 = turnState.myShips[0]; var ship2 = turnState.myShips[1]; var nextShip1Position1 = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship1.fposition, ShipMoveCommand.Faster)); var nextShip1Position2 = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship1.fposition, ShipMoveCommand.Wait)); var nextShip2Position1 = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship2.fposition, ShipMoveCommand.Faster)); var nextShip2Position2 = FastShipPosition.GetFinalPosition(FastShipPosition.Move(ship2.fposition, ShipMoveCommand.Wait)); var target1 = barrels1.FirstOrDefault( b => FastShipPosition.DistanceTo(nextShip1Position1, b.barrel.fcoord) < b.dist - 1 || FastShipPosition.DistanceTo(nextShip1Position2, b.barrel.fcoord) < b.dist - 1); var target2 = barrels2.FirstOrDefault( b => FastShipPosition.DistanceTo(nextShip2Position1, b.barrel.fcoord) < b.dist - 1 || FastShipPosition.DistanceTo(nextShip2Position2, b.barrel.fcoord) < b.dist - 1); while (true) { if (target1 == null) { StrategicDecision decision; strateg.decisions.TryGetValue(ship1.id, out decision); strateg.decisions[ship1.id] = strateg.RunAway(turnState, ship1, decision); } if (target2 == null) { StrategicDecision decision; strateg.decisions.TryGetValue(ship2.id, out decision); strateg.decisions[ship2.id] = strateg.RunAway(turnState, ship2, decision); } if (target1 == null && target2 == null) { return; } if (target1 != null && target2 == null) { var barrelToFire = barrels1.TakeWhile(b => b != target1).LastOrDefault(); strateg.decisions[ship1.id] = strateg.Collect(target1.barrel).FireTo(barrelToFire?.barrel.fcoord); return; } if (target2 != null && target1 == null) { var barrelToFire = barrels2.TakeWhile(b => b != target2).LastOrDefault(); strateg.decisions[ship2.id] = strateg.Collect(target2.barrel).FireTo(barrelToFire?.barrel.fcoord); return; } if (target1.barrel != target2.barrel) { var barrelToFire1 = barrels1.TakeWhile(b => b.barrel != target1.barrel && b.barrel != target2.barrel).LastOrDefault(); strateg.decisions[ship1.id] = strateg.Collect(target1.barrel).FireTo(barrelToFire1?.barrel.fcoord); var barrelToFire2 = barrels2.TakeWhile(b => b.barrel != target1.barrel && b.barrel != target2.barrel && b.barrel != barrelToFire1?.barrel).LastOrDefault(); strateg.decisions[ship2.id] = strateg.Collect(target2.barrel).FireTo(barrelToFire2?.barrel.fcoord); return; } var dist1 = Math.Min(FastShipPosition.DistanceTo(nextShip1Position1, target1.barrel.fcoord), FastShipPosition.DistanceTo(nextShip1Position2, target1.barrel.fcoord)); var dist2 = Math.Min(FastShipPosition.DistanceTo(nextShip2Position1, target1.barrel.fcoord), FastShipPosition.DistanceTo(nextShip2Position2, target1.barrel.fcoord)); if (dist1 < dist2) { target2 = barrels2.FirstOrDefault( b => b.barrel != target1.barrel && (FastShipPosition.DistanceTo(nextShip2Position1, b.barrel.fcoord) < b.dist - 1 || FastShipPosition.DistanceTo(nextShip2Position2, b.barrel.fcoord) < b.dist - 1)); } else { target1 = barrels1.FirstOrDefault( b => b.barrel != target2.barrel && (FastShipPosition.DistanceTo(nextShip1Position1, b.barrel.fcoord) < b.dist - 1 || FastShipPosition.DistanceTo(nextShip1Position2, b.barrel.fcoord) < b.dist - 1)); } } }
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) }; } }
private CollisionType GetCollisionType(int my, ShipMoveCommand myc, int other, ShipMoveCommand oc) { uint myMovement; uint otherMovement; var collisionType = CollisionChecker.Move(my, myc, other, oc, out myMovement, out otherMovement); Console.Out.WriteLine(FastShipPosition.ToShipPosition(FastShipPosition.GetMovedPosition(myMovement)) + " - " + FastShipPosition.ToShipPosition(FastShipPosition.GetFinalPosition(myMovement))); Console.Out.WriteLine(FastShipPosition.ToShipPosition(FastShipPosition.GetMovedPosition(otherMovement)) + " - " + FastShipPosition.ToShipPosition(FastShipPosition.GetFinalPosition(otherMovement))); return(collisionType); }
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); }
public List <PathItem> FindPath(TurnState turnState, int ftarget, NavigationMethod navigationMethod) { var ship = turnState.FindMyShip(shipId); //if (FastShipPosition.Collides(ship.fposition, ftarget)) // return new List<PathItem>(); var queue = new Queue <ShipPathChainItem>(); queue.Enqueue(ShipPathChainItem.Start(ship.fposition, ftarget)); var used = new Dictionary <ShipMovementState, ShipPathChainItem>(); while (queue.Any()) { var current = queue.Dequeue(); if (current.depth != Settings.NAVIGATION_PATH_DEPTH) { var turnForecast = gameState.forecaster.GetTurnForecast(current.depth); foreach (var moveCommand in ShipMoveCommands.all) { var newShipMovement = FastShipPosition.Move(current.fposition, moveCommand); var newMovedPos = FastShipPosition.GetMovedPosition(newShipMovement); var newPos = FastShipPosition.GetFinalPosition(newShipMovement); var newMovementState = new ShipMovementState(newPos, current.depth + 1); if (!used.ContainsKey(newMovementState)) { var onMyShip = false; foreach (var otherShip in turnState.myShips) { if (otherShip == ship) { continue; } var otherPosition = turnForecast.myShipsSourcePositions[otherShip.index]; uint myMovement; uint otherMovement; var collisionType = CollisionChecker.Move(current.fposition, moveCommand, otherPosition, turnForecast.myShipsMoveCommands[otherShip.index], out myMovement, out otherMovement); if ((collisionType & (CollisionType.MyMove | CollisionType.MyRotation)) != CollisionType.None) { newShipMovement = myMovement; newMovedPos = FastShipPosition.GetMovedPosition(newShipMovement); newPos = FastShipPosition.GetFinalPosition(newShipMovement); newMovementState = new ShipMovementState(newPos, current.depth + 1); onMyShip = used.ContainsKey(newMovementState); break; } } if (onMyShip) { continue; } var onEnemyShip = false; if (current.depth == 0) { foreach (var enemyShip in turnState.enemyShips) { var enemyPosition = enemyShip.fposition; foreach (var enemyMoveCommand in ShipMoveCommands.all) { uint myMovement; uint enemyMovement; var collisionType = CollisionChecker.Move(current.fposition, moveCommand, enemyPosition, enemyMoveCommand, out myMovement, out enemyMovement); if ((collisionType & (CollisionType.MyMove | CollisionType.MyRotation)) != CollisionType.None) { newShipMovement = myMovement; newMovedPos = FastShipPosition.GetMovedPosition(newShipMovement); newPos = FastShipPosition.GetFinalPosition(newShipMovement); newMovementState = new ShipMovementState(newPos, current.depth + 1); onEnemyShip = used.ContainsKey(newMovementState); break; } } } } else { var prevEnemyFinalPositions = gameState.forecaster.GetTurnForecast(Math.Min(current.depth - 1, Settings.NAVIGATOR_ENEMY_POSITION_DEPTH)).enemyShipsFinalPositions; foreach (var enemyPosition in prevEnemyFinalPositions) { uint myMovement; uint enemyMovement; var collisionType = CollisionChecker.Move(current.fposition, moveCommand, enemyPosition, ShipMoveCommand.Wait, out myMovement, out enemyMovement); if ((collisionType & (CollisionType.MyMove | CollisionType.MyRotation)) != CollisionType.None) { newShipMovement = myMovement; newMovedPos = FastShipPosition.GetMovedPosition(newShipMovement); newPos = FastShipPosition.GetFinalPosition(newShipMovement); newMovementState = new ShipMovementState(newPos, current.depth + 1); onEnemyShip = used.ContainsKey(newMovementState); break; } } //onEnemyShip = gameState.forecaster.GetTurnForecast(Math.Min(current.depth, Settings.NAVIGATOR_ENEMY_POSITION_DEPTH)).enemyShipsFinalPositions // .Any(m => FastShipPosition.CollidesShip(newPos, m) || FastShipPosition.CollidesShip(newMovedPos, m)); } if (onEnemyShip) { //used.Add(newMovementState, null); continue; } var damage = turnForecast.mineDamageCoordMap[FastShipPosition.Coord(newPos)] + turnForecast.mineDamageCoordMap[FastShipPosition.Bow(newPos)] + turnForecast.mineDamageCoordMap[FastShipPosition.Stern(newPos)] + turnForecast.nearMineDamageCoordMap[FastShipPosition.Bow(newPos)] + turnForecast.nearMineDamageCoordMap[FastShipPosition.Stern(newPos)]; if (newMovedPos != newPos) { damage += turnForecast.mineDamageCoordMap[FastShipPosition.Bow(newMovedPos)] + turnForecast.mineDamageCoordMap[FastShipPosition.Stern(newMovedPos)] + turnForecast.nearMineDamageCoordMap[FastShipPosition.Bow(newMovedPos)] + turnForecast.nearMineDamageCoordMap[FastShipPosition.Stern(newMovedPos)]; } var cannonedBowOrStern = turnForecast.cannonballCoordsMap[FastShipPosition.Bow(newPos)] || turnForecast.cannonballCoordsMap[FastShipPosition.Stern(newPos)]; if (cannonedBowOrStern) { damage += Constants.LOW_DAMAGE; } var cannonedCenter = turnForecast.cannonballCoordsMap[FastShipPosition.Coord(newPos)]; if (cannonedCenter) { damage += Constants.HIGH_DAMAGE; } if (Settings.NEAR_ENEMYSHIP_VIRTUAL_DAMAGE > 0) { var nearEnemyShip = turnState.enemyShips.Any(m => FastShipPosition.DistanceTo(newPos, m.fcoord) < Settings.NEAR_ENEMY_SHIP_MIN_DIST); if (nearEnemyShip) { damage += Settings.NEAR_ENEMYSHIP_VIRTUAL_DAMAGE; } } var next = current.Next(newPos, moveCommand, ftarget, damage); queue.Enqueue(next); used.Add(newMovementState, next); } } } } ShipPathChainItem bestChainItem = null; foreach (var chainItem in used.Values.Where(v => v != null)) { if (chainItem.prev != null) { if (bestChainItem == null) { bestChainItem = chainItem; } else { switch (navigationMethod) { case NavigationMethod.Approach: bestChainItem = SelectBestPath_Approach(chainItem, bestChainItem, ship); break; case NavigationMethod.Collect: bestChainItem = SelectBestPath_Collect(chainItem, bestChainItem, ship); break; default: bestChainItem = SelectBestPath(chainItem, bestChainItem, ship); break; } } } } if (bestChainItem == null) { return(new List <PathItem>()); } var chainDump = new List <ShipPathChainItem>(); var chain = new List <PathItem>(); while (bestChainItem.prev != null) { chain.Add(new PathItem { command = bestChainItem.command, targetPosition = bestChainItem.fposition, sourcePosition = bestChainItem.prev.fposition }); chainDump.Add(bestChainItem); bestChainItem = bestChainItem.prev; } chainDump.Reverse(); if (Settings.DUMP_BEST_PATH) { Console.Error.WriteLine($"Best path for ship {shipId}"); foreach (var item in chainDump) { Console.Error.WriteLine($"{item.command} - {FastShipPosition.ToShipPosition(item.fposition)} - dmg:{item.damage}"); } } chain.Reverse(); return(chain); }