2022-03-13 04:29:00 +00:00
|
|
|
using MultiversalDiplomacy.Model;
|
|
|
|
using MultiversalDiplomacy.Orders;
|
|
|
|
|
|
|
|
namespace MultiversalDiplomacy.Adjudicate;
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Helper class encapsulating the convoy pathfindind code.
|
|
|
|
/// </summary>
|
|
|
|
public static class PathFinder
|
|
|
|
{
|
|
|
|
/// <summary>
|
|
|
|
/// Determines if a convoy path exists for a move in a convoy order.
|
|
|
|
/// </summary>
|
|
|
|
public static bool ConvoyPathExists(World world, ConvoyOrder order)
|
|
|
|
=> ConvoyPathExists(world, order.Target, order.Location, order.Season);
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Determines if a convoy path exists for a move order.
|
|
|
|
/// </summary>
|
|
|
|
public static bool ConvoyPathExists(World world, MoveOrder order)
|
|
|
|
=> ConvoyPathExists(world, order.Unit, order.Location, order.Season);
|
|
|
|
|
|
|
|
private static bool ConvoyPathExists(
|
|
|
|
World world,
|
|
|
|
Unit movingUnit,
|
|
|
|
Location unitLocation,
|
|
|
|
Season unitSeason)
|
|
|
|
{
|
|
|
|
// A convoy path exists between two locations if both are land locations in provinces that
|
|
|
|
// also have coasts, and between those coasts there is a path of adjacent sea provinces
|
|
|
|
// (not coastal) that are occupied by fleets. The move order is valid even if the fleets
|
|
|
|
// belong to another power or were not given convoy orders; it will simply fail.
|
|
|
|
IDictionary<(Location location, Season season), Unit> fleets = world.Units
|
|
|
|
.Where(unit => unit.Type == UnitType.Fleet)
|
|
|
|
.ToDictionary(unit => (unit.Location, unit.Season));
|
|
|
|
|
|
|
|
// Verify that the origin is a coastal province.
|
|
|
|
if (movingUnit.Location.Type != LocationType.Land) return false;
|
2022-03-30 19:52:57 +00:00
|
|
|
IEnumerable<Location> originCoasts = movingUnit.Province.Locations
|
2022-03-13 04:29:00 +00:00
|
|
|
.Where(location => location.Type == LocationType.Water);
|
|
|
|
if (!originCoasts.Any()) return false;
|
|
|
|
|
|
|
|
// Verify that the destination is a coastal province.
|
|
|
|
if (unitLocation.Type != LocationType.Land) return false;
|
|
|
|
IEnumerable<Location> destCoasts = unitLocation.Province.Locations
|
|
|
|
.Where(location => location.Type == LocationType.Water);
|
|
|
|
if (!destCoasts.Any()) return false;
|
|
|
|
|
|
|
|
// Seed the to-visit set with the origin coasts. Coastal locations will be filtered out of
|
|
|
|
// locations added to the to-visit set, but the logic will still work with these as
|
|
|
|
// starting points.
|
|
|
|
Queue<(Location location, Season season)> toVisit = new(
|
|
|
|
originCoasts.Select(location => (location, unitSeason)));
|
|
|
|
HashSet<(Location, Season)> visited = new();
|
|
|
|
|
|
|
|
// Begin pathfinding.
|
|
|
|
while (toVisit.Any())
|
|
|
|
{
|
|
|
|
// Visit the next point in the queue.
|
|
|
|
(Location currentLocation, Season currentSeason) = toVisit.Dequeue();
|
|
|
|
visited.Add((currentLocation, currentSeason));
|
|
|
|
|
2024-08-12 21:12:49 +00:00
|
|
|
var adjacents = GetAdjacentPoints(world, currentLocation, currentSeason);
|
2022-03-13 04:29:00 +00:00
|
|
|
foreach ((Location adjLocation, Season adjSeason) in adjacents)
|
|
|
|
{
|
|
|
|
// If the destination is adjacent, then a path exists.
|
|
|
|
if (destCoasts.Contains(adjLocation) && unitSeason == adjSeason) return true;
|
|
|
|
|
|
|
|
// If not, add this location to the to-visit set if it isn't a coast, has a fleet,
|
|
|
|
// and hasn't already been visited.
|
|
|
|
if (!adjLocation.Province.Locations.Any(l => l.Type == LocationType.Land)
|
|
|
|
&& fleets.ContainsKey((adjLocation, adjSeason))
|
|
|
|
&& !visited.Contains((adjLocation, adjSeason)))
|
|
|
|
{
|
|
|
|
toVisit.Enqueue((adjLocation, adjSeason));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the destination was never reached, then no path exists.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2024-08-12 21:12:49 +00:00
|
|
|
private static List<(Location, Season)> GetAdjacentPoints(World world, Location location, Season season)
|
2022-03-13 04:29:00 +00:00
|
|
|
{
|
2024-08-12 21:12:49 +00:00
|
|
|
List<(Location, Season)> adjacentPoints = [];
|
2022-03-13 04:29:00 +00:00
|
|
|
List<Location> adjacentLocations = location.Adjacents.ToList();
|
2024-08-12 21:12:49 +00:00
|
|
|
List<Season> adjacentSeasons = GetAdjacentSeasons(world, season).ToList();
|
2022-03-13 04:29:00 +00:00
|
|
|
|
|
|
|
foreach (Location adjacentLocation in adjacentLocations)
|
|
|
|
{
|
|
|
|
adjacentPoints.Add((adjacentLocation, season));
|
|
|
|
}
|
|
|
|
foreach (Season adjacentSeason in adjacentSeasons)
|
|
|
|
{
|
|
|
|
adjacentPoints.Add((location, adjacentSeason));
|
|
|
|
}
|
|
|
|
foreach (Location adjacentLocation in adjacentLocations)
|
|
|
|
{
|
|
|
|
foreach (Season adjacentSeason in adjacentSeasons)
|
|
|
|
{
|
|
|
|
adjacentPoints.Add((adjacentLocation, adjacentSeason));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return adjacentPoints;
|
|
|
|
}
|
2024-08-12 21:12:49 +00:00
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Returns all seasons that are adjacent to a season.
|
|
|
|
/// </summary>
|
|
|
|
public static IEnumerable<Season> GetAdjacentSeasons(World world, Season season)
|
|
|
|
{
|
|
|
|
List<Season> adjacents = [];
|
|
|
|
|
|
|
|
// The immediate past and all immediate futures are adjacent.
|
2024-08-12 21:52:50 +00:00
|
|
|
if (season.Past != null) adjacents.Add(world.GetSeason(season.Past));
|
2024-08-12 21:12:49 +00:00
|
|
|
adjacents.AddRange(season.Futures);
|
|
|
|
|
|
|
|
// Find all adjacent timelines by finding all timelines that branched off of this season's
|
|
|
|
// timeline, i.e. all futures of this season's past that have different timelines. Also
|
|
|
|
// include any timelines that branched off of the timeline this timeline branched off from.
|
2024-08-12 21:51:07 +00:00
|
|
|
List<Season> adjacentTimelineRoots = [];
|
2024-08-12 21:12:49 +00:00
|
|
|
Season? current;
|
|
|
|
for (current = season;
|
2024-08-12 21:52:50 +00:00
|
|
|
current?.Past != null && world.GetSeason(current.Past).Timeline == current.Timeline;
|
|
|
|
current = world.GetSeason(current.Past))
|
2024-08-12 21:12:49 +00:00
|
|
|
{
|
|
|
|
adjacentTimelineRoots.AddRange(
|
|
|
|
current.Futures.Where(s => s.Timeline != current.Timeline));
|
|
|
|
}
|
|
|
|
|
|
|
|
// At the end of the for loop, if this season is part of the first timeline, then current
|
|
|
|
// is the root season (current.past == null); if this season is in a branched timeline,
|
|
|
|
// then current is the branch timeline's root season (current.past.timeline !=
|
|
|
|
// current.timeline). There are co-branches if this season is in a branched timeline, since
|
|
|
|
// the first timeline by definition cannot have co-branches.
|
2024-08-12 21:52:50 +00:00
|
|
|
if (current?.Past != null && world.GetSeason(current.Past) is Season past)
|
2024-08-12 21:12:49 +00:00
|
|
|
{
|
2024-08-12 21:51:07 +00:00
|
|
|
IEnumerable<Season> cobranchRoots = past.Futures
|
|
|
|
.Where(s => s.Timeline != current.Timeline && s.Timeline != past.Timeline);
|
2024-08-12 21:12:49 +00:00
|
|
|
adjacentTimelineRoots.AddRange(cobranchRoots);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Walk up all alternate timelines to find seasons within one turn of this season.
|
|
|
|
foreach (Season timelineRoot in adjacentTimelineRoots)
|
|
|
|
{
|
|
|
|
for (Season? branchSeason = timelineRoot;
|
|
|
|
branchSeason != null && branchSeason.Turn <= season.Turn + 1;
|
|
|
|
branchSeason = branchSeason.Futures
|
|
|
|
.FirstOrDefault(s => s!.Timeline == branchSeason.Timeline, null))
|
|
|
|
{
|
|
|
|
if (branchSeason.Turn >= season.Turn - 1) adjacents.Add(branchSeason);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return adjacents;
|
|
|
|
}
|
2022-03-13 04:29:00 +00:00
|
|
|
}
|