public List <City> GetShortestPath(IPandemicState state, City fromCity, City toCity)
{
var citiesWithResearchStations = state.Cities.Where(n => n.HasResearchStation).ToList();
var cacheKey = citiesWithResearchStations.Count < 2 ? $"Pandemic.ShortestPath.{fromCity}-{toCity}" : $"Pandemic.{state.Id}.ShortestPath.{fromCity}-{toCity}";
var cacheExpires = citiesWithResearchStations.Count < 2 ? TimeSpan.FromMinutes(30) : TimeSpan.FromMilliseconds(2000);
List <City> cacheEntry;
if (_memoryCache.TryGetValue(cacheKey, out cacheEntry))
{
return(cacheEntry);
}
var cityGraph = GetCityGraph(state);
var route = cityGraph.Dijkstra((uint)fromCity + 1, (uint)toCity + 1);
var path = route.GetPath();
var citiesTravelledTo = new List <City>();
foreach (var node in path)
{
citiesTravelledTo.Add((City)(node - 1));
}
cacheEntry = citiesTravelledTo;
var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(cacheExpires);
_memoryCache.Set(cacheKey, cacheEntry, cacheEntryOptions);
return(citiesTravelledTo);
}
public bool ShouldBuildResearchStation(IPandemicState state, City currentLocation, PlayerRole playerRole, List <PandemicPlayerCard> playerHand)
{
if (!CouldBuildResearchStation(state, currentLocation, playerRole, playerHand))
{
return(false);
}
var nearestCityWithResearchStation = _routeHelper.GetNearestCitywithResearchStation(state, currentLocation);
if (nearestCityWithResearchStation == null)
{
return(true);
}
var minimumDistanceBetweenResearchStations = 2; // could be dynamic
var routeToNearestResearchStation = _routeHelper.GetShortestPath(state, currentLocation, nearestCityWithResearchStation.Value);
if (routeToNearestResearchStation.Count > minimumDistanceBetweenResearchStations)
{
return(true);
}
return(false);
}
public bool CouldBuildResearchStation(IPandemicState state, City currentLocation, PlayerRole playerRole, List <PandemicPlayerCard> playerHand)
{
if (state.ResearchStationStock < 1)
{
return(false);
}
var atResearchStation = state.Cities.Single(c => c.City.Equals(currentLocation)).HasResearchStation;
if (atResearchStation)
{
return(false);
}
if (playerRole == PlayerRole.OperationsExpert)
{
return(true);
}
if (playerHand.Any(c => c.PlayerCardType == PlayerCardType.City && (City)c.Value == currentLocation))
{
return(true);
}
return(false);
}
private void TreatDisease(IPandemicState state, City city, Disease disease)
{
_state = state;
var diseaseState = _state.DiscoveredCures[disease];
var currentPlayerRole = _state.PlayerStates[_currentPlayerId].PlayerRole;
var node = _state.Cities.Single(c => c.City == city);
if (disease == 0)
{
return;
}
if (diseaseState == DiseaseState.Cured || currentPlayerRole == PlayerRole.Medic)
{
_state.DiseaseCubeReserve[disease] += node.DiseaseCubes[disease];
node.DiseaseCubes[disease] = 0;
}
else
{
node.DiseaseCubes[disease]--;
_state.DiseaseCubeReserve[disease]++;
}
_stateDeltas.Add(new DiseaseChangedDelta()
{
City = node.City,
Disease = disease,
NewAmount = node.DiseaseCubes[disease]
});
}
private List <int> PlayersWeCouldKnowledgeShareWith(int currentPlayerId, IPandemicState state)
{
var currentPlayerState = state.PlayerStates[currentPlayerId];
var currentPlayerLocation = currentPlayerState.Location;
var currentPlayerRole = currentPlayerState.PlayerRole;
var currentPlayerCityCards = currentPlayerState.PlayerHand
.Where(c => c.PlayerCardType == PlayerCardType.City).ToList();
// If there are no other players in the same location as this player, then no knowledge sharing is possible
var otherPlayersInSameCity = state.PlayerStates
.Where(p => p.Key != currentPlayerId && p.Value.Location == currentPlayerLocation).ToList();
if (!otherPlayersInSameCity.Any())
{
return(new List <int>());
}
var weCanShareWithPlayerIds = new List <int>();
// If a researcher is in this city, and has at least one city card, then knowledge sharing is possible
if ((currentPlayerRole == PlayerRole.Researcher && currentPlayerCityCards.Any()) ||
(otherPlayersInSameCity.Any(p => p.Value.PlayerRole == PlayerRole.Researcher &&
p.Value.PlayerHand.Any(c => c.PlayerCardType == PlayerCardType.City))))
{
weCanShareWithPlayerIds.AddRange(otherPlayersInSameCity.Select(p => p.Key).ToList());
}
// If another player in this city, has the city card of this city, then knowledge sharing is possible
weCanShareWithPlayerIds.AddRange(otherPlayersInSameCity
.Where(c => c.Value.PlayerHand.Any(ph => ph.PlayerCardType == PlayerCardType.City && (City)ph.Value == currentPlayerLocation))
.Select(p => p.Key).ToList());
return(weCanShareWithPlayerIds);
}
private void BuildResearchStation(IPandemicState state, City city, bool haveGrant = false)
{
_state = state;
var playerState = _state.PlayerStates[_currentPlayerId];
var node = _state.Cities.Single(c => c.City == city);
node.HasResearchStation = true;
_state.ResearchStationStock--;
if (!haveGrant && playerState.PlayerRole != PlayerRole.OperationsExpert)
{
var cardToDiscard = playerState.PlayerHand.Single(c => c.PlayerCardType == PlayerCardType.City && (City)c.Value == city);
playerState.PlayerHand.Remove(cardToDiscard);
_state.PlayerDiscardPile.AddCard(cardToDiscard);
_stateDeltas.Add(new CardIsDrawnOrDiscardedDelta {
PlayerId = _currentPlayerId, PandemicPlayerCard = cardToDiscard, DrawnOrDiscarded = DrawnOrDiscarded.Discarded
});
}
_stateDeltas.Add(new ResearchStationDelta()
{
City = city
});
}
public City GetBestCityToTravelToWithoutDiscarding(IPandemicState state, City startingLocation)
{
var startingNode = state.Cities.Single(n => n.City == startingLocation);
var threeCubeCities = state.Cities.Where(c => c.DiseaseCubeCount >= 3).ToList();
var bestCandidate =
threeCubeCities.OrderBy(c => GetDistance(state, startingLocation, c.City)).FirstOrDefault();
if (bestCandidate != null)
{
var connections = startingNode.ConnectedCities.ToList();
if (startingNode.HasResearchStation)
{
var researchStationNodes = state.Cities
.Where(n => n.HasResearchStation && n.City != startingLocation)
.Select(n => n.City);
connections.AddRange(researchStationNodes);
}
var bestDriveFerryOrShuttleFlightTo = connections.OrderBy(c => GetDistance(state, bestCandidate.City, c)).First();
return(bestDriveFerryOrShuttleFlightTo);
}
return(bestCandidate == null?GetRandomNeighbour(state, startingLocation) : bestCandidate.City);
}
public List <PandemicPlayerCard> GetWeakCityCards(IPandemicState state, PlayerRole playerRole, IEnumerable <PandemicPlayerCard> cards)
{
var weakCityCards = new List <PandemicPlayerCard>();
var cardsByColour = GetCityCardsByColour(cards);
// If we have a city card for a cured or eradicated disease then we can consider that as weak
var diseaseStates = state.DiscoveredCures;
foreach (var diseaseState in diseaseStates)
{
// if we have a card relating to a cured or eradicated disease, then is a weak card
// ( we are not taking into account, if card is useful to facilitate flights here )
if (diseaseState.Value == DiseaseState.Cured || diseaseState.Value == DiseaseState.Eradicated)
{
weakCityCards.AddRange(cardsByColour[diseaseState.Key]);
}
else
{
// card still considered weak, for uncured diseases, if there are only 1-2 of these colour in hand
// TODO this logic may change when we add in Share-Knowledge action, if other player needs that card
if (cardsByColour[diseaseState.Key].Count < 3)
{
weakCityCards.AddRange(cardsByColour[diseaseState.Key]);
}
}
}
return(weakCityCards);
}
public void TakeActionsTurn(IPandemicState state, IPandemicTurn turn)
{
_state = state;
_currentPlayerId = turn.CurrentPlayerId;
ApplyPlayerAction(_state, turn.ActionTaken);
_state.ActionsPlayed++;
}
public void TakeDiscardCardsTurn(IPandemicState state, IPandemicTurn turn)
{
if (!turn.CardsToDiscard.Any())
{
return;
}
_state = state;
_currentPlayerId = turn.CurrentPlayerId;
var playerState = _state.PlayerStates[_currentPlayerId];
foreach (var cardToDiscard in turn.CardsToDiscard)
{
var cardInPlayerDeck = playerState.PlayerHand
.SingleOrDefault(c => c.PlayerCardType == cardToDiscard.PlayerCardType && c.Value == cardToDiscard.Value);
if (cardInPlayerDeck != null)
{
playerState.PlayerHand.Remove(cardInPlayerDeck);
state.PlayerDiscardPile.AddCard(cardInPlayerDeck);
_stateDeltas.Add(new CardIsDrawnOrDiscardedDelta {
PlayerId = _currentPlayerId, PandemicPlayerCard = cardInPlayerDeck, DrawnOrDiscarded = DrawnOrDiscarded.Discarded
});
}
}
}
public bool ShouldPlayAirLift(IPandemicState state)
{
var bestCityOnBoard = _routeHelper.GetBestLocationOnBoard(state.Cities);
var valueOfBestCity = _routeHelper.GetLocationValue(state, bestCityOnBoard);
var playerLocationValues = state.PlayerStates.Select(s => _routeHelper.GetLocationValue(state, s.Value.Location));
return(playerLocationValues.Any(lv => valueOfBestCity - lv > 3));
}
public KnowledgeShare GetSuggestedKnowledgeShare(int currentPlayerId, IPandemicState state)
{
var currentPlayerState = state.PlayerStates[currentPlayerId];
var currentPlayerCityCards = currentPlayerState.PlayerHand
.Where(c => c.PlayerCardType == PlayerCardType.City).Select(c => (City)c.Value).ToList();
var diseaseStates = state.DiscoveredCures;
var city = currentPlayerState.Location;
var playersWeCouldShareKnowledgeWith = PlayersWeCouldKnowledgeShareWith(currentPlayerId, state);
// if we are a researcher, then we can give any city card ( can go other way too, but this will be sufficient for bot )
if (currentPlayerState.PlayerRole == PlayerRole.Researcher)
{
var suggestedKnowledgeShare = GetSuggestedKnowledgeShareForResearcher(currentPlayerId, state,
playersWeCouldShareKnowledgeWith,
currentPlayerState, diseaseStates, currentPlayerCityCards);
return(suggestedKnowledgeShare);
}
// if the current city is for a cured or eradicated disease - don't knowledge share
if (diseaseStates[city.GetDefaultDisease()] != DiseaseState.NotCured)
{
return(null);
}
var playerToShareKnowledgeWith = playersWeCouldShareKnowledgeWith?.FirstOrDefault();
if (playerToShareKnowledgeWith == null)
{
return(null);
}
// do not return a knowledgeShare unless it improves gameState
// Otherwise we may just be knowledge sharing the same card back and forth !
var disease = city.GetDefaultDisease();
if (diseaseStates[disease] != DiseaseState.NotCured)
{
return(null);
}
var candidatePlayer = state.PlayerStates[playerToShareKnowledgeWith.Value];
var ourDiseaseCount = currentPlayerState.PlayerHand
.Count(c => c.PlayerCardType == PlayerCardType.City && ((City)c.Value).GetDefaultDisease() == disease);
var candidateDiseaseCount = candidatePlayer.PlayerHand
.Count(c => c.PlayerCardType == PlayerCardType.City && ((City)c.Value).GetDefaultDisease() == disease);
if (ourDiseaseCount == 0 || candidateDiseaseCount <= ourDiseaseCount)
{
return(null);
}
return(new KnowledgeShare
{
Player1 = currentPlayerId,
Player2 = playerToShareKnowledgeWith.Value,
CityCardToGive = state.PlayerStates[currentPlayerId].Location
});
}
public City GetRandomNeighbour(IPandemicState state, City startingLocation)
{
var connectionCount = state.Cities.Single(n => n.City == startingLocation).ConnectedCities.Count();
var moveDie = new Die(connectionCount);
var moveDieRoll = moveDie.Roll();
var moveTo = state.Cities.Single(n => n.City == startingLocation).ConnectedCities.ToArray()[moveDieRoll - 1];
return(moveTo);
}
public InfectionDeckTests()
{
_gameState = new PandemicState();
_stateEditor = new PandemicStateEditor(new PandemicActionValidator());
_stateEditor.Clear(_gameState);
var players = new List <PandemicBotStandard>();
_stateEditor.Setup(_gameState, players);
}
public void Clear(IPandemicState state, int pandemicCardCount = 6)
{
_state = state;
_state.Id = "1"; // TODO Guid.NewGuid().ToString();
_stateDeltas = new List <IDelta>();
_state.ActionsPlayed = 0;
_state.OutbreakCount = 0;
var players = new List <IPlayer <IPandemicTurn> >();
SetupPlayerStates(_state, players);
_state.IsGameOver = false;
_state.Cities = new List <MapNode>();
_state.InfectionDeck = new InfectionDeck();
_state.InfectionDiscardPile = new CardDeck <Card>();
_state.PlayerDeck = new PlayerDeck();
_state.EventCardsQueue = new PlayerDeck();
_state.PandemicCardCount = pandemicCardCount;
_state.PlayerDiscardPile = new PlayerDeck();
SetupPlayerDeck(_state);
_state.DiscoveredCures = new Dictionary <Disease, DiseaseState>();
_state.InfectionRateMarker = 0;
_state.InfectionRateTrack = new int[] { 2, 2, 2, 3, 3, 4, 4 };
var nodeFactory = new MapNodeFactory();
var cities = Enum.GetValues(typeof(City));
foreach (var city in cities)
{
_state.Cities.Add(nodeFactory.CreateMapNode((City)city));
}
_state.ResearchStationStock = 6;
_state.DiseaseCubeReserve = new Dictionary <Disease, int>
{
{ Disease.Blue, 24 },
{ Disease.Black, 24 },
{ Disease.Red, 24 },
{ Disease.Yellow, 24 }
};
_state.DiscoveredCures = new Dictionary <Disease, DiseaseState>
{
{ Disease.Blue, DiseaseState.NotCured },
{ Disease.Black, DiseaseState.NotCured },
{ Disease.Red, DiseaseState.NotCured },
{ Disease.Yellow, DiseaseState.NotCured }
};
// Atlanta starts with a research station
_state.Cities.Single(c => c.City == City.Atlanta).HasResearchStation = true;
_state.ResearchStationStock--;
}
private void AddDiseaseCubes(IPandemicState state, City city, int count = 1)
{
_state = state;
var disease = city.GetDefaultDisease();
for (var i = 0; i < count; i++)
{
AddDiseaseCube(_state, disease, city);
}
}
public IEnumerable <IDelta> Setup(IPandemicState state, IEnumerable <IPlayer <IPandemicTurn> > players, int pandemicCardCount = 6)
{
_state = state;
_stateDeltas = new List <IDelta>();
Clear(_state);
_state.PandemicCardCount = pandemicCardCount;
SetupPlayerStates(_state, players);
PerformInitialInfections(_state);
return(_stateDeltas);
}
public bool ShouldPlayOneQuietNight(IPandemicState state)
{
var citiesWithThreeOfOneDisease = state.Cities
.Where(c => c.DiseaseCubes[Disease.Black] == 3 ||
c.DiseaseCubes[Disease.Blue] == 3 ||
c.DiseaseCubes[Disease.Yellow] == 3 ||
c.DiseaseCubes[Disease.Blue] == 3);
return(citiesWithThreeOfOneDisease.Count() > 3 && state.InfectionRateMarker > 1);
}
// TODO state deltas
public IEnumerable <IDelta> InfectCities(IPandemicState state)
{
_state = state;
_stateDeltas = new List <IDelta>();
var oneQuietNightCard = _state.EventCardsQueue.Cards
.SingleOrDefault(c => c.PlayerCardType == PlayerCardType.Event && (EventCard)c.Value == EventCard.OneQuietNight);
if (oneQuietNightCard != null)
{
state.PlayerDiscardPile.AddCard(oneQuietNightCard);
state.EventCardsQueue.Cards.Remove(oneQuietNightCard);
_stateDeltas.Add(new CardIsDrawnOrDiscardedDelta {
PlayerId = _currentPlayerId, PandemicPlayerCard = oneQuietNightCard, DrawnOrDiscarded = DrawnOrDiscarded.Discarded
});
return(_stateDeltas);
}
var infectionRate = _state.InfectionRateTrack[_state.InfectionRateMarker];
if (_state.InfectionDeck.CardCount < infectionRate)
{
_state.IsGameOver = true;
_state.GameOverReason = "Infection deck empty";
return(_stateDeltas);
}
var infectionCards = _state.InfectionDeck.Draw(infectionRate).ToList();
foreach (var infectionCard in infectionCards)
{
if (!_state.IsGameOver)
{
var city = (City)infectionCard.Value;
var disease = city.GetDefaultDisease();
AddDiseaseCube(_state, disease, city);
}
}
if (!state.IsGameOver)
{
_state.InfectionDiscardPile.AddCards(infectionCards);
foreach (var infectionCard in infectionCards)
{
_stateDeltas.Add(new CardIsDrawnOrDiscardedDelta
{
InfectionCard = (City)infectionCard.Value,
DrawnOrDiscarded = DrawnOrDiscarded.Discarded
});
}
}
return(_stateDeltas);
}
private void DriveOrFerry(IPandemicState state, City city)
{
_state = state;
var playerState = _state.PlayerStates[_currentPlayerId];
playerState.Location = city;
_stateDeltas.Add(new PlayerMovedDelta()
{
PlayerId = _currentPlayerId,
City = city
});
}
public IEnumerable <string> ValidatePlayerEventPlayed(int playerId, IPandemicState state, PlayerEventPlayed newEventCard)
{
var validationFailures = new List <string>();
var playerState = state.PlayerStates[playerId];
if (!playerState.PlayerHand.Any(c => c.PlayerCardType == PlayerCardType.Event && (EventCard)c.Value == newEventCard.EventCard))
{
validationFailures.Add($"Player doesn't have event card {newEventCard.EventCard}");
}
return(validationFailures);
}
private PandemicPlayerState GetPlayerStateByRole(IPandemicState state, PlayerRole playerRole)
{
_state = state;
foreach (var playerState in _state.PlayerStates)
{
if (playerState.Value.PlayerRole == playerRole)
{
return(playerState.Value);
}
}
return(null);
}
public IEnumerable <string> ValidatePlayerAction(int playerId, IPandemicState state, PlayerAction newPlayerAction)
{
var validationFailures = new List <string>();
var validationFailure = GetActionValidationFailures(state, playerId, newPlayerAction);
if (!string.IsNullOrWhiteSpace(validationFailure))
{
validationFailures.Add(validationFailure);
}
return(validationFailures);
}
public void AddDiseaseCube(IPandemicState state, Disease disease, City city, List <City> ignoreCities = null)
{
_state = state;
var node = _state.Cities.Single(n => n.City == city);
// Dont place disease if quarantineSpecialist is here or in neighbouring city
var quarantineSpecialist = GetPlayerStateByRole(_state, PlayerRole.QuarantineSpecialist);
if (quarantineSpecialist != null)
{
if (quarantineSpecialist.Location == city || _state.Cities.Single(n => n.City == quarantineSpecialist.Location).ConnectedCities.Contains(city))
{
return;
}
}
ignoreCities = ignoreCities ?? new List <City>();
if (node.DiseaseCubes[disease] < 3)
{
if (_state.DiseaseCubeReserve[disease] == 0)
{
_state.IsGameOver = true;
_state.GameOverReason = $"Ran out of {disease} disease cubes";
return;
}
node.DiseaseCubes[disease] += 1;
_state.DiseaseCubeReserve[disease]--;
_stateDeltas.Add(new DiseaseChangedDelta()
{
City = city, Disease = disease, NewAmount = node.DiseaseCubes[disease]
});
return;
}
_state.OutbreakCount++;
if (_state.OutbreakCount > 7)
{
_state.IsGameOver = true;
_state.GameOverReason = "More than seven outbreaks";
return;
}
ignoreCities.Add(city);
foreach (var connectedCity in node.ConnectedCities.Where(c => !ignoreCities.Contains(c)))
{
AddDiseaseCube(_state, disease, connectedCity, ignoreCities);
}
}
public List <PandemicPlayerCard> GetCardsToDiscardToCure(IPandemicState state, Disease disease, PlayerRole playerRole, IEnumerable <PandemicPlayerCard> cards)
{
var cardCountToDiscard = playerRole == PlayerRole.Scientist ? 4 : 5;
var candidateDiscards = GetCityCardsByColour(cards)[disease];
if (cardCountToDiscard > candidateDiscards.Count)
{
throw new CardboardException($"Cant find enough cards to discard to cure disease {disease}");
}
return(candidateDiscards.Take(cardCountToDiscard).ToList());
}
public IEnumerable <IDelta> Epidemic(IPandemicState state)
{
_state = state;
_stateDeltas = new List <IDelta>();
var bottomCard = _state.InfectionDeck.DrawBottom();
_state.InfectionDiscardPile.AddCard(bottomCard);
AddDiseaseCubes(_state, (City)bottomCard.Value, 3);
// Intensify
_state.InfectionDiscardPile.Shuffle();
_state.InfectionDeck.AddCardDeck(_state.InfectionDiscardPile, CardDeckPosition.Top);
_state.InfectionRateMarker++;
return(_stateDeltas);
}
public void TakePlayEventCardsTurn(IPandemicState state, IPandemicTurn turn)
{
if (turn.EventCardsPlayed == null || !turn.EventCardsPlayed.Any())
{
return;
}
_state = state;
_currentPlayerId = turn.CurrentPlayerId;
var playerState = _state.PlayerStates[_currentPlayerId];
foreach (var eventCardToPlay in turn.EventCardsPlayed)
{
if (eventCardToPlay.EventCard == EventCard.OneQuietNight)
{
var card = playerState.PlayerHand.Single(c => c.PlayerCardType == PlayerCardType.Event && (EventCard)c.Value == EventCard.OneQuietNight);
_state.EventCardsQueue.AddCard(card);
playerState.PlayerHand.Remove(card);
state.PlayerDiscardPile.AddCard(card);
_stateDeltas.Add(new CardIsDrawnOrDiscardedDelta {
PlayerId = _currentPlayerId, PandemicPlayerCard = card, DrawnOrDiscarded = DrawnOrDiscarded.Discarded
});
}
if (eventCardToPlay.EventCard == EventCard.GovernmentGrant)
{
var card = playerState.PlayerHand.Single(c => c.PlayerCardType == PlayerCardType.Event && (EventCard)c.Value == EventCard.GovernmentGrant);
BuildResearchStationWithGovernmentGrant(_state, eventCardToPlay.City.Value);
playerState.PlayerHand.Remove(card);
state.PlayerDiscardPile.AddCard(card);
_stateDeltas.Add(new CardIsDrawnOrDiscardedDelta {
PlayerId = _currentPlayerId, PandemicPlayerCard = card, DrawnOrDiscarded = DrawnOrDiscarded.Discarded
});
}
if (eventCardToPlay.EventCard == EventCard.Airlift)
{
var card = playerState.PlayerHand.Single(c => c.PlayerCardType == PlayerCardType.Event && (EventCard)c.Value == EventCard.Airlift);
_state.PlayerStates[eventCardToPlay.PlayerId].Location = eventCardToPlay.City.Value;
playerState.PlayerHand.Remove(card);
state.PlayerDiscardPile.AddCard(card);
_stateDeltas.Add(new CardIsDrawnOrDiscardedDelta {
PlayerId = _currentPlayerId, PandemicPlayerCard = card, DrawnOrDiscarded = DrawnOrDiscarded.Discarded
});
}
}
}
private void ApplyPlayerAction(IPandemicState state, PlayerAction action)
{
_state = state;
_currentPlayerId = action.PlayerId;
var validationFailures = _validator.ValidatePlayerAction(_currentPlayerId, state, action).ToList();
if (validationFailures.Any())
{
throw new CardboardException(validationFailures[0]);
}
switch (action.PlayerActionType)
{
case PlayerActionType.TreatDisease:
TreatDisease(_state, action.City, action.Disease);
break;
case PlayerActionType.DriveOrFerry:
DriveOrFerry(_state, action.City);
break;
case PlayerActionType.BuildResearchStation:
BuildResearchStation(_state, action.City);
break;
case PlayerActionType.CharterFlight:
CharterFlight(_state, action.City);
break;
case PlayerActionType.DirectFlight:
DirectFlight(_state, action.City);
break;
case PlayerActionType.ShuttleFlight:
ShuttleFlight(_state, action.City);
break;
case PlayerActionType.DiscoverCure:
DiscoverCure(_state, action.Disease, action.CardsToDiscard);
break;
case PlayerActionType.ShareKnowledge:
ShareKnowledge(_state, action.City, action.PlayerId, action.OtherPlayerId);
break;
}
}
public Graph <City, string> GetCityGraph(IPandemicState state)
{
var citiesWithResearchStations = state.Cities.Where(n => n.HasResearchStation).ToList();
var cacheKey = citiesWithResearchStations.Count < 2 ? "Pandemic.CityGraph" : $"Pandemic.{state.Id}.CityGraph.R{state.ResearchStationStock}";
var cacheExpires = citiesWithResearchStations.Count < 2 ? TimeSpan.FromMinutes(30) : TimeSpan.FromMilliseconds(2000);
Graph <City, string> cacheEntry;
if (_memoryCache.TryGetValue(cacheKey, out cacheEntry))
{
return(cacheEntry);
}
var graph = new Graph <City, string>();
foreach (var city in Enum.GetValues(typeof(City)))
{
graph.AddNode((City)city);
}
foreach (var cityNode in state.Cities)
{
foreach (var connectedCity in cityNode.ConnectedCities)
{
graph.Connect((uint)cityNode.City + 1, (uint)connectedCity + 1, 1, $"{cityNode.City}-{connectedCity}");
}
// Connect all cities with research stations together
if (cityNode.HasResearchStation)
{
foreach (var researchStationCity in citiesWithResearchStations)
{
if (researchStationCity.City != cityNode.City)
{
graph.Connect((uint)cityNode.City + 1, (uint)researchStationCity.City + 1, 1, $"Shuttle:{cityNode.City}-{researchStationCity.City}");
}
}
}
}
cacheEntry = graph;
var cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(cacheExpires);
_memoryCache.Set(cacheKey, cacheEntry, cacheEntryOptions);
return(graph);
}
public Tests()
{
_serviceProvider = ServiceProviderFactory.GetServiceProvider(new MessageSenderConfiguration());
_stateEditor = _serviceProvider.GetService <IPandemicStateEditor>();
_playerFactory = _serviceProvider.GetService <IPlayerFactory <IPandemicTurn> >();
_sut = _playerFactory.CreatePlayers(new PlayerConfiguration {
PlayerCount = 1
}).SingleOrDefault();
_state = _serviceProvider.GetService <IPandemicState>();
_stateEditor.Clear(_state, 6);
var turnValidator = A.Fake <IPandemicActionValidator>();
_turn = new PandemicTurn(turnValidator);
}
