Example #1
0
 public TronGame(GameEngineSettings settings, GameOptions options, ILoggerFactory loggerFactory)
 {
     _ID            = Guid.NewGuid().ToString().Replace("-", "");
     this.settings  = settings;
     this.isWorking = false;
     this.logger    = loggerFactory.CreateLogger("TronGame");
     this.options   = options;
     this.board     = new byte[settings.TronBoardSizeY, settings.TronBoardSizeX];
     this.players   = new List <IPlayer>();
 }
Example #2
0
		public static void Main(string[] args)
		{
			var ioProvider = new ConsoleIOProvider();
			var player = new Player();
			var field = new Field();

			var gameUISettngs = new DefaultUIEngineSettings<ConsoleIOProvider>(ioProvider, player);
			var gameUI = new UIEngine<ConsoleIOProvider>(gameUISettngs);
			var gameEngineSettings = new GameEngineSettings<IDefaultUIEngine, IIntegerStats>(gameUI, field, player, InFileScores.Instance);
			var gameEngine = new GameEngine(gameEngineSettings);
			gameEngine.Start();
		}
		private FakeGameEngine()
		{
			this._ioProvider = new ConsoleIOProvider();
			this._player = new Player();
			this._field = new Field();
			this._movement = new StraightMovement(this._field);

			var gameUISettngs = new DefaultUIEngineSettings<ConsoleIOProvider>(this._ioProvider, this._player);
			var gameUI = new UIEngine<ConsoleIOProvider>(gameUISettngs);
			this._gameEngineSettings = new GameEngineSettings<IDefaultUIEngine, IIntegerStats>(gameUI, this._field, this._player, InFileScores.Instance, this._movement);

			this._sampleGameEngine = new GameEngine(this._gameEngineSettings);
		}
        /// <summary>
        ///     Initializes a new instance of the <see cref="GameWindow"/> class
        ///     using the specified parameters.
        /// </summary>
        public GameWindow(
            Size nominalSize,
            ChickenTeamSettings lightTeam,
            ChickenTeamSettings darkTeam,
            PositionMode positionMode)
            : this()
        {
            Action <GamePositionEventArgs> positionCallback;

            switch (positionMode)
            {
            case PositionMode.Random:
                positionCallback = UnitPositioningHelper.PositionRandomly;
                break;

            case PositionMode.LineFight:
                positionCallback = UnitPositioningHelper.PositionForLineFight;
                break;

            default:
                throw positionMode.CreateEnumValueNotImplementedException();
            }

            var settings = new GameEngineSettings(nominalSize, lightTeam, darkTeam, this.PaintGame)
            {
                PositionCallback = positionCallback
            };

            _gameEngine            = new GameEngine(settings);
            _gameEngine.GameEnded += this.GameEngine_GameEnded;

            this.Title = string.Format(
                "{0} [{1}x{2}] [L: {3}x {4}  -vs-  D: {5}x {6}]",
                this.Title,
                nominalSize.Width,
                nominalSize.Height,
                lightTeam.UnitCount,
                lightTeam.Type.Name,
                darkTeam.UnitCount,
                darkTeam.Type.Name);
        }
		private void MainForm_Load(object sender, EventArgs e)
		{
			var ioProvider = new WindowsFormsIOProvider(this);
			var player = new Player();
			var field = new Field();

			var gameUISettngs = new DefaultUIEngineSettings<WindowsFormsIOProvider>(
				ioProvider,
				player,
				ioProviderSettings: new WindowsFormsIOProviderSettings(),
				startRenderer: new StartWindowRenderer<WindowsFormsIOProvider>(),
				exitRenderer: new ExitWindowRenderer<WindowsFormsIOProvider>(),
				chooseDifficultyRenderer: new ChooseDifficultyWindowRenderer<WindowsFormsIOProvider>(),
				helpDisplayRenderer: new HelpDisplayWindowRenderer<WindowsFormsIOProvider>(),
				fieldRenderer: new FieldWindowsRenderer<WindowsFormsIOProvider>());

			var gameUI = new UIEngine<WindowsFormsIOProvider>(gameUISettngs);
			var gameEngineSettings = new GameEngineSettings<IDefaultUIEngine, IIntegerStats>(gameUI, field, player, InMemoryScores.Instance);
			var gameEngine = new GameEngine(gameEngineSettings);
			this._gameEngine = gameEngine;

			Task.Run(() => gameEngine.Start());
		}
Example #6
0
 public GameCreationFactory(IOptions <GameEngineSettings> settings, ILoggerFactory logger)
 {
     this.settings = settings.Value;
     this.logger   = logger;
 }
Example #7
0
 public GameService(IOptions <GameEngineSettings> settings, IGameCreationFactory gameCreationFactory)
 {
     this.settings            = settings.Value;
     this.games               = new ConcurrentDictionary <string, IGame>();
     this.gameCreationFactory = gameCreationFactory;
 }
        /// <summary>
        ///     Initializes a new instance of the <see cref="GameEngine"/> class.
        /// </summary>
        public GameEngine(GameEngineSettings settings)
        {
            #region Argument Check

            if (settings == null)
            {
                throw new ArgumentNullException("settings");
            }

            #endregion

            if (SettingsCache.Instance.UsePerformanceCounters)
            {
                PerformanceCounterHelper.Initialize();
            }

            // Pre-initialized fields and properties
            _paintCallback        = settings.PaintCallback;
            _positionCallback     = settings.PositionCallback.EnsureNotNull();
            this.Data             = new GameEngineData(settings.NominalSize);
            _moveCount            = new ThreadSafeValue <long>();
            _winningTeam          = new ThreadSafeValue <GameTeam?>();
            _lastGamePresentation = new ThreadSafeValue <GamePresentation>();

            // Post-initialized fields and properties
            _lightTeamLogicExecutor = CreateLogicExecutor(this, settings.LightTeamSettings, GameTeam.Light);
            _darkTeamLogicExecutor  = CreateLogicExecutor(this, settings.DarkTeamSettings, GameTeam.Dark);
            _logicExecutors         = new[] { _lightTeamLogicExecutor, _darkTeamLogicExecutor }.ToArray().AsReadOnly();

            _allChickens = _logicExecutors.SelectMany(item => item.Units).ToArray().AsReadOnly();
            _allChickens.DoForEach((item, index) => item.UniqueId = new GameObjectId(index + 1));

            _aliveChickensDirect = new List <ChickenUnit>();
            this.AliveChickens   = _aliveChickensDirect.AsReadOnly();

            _shotUnitsDirect = new List <ShotUnit>(_allChickens.Count);
            this.ShotUnits   = _shotUnitsDirect.AsReadOnly();

            _moveInfos      = new Dictionary <ChickenUnit, MoveInfo>(_allChickens.Count);
            _moveInfoStates = new Dictionary <ChickenUnit, MoveInfoStates>(_allChickens.Count);
            _previousMoves  = new Dictionary <ChickenUnit, MoveInfo>(_allChickens.Count);
            _newShotUnits   = new List <ShotUnit>(_allChickens.Count);

            #region Argument Check

            var maxChickenCount = this.Data.NominalSize.Width * this.Data.NominalSize.Height / 2;
            if (_allChickens.Count > maxChickenCount)
            {
                throw new ArgumentException(
                          string.Format(
                              "Too many chickens ({0}) for the board of nominal size {1}x{2}. Maximum is {3}.",
                              _allChickens.Count,
                              this.Data.NominalSize.Width,
                              this.Data.NominalSize.Height,
                              maxChickenCount),
                          "settings");
            }

            #endregion

            ResetInternal();
        }