/// <summary>
/// Recalculates every route in case of a blokage
/// </summary>
/// <param name="town"></param>
/// <param name="player"></param>
public void CalculateLongestRoad(HexPoint town, GamePlayer player)
{
Route current = LongestRoute;
// When we have a current route, check if the new town is part of it
if (current != null)
{
// But only when the player building the town is other then the player owning
// the current route
if (!player.Equals(LongestRouteOwner))
{
// Create a list of hexpoints in current route
List<HexPoint> routePoints = new List<HexPoint>();
// Put all points into the list
foreach (RouteNode node in current)
{
if (!routePoints.Contains(node.GetNeighbourPoints()[0]))
routePoints.Add(node.GetNeighbourPoints()[0]);
if (!routePoints.Contains(node.GetNeighbourPoints()[1]))
routePoints.Add(node.GetNeighbourPoints()[1]);
}
// Check if the town is placed on a hexpoint in the route
if (routePoints.Contains(town))
{
// We have a winner! Nice play. This means given town which is built blocks
// We should iterate over all players, calculating their longest routes.
// If current keeper of the longest route has a new route with length
// equalling length of another player, current keeper keeps his LR.
// However, when two other players both have longest route, no one gets
// the route.
// TODO: make static function call of CalculateALongestRoute
Route phony = new Route();
// Get us some nice new dictionairy to store the calculated routes
Dictionary<GamePlayer, Route> playersRoutes = new Dictionary<GamePlayer, Route>();
// Fill the dictionairy with new routes
foreach (GamePlayer p in _Players)
playersRoutes.Add(p, phony.CalculateALongestRoute(p, this));
// Sweet! Now let's see who is the winner of the routecontest
// First get the longest route of current keeper of LR
Route currentWinnerRoute = playersRoutes[LongestRouteOwner];
// Get the length of the longest route(s)
int newWinnerLength = playersRoutes.Max(kvp => kvp.Value.Count);
Route newRoute = null;
if (currentWinnerRoute.Count == newWinnerLength)
{
// Current keeper of longest route has a new route with the maximum length.
// Therefore, he stays the keeper of the longest route
newRoute = currentWinnerRoute;
}
else
{
// Some other player(s) have a longer route then the previous route, and still longer
// then the longest route of the keeper of the previous route.
// Determine if we have a single player having so. If a single player is found,
// declare him the winner. When multiple players are found, no one gets
// declared winner.
IEnumerable<KeyValuePair<GamePlayer, Route>> winners =
playersRoutes.Where(kvp => kvp.Value.Count == newWinnerLength);
// We have more then one new winners. No one gets LR.
if (winners.Count() > 1)
{
newRoute = null;
}
// Only one new winner
if (winners.Count() == 1)
{
newRoute = winners.First().Value;
}
// Old player lost route, no players with routes > 4
if (winners.Count() == 0)
{
newRoute = null;
}
}
}
}
}
else
{
CalculateLongestRoad(player);
}
}