public StandartTwoPlayerEngine(IRenderer renderer, IInputProvider input)
{
this._renderer = renderer;
this._input = input;
this._board = new Board();
this._movementStrategy = new NormalMovementStrategy();
}
public KingSurvivalEngine(IRenderer renderer, IInputProvider inputProvider,IBoard board, IWinningConditions winningConditions)
{
this.renderer = renderer;
this.provider = inputProvider;
this.winningConditions = winningConditions;
this.board = board;
}
public Calculator(IInputProvider inputProvider, IOutputProvider outputProvider, IParseProvider parseProvider, IMathProvider mathProvider)
{
_inputProvider = inputProvider;
_outputProvider = outputProvider;
_parseProvider = parseProvider;
_mathProvider = mathProvider;
}
private void CheckProvider()
{
switch (providerType)
{
case ProviderType.Player:
_inputProvider = PlayerInputProvider.Instance;
break;
case ProviderType.Enemy:
EnemyInputProvider provider;
if ((provider = GetComponent <EnemyInputProvider>()) == null)
{
this.gameObject.AddComponent(typeof(EnemyInputProvider));
provider = GetComponent <EnemyInputProvider>();
}
_inputProvider = provider;
break;
default:
_inputProvider = new NullInputProvider();
break;
}
}
private static void LoadSettings()
{
lock (SettingLock)
{
if (settings != null)
{
return;
}
var settingsEntries = ClientData.GetSettings();
settings = settingsEntries.ToDictionary(s => s.Name);
if (ClientData.CheckForUpdates())
{
settings = ClientData.GetSettings().ToDictionary(s => s.Name);
}
commandBindings = new ObservableCollection <CommandBinding>();
commandBindings.CollectionChanged += OnCommandBindingsChanged;
foreach (var cbe in ClientData.GetCommandBindings())
{
IInputProvider provider = Enumerable.FirstOrDefault <IInputProvider> (Modules.Input, ip => Extensions.GetSimpleName(ip.GetType()) == cbe.ProviderType);
if (provider == null)
{
continue;
}
commandBindings.Add(new CommandBinding(provider, cbe.Command, cbe.Input));
}
}
}
public TwoPlayerEngine(IRenderer render, IInputProvider inputProvider)
{
this.renderer = render;
this.input = inputProvider;
this.movementStrategy = new NormalMovementStrategy();
this.board = new TheBoard();
}
public void LoadPictures()
{
IInputProvider iprov = Provider.Instance as IInputProvider;
PictureList pl = iprov.GetPictures(new PictureSearch()
{
SearchProvider = Provider,
MaxPictureCount = 10,
BannedURLs = Settings.CurrentSettings.BannedImages,
PreviewOnly = true
});
foreach (Picture p in pl.Pictures)
{
PictureBox pb = new PictureBox();
Image i = p.GetThumbnail();
if (i == null)
{
continue;
}
pb.Image = i;
pb.Width = i.Width;
pb.Height = i.Height;
flowLayoutPanel1.Controls.Add(pb);
}
}
public BitmapProcessor(
IChangeDetector <Bitmap> changeDetector,
IInputProvider <Bitmap> inputProvider)
{
_changeDetector = changeDetector;
_inputProvider = inputProvider;
}
public Calculator(IInputProvider inputProvider, IOutputProvider outputProvider, IParseProvider parseProvider, IMathProvider mathProvider)
{
_inputProvider = inputProvider;
_outputProvider = outputProvider;
_parseProvider = parseProvider;
_mathProvider = mathProvider;
}
private static string GetInputProviderArgument(IInputProvider inputProvider)
{
var argument = string.Empty;
if (inputProvider is IConsoleInputProvider)
{
Console.WriteLine("Parameters will be taken until empty line");
while (true)
{
string line = Console.ReadLine();
if (string.IsNullOrEmpty(line))
{
break;
}
argument = $"{argument} | {line}";
}
}
else if (inputProvider is IFileInputProvider)
{
Console.WriteLine("Filename");
while (string.IsNullOrEmpty(argument))
{
argument = Console.ReadLine();
}
Console.WriteLine();
}
else
{
throw new DevelopmentException($"{nameof(GetInputProviderArgument)} executed for not supported provider");
}
return(argument);
}
public StandartTwoPlayerEngine(IRenderer renderer, IInputProvider provider)
{
this.renderer = renderer;
this.board = new Board.Board();
this.input = provider;
this.movementStrategy = new NormalMovementStrategy();
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsoleGame" /> class.
/// </summary>
/// <param name="inputProvider">The input provider.</param>
/// <param name="renderer">The renderer.</param>
/// <param name="damageHandler">The damage handler.</param>
public ConsoleGame(IInputProvider inputProvider, ConsoleRenderer renderer, ICellDamageHandler damageHandler)
{
this.engine = new Engine(renderer, damageHandler);
this.inputProvider = inputProvider;
this.renderer = renderer;
this.damageHandler = damageHandler;
}
public Engine(IInputProvider inputProvider, IOutputWriter outputWriter, ICommandParser commandParser)
{
this.commandParser = commandParser;
this.inputProvider = inputProvider;
this.outputWriter = outputWriter;
}
public MainWindow(
IEnumerable <IControlContentProvider> controlContentProviders,
IEnumerable <IPresenter <Bitmap> > presenters,
IProcessor <Bitmap> bitmapProcessor,
Configuration config,
IInputProvider <Bitmap> inputProvider,
IChangeDetector <Bitmap> changeDetector)
{
_bitmapProcessor = bitmapProcessor;
_config = config;
_inputProvider = inputProvider;
_changeDetector = changeDetector;
_bitmapPresenters = presenters.ToArray();
InitializeComponent();
trackAccuracy.Value = _config.MaxGlitches;
trackTolerance.Value = _config.Tolerance;
foreach (var ccp in controlContentProviders)
{
var control = this.Controls.Find(ccp.Tag, true).SingleOrDefault();
ccp.Control = control;
}
btStart_Click(this, null);
CheckForChange_Tick(this, null);
}
public AppLogic(IOutputProvider output, IInputProvider input, ICredentialManager credentialManager, IDataManager inventoryManager)
{
_output = output;
_input = input;
_credentialManager = credentialManager;
_inventoryManager = inventoryManager;
}
void Start()
{
PlayerCore = GetComponent <PlayerCore>();
_inputProvider = GetComponent <IInputProvider>();
OnStart();
Initialize();
}
public MyGame()
{
_graphics = new GraphicsDeviceManager(this);
_inputProvider = new KeyboardInputProvider();
_spritePack = new SpritePack();
Content.RootDirectory = "Content";
}
private void InputTimerElapsedHandler(ThreadPoolTimer timer)
{
if (_CurrentInputProvider != null)
{
_CurrentInputProvider.Update();
if (InputState.IsEmpty())
{
_InputProviderInactiveCount++;
}
if (_InputProviderInactiveCount > 10)
{
_InputProviderInactiveCount = 0;
_CurrentInputProvider = null;
}
}
else
{
foreach (var provider in InputProviders)
{
provider.Update();
if (!InputState.IsEmpty())
{
_CurrentInputProvider = provider;
}
}
}
}
public StandardTwoPlayerEngine(IRenderer renderer, IInputProvider inputProvider)
{
this.renderer = renderer;
this.input = inputProvider;
movementStrategy = new NormalMovementStrategy();
this.board = new Board();
}
public CommandBindingViewModel(IInputProvider provider)
{
if (provider == null)
throw new ArgumentNullException ("provider");
this.provider = provider;
}
private void Form1_Load(object sender, EventArgs e)
{
WallbaseImageSearchSettings wiss = new WallbaseImageSearchSettings();
wiss.SA = "toplist";
PictureSearch ps = new PictureSearch();
ps.SearchProvider = new ActiveProviderInfo("Wallbase")
{
Active = true, ProviderConfig = wiss.Save()
};
ps.MaxPictureCount = 100;
string path = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "TEMP");
Directory.CreateDirectory(path);
ps.SaveFolder = path;
IInputProvider p = ps.SearchProvider.Instance as IInputProvider;
pl = p.GetPictures(ps);
Timer t = new Timer();
t.Tick += t_Tick;
t.Interval = 5000;
t.Enabled = true;
}
public ShowRecipeByName(IRecipeManager recipeManager, IInputProvider inputProvider, IModelDrawer <Recipe> recipeDrawer) :
base(title: "Show recipe by name")
{
this.inputProvider = inputProvider;
this.recipeDrawer = recipeDrawer;
this.recipeManager = recipeManager;
}
private bool gameStartSignalFired = false; // シーン読み込みのたび1回だけ発行する想定
InputPresenter(IInputProvider input, Player player, GameController gameController, SignalBus signalBus)
{
this.player = player;
this.input = input;
this.gameController = gameController;
this.signalBus = signalBus;
// 各種操作を監視してPlayerを動かす
this.input.OnShot.Subscribe(push => {
this.player.Shot(push);
// ゲーム開始操作を兼ねるためSignal発行(そのシーンで1回だけ)
if (!gameStartSignalFired)
{
signalBus.Fire <GameStartSignal>();
gameStartSignalFired = true;
}
});
this.input.OnThrow.Subscribe(angle => this.player.Throw(angle));
this.input.OnBomb.Subscribe(_ => this.player.Bomb());
this.input.OnMovePlayer
.Where(info => Vector2.zero != info.MoveSpeed)
.Subscribe(info => this.player.MovePlayer(info));
// 各種操作を監視してGameControllerへ通知する
this.input.OnMenu.Subscribe(_ => { }); // TODO:後で実装
this.input.OnSpeedEdit.Subscribe(rate => this.gameController.UpdateSpeedMagnification(rate, EditMode.Rate_Delta));
}
/// <summary>
/// Method that start the main logic of the game.
/// </summary>
/// <param name="output">Output renderer</param>
/// <param name="input">Iput provider</param>
/// <param name="cmmandLogger">Command logger</param>
public static void Start(IRenderer output, IInputProvider input, ILogger cmmandLogger)
{
output.ShowInfoMessage("Please ente your name: ");
string playerName = input.GetPlayerName();
output.ShowInfoMessage("Please enter a dimension for the board the standard is 9x9");
int dimension = input.GetPlayFieldDimensions();
ICell playerCell = new Cell(new Position(dimension / 2, dimension / 2));
IPlayField playField = null;
var player = new Player.Player(playerName, playerCell);
try
{
var playFieldGenerator = new StandardPlayFieldGenerator(player.CurentCell.Position, dimension, dimension);
playField = new PlayField.PlayField(playFieldGenerator, player.CurentCell.Position, dimension, dimension);
}
catch (ArgumentOutOfRangeException e)
{
output.ShowInfoMessage(e.Message);
}
ICommandFactory commandFactory = new SimpleCommandFactory();
IMementoCaretaker memory = new MementoCaretaker(new List<IMemento>());
IScoreLadder ladder = ScoreLadder.Instance;
IGameEngine gameEngine = new StandardGameEngine(output, input, playField, commandFactory, cmmandLogger, player,memory,ladder);
gameEngine.Initialize(RandomNumberGenerator.Instance);
gameEngine.Start();
}
/// <summary>
/// Constructor with a specified input provider, used for unit tests
/// </summary>
/// <param name="ip"></param>
public MoveProvider(IInputProvider ip)
{
// validate the inputs
// If ip is null, throw an ArgumentNullException
this.ip = ip;
}
/// <summary>
/// Method that start the main logic of the game.
/// </summary>
/// <param name="output">Output renderer</param>
/// <param name="input">Iput provider</param>
/// <param name="cmmandLogger">Command logger</param>
public static void Start(IRenderer output, IInputProvider input, ILogger cmmandLogger)
{
output.ShowInfoMessage("Please ente your name: ");
string playerName = input.GetPlayerName();
output.ShowInfoMessage("Please enter a dimension for the board the standard is 9x9");
int dimension = input.GetPlayFieldDimensions();
ICell playerCell = new Cell(new Position(dimension / 2, dimension / 2));
IPlayField playField = null;
var player = new Player.Player(playerName, playerCell);
try
{
var playFieldGenerator = new StandardPlayFieldGenerator(player.CurentCell.Position, dimension, dimension);
playField = new PlayField.PlayField(playFieldGenerator, player.CurentCell.Position, dimension, dimension);
}
catch (ArgumentOutOfRangeException e)
{
output.ShowInfoMessage(e.Message);
}
ICommandFactory commandFactory = new SimpleCommandFactory();
IMementoCaretaker memory = new MementoCaretaker(new List <IMemento>());
IScoreLadder ladder = ScoreLadder.Instance;
IGameEngine gameEngine = new StandardGameEngine(output, input, playField, commandFactory, cmmandLogger, player, memory, ladder);
gameEngine.Initialize(RandomNumberGenerator.Instance);
gameEngine.Start();
}
public RestartController(MonoBehaviour script, DataCenter dataCenter, IInputProvider inputProvider)
{
this.script = script;
this.dataCenter = dataCenter;
this.inputProvider = inputProvider;
this.thisCoroutine = Updater();
this.script.StartCoroutine(this.thisCoroutine);
}
public void SetUp()
{
_inputProvider = Substitute.For <IInputProvider>();
var inputBackend = Substitute.For <IInputBackend>();
inputBackend.CreateInputProvider().Returns(_inputProvider);
_inputSystem = new InputSystem(inputBackend);
}
public BindWindow(IInputProvider provider)
{
InitializeComponent();
this.provider = provider;
Loaded += (sender, e) => StartRecording();
}
public StandardTwoPlayerEngine(IRenderer renderer, IInputProvider inputProvider, bool testing = false)
{
this.renderer = renderer;
this.input = inputProvider;
this.movementStrategy = new NormalMovementStrategy();
this.board = new Board();
this.testing = testing;
}
public void Register(IInputProvider input)
{
if (input != null)
{
Context.Debug(() => $"Registering {input.GetType().Name}.");
}
InputProvider = input;
}
public void Awake()
{
_inputProvider = InputFactoring.CreateInstance();
_timeToHint = ContextProvider.Context.GameSettings.TimeToHint;
Enable(true);
Update();
}
public ConferenceTrackManager(IDisplay display, IInputCollector inputCollector, IInputProvider inputProvider, IInputProcessor inputProcessor, TrackGenerator trackGenerator)
{
_display = display;
_inputCollector = inputCollector;
_inputProvider = inputProvider;
_inputProcessor = inputProcessor;
_trackGenerator = trackGenerator;
}
private void StartInputRecording(IInputProvider provider, InputKeysModel target)
{
_targetInputModel = target;
_model.Overlay = _inputOverlay ??= new InputOverlay();
_inputProvider = provider;
_inputProvider.KeyDown += OnInputProviderKeyDown;
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
/// <param name="inputProvider">The input provider.</param>
/// <param name="outputProvider">The output provider.</param>
/// <param name="stateFactory">The factory that creates the game states.</param>
public Game(IInputProvider inputProvider, IOutputProvider outputProvider, IStateFactory stateFactory)
{
this.InputProvider = inputProvider;
this.OutputProvider = outputProvider;
this.StateFactory = stateFactory;
this.State = stateFactory.GetStartMenuState(this);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
#region public methods
public void Init(IInputProvider iInputProvider, float speed)
{
_iInputProvider = iInputProvider;
_speed = speed;
_leftBorder = LeftWall.localPosition.x + (LeftWall.localScale.x + Width) / 2;
_rightBorder = RightWall.localPosition.x - (RightWall.localScale.x + Width) / 2;
}
public SSASOutputController(
OutputContext context,
IAction initializer,
IInputProvider inputProvider,
IOutputProvider outputProvider
) : base(context, initializer, inputProvider, outputProvider)
{
}
protected BaseChessEngine(IRenderer renderer, IInputProvider inputProvider, IMovementStrategy movementStrategy)
{
this.Renderer = renderer;
this.MovementStrategy = movementStrategy;
this.Input = inputProvider;
this.Board = new Board();
this.GameState = GameState.Playing;
}
public void Init()
{
var mockReader = new Mock<IReader>();
mockReader.Setup(r => r.ReadText()).Returns(FakePlayerName);
this.reader = mockReader.Object;
this.inputProvider = new ConsoleInputProvider(this.reader);
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public MenuState(IInputProvider pInputProv, NavRoot pNavRoot,InteractionSettings pSettings){
vInputProv = pInputProv;
vSettings = pSettings;
Arc = new ArcState(pNavRoot, vSettings);
Cursor = new CursorState(vSettings);
OnSideChange += (() => {});
}
/// <summary>
/// Constructor for the Engine class.
/// </summary>
/// <param name="renderer">IRenderer object</param>
/// <param name="inputProvider">IInputProvider object.</param>
public Engine(IRenderer renderer, IInputProvider inputProvider)
{
this.inputProvider = inputProvider;
this.renderer = renderer;
this.scoreBoard = Scoreboard.Instance;
this.wordDataBase = new WordDatabase(this.dataSerialization);
this.wordFactory = new WordFactory(this.wordDataBase);
this.gameLogic = new DefaultGameLogic();
this.gameLogic.Word = this.wordFactory.GetWord(Categories.IT);
}
public CommandBindingViewModel(IInputProvider provider, CommandBindingEntry entry)
{
if (provider == null)
throw new ArgumentNullException ("provider");
this.provider = provider;
Input = entry.Input;
ProviderType = entry.ProviderType;
Command = entry.Command;
}
public InputBridge()
{
if (Input.GetJoystickNames().Length <= 0)
{
provider = new DesktopInput();
}
else
{
provider = new GamepadInput();
}
}
/// <summary>
/// Creates a new keybinding.
/// </summary>
/// <exception cref="ArgumentNullException"><paramref name="provider"/> or <paramref name="input"/> is <c>null</c>.</exception>
public CommandBinding(IInputProvider provider, Command action, string input)
{
if (provider == null)
throw new ArgumentNullException ("provider");
if (input == null)
throw new ArgumentNullException ("input");
Provider = provider;
Command = action;
Input = input;
}
public ConsoleEngine(
IScoreBoardService scoreBoardService,
IRenderer renderer,
IPlayer player,
IWordGenerator wordGenerator,
ICommandFactory commandFactory,
IInputProvider inputProvider)
: base(scoreBoardService, renderer, player, wordGenerator, commandFactory)
{
this.InputProvider = inputProvider;
}
public KingSurvivalEngineContext(IRenderer renderer, IInputProvider inputProvider, IBoard board, IWinningConditions winningConditions, IList<IPlayer> players)
{
this.renderer = renderer;
this.provider = inputProvider;
this.winningConditions = winningConditions;
this.players = players;
this.memory = new BoardMemory();
this.currentPlayerIndex = 0;
this.board = board;
this.kingPlayer = this.players[0];
this.pawnPlayer = this.players[1];
}
public IChessEngine GetEngine(GameType gameType, IRenderer renderer, IInputProvider inputProvider, IMovementStrategy movementStrategy)
{
switch (gameType)
{
case GameType.Chess:
return new StandartTwoPlayerEngine(renderer, inputProvider, movementStrategy);
case GameType.KingSurvival:
return new KingSurvivalEngine(renderer, inputProvider, movementStrategy);
default:
throw new ArgumentException();
}
}
/// <summary>
/// Constructor for King Survival Engine
/// </summary>
/// <param name="renderer">The output renderer</param>
/// <param name="inputProvider">The input provider</param>
/// <param name="board">The board for the game</param>
/// <param name="winningConditions">Winning conditions for the game</param>
/// <param name="players">Players that are playing the game</param>
/// <param name="memory">The memory for the board</param>
/// <param name="context">Context for command execute</param>
/// <param name="commandFactory">Command Factory</param>
public KingSurvivalEngine(
IRenderer renderer,
IInputProvider inputProvider,
IBoard board,
IWinningConditions winningConditions,
IList<IPlayer> players,
BoardMemory memory,
ICommandContext context,
ICommandFactory commandFactory)
{
this.context = new KingSurvivalEngineContext(renderer, inputProvider, board, winningConditions, players, memory, context, commandFactory);
}
public bool Create(IInputListener listener, out IInputProvider provider)
{
try
{
provider = new KinectProvider(listener);
return provider.Available;
}
catch
{
provider = null;
return false;
}
}
public override void Update(IInputProvider input)
{
ushort keycode;
while (input.TryGetKeyboardEvent(m_TranslateASCII, out keycode)) {
if (m_BufferCount >= 16)
continue;
if (m_ReportUpDownEvents && ((keycode & 0x0F00) == EventUp) || ((keycode & 0x0F00) == EventDown)) {
m_CommandBuffer[m_CommandBuffer[m_BufferCount++]] = keycode;
}
else if (m_ReportPressEvents && ((keycode & 0x0F00) == EventPress)) {
m_CommandBuffer[m_CommandBuffer[m_BufferCount++]] = keycode;
}
}
}
public CoreEngine(IUIEngine uiEngine, IField field, IPlayer player, IActionProvider actionProvider = null, IMovement movement = null, ISolvedChecker solvedChecker = null)
{
this._uiEngine = uiEngine;
this._inputProvider = uiEngine.InputProvider;
this._field = field;
this._player = player;
this._highScores = HighScores.Instance;
this.ActionProvider = actionProvider ?? new DefaultActionProvider(this);
this.Movement = movement ?? new BackwardMovement(field);
this.SolvedChecker = solvedChecker ?? new DefaultSolvedChecker();
this.AttachUIToEvents();
}
public void Start(IRenderer renderer, IInputProvider provider)
{
renderer.RenderMainMenu();
IWinningConditions winningConditions = new WinningConditions();
var players = new List<IPlayer>();
var kingPlayer = new Player("king");
var pawnPlayer = new Player("pawn");
players.Add(kingPlayer);
players.Add(pawnPlayer);
var board = new Board.Board();
var engine = new KingSurvivalEngine(renderer, provider, board, winningConditions, players);
engine.InitializeGame().StartGame();
}
/// <summary>
/// Method for starting a game
/// </summary>
/// <param name="renderer">The renderer on which the info is going to be rendered</param>
/// <param name="provider">The input provider that provides information</param>
public void Start(IRenderer renderer, IInputProvider provider)
{
renderer.RenderMainMenu();
IWinningConditions winningConditions = new WinningConditions();
var players = new List<IPlayer>();
var kingPlayer = new Player(provider.GetPlayerName());
var pawnPlayer = new Player(provider.GetPlayerName());
players.Add(kingPlayer);
players.Add(pawnPlayer);
var board = new Board.Board();
var memory = new BoardMemory();
var context = new CommandContext(memory, board, players[0]);
var commandFactory = new CommandFactory();
var engine = new KingSurvivalEngine(renderer, provider, board, winningConditions, players, memory, context, commandFactory);
engine.InitializeGame().StartGame();
}
/// <summary>
/// Constructor with which you can supply the input and the output provider independently
/// </summary>
/// <param name="input">The input provider</param>
/// <param name="output">The output provider</param>
public Interpreter(IInputProvider input, IOutputProvider output, String program = "")
{
if (input == null) throw new ArgumentNullException("input");
if (output == null) throw new ArgumentNullException("output");
this.inputProvider = input;
this.outputDestination = output;
InitializeActionList(input, output);
ValidateSourceFile(program);
ProgramString = program;
PointerPosition = 0;
loopIndexes = new Stack<Int32>();
MemoryCells = new List<Int32>();
MemoryCells.Add(0);
}
/// <summary>
/// Standard game engine constructor.
/// </summary>
/// <param name="renderer">Output renderer.</param>
/// <param name="inputProvider">Input provider.</param>
/// <param name="playField">Game play field.</param>
/// <param name="commandFactory">Game command factory.</param>
/// <param name="logger">Command execution logger.</param>
/// <param name="player">Player</param>
public StandardGameEngine(
IRenderer renderer,
IInputProvider inputProvider,
IPlayField playField,
ICommandFactory commandFactory,
ILogger logger,
IPlayer player,
IMementoCaretaker memory,
IScoreLadder ladder)
{
this.playField = playField;
this.renderer = renderer;
this.input = inputProvider;
this.ladder = ladder;
this.commandFactory = commandFactory;
this.logger = logger;
this.player = player;
this.memory = memory;
}
/// <summary>
/// Constructor for creating King Survival Engine
/// </summary>
/// <param name="renderer">The output renderer</param>
/// <param name="inputProvider">The input provider</param>
/// <param name="board">The board for the game</param>
/// <param name="winningConditions">Winning conditions for the game</param>
/// <param name="players">Players that are playing the game</param>
/// <param name="memory">The memory for the board</param>
/// <param name="context">Context for command execute</param>
/// <param name="commandFactory">Command Factory</param>
public KingSurvivalEngineContext(
IRenderer renderer,
IInputProvider inputProvider,
IBoard board,
IWinningConditions winningConditions,
IList<IPlayer> players,
BoardMemory memory,
ICommandContext context,
ICommandFactory commandFactory)
{
this.renderer = renderer;
this.provider = inputProvider;
this.winningConditions = winningConditions;
this.players = players;
this.memory = memory;
this.currentPlayerIndex = 0;
this.board = board;
this.kingPlayer = this.players[0];
this.pawnPlayer = this.players[1];
this.context = context;
this.commandFactory = commandFactory;
}
internal void UnregisterInputProvider(IInputProvider inputProvider)
{
_inputProviders.Remove(inputProvider);
}
internal InputProviderSite RegisterInputProvider(IInputProvider inputProvider)
{
SecurityHelper.DemandUnrestrictedUIPermission();
// VerifyAccess();
// Create a site for this provider, and keep track of it.
InputProviderSite site = new InputProviderSite(this, inputProvider);
_inputProviders[inputProvider] = site;
return site;
}
public Shape(IInputProvider input)
{
widthAndHeightInput = input;
}
private void InputTimerElapsedHandler(ThreadPoolTimer timer)
{
if (_CurrentInputProvider != null)
{
_CurrentInputProvider.Update();
if (InputState.IsEmpty())
_InputProviderInactiveCount++;
if (_InputProviderInactiveCount > 10)
{
_InputProviderInactiveCount = 0;
_CurrentInputProvider = null;
}
}
else
{
foreach (var provider in InputProviders)
{
provider.Update();
if (!InputState.IsEmpty())
_CurrentInputProvider = provider;
}
}
}
