public static void RunSimulations(SeasonSimulationOptions simulationOptions, IUnityContainer container, ILogger logger)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
if (!string.IsNullOrWhiteSpace(simulationOptions.StrategyName))
{
RegisterStrategyByName(container, simulationOptions.StrategyName);
}
if(simulationOptions.ListUsage)
{
ListUsage();
}
else if (simulationOptions.CalculateTeamStrengthOnly)
{
CalculateTeamStrengths(container, logger);
}
else if (simulationOptions.CalculateHomeAdvantageRatioOnly)
{
CalculateHomeAdvantageRatio(container, logger);
}
else if (simulationOptions.CalculatePlayerFormOnly)
{
CalculatePlayerForm(container, logger);
}
else
{
RunSeasonSimulation(container, logger, simulationOptions);
}
stopwatch.Stop();
logger.Log(Tag.Progress, string.Format("Simulation time: {0}", stopwatch.Elapsed.ToFormatted()));
}
public SeasonSimulationResult PerformSimulation(IStrategy strategy, SeasonSimulationOptions options)
{
if (strategy == null) throw new ArgumentNullException("strategy");
var allPlayers = GetPlayersForFirstGameweek();
var maxGameweek = CalculateMaxGameweek(options.MaximumGameweek);
_logger.Log(Tag.Simulation, string.Concat("Max gameweek is ", maxGameweek));
var startingTeam = options.UseSavedInitialTeam ? SelectInitialTeamByIds(allPlayers, options.InitialTeamPlayerIds) : strategy.PickStartingTeam(allPlayers);
_logger.Log(Tag.Simulation, "Starting team picked");
LogHelper.LogTeam(startingTeam, _logger);
if (options.ChooseInitialTeamOnly)
{
return new SeasonSimulationResult();
}
var seasonState = _decisionActioner.ValidateAndApplyStartingTeam(startingTeam, allPlayers);
_logger.Log(Tag.Simulation, "Applied starting team");
return SimulateSeason(seasonState, strategy, maxGameweek);
}
private static SeasonSimulationOptions CreateSimulationOptions(Arguments arguments)
{
var options = new SeasonSimulationOptions
{
CalculateTeamStrengthOnly = GetBoolArgument(arguments, ConsoleOptions.CalculateTeamStrengthsOnly),
ChooseInitialTeamOnly = GetBoolArgument(arguments, ConsoleOptions.ChooseInitialTeamOnly),
CalculatePlayerFormOnly = GetBoolArgument(arguments, ConsoleOptions.CalculatePlayerFormOnly),
ListUsage = GetBoolArgument(arguments, ConsoleOptions.ListUsage),
CalculateHomeAdvantageRatioOnly = GetBoolArgument(arguments, ConsoleOptions.CalculateHomeAdvantageOnly),
UseSavedInitialTeam = GetBoolArgument(arguments, ConsoleOptions.UseSavedInitialTeam),
StrategyName = GetStringArgument(arguments, ConsoleOptions.StrategyName)
};
var maxGameweekString = arguments[ConsoleOptions.MaxGameweek];
if (!string.IsNullOrWhiteSpace(maxGameweekString))
{
options.MaximumGameweek = int.Parse(maxGameweekString);
}
return options;
}
public void SetUp()
{
_allPlayers = TeamCreationHelper.CreatePlayersWithPastFixtures(1);
_playerServiceMock = new Mock<IMultiplePlayersService>();
_playerServiceMock.Setup(x => x.GetAllPlayers()).Returns(_allPlayers);
_startingTeam = TeamCreationHelper.CreateTestTeam();
var startingSeasonState = new SeasonState { CurrentTeam = _startingTeam };
_strategyMock = new Mock<IStrategy>();
_strategyMock.Setup(x => x.MakeTransfers(It.IsAny<SeasonState>())).Returns((SeasonState seasonState) => new TransferActions());
_strategyMock.Setup(x => x.PickStartingTeam(It.IsAny<IList<Player>>())).Returns(_startingTeam);
_strategyMock.Setup(x => x.PickGameweekTeam(It.IsAny<SeasonState>())).Returns(_startingTeam);
_timeAdjustorMock = new Mock<ITimeAdjustor>();
_timeAdjustorMock.Setup(x => x.AdjustPlayersToGameweek(It.IsAny<IList<Player>>(), It.IsAny<int>())).Returns(
(IList<Player> players, int gameweek) => players);
_timeAdjustorMock.Setup(x => x.AdjustTeamToGameweek(It.IsAny<Team>(), It.IsAny<IList<Player>>(), It.IsAny<int>())).Returns(
(Team team, IList<Player> players, int gameweek) => team);
_gameweekSimulatorMock = new Mock<IGameweekSimulator>();
_gameweekSimulatorMock.Setup(
x => x.CalculatePlayerPerformances(It.IsAny<Team>(), It.IsAny<int>(), It.IsAny<IList<Player>>())).
Returns(new List<PlayerGameweekPerformance>());
_decisionActionerMock = new Mock<IDecisionActioner>();
_simulationOptions = new SeasonSimulationOptions();
_decisionActionerMock.Setup(
x => x.ValidateAndApplyTransfers(It.IsAny<SeasonState>(), It.IsAny<TransferActions>())).Returns((SeasonState s, TransferActions a) => new TransferActionsResult{UpdatedSeasonState = s});
_decisionActionerMock.Setup(x => x.ValidateAndApplyStartingTeam(It.IsAny<Team>(), It.IsAny<IList<Player>>())).Returns(startingSeasonState);
_decisionActionerMock.Setup(x => x.ValidateAndApplyGameweekTeamSelection(It.IsAny<SeasonState>(), It.IsAny<Team>())).Returns(startingSeasonState);
_seasonSimulator = new SeasonSimulator(_playerServiceMock.Object, _timeAdjustorMock.Object,
_gameweekSimulatorMock.Object, _decisionActionerMock.Object, new Mock<ILogger>().Object);
}
private static void RunSeasonSimulation(IUnityContainer container, ILogger logger, SeasonSimulationOptions simulationOptions)
{
logger.Log(Tag.Progress, "Starting season simulation");
var strategy = container.Resolve<IStrategy>();
var simulator = container.Resolve<ISeasonSimulator>();
var result = simulator.PerformSimulation(strategy, simulationOptions);
logger.Log(Tag.Progress, "Ending season simulation");
if (!simulationOptions.ChooseInitialTeamOnly)
{
logger.Log(Tag.Progress, string.Format("Total points: {0}", result.TotalPointsScored));
}
}