public TransferActionsResult ValidateAndApplyTransfers(SeasonState seasonState, TransferActions transferActions) { if (seasonState == null) throw new ArgumentNullException("seasonState"); if (transferActions == null) throw new ArgumentNullException("transferActions"); var transferValidity = _transferValidator.ValidateTransfers(seasonState, transferActions); if(transferValidity != TransferValidity.Valid) { throw new InvalidTransferException(transferValidity); } _transferActioner.VerboseLoggingEnabled = true; var result = _transferActioner.ApplyTransfers(seasonState, transferActions); return result; }
public TransferValidity ValidateTransfers(SeasonState seasonState, TransferActions transferActions) { if (seasonState.Gameweek == 1 && transferActions.Transfers.Any()) { return TransferValidity.NoTransfersAllowedInFirstGameweek; } foreach (var transfer in transferActions.Transfers) { var transferValidity = CheckTransferValidity(transfer, seasonState.CurrentTeam); if (transferValidity != TransferValidity.Valid) { return transferValidity; } } if (transferActions.Transfers.DistinctBy(t => t.PlayerIn.Id).Count() != transferActions.Transfers.Count) { return TransferValidity.PlayerTransferredInMultipleTimes; } if (transferActions.Transfers.DistinctBy(t => t.PlayerOut.Id).Count() != transferActions.Transfers.Count) { return TransferValidity.PlayerTransferredOutMultipleTimes; } var wildcardValidity = CheckWildcardValidity(seasonState, transferActions); if(wildcardValidity != TransferValidity.Valid) { return wildcardValidity; } if(!TeamCanAffordTransfers(seasonState, transferActions)) { return TransferValidity.NotEnoughMoney; } var teamVailidity = CheckResultingTeamValidity(seasonState, transferActions); if(teamVailidity != TeamValidationStatus.Valid) { return TransferValidity.LeavesTeamInInvalidState; } return TransferValidity.Valid; }
public TransferActionsResult ApplyTransfers(SeasonState seasonState, TransferActions transferActions) { var actionResults = new TransferActionsResult(); if (VerboseLoggingEnabled) { _logger.Log(Tag.Transfers, string.Format("Applying gameweek {0} transfers", seasonState.Gameweek), true); } //set transferred in player cost foreach (var transfer in transferActions.Transfers) { seasonState.CurrentTeam = ProcessTransfer(transfer, seasonState.CurrentTeam); } seasonState.CurrentTeam.EnsureValidCaptains(); actionResults.TotalTransfersMade = transferActions.Transfers.Count; actionResults.PenalisedTransfersMade = Math.Max(transferActions.Transfers.Count - seasonState.FreeTransfers, 0); seasonState.Money = CommonTransferFunctions.CalculateUpdatedTeamMoney(transferActions.Transfers, seasonState.Money); if (VerboseLoggingEnabled) { _logger.Log(Tag.Transfers, string.Format("Total transfers made: {0}", actionResults.TotalTransfersMade)); _logger.Log(Tag.Transfers, string.Format("Penalised transfers made: {0}", actionResults.PenalisedTransfersMade)); _logger.Log(Tag.Transfers, string.Format("Updated money: {0}", seasonState.Money.ToMoney())); } UpdateFreeTransfers(transferActions, seasonState); actionResults.UpdatedSeasonState = seasonState; actionResults = ApplyWildcards(seasonState, transferActions, actionResults); return actionResults; }
private static void UpdateFreeTransfers(TransferActions actions, SeasonState seasonState) { //transfers carry over if you're playing wildcard if (!actions.PlayTransferWindowWildcard && !actions.PlayStandardWildcard) { //deduct the transfers made seasonState.FreeTransfers -= actions.Transfers.Count; //you can never have negative free transfers seasonState.FreeTransfers = Math.Max(seasonState.FreeTransfers, 0); //add on one transfer for new game week seasonState.FreeTransfers++; //add one another free transfer if you didn't make any this week if (actions.Transfers.Count == 0) { seasonState.FreeTransfers++; } //you can only ever have a max of two free transfers seasonState.FreeTransfers = Math.Min(seasonState.FreeTransfers, 2); } }
private bool TeamCanAffordTransfers(SeasonState seasonState, TransferActions transferActions) { var newMoneyValue = CommonTransferFunctions.CalculateUpdatedTeamMoney(transferActions.Transfers, seasonState.Money); return newMoneyValue >= 0; }
private TransferValidity CheckWildcardValidity(SeasonState seasonState, TransferActions transferActions) { if (transferActions.PlayStandardWildcard && seasonState.StandardWildCardPlayed) { return TransferValidity.WildcardPlayedTwice; } if (transferActions.PlayTransferWindowWildcard) { if (seasonState.TransferWindowWildcardPlayed) { return TransferValidity.WildcardPlayedTwice; } var insideTransferWindowWildcardPeriod = IsInsideTransferWindow(seasonState.Gameweek); if (!insideTransferWindowWildcardPeriod) { return TransferValidity.WildcardPlayedOutsideWindow; } } return TransferValidity.Valid; }
private TeamValidationStatus CheckResultingTeamValidity(SeasonState seasonState, TransferActions transferActions) { var clonedSeasonState = seasonState.ShallowClone(); _transferActioner.VerboseLoggingEnabled = false; var result = _transferActioner.ApplyTransfers(clonedSeasonState, transferActions); return result.UpdatedSeasonState.CurrentTeam.Validity; }
public void transfer_actions_and_results_are_included_in_gameweek_results() { //Arrange //set up 2 gameweeks as first has no transfers _allPlayers = TeamCreationHelper.CreatePlayersWithPastFixtures(2); _playerServiceMock.Setup(x => x.GetAllPlayers()).Returns(_allPlayers); var transfers = new TransferActions{Transfers = new List<Transfer>{new Transfer(), new Transfer()}}; _strategyMock.Setup(x => x.MakeTransfers(It.IsAny<SeasonState>())).Returns(transfers); //Act var result = _seasonSimulator.PerformSimulation(_strategyMock.Object, _simulationOptions); //Assert Assert.That(result.GameweekResults[1].TransferActions, Is.EqualTo(transfers)); Assert.That(result.GameweekResults[1].TransferResults, Is.Not.Null); }
public void strategy_not_asked_to_make_transfer_decision_for_first_gameweek() { //Arrange var decision = new TransferActions(); _strategyMock.Setup(x => x.MakeTransfers(It.Is<SeasonState>(s => s.Gameweek == 1))).Returns(decision); //Act _seasonSimulator.PerformSimulation(_strategyMock.Object, _simulationOptions); //Assert _strategyMock.Verify(x => x.MakeTransfers(It.Is<SeasonState>(s => s.Gameweek == 1)), Times.Never()); }
public void SetUp() { _seasonState = new SeasonState { Gameweek = 2, FreeTransfers = 1, CurrentTeam = TeamCreationHelper.CreateTestTeam(4, 3, 3, Position.Defender, Position.Midfielder, Position.Midfielder) }; _transferActions = new TransferActions(); _transferValidatorMock = new Mock<ITransferValidator>(); _transferActionerMock = new Mock<ITransferActioner>(); _decisionActioner = new DecisionActioner(_transferActionerMock.Object, _transferValidatorMock.Object); _allPlayers = new List<Player>(); }
public void can_not_transfer_the_same_player_in_multiple_times_in_same_gameweek() { // Arrange var playerIn = _seasonState.AllPlayers.First(); _transferActions = new TransferActions { Transfers = new List<Transfer> { new Transfer { PlayerIn = playerIn, PlayerOut = _seasonState.CurrentTeam.Players.Where(p => p.Position == playerIn.Position).ElementAt(0) }, new Transfer { PlayerIn = playerIn, PlayerOut = _seasonState.CurrentTeam.Players.Where(p => p.Position == playerIn.Position).ElementAt(1) } } }; //Act var transferValidity = _transferValidator.ValidateTransfers(_seasonState, _transferActions); //Assert Assert.That(transferValidity, Is.EqualTo(TransferValidity.PlayerTransferredInMultipleTimes)); }
public void SetUp() { _seasonState = new SeasonState { CurrentTeam = TeamCreationHelper.CreateTestTeam(), AllPlayers = TeamCreationHelper.CreatePlayerList(10,10,10,10, startingId: 100), Gameweek = 2 }; _transferActions = new TransferActions(); _transferActionerMock = new Mock<ITransferActioner>(); _transferActionerMock.Setup(x => x.ApplyTransfers(It.IsAny<SeasonState>(), It.IsAny<TransferActions>())). Returns((SeasonState s, TransferActions t) => new TransferActionsResult{UpdatedSeasonState = s}); _configSettingsMock = new Mock<IConfigurationSettings>(); _transferValidator = new TransferValidator(_configSettingsMock.Object, _transferActionerMock.Object); }
public void can_not_transfer_the_same_player_out_multiple_times_in_same_gameweek() { // Arrange var playerOut = _seasonState.CurrentTeam.Players.First(); _transferActions = new TransferActions { Transfers = new List<Transfer> { new Transfer { PlayerIn = _seasonState.AllPlayers[0], PlayerOut = playerOut }, new Transfer { PlayerIn = _seasonState.AllPlayers[1], PlayerOut =playerOut } } }; //Act var transferValidity = _transferValidator.ValidateTransfers(_seasonState, _transferActions); //Assert Assert.That(transferValidity, Is.EqualTo(TransferValidity.PlayerTransferredOutMultipleTimes)); }
private TransferActionsResult ApplyWildcards(SeasonState seasonState, TransferActions actions, TransferActionsResult result) { if (actions.PlayStandardWildcard) { if (VerboseLoggingEnabled) { _logger.Log(Tag.Transfers, "Standard wildcard played", true); } seasonState.StandardWildCardPlayed = true; result.PenalisedTransfersMade = 0; } else if (actions.PlayTransferWindowWildcard) { if (VerboseLoggingEnabled) { _logger.Log(Tag.Transfers, "Transfer window wildcard played", true); } seasonState.TransferWindowWildcardPlayed = true; result.PenalisedTransfersMade = 0; } return result; }
private StrategyDecisionsResult ProcessStrategyDecisions(SeasonState seasonState, IStrategy strategy) { var updatedSeasonState = seasonState; var transferActions = new TransferActions(); var transferResults = new TransferActionsResult(); //no transfers in first gameweek if (seasonState.Gameweek > 1) { transferActions = strategy.MakeTransfers(updatedSeasonState); transferResults = _decisionActioner.ValidateAndApplyTransfers(updatedSeasonState, transferActions); updatedSeasonState = transferResults.UpdatedSeasonState; } var selectedTeamForGameweek = strategy.PickGameweekTeam(updatedSeasonState); updatedSeasonState = _decisionActioner.ValidateAndApplyGameweekTeamSelection(updatedSeasonState, selectedTeamForGameweek); return new StrategyDecisionsResult { TransfersMade = transferActions, TransferResults = transferResults, UpdatedSeasonState = updatedSeasonState }; }