public GameController(ILogger <GameController> logger, IGameBuilder builder, IGameHost gameHost, IGameSimulationService simulator)
{
_logger = logger;
_builder = builder;
_gameHost = gameHost;
_simulator = simulator;
}
public CompositionRoot(IDomainEventChannelFactory domainEventChannelFactory,
IGameBuilder gameBuilder,
IUICommandChannelFactory commandChannelFactory,
IGameViewFactory gameViewFactory)
{
this.GameId = Guid.NewGuid();
this.domainEventChannel = MaybeConvertions.ToMaybe(domainEventChannelFactory.Create());
// Application
gameService = new GameService(this.domainEventChannel,
new GameInMemoryRepository(),
gameBuilder);
gameService.GenerateNewGame(this.GameId);
// View
this.uiCommandChannel = commandChannelFactory.Create();
this.gameView = gameViewFactory.Create(this.uiCommandChannel);
// Handlers
this.fromUICommandsToDomainHandler =
new FromUICommandsToDomainHandler(this.uiCommandChannel, this.gameService, this.GameId);
this.fromDomainEventsToViewHandler =
new FromDomainEventsToViewHandler(this.domainEventChannel, this.gameView);
}
public CompositionRootBuilder()
{
domainEventChannelFactory = new DomainEventChannelFactory();
gameBuilder = new GameBuilder();
commandChannelFactory = new UICommandChannelFactory();
gameViewFactory = new GameViewFactory();
}
public GameHandler(IGameBuilder gameBuilder, IMoveHandler moveHandler, IBoardHandler boardHandler)
{
_gameBuilder = gameBuilder;
_moveHandler = moveHandler;
_boardHandler = boardHandler;
Game = null;
}
public GameHandler(IGameBuilder gameBuilder, IMoveHandler moveHandler, IBoardHandler boardHandler)
{
_gameBuilder = gameBuilder;
_moveHandler = moveHandler;
_boardHandler = boardHandler;
Game = null;
}
public GameService(IGameRepository gameRepository, IJudge judge, IGameBuilder gameBuilder, ICPUPlayer cpuPlayer)
{
this.gameRepository = gameRepository;
this.judge = judge;
this.gameBuilder = gameBuilder;
this.cpuPlayer = cpuPlayer;
}
public void Init(IRegistrator registrator)
{
_builder = new GameBuilder();
registrator.Register(_builder);
_inputManager = _builder.GetImpl <IInputManager>();
_outputManager = _builder.GetImpl <IOutputManager>();
_drawLoopExecutor = _builder.GetImpl <IDrawLoopExecutor>();
}
public GameService(Maybe <IDomainEventChannel> domainEventChannel,
IGameRepository gameRepository,
IGameBuilder gameBuilder)
{
this.domainEventChannel = domainEventChannel;
this.gameRepository = gameRepository;
this.gameBuilder = gameBuilder;
}
public MinefieldGame(IGameBuilder gameBuilder, IGameStateProcessor gameStateProcessor,
IInputManager inputManager, IDisplayManager displayManager)
{
_gameBuilder = gameBuilder;
_gameStateProcessor = gameStateProcessor;
_inputManager = inputManager;
_displayManager = displayManager;
}
public MainWindow()
{
InitializeComponent();
//TODO: Get UniverseSize from config or UI and draw/resize the canvas
UniverseSize = 25;
//TODO: Use dependency injection
gameBuilder = new GameBuilder(new GameOfLife(UniverseSize));
BuildAndDraw();
}
private static IParticipant GetOrAddParticipantIfMissing(IGameBuilder gameBuilder, Dictionary <IIdentifier, IParticipant> participantDictionary, IIdentifier participantIdentifier)
{
if (!participantDictionary.ContainsKey(participantIdentifier))
{
IParticipant student = gameBuilder.CreateParticipant(participantIdentifier);
participantDictionary.Add(participantIdentifier, student);
student.Sign();
}
return(participantDictionary[participantIdentifier]);
}
public void TestPlayerRaceRandomization()
{
Game Game = null;
IGameBuilder builder = NewGameBuilder.Create().
SetMap(new DemoMap()).
SetPlayerName("Player 1").
SetPlayerName("Player 2").
SetPlayerName("Player 3");
IDictionary <Type, IDictionary <string, int> > racesResults =
new Dictionary <Type, IDictionary <string, int> >();
IDictionary <String, int> dict = null;
int i = 0;
while (i++ < 1000)
{
Game = builder.Build();
for (var j = 0; j < Game.Players.Count; j++)
{
var name = Game.Players[j].Name;
var race = Game.Players[j].Race;
if (racesResults.ContainsKey(race.GetType()))
{
dict = racesResults[race.GetType()];
if (dict.ContainsKey(name))
{
dict[name]++;
}
else
{
dict[name] = 1;
}
}
else
{
dict = new Dictionary <String, int>();
dict.Add(name, 1);
racesResults[race.GetType()] = dict;
}
}
}
var normalDistribMean = 1.0 / racesResults.Keys.Count;
foreach (var type in racesResults.Keys)
{
foreach (var name in racesResults[type].Keys)
{
var percentage = racesResults[type][name] / (double)racesResults[type].Values.Sum();
Assert.IsTrue(normalDistribMean - 0.1 < percentage && percentage < normalDistribMean + 0.1);
}
}
}
public FiveOneTwoGameCreator(int _gameSize)
{
if (_gameSize <= 3)
{
throw new ArgumentException(nameof(_gameSize) + " should be more or equal then 3 ");
}
gameSize = _gameSize;
gameBuilder = new FiveOneTwoGameBuilder();
fieldBuilder = new FiveOneTwoFieldBuilder(gameSize);
}
public GameWindow(IGameBuilder builder)
{
InitializeComponent();
game = builder.build();
createPVM();
createGVM();
initializeDataContext();
drawMap();
beginTurn();
//Center the screen when the window is loaded
this.Loaded+=new RoutedEventHandler(GameWindow_Loaded);
}
Compilation([NotNull] Context ctx, [NotNull] IGameBuilder game, bool wantDebugInfo)
{
Context = ctx;
Game = game;
WantDebugInfo = wantDebugInfo;
var equalizer = new AtomNameEqualityComparer(ctx.IgnoreCase);
Globals = new Dictionary <ZilAtom, IGlobalBuilder>(equalizer);
Constants = new Dictionary <ZilAtom, IOperand>(equalizer);
Routines = new Dictionary <ZilAtom, IRoutineBuilder>(equalizer);
Objects = new Dictionary <ZilAtom, IObjectBuilder>(equalizer);
Properties = new Dictionary <ZilAtom, IPropertyBuilder>(equalizer);
Flags = new Dictionary <ZilAtom, IFlagBuilder>(equalizer);
SoftGlobals = new Dictionary <ZilAtom, SoftGlobal>(equalizer);
}
public void SetUp()
{
_gameBuilder = MockRepository.GenerateMock <IGameBuilder>();
_gameStateProcessor = MockRepository.GenerateMock <IGameStateProcessor>();
_inputManager = MockRepository.GenerateMock <IInputManager>();
_displayManager = MockRepository.GenerateMock <IDisplayManager>();
_testGameState = MockRepository.GenerateStub <IGameState>();
_gameBuilder.Stub(x => x.Build(
Arg <int> .Is.Anything,
Arg <int> .Is.Anything,
Arg <int> .Is.Anything,
Arg <int> .Is.Anything)).Return(_testGameState);
_game = new MinefieldGame(_gameBuilder, _gameStateProcessor, _inputManager, _displayManager);
}
/// <summary>
/// Initializes a new instance of GameEngin object.
/// </summary>
/// <param name="builder">IGameBuilder object used for building core game objects.</param>
/// <param name="board">GameBoard used in the game.</param>
/// <param name="provider">Object which provides some useful game settings.</param>
public GameEngine(IGameBuilder builder, GameBoard board, ISettingsProvider provider)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (board == null)
{
throw new ArgumentNullException(nameof(board));
}
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
_provider = provider;
_builder = builder;
_gameBoard = board;
}
public CompositionRoot(IDomainEventChannelFactory domainEventChannelFactory,
IGameBuilder gameBuilder,
IUICommandChannelFactory commandChannelFactory,
IGameViewFactory gameViewFactory)
{
// Domain
this.domainEventChannel = domainEventChannelFactory.Create();
this.game = gameBuilder.Create(this.domainEventChannel);
// View
this.uiCommandChannel = commandChannelFactory.Create();
this.gameView = gameViewFactory.Create(this.uiCommandChannel);
// Handlers
this.fromUICommandsToDomainHandler =
new FromUICommandsToDomainHandler(this.uiCommandChannel, this.game);
this.fromDomainEventsToViewHandler =
new FromDomainEventsToViewHandler(this.domainEventChannel, this.gameView);
}
/// <summary>
/// Initializes a new instance of GameViewModel object.
/// </summary>
/// <param name="builder">An object that builds core game objects.</param>
/// <param name="viewModelChanger">An object that changes views in the application.</param>
/// <param name="accessor">An object that have access to control keys.</param>
/// <param name="provider">An object that provides some configuration settings used in the game.</param>
public GameViewModel(IGameBuilder builder, IViewModelChanger viewModelChanger, IHaveControlKeys accessor, ISettingsProvider provider) : base("Game")
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
_builder = builder;
if (accessor == null)
{
throw new ArgumentNullException(nameof(accessor));
}
_accessor = accessor;
if (viewModelChanger == null)
{
throw new ArgumentNullException(nameof(viewModelChanger));
}
_viewModelChanger = viewModelChanger;
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
_provider = provider;
}
/// <summary>
/// Initializes a new instance of MainWindowViewModel.
/// </summary>
/// <param name="builder">An object that is responsible for building core game objects.</param>
/// <param name="highscores">The list of the highscores in the game.</param>
/// <param name="gameSerializer">An object that is responsible for saving and loading GameState.</param>
/// <param name="validator">An object that validates control keys used in the game.</param>
/// <param name="provider">An object that provides some configuration settings used in the game.</param>
public MainWindowViewModel(IGameBuilder builder, HighscoreList highscores, IGameSerializer gameSerializer,
IKeysValidator validator, ISettingsProvider provider) : base("Main")
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
_provider = provider;
var vm = new List <ViewModelBase>
{
new StartMenuViewModel(this, gameSerializer),
new OptionsViewModel(this, validator),
new HighscoresViewModel(highscores),
new GameViewModel(builder, this, this, provider),
new EndGameViewModel(highscores),
new PauseViewModel(this, gameSerializer)
};
foreach (var result in vm.OfType <CloseableViewModel>())
{
result.RequestClose += (sender, args) => OnCloseView((sender as ViewModelBase)?.Name);
}
ViewModels = vm;
}
public GameServices(IGameBuilder gameBuilder, IGameRepository gameRepository)
{
_gameBuilder = gameBuilder;
_gameRepository = gameRepository;
}
public GameBuilder(IGameBuilder gameBuilder)
{
_Builder = gameBuilder;
}
public Student(IGameBuilder gameBuilder, IIdentifier studentIdentifier)
{
StudentIdentifier = studentIdentifier;
MyYearBook = gameBuilder.CreateYearBook(this);
YearBookRecieved = MyYearBook;
}
public static void Compile([NotNull] Context ctx, [NotNull] IGameBuilder gb)
{
var compilation = new Compilation(ctx, gb, gb.DebugFile != null && ctx.WantDebugInfo);
compilation.Compile();
}
public void ConfigureCommands(IGameBuilder gameBuilder)
{
gameBuilder.AddHelp();
}
public static void AddHelp(this IGameBuilder gameBuilder)
{
gameBuilder.AddCommand<HelpCommand>();
}
public void Register(IGameBuilder builder)
{
builder.SetComponent <IInputManager>(new InputManager());
builder.SetComponent <IOutputManager>(new OutputManager());
builder.SetComponent <IDrawLoopExecutor>(new DrawLoopExecutor());
}
