public GameViewModel(IGameSettings gameSettings, IQuestsManager questsManager, IDialogService dialogService)
{
_gameSettings = gameSettings;
_questsManager = questsManager;
_dialogService = dialogService;
_game = Mvx.GetSingleton <IGame>();
BoardViewModel = new BoardViewModel(Game.Info.BoardSize);
BoardViewModel.BoardTapped += (s, e) => OnBoardTapped(e);
BoardViewModel.IsTouchInputOffsetEnabled = gameSettings.Display.AddTouchInputOffset;
// Set empty node (should be in the beginning of every gametree) as current node for board rendering
RefreshBoard(Game.Controller.GameTree.LastNode);
_uiConnector = new UiConnector(Game.Controller);
_phaseStartHandlers = new Dictionary <GamePhaseType, Action <IGamePhase> >();
_phaseEndHandlers = new Dictionary <GamePhaseType, Action <IGamePhase> >();
SetupPhaseChangeHandlers(_phaseStartHandlers, _phaseEndHandlers);
Game.Controller.RegisterConnector(_uiConnector);
Game.Controller.GameEnded += (s, e) => OnGameEnded(e);
Game.Controller.GameTree.LastNodeChanged += (s, e) => OnCurrentNodeChanged(e);
Game.Controller.TurnPlayerChanged += (s, e) => OnTurnPlayerChanged(e);
Game.Controller.GamePhaseChanged += (s, e) => OnGamePhaseChanged(e);
ObserveDebuggingMessages();
}
public void RefreshViewport(IGameSettings settings, IWindowInfo window, IViewport viewport, bool updateViewportScreenArea)
{
var area = viewport.GetScreenArea(settings, window, updateViewportScreenArea);
ScreenViewport = viewport.ScreenArea;
_graphics.Viewport(area.X, area.Y, area.Width, area.Height);
}
private void onGameWindowLoaded(TypedParameter settingsParameter, IGameSettings settings)
{
TypedParameter gameWindowParameter = new TypedParameter(typeof(IGameWindow), GameWindow);
Settings = _resolver.Container.Resolve <IRuntimeSettings>(settingsParameter, gameWindowParameter);
_graphics.ClearColor(0f, 0f, 0f, 1f);
_graphics.Init();
_glUtils.GenBuffers();
Factory = _resolver.Container.Resolve <IGameFactory>();
IAGSInput input = _resolver.Container.Resolve <IAGSInput>();
input.Init(settings.VirtualResolution);
Input = input;
TypedParameter inputParamater = new TypedParameter(typeof(IInput), Input);
TypedParameter gameParameter = new TypedParameter(typeof(IGame), this);
RenderLoop = _resolver.Container.Resolve <IRendererLoop>(inputParamater, gameParameter, gameWindowParameter);
updateResolver();
HitTest = _resolver.Container.Resolve <IHitTest>();
AudioSettings = _resolver.Container.Resolve <IAudioSettings>();
SaveLoad = _resolver.Container.Resolve <ISaveLoad>();
_glUtils.AdjustResolution(settings.VirtualResolution.Width, settings.VirtualResolution.Height);
Events.OnLoad.Invoke();
}
public Board(IShipPositionsRandomizer shipPositionsRandomizer, IGameSettings gameSettings)
{
_gameSettings = gameSettings;
_shipPositionsRandomizer = shipPositionsRandomizer;
Ships = _shipPositionsRandomizer.RandomizeShipsPositions();
Fields = FillTheFields(Ships);
}
public static void PowerPillEaten(IGameSettings gameSettings, GameState gameState, CellLocation powerPillLocation, GameNotifications gameNotifications)
{
gameState.IncreaseScore(50);
gameNotifications.Publish(GameNotification.EatPowerPill);
MakeGhostsEdible(gameSettings, gameState);
gameState.RemovePowerPill(powerPillLocation);
}
public static void TestKnuthRandomizedParallelOnRange(IGameSettings settings)
{
var generator = new GenerateKeyRangesService();
var serviceUnderTests = new KnuthSolverRandomizedParallelService(generator);
TestOnRange(serviceUnderTests, settings, "KnuthRandomizedParallel");
}
public Game(IGameSettings gameSettings, List <List <ActionType> > sequences)
{
_gameSettings = gameSettings;
_sequences = sequences;
Board = new Board(gameSettings);
}
public static void CompleteRespawning(GameState gameState, IGameSettings gameSettings)
{
MakeGhostsNotEdible(gameState);
MoveGhostsHome(gameState);
MovePacManHome(gameState, gameSettings);
gameState.ShowGhosts();
}
public GameLogic(IGameSettings settings)
{
Settings = settings;
Level = new Level(settings, LoadPlayers());
Level.Initialise();
}
public MineSearchGame(IGameSettings gameSettings)
{
var cellsFactory = new MineSearchCellsFactory(gameSettings);
Cells = cellsFactory.CreateCells();
RemainingMineCount = gameSettings.MineCount;
_remainingCellsToReveal = Cells.Count(cell => cell is SafeCell);
}
private void ReadSettings()
{
var appSettings = ConfigurationManager.AppSettings;
_gameSettings = new GameSettings();
_gameSettings.ReadFromApplicationSettings(appSettings);
}
public AGSInspector(IGameFactory factory, IGameSettings settings, IGameState state)
{
_state = state;
_props = new Dictionary <Category, List <InspectorProperty> >();
_factory = factory;
_settings = settings;
}
public AGSFontFactory(IResourceLoader resources, IDevice device, IGameSettings settings)
{
_device = device;
_resources = resources;
_settings = settings;
_installedFonts = new ConcurrentDictionary <string, string>();
}
public void LoadFrom(IGameSettings settings)
{
Title = settings.Title;
VirtualResolution = settings.VirtualResolution;
Vsync = settings.Vsync;
PreserveAspectRatio = settings.PreserveAspectRatio;
WindowState = settings.WindowState;
WindowBorder = settings.WindowBorder;
_windowSize = new AGS.API.Size(_gameWindow.ClientWidth, _gameWindow.ClientHeight);
var messageBoxSettings = Defaults?.MessageBox;
var fontSettings = Defaults?.Fonts;
var dialogSettings = Defaults?.Dialog;
Defaults = settings.Defaults;
if (Defaults.MessageBox == null)
{
Defaults.MessageBox = messageBoxSettings;
}
if (Defaults.Fonts == null)
{
Defaults.Fonts = fontSettings;
}
if (Defaults.Dialog == null)
{
Defaults.Dialog = dialogSettings;
}
}
public GameFieldGraphicsComponent(IGameFieldEntity gameField, IGraphicsSettings graphicsSettings, IGraphicsSystem graphicsSystem, IGameSettings gameSettings)
{
_gameFieldEntity = gameField ?? throw new ArgumentNullException(nameof(gameField));
_graphicsSettings = graphicsSettings ?? throw new ArgumentNullException(nameof(graphicsSettings));
_graphicsSystem = graphicsSystem ?? throw new ArgumentNullException(nameof(graphicsSystem));
_gameSettings = gameSettings ?? throw new ArgumentNullException(nameof(gameSettings));
}
public OnlineGameViewModel(IGameSettings gameSettings, IQuestsManager questsManager, IDialogService dialogService)
: base(gameSettings, questsManager, dialogService)
{
(Game.Controller as RemoteGameController).Server.Events.UndoRequestReceived += Events_UndoRequestReceived;
(Game.Controller as RemoteGameController).Server.Events.UndoDeclined += Events_UndoDeclined;
ChatViewModel = new ChatViewModel((Game.Controller as RemoteGameController).Chat, (Game.Controller as RemoteGameController).Connectors.First(connector => connector is IRemoteConnector) as IRemoteConnector);
}
private static async void StartupKgs(IGameSettings settings, IAppNotificationService notifications)
{
if (settings.Interface.KgsAutoLogin && settings.Interface.KgsRememberPassword)
{
await Connections.Kgs.LoginAsync(settings.Interface.KgsName, settings.Interface.KgsPassword);
}
}
public FieldElement(IGameSettings gameSettings, GameField field, Tile.Factory tileFactory, Crystal.Factory crystalFactory)
{
_field = field;
_gameSettings = gameSettings;
_tileFactory = tileFactory;
_crystalFactory = crystalFactory;
}
public IMastermindGame PrepareGame(string answer, IGameSettings gameSettings)
{
var checkAnswers = new AnswerCheckService();
var mastermindGame = new MastermindGameService(answer, checkAnswers, gameSettings);
return(mastermindGame);
}
public GameController(IGameSettings gameSettings, int rX, int rY, GraphicsMode graphicsMode,
string title, int major, int minor, IDirectoryHandler directoryHandler)
: base(rX, rY, graphicsMode, title, GameWindowFlags.Default, DisplayDevice.Default,
major, minor, GraphicsContextFlags.Default)
{
// Add OpenGL/GPU information tags to sentry
var glVersion = GL.GetString(StringName.Version);
var glslVersion = GL.GetString(StringName.ShadingLanguageVersion);
var gpuVendor = GL.GetString(StringName.Vendor);
var renderer = GL.GetString(StringName.Renderer);
ServiceLocator.ErrorReporting.AddTags(new Dictionary <string, string>
{
{ "opengl", glVersion },
{ "glsl", glslVersion },
{ "vendor", gpuVendor },
{ "gpu", renderer }
});
// Add backend information tags to sentry
var sdl = Configuration.RunningOnSdl2;
Console.WriteLine("Running on SDL2: {0}", sdl);
ServiceLocator.ErrorReporting.AddTags(new Dictionary <string, string>
{
{ "sdl", sdl.ToString() }
});
KeyDown += Keyboard_KeyDown;
this.VSync = (bool)gameSettings["VSync"] ? VSyncMode.On : VSyncMode.Off;
this.WindowState = (WindowState)Enum.Parse(typeof(WindowState), (string)gameSettings["WindowState"]);
DebugMode.Value = (bool)gameSettings["Debug"];
_gameSettings = gameSettings;
_directoryHandler = directoryHandler;
}
public static void TestSwaszekOnRange(IGameSettings settings)
{
var generator = new GenerateKeyRangesService();
var serviceUnderTests = new SwaszekSolverService(generator);
TestOnRange(serviceUnderTests, settings, "Swaszek");
}
public void RefreshViewport(IGameSettings settings, IGameWindow gameWindow)
{
if (settings.PreserveAspectRatio) //http://www.david-amador.com/2013/04/opengl-2d-independent-resolution-rendering/
{
float targetAspectRatio = (float)settings.VirtualResolution.Width / settings.VirtualResolution.Height;
Size screen = new Size(gameWindow.Width, gameWindow.Height);
int width = screen.Width;
int height = (int)(width / targetAspectRatio + 0.5f);
if (height > screen.Height)
{
//It doesn't fit our height, we must switch to pillarbox then
height = screen.Height;
width = (int)(height * targetAspectRatio + 0.5f);
}
// set up the new viewport centered in the backbuffer
int viewX = (screen.Width / 2) - (width / 2);
int viewY = (screen.Height / 2) - (height / 2);
ScreenViewport = new Rectangle(viewX, viewY, width, height);
_graphics.Viewport(viewX, viewY, width, height);
}
else
{
ScreenViewport = new Rectangle(0, 0, gameWindow.Width, gameWindow.Height);
_graphics.Viewport(0, 0, gameWindow.Width, gameWindow.Height);
}
}
public Board(IGameSettings gameSettings)
{
Grid = new Tile[gameSettings.BoardXSize, gameSettings.BoardYSize];
//Initilize Grid
var xLength = Grid.GetLength(0);
var ylength = Grid.GetLength(1);
for (int i = 0; i < xLength; i++)
{
for (int j = 0; j < ylength; j++)
{
Grid[i, j] = new Tile();
}
}
//Set Mines
foreach (var minePoint in gameSettings.Mines)
{
Grid[minePoint.X, minePoint.Y].TileType = TileType.Mine;
}
//Set Exit
Grid[gameSettings.Exit.X, gameSettings.Exit.Y].TileType = TileType.Exit;
}
private void initServices()
{
m_LivesManager = new LivesManager(r_GameScreen);
m_ScoreManager = this.Game.Services.GetService(typeof(IScoreManager)) as IScoreManager;
m_GameSettings = this.Game.Services.GetService(typeof(IGameSettings)) as IGameSettings;
m_LivesManager.AllPlayersDied += livesManager_AllPlayersDied;
}
public void RefreshViewport(IGameSettings settings, IGameWindow gameWindow)
{
if (settings.PreserveAspectRatio) //http://www.david-amador.com/2013/04/opengl-2d-independent-resolution-rendering/
{
float targetAspectRatio = (float)settings.VirtualResolution.Width / settings.VirtualResolution.Height;
Size screen = new Size(gameWindow.Width, gameWindow.Height);
int width = screen.Width;
int height = (int)(width / targetAspectRatio + 0.5f);
if (height > screen.Height)
{
//It doesn't fit our height, we must switch to pillarbox then
height = screen.Height;
width = (int)(height * targetAspectRatio + 0.5f);
}
// set up the new viewport centered in the backbuffer
int viewX = (screen.Width / 2) - (width / 2);
int viewY = (screen.Height / 2) - (height / 2);
_graphics.Viewport(viewX, viewY, width, height);
}
else
{
_graphics.Viewport(0, 0, gameWindow.Width, gameWindow.Height);
}
}
public Game(IGameSettings settings)
{
BlindStructure = settings.BlindStructure;
InitialStack = settings.InitialStack;
Seed = settings.Seed;
Deck = new Deck(Seed);
}
/// <summary>
/// Initializes the model.
/// </summary>
/// <param name="gameType">Type of the game.</param>
/// <param name="gameSettings">The game settings.</param>
/// <param name="selectedGame">The selected game.</param>
/// <returns>IGame.</returns>
protected virtual IGame InitModel(IGameType gameType, IGameSettings gameSettings, string selectedGame)
{
var game = GetModelInstance <IGame>();
game.Type = gameType.Name;
game.Name = gameType.Name;
game.IsSelected = selectedGame == gameType.Name;
game.UserDirectory = gameType.UserDirectory;
game.SteamAppId = gameType.SteamAppId;
game.WorkshopDirectory = gameType.WorkshopDirectory;
game.LogLocation = gameType.LogLocation;
game.ChecksumFolders = gameType.ChecksumFolders;
game.GameFolders = gameType.GameFolders ?? new List <string>();
game.BaseGameDirectory = gameType.BaseGameDirectory;
game.AdvancedFeaturesSupported = gameType.AdvancedFeaturesSupported;
game.LauncherSettingsFileName = gameType.LauncherSettingsFileName;
game.LauncherSettingsPrefix = gameType.LauncherSettingsPrefix;
game.RemoteSteamUserDirectory = gameType.RemoteSteamUserDirectory;
game.CloseAppAfterGameLaunch = true;
var setExeLocation = true;
var setUserDirLocation = true;
if (gameSettings != null)
{
game.CloseAppAfterGameLaunch = gameSettings.CloseAppAfterGameLaunch.GetValueOrDefault(true);
game.RefreshDescriptors = gameSettings.RefreshDescriptors;
if (!string.IsNullOrWhiteSpace(gameSettings.LaunchArguments))
{
game.LaunchArguments = gameSettings.LaunchArguments;
}
if (!string.IsNullOrWhiteSpace(gameSettings.ExecutableLocation))
{
setExeLocation = false;
game.ExecutableLocation = gameSettings.ExecutableLocation;
}
if (!string.IsNullOrWhiteSpace(gameSettings.UserDirectory))
{
setUserDirLocation = false;
game.UserDirectory = gameSettings.UserDirectory;
}
}
if (setExeLocation || setUserDirLocation)
{
var settings = GetDefaultGameSettings(game);
if (setExeLocation)
{
game.ExecutableLocation = settings.ExecutableLocation ?? string.Empty;
game.LaunchArguments = settings.LaunchArguments ?? string.Empty;
}
if (setUserDirLocation)
{
game.UserDirectory = settings.UserDirectory;
}
}
if (string.IsNullOrWhiteSpace(game.UserDirectory))
{
game.UserDirectory = gameType.UserDirectory;
}
return(game);
}
internal Controller(IGameSettings settings, IPokemonData[, ][] pms)
{
GameSettings = settings;
Board = new Board(GameSettings);
Teams = new Team[2];
var ppt = settings.Mode.PlayersPerTeam();
for (int t = 0; t < Teams.Length; ++t)
{
var players = new Player[ppt];
players[0] = new Player(this, t, 0, pms[t, 0]);
if (ppt == 2)
{
players[1] = new Player(this, t, 1, pms[t, 1]);
}
Teams[t] = new Team(t, players, settings);
}
ReportBuilder = new ReportBuilder(this);
SwitchController = new SwitchController(this);
InputController = new InputController(this);
TurnController = new TurnController(this);
#if TEST
randomSeeds = new Random(1);
random = new Random(randomSeeds.Next());
#else
random = new Random();
#endif
Timer = new GoTimer(GameSettings.Mode.PlayersPerTeam() == 1 ? new Player[] { Teams[0].GetPlayer(0), Teams[1].GetPlayer(0) } : new Player[] { Teams[0].GetPlayer(0), Teams[0].GetPlayer(1), Teams[1].GetPlayer(0), Teams[1].GetPlayer(1) });
Timer.Start();
}
public Level(IGameSettings settings, ReadOnlyDictionary <string, IGameEntity> players)
{
Board = new PlayerBoard(settings);
Players = players;
ActionManager = new ActionManager(Board);
}
public GameOutward(IGameSettings settings, string[,] players, ReportFragment fragment)
{
Settings = settings;
Board = new BoardOutward(Settings);
TurnNumber = fragment.TurnNumber;
var ppp = settings.Mode.PokemonsPerPlayer();
Board.Players[0, 0] = new PlayerOutward(players[0, 0], ppp);
Board.Players[1, 0] = new PlayerOutward(players[1, 0], ppp);
Board.Players[0, 0].SetAll(fragment.P00);
Board.Players[1, 0].SetAll(fragment.P10);
if (Settings.Mode.PlayersPerTeam() == 2)
{
Board.Players[0, 1] = new PlayerOutward(players[0, 1], ppp);
Board.Players[1, 1] = new PlayerOutward(players[1, 1], ppp);
Board.Players[0, 1].SetAll(fragment.P01);
Board.Players[1, 1].SetAll(fragment.P11);
}
Board.Weather = fragment.Weather;
foreach (var pm in fragment.Pokemons)
{
pm.Init(this);
}
#if TEST
LogAppended = delegate { };
TurnEnd = delegate { };
#endif
}
public Game(ICollection <string> userIds, IMapInfo mapInfo, IGameSettings settings)
{
if (userIds == null)
{
throw new ArgumentNullException(nameof(userIds));
}
if (mapInfo == null)
{
throw new ArgumentNullException(nameof(mapInfo));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
this.actionPoints = settings.ActionPoints;
var tanks = userIds.Select(x => new Tank(new Health(settings.TankHealthPoint), x)).ToArray();
var map = new Map(new MapCreationData(mapInfo, tanks), new BattlefieldBuilder(),
new RandomSpawnService());
// намерено скрываем типы используемых интерфейсов внутри класса игры
this.mapAdapter = new MapAdapter(map);
this.bulletService = new BulletService(this.mapAdapter, settings.BulletActionPoints);
this.moveService = new MoveService(this.mapAdapter);
this.zoneService = new ZoneService(this.mapAdapter, settings.ZoneRadius);
this.DestroyedObjects = new DestroyedInfo(new Dictionary <string, Coordinates>(), new ICellContentInfo[0]);
}
private void InitializeStyle()
{
IGameSettings settingsService = Mvx.Resolve <IGameSettings>();
ControlStyle controlStyle = settingsService.Display.ControlStyle;
switch (controlStyle)
{
case ControlStyle.Wood:
Application.Current.Resources.Add(typeof(Button), Application.Current.Resources["woodButtonStyle"]);
Application.Current.Resources.Add(typeof(ToggleButton), Application.Current.Resources["woodToggleButtonStyle"]); // Not currently used
Application.Current.Resources["DefaultButtonStyle"] = Application.Current.Resources["woodButtonStyle"];
break;
case ControlStyle.Lite:
Application.Current.Resources.Add(typeof(Button), Application.Current.Resources["liteButtonStyle"]);
Application.Current.Resources.Add(typeof(ToggleButton), Application.Current.Resources["liteToggleButtonStyle"]);
Application.Current.Resources["DefaultButtonStyle"] = Application.Current.Resources["liteButtonStyle"];
break;
case ControlStyle.OperatingSystem:
Application.Current.Resources.Add(typeof(Button), Application.Current.Resources["OperatingSystemButtonStyle"]);
Application.Current.Resources["DefaultButtonStyle"] = Application.Current.Resources["OperatingSystemButtonStyle"];
break;
}
}
public void Init(IGameSettings gameSettings)
{
if (_gameSettings != null)
{
throw new InvalidOperationException("GameSettings has already been initialized");
}
_gameSettings = gameSettings;
}
/// <summary>
/// Initializes a copy of the <see cref="IGameSettings"/> class.
/// </summary>
/// <param name="rhs">Settings to copy.</param>
public GameSettings(IGameSettings rhs)
{
Rows = rhs.Rows;
Columns = rhs.Columns;
MineCount = rhs.MineCount;
PointGenerator = rhs.PointGenerator;
UseQuestionableState = rhs.UseQuestionableState;
}
public TexasHoldemGame(IGameSettings settings)
{
if (settings.MaxBuyIn < settings.MinBuyIn)
{
throw new ArgumentException("Cannot have a smaller MinBuyIn than MaxBuyIn.");
}
_settings = settings;
_players = new HashSet<Player>();
}
public AGSRuntimeSettings(IGameSettings settings, IGameWindow gameWindow, IMessagePump messagePump, IGLUtils glUtils)
{
_glUtils = glUtils;
_gameWindow = gameWindow;
_messagePump = messagePump;
Title = settings.Title;
VirtualResolution = settings.VirtualResolution;
Vsync = settings.Vsync;
PreserveAspectRatio = settings.PreserveAspectRatio;
WindowState = settings.WindowState;
WindowBorder = settings.WindowBorder;
}
public AGSGameWindow(IGameSettings settings, IGameWindowSize windowSize, Resolver resolver)
{
_windowSize = windowSize;
_gameWindow = new GameWindow(settings.WindowSize.Width, settings.WindowSize.Height,
GraphicsMode.Default, settings.Title);
var updater = new ContainerBuilder();
updater.RegisterType<AGSInput>().SingleInstance().As<IInput>();
updater.RegisterInstance(_gameWindow);
updater.Update(resolver.Container);
_updateFrameArgs = new FrameEventArgs();
_renderFrameArgs = new FrameEventArgs();
_gameWindow.UpdateFrame += onUpdateFrame;
_gameWindow.RenderFrame += onRenderFrame;
}
/// <summary>
/// The default Constructor.
/// </summary>
public SceneManager(GameWindow gameWindow, Camera camera, FontLibrary fontLibrary, string fontPath, IDirectoryHandler directoryHandler, IGameSettings gameSettings, ValueWrapper<bool> debug)
{
GameWindow = gameWindow;
SceneList = new List<Scene>();
_scenesToAdd = new List<Scene>();
_scenesToRemove = new List<Scene>();
Directories = directoryHandler;
FontPath = fontPath;
GameFontLibrary = fontLibrary;
DefaultFont = GameFontLibrary.GetFirstOrDefault(GameFontType.Default);
FontDrawing = new QFontDrawing();
FontDrawing.ProjectionMatrix = camera.ScreenProjectionMatrix;
ScreenCamera = camera;
ScreenCamera.Center = Vector2.Zero;
ScreenCamera.MaximumScale = new Vector2(10000, 10000);
GameSettings = gameSettings;
Debug = debug;
}
/// <summary>
/// Initializes a new instance of the <see cref="MineSearchGameViewModel"/> class.
/// </summary>
/// <param name="gameSettings">Game settings to use.</param>
public MineSearchGameViewModel(IGameSettings gameSettings)
{
NewGameCommand = new DelegateCommand<IGameSettings>(NewGame);
StartGameCommand = new DelegateCommand(StartGame);
EndGameCommand = new DelegateCommand(EndGame);
_gameTimer = new DispatcherTimer
{
Interval = TimeSpan.FromSeconds(GameTimerIntervalSeconds)
};
_gameTimer.Tick += GameTimerOnTick;
NewGame(gameSettings);
}
private void NewGame(IGameSettings gameSettings)
{
InactivateGame();
if (gameSettings != null)
{
GameSettings = gameSettings;
}
Game = new MineSearchGame(GameSettings);
CreateCellViewModels();
GameDurationSeconds = 0;
GameStatus = GameStatus.Neutral;
//PrintBoard();
}
public AGSSayLocationProvider(IGameSettings settings, IObject obj)
{
_settings = settings;
_obj = obj;
}
/// <summary>
/// Initializes a new instance of the <see cref="MineSearchCellsFactory"/> class.
/// </summary>
/// <param name="gameSettings">Game settings.</param>
public MineSearchCellsFactory(IGameSettings gameSettings)
{
_gameSettings = gameSettings;
}
