public EffectsManager(IEffectsMgrClient effectsClient) { _effectsClient = effectsClient; _generalFactory = References.GeneralFactory; _gameMgr = References.GameManager; _myPoolMgr = References.MyPoolManager; Subscribe(); }
public BallController(IBall spriteEntity, IGameManager gameManager):base(gameManager) { Ball = spriteEntity; State = new StartBallState(this, gameManager, PlayerIndex.One); View = new BallView(Ball, this ); GameScore = GameManager["GameScore"] as GameScore; }
public GameTableViewModel(IGameManager gameManager) { if (gameManager == null) throw new ArgumentNullException("gameManager"); GameManager = gameManager; InitializeGameCells(GameManager, GameManager.GameCells); }
public ApplicationViewModel(IGameManager gameManager) { if (gameManager == null) throw new ArgumentNullException("gameManager"); GameManager = gameManager; GameTableViewModel = new GameTableViewModel(gameManager); }
public PadelEntityController(IPadel padel, IGameManager gameManager) { GameManager = gameManager; Padel = padel; View = new PadelView(padel, this); }
public WCFHost(IBanManager banManager, IClientManager clientManager, IAdminManager adminManager, IGameManager gameManager) { BanManager = banManager; ClientManager = clientManager; AdminManager = adminManager; GameManager = gameManager; }
public PlayerScoredBallState(IBallController ballController, PlayerIndex playerIndex, IGameManager gameManager) { _ballController = ballController; _playerIndex = playerIndex; _gameManager = gameManager; GameScore = gameManager["GameScore"] as GameScore; }
public SettingsViewModel(IScreen screen, ISettingsManager settingsManager, IVersionManager versionManager, IGameManager gameManager) { HostScreen = screen; _settingsManager = settingsManager; _versionManager = versionManager; _gameManager = gameManager; ApiKey = _settingsManager.Settings.ApiKey; AuthUser = _settingsManager.Settings.AuthUser; AuthPass = _settingsManager.Settings.AuthPass; Endpoint = _settingsManager.Settings.Endpoint; PbxFolder = _settingsManager.Settings.PbxFolder; SyncStarred = _settingsManager.Settings.SyncStarred; DownloadOnStartup = _settingsManager.Settings.DownloadOnStartup; PatchTableScripts = _settingsManager.Settings.PatchTableScripts; MinimizeToTray = _settingsManager.Settings.MinimizeToTray; ReformatXml = _settingsManager.Settings.ReformatXml; XmlFileVP = _settingsManager.Settings.XmlFile[Platform.PlatformType.VP]; StartWithWindows = _settingsManager.Settings.StartWithWindows; DownloadOrientation = _settingsManager.Settings.DownloadOrientation; DownloadOrientationFallback = _settingsManager.Settings.DownloadOrientationFallback; DownloadLighting = _settingsManager.Settings.DownloadLighting; DownloadLightingFallback = _settingsManager.Settings.DownloadLightingFallback; SaveSettings = ReactiveCommand.CreateAsyncTask(_ => Save()); SaveSettings.IsExecuting.ToProperty(this, vm => vm.IsValidating, out _isValidating); SaveSettings.ThrownExceptions.Subscribe(e => { // todo either remove or treat correctly. Console.WriteLine("Exception while saving settings."); }); ChooseFolder.Subscribe(_ => OpenFolderDialog()); CloseSettings.InvokeCommand(HostScreen.Router, r => r.NavigateBack); _settingsManager.WhenAnyValue(sm => sm.Settings.IsFirstRun).ToProperty(this, vm => vm.IsFirstRun, out _isFirstRun); _settingsManager.WhenAnyValue(sm => sm.CanCancel) .CombineLatest(screen.Router.NavigationStack.Changed, (canCancel, _) => canCancel || screen.Router.NavigationStack.Count > 1) .DistinctUntilChanged() .StartWith(true) .ToProperty(this, vm => vm.CanCancel, out _canCancel); OrientationSettings.Add(new OrientationSetting("Portrait", SettingsManager.Orientation.Portrait)); OrientationSettings.Add(new OrientationSetting("Landscape", SettingsManager.Orientation.Landscape)); OrientationSettings.Add(new OrientationSetting("Universal (VP10)", SettingsManager.Orientation.Universal)); LightingSettings.Add(new LightingSetting("Day", SettingsManager.Lighting.Day)); LightingSettings.Add(new LightingSetting("Night", SettingsManager.Lighting.Night)); LightingSettings.Add(new LightingSetting("Universal (VP10)", SettingsManager.Lighting.Universal)); XmlFilesVP.Add("Visual Pinball"); XmlFilesVP.Add("Vpdb"); OrientationFallbackSettings.Add(new OrientationSetting("Same *", SettingsManager.Orientation.Same)); OrientationFallbackSettings.Add(new OrientationSetting("Portrait", SettingsManager.Orientation.Portrait)); OrientationFallbackSettings.Add(new OrientationSetting("Landscape", SettingsManager.Orientation.Landscape)); OrientationFallbackSettings.Add(new OrientationSetting("Any", SettingsManager.Orientation.Any)); LightingFallbackSettings.Add(new LightingSetting("Same *", SettingsManager.Lighting.Same)); LightingFallbackSettings.Add(new LightingSetting("Day", SettingsManager.Lighting.Day)); LightingFallbackSettings.Add(new LightingSetting("Night", SettingsManager.Lighting.Night)); LightingFallbackSettings.Add(new LightingSetting("Any", SettingsManager.Lighting.Any)); }
public DriftCorrector(Transform transform, Rigidbody rigidbody, string optionalClientName = "Unknown") { D.Assert(!rigidbody.useGravity); // can be isKinematic until operations commence ClientName = optionalClientName; _transform = transform; _rigidbody = rigidbody; _gameMgr = References.GameManager; _jobMgr = References.JobManager; }
public virtual void Update(ISpriteEntity spriteEntity, GameTime gameTime, BallInput ballInput) { ballInput.PlayScored(); _gameManager = ((IGameManager)spriteEntity.Game.Services.GetService(typeof(IGameManager))); int score = (int)_gameManager[PlayerScoreKey]; score++; _gameManager[PlayerScoreKey] = score; }
protected override void Initialize() { IOCContainer.Register(this); _gameManager = GameFactory.GetGameManager(); _gameManager.Initialize(_graphics); base.Initialize(); }
protected override void Awake() { base.Awake(); _gameTime = GameTime.Instance; _gameMgr = References.GameManager; _rotationPeriod = GameTimeDuration.OneDay; _rotationRate = _relativeRotationRate * Constants.DegreesPerRotation / (float)_rotationPeriod.TotalInHours; Subscribe(); enabled = false; }
public GamesImporterController(FantasyDataGamesImporter importer, IGameManager gameManager) { if (importer == null) { throw new ArgumentNullException("importer"); } _importer = importer; _gameManager = gameManager; }
public FantasyDataGamesImporter(IGameManager gameManager, ITeamRepository teamRepository, IGameOptionRepository optionRepository) { _gameManager = gameManager; _teamRepository = teamRepository; _optionRepository = optionRepository; _fantasyDataGames = new List<FantasyDataGame>(); _connectionString = ConfigurationManager.ConnectionStrings["sportpicksdb"].ConnectionString; _season = Convert.ToInt32(ConfigurationManager.AppSettings["CurrentNflSeason"]); _fantasyDataApiKey = ConfigurationManager.AppSettings["FantasyDataApiKey"]; _fantasyDataGamesUrl = ConfigurationManager.AppSettings["FantasyDataScoresUrl"]; }
public GameCellViewModel(GameTableViewModel gameTableViewModel, IGameManager gameManager, GameCell gameCell) { if (gameManager == null) throw new ArgumentNullException("gameManager"); if (gameCell == null) throw new ArgumentNullException("gameCell"); if (gameTableViewModel == null) throw new ArgumentNullException("gameTableViewModel"); GameTableViewModel = gameTableViewModel; GameManager = gameManager; GameCell = gameCell; Symbol = GetSymbol(GameManager, GameCell); InitializeCommands(); }
private String GetSymbol(IGameManager gameManager, GameCell gameCell) { if (gameCell.Owner == Player.NonPlayer) { return ""; } if (gameCell.Owner == gameManager.Players.First()) { return "X"; } return "O"; }
/// <summary> /// Constructs a new instance of <see cref="UnityServer"/> from "unity.config" file. /// </summary> public UnityServer() { var map = new ExeConfigurationFileMap {ExeConfigFilename = "unity.config"}; var config = ConfigurationManager.OpenMappedExeConfiguration(map, ConfigurationUserLevel.None); UnityConfigurationSection section = (UnityConfigurationSection) config.GetSection("unity"); _container = new UnityContainer(); section.Configure(_container, "container"); _shotTracker = _container.Resolve<IShotTracker>(); _positionTracker = _container.Resolve<IPositionTracker>(); _playerManagement = _container.Resolve<IPlayerManagement>(); _signalStrengthTracker = _container.Resolve<ISignalStrengthTracker>(); _gameManager = _container.Resolve<IGameManager>(); ServerConsole = _container.Resolve<Console.Console>(); }
public async Task <MoveResult> Move( MoveInput input, [Service] IGameManager gameManager, [Service] IEventSender eventSender, CancellationToken cancellationToken ) { MoveResult result = await gameManager.Move(input.ToMove(), cancellationToken); if (result.IsValid) { await eventSender.SendAsync(new OnMoveMessage(result.Move)); } return(result); }
public InGameMenuPresenter( IInGameMenuView view, IApplicationController controller, IGameManager gameManager, IApplicationService applicationService) { this.view = view; this.controller = controller; this.gameManager = gameManager; this.applicationService = applicationService; this.view.Exit += View_Exit; this.view.ExitToMenu += View_ExitToMenu; this.view.StartNewGame += View_StartNewGame; this.view.ContinueGame += View_ContinueGame; }
public WebSocketEndpoint( GameManager gameManager, ILogger logger, IAppSettings settings, ITokenProvider tokenProvider, IGamePacketSerializer packetSerializer) { connection = new WSGameServerConnection( logger, settings, tokenProvider, packetSerializer); connection.Register("game_event", new GameEventPacketHandler(gameManager)); this.gameManager = gameManager; }
public override IEntity CreateEntity(IGameManager gameManager, Vector2 position) { IEntity entity = InstantiatePrefab(Prefab, gameManager, position); if (entity is IMicro micro) { micro.UpdateProvider = MicroUpdateProvider; ClosestProximityController closestProximityController = new ClosestProximityController(ControllerUpdateProvider); closestProximityController.Controllable = micro; micro.Controller = closestProximityController; micro.BreedingFactory = this; } return(entity); }
public SessionController( ILogger <SessionController> logger, IGameData gameData, ISessionInfoProvider sessionInfoProvider, IAuthManager authManager, ISessionManager sessionManager, IGameManager gameManager, ISecureHasher secureHasher) : base(logger, gameData, authManager, sessionInfoProvider, sessionManager, secureHasher) { this.gameData = gameData; this.authManager = authManager; this.sessionManager = sessionManager; this.gameManager = gameManager; this.secureHasher = secureHasher; }
public GameManagers(IGameManager gameManager, IActivateCardManager activateCardManager, IBarsPlayerManager barsPlayerManager, IBarsEnemyManager barsEnemyManager, IEnemyManager enemyManager, IAlliesManager alliesManager, IPlayersManager playersManager, IDeckManager deckManager, IInventoryManager inventoryManager, ITargetManager targetManager, ITokenRewardManager tokenRewardManager) { GameManager = gameManager; ActivateCardManager = activateCardManager; BarsPlayerManager = barsPlayerManager; BarsEnemyManager = barsEnemyManager; EnemyManager = enemyManager; AlliesManager = alliesManager; PlayersManager = playersManager; DeckManager = deckManager; InventoryManager = inventoryManager; TargetManager = targetManager; TokenRewardManager = tokenRewardManager; }
public void SetUp() { ActionLog actionLog = new ActionLog(); GlobalConstants.ActionLog = actionLog; this.scriptingEngine = new ScriptingEngine(); this.target = new ConcreteRumourMill(); IWorldInstance world = Mock.Of <IWorldInstance>(); IGameManager gameManager = Mock.Of <IGameManager>( manager => manager.NeedHandler == Mock.Of <INeedHandler>( handler => handler.GetManyRandomised(It.IsAny <IEnumerable <string> >()) == new List <INeed>()) && manager.SkillHandler == Mock.Of <IEntitySkillHandler>( handler => handler.GetDefaultSkillBlock() == new Dictionary <string, IEntitySkill> { { "light blades", new EntitySkill( "light blades", 5, 7) } }) && manager.RelationshipHandler == Mock.Of <IEntityRelationshipHandler>() && manager.ObjectIconHandler == Mock.Of <IObjectIconHandler>()); GlobalConstants.GameManager = gameManager; IGender gender = Mock.Of <IGender>( g => g.PersonalSubject == "her"); IDictionary <string, IEntitySkill> skills = gameManager.SkillHandler.GetDefaultSkillBlock(); this.left = Mock.Of <IEntity>( entity => entity.PlayerControlled == true && entity.JoyName == "TEST1" && entity.Skills == skills); this.right = Mock.Of <IEntity>( entity => entity.JoyName == "TEST2" && entity.Skills == skills); }
public void StartUpSettingsFileLoaded() { //Проверяем, что ссылка на скриптовый объект с настройками привязался var settings = Container.Resolve <GameSettings>(); Assert.NotNull(settings); //Записываем туда пустые данные settings.SetData(new Data()); //Грузим настройки через менеджер IGameManager manager = Container.Resolve <IGameManager>(); manager.LoadStartUpSettingsFile(GameConst.StartUpSettingsFile); Assert.Greater(settings.Data.stats.Length, 0); }
public GameController(IGameManager gameManager, ChangeSceneSignal changeSceneSignal, GameStatusChangedSignal gameStatusChangedSignal, AreaClickedSignal areaClickedSignal, CurrentMarkChangedSignal currentMarkChangedSignal, ResetSignal resetSignal, RestartSignal restartSignal ) { _gameManager = gameManager; _changeSceneSignal = changeSceneSignal; _areaClickedSignal = areaClickedSignal; _gameStatusChangedSignal = gameStatusChangedSignal; _currentMarkChangedSignal = currentMarkChangedSignal; _resetSignal = resetSignal; _restartSignal = restartSignal; }
public WebSocketConnectionProvider( ILogger <WebSocketConnectionProvider> logger, IIntegrityChecker integrityChecker, IGameData gameData, IGameManager gameManager, IGamePacketManager packetManager, IGamePacketSerializer packetSerializer, ISessionManager sessionManager) { this.logger = logger; this.integrityChecker = integrityChecker; this.gameData = gameData; this.gameManager = gameManager; this.packetManager = packetManager; this.packetSerializer = packetSerializer; this.sessionManager = sessionManager; }
private void AddManager(string[] typeNames, bool constant) { GameObject go = constant ? _constManagerLayer : _dynamicManagerLayer; List <IGameManager> managerPool = constant ? _constManagers : _dynamicManagers; Type managerBaseType = typeof(IGameManager); for (int i = 0; i < typeNames.Length; i++) { string name = typeNames[i]; Type type = Type.GetType(name); if (type != null) { if (managerBaseType.IsAssignableFrom(type)) { if (type.IsSubclassOf(typeof(MonoBehaviour))) { GameObject node = new GameObject(type.Name); node.transform.parent = go.transform; managerPool.Add(node.AddComponent(type) as IGameManager); } else { IGameManager mgr = GameManageHelper.GetCustomManage(type); if (mgr != null) { managerPool.Add(mgr); } } } else { string msg = string.Format("type is not inherit form IGameManager: {0}", name); Error(msg); throw new Exception(msg); } } else { string msg = string.Format("type is not found: {0}", name); Error(msg); throw new Exception(msg); } } }
public override void Spawn(IGameManager gameManager) { base.Spawn(gameManager); var snakeLength = _gameManager.Settings.SnakeStartLength; while (true) { var startCell = _gameManager.GetRandomEmptyCell(); var fit = true; for (var dX = 1; dX < snakeLength; dX++) { if (startCell.X + dX >= _gameManager.Settings.GameFieldSize || _gameManager.GetGameFieldCellEntities(startCell.X + dX, startCell.Y, startCell.Z).Count != 0) { fit = false; break; } } if (fit) { for (var dX = 0; dX < snakeLength; dX++) { var cell = new GameFieldCell { X = startCell.X + dX, Y = startCell.Y, Z = startCell.Z }; _gameManager.AssignGameEntityToGameFieldCell(this, cell); var snakePart = Instantiate(_gameManager.Settings.SnakePartPrefab, _gameManager.GameCellToWorldCoords(cell), Quaternion.identity, transform); _snakeParts.Add(snakePart.transform); _cells.Add(cell); } break; } } }
private void Start() { gameManager = interfaceFactory.GameManager; errorHandler = interfaceFactory.ErrorHandler; uiManager = interfaceFactory.UIManager; if (gameManager == null || errorHandler == null || uiManager == null) { gameObject.SetActive(false); } else { if (componentMissing) { errorHandler.ReportError("Tourist Manager component missing", ErrorState.restart_scene); } inventoryUI = uiManager.InventoryUI; if (inventoryUI == null) { errorHandler.ReportError("Inventory UI missing", ErrorState.restart_scene); } turnsManager = gameManager.TurnsManager; if (turnsManager == null) { errorHandler.ReportError("Turns Manager missing", ErrorState.restart_scene); } else { if (turnsManager.TurnBasedObjects == null) { errorHandler.ReportError("Turn based objects list not initialized", ErrorState.restart_scene); } else { turnsManager.TurnBasedObjects.Add(this); } } playerManager = gameManager.PlayerManager; if (playerManager == null) { errorHandler.ReportError("Player Manager missing", ErrorState.restart_scene); } } }
public LettersHub(IWordService wordService, IFileHelper fileHelper, IFilenameHelper filenameHelper, IJoinRoomHelper joinRoomHelper, IGameManager gameManager) { _wordService = wordService; _fileHelper = fileHelper; _filenameHelper = filenameHelper; _joinRoomHelper = joinRoomHelper; _gameManager = gameManager; if (!File.Exists(_filenameHelper.GetDictionaryFilename())) { File.Create(_filenameHelper.GetDictionaryFilename()); } if (!File.Exists(_filenameHelper.GetGuessedWordsFilename())) { File.Create(_filenameHelper.GetGuessedWordsFilename()); } }
public DiceManager(IGameManager gameManager, StringBuilder log) { Log = log; GameManager = gameManager; DiceList = new List <Dice>(); DiceCreator = new DiceCreator(); Dice newDice; int chipsCount = GameManager.CurrentPlayer.Chips > 3 ? 3 : GameManager.CurrentPlayer.Chips; for (int diceId = 1; diceId <= chipsCount; diceId++) { newDice = DiceCreator.CreateDice(diceId); DiceList.Add(newDice); } ChipsManager = new ChipsManager(GameManager, DiceList); }
/// <summary> /// initialized by the Game manager with the required dependencies /// </summary> public void Init(IGameManager gameManager, IInput input) { _gameManager = gameManager; //Event registrations _gameManager.LevelInitiazed += OnLevelInitialized; _gameManager.LevelStarted += OnLevelStarted; _gameManager.TowerLevelChanged += OnTowerLevelChanged; _gameManager.GameplayStarted += OnGamePlayStarted; _gameManager.LevelCompleted += OnLevelFinished; _gameManager.GameOver += OnLevelFinished; _gameManager.BlockReduced += OnBlockReduced; //Object creations. passing dependencies and event callbacks _tower = new Tower(ObjectPooler.Instance, _gameManager.RaiseTowerLevelChangedEvent, _gameManager.RaiseBlockReducedEvent); _scoreManger = new ScoreManager(_gameManager.RaiseScoredEvent, _gameManager.RaiseLevelCompletedEvent); _ballManager = new BallManager(input, _camera, _ballSettings, _gameManager.RaiseGameOverEvent); }
/// <summary> /// 状态结束 /// </summary> /// <param name="currStateName"></param> /// <param name="nextStateName"></param> public void OnEndStateExit(string currStateName, string nextStateName) { _loadLevelExceptionCount = 0; for (int i = 0; i < _constManagers.Count; i++) { IGameManager mamager = _constManagers[i]; try { mamager.OnEndStateExit(currStateName, nextStateName); } catch (Exception e) { ShowExceptionPopup(e, _evtOnExceptionPopupConfirm, mamager.GetType().Name); } } DestroyDynamicManager(); Facade.Instance.ClearAll(); }
// Execute some logic when the game scene has loaded public override void OnGameLoad(IGameManager gameManager) { // Register an item sprite from our asset bundle, so the game knows how to render it gameManager.GetItemManager().RegisterAsset(this, CandyBarItem.ID, "assets/candy-bar.png"); // Loop through all players foreach (IPlayer player in gameManager.GetPlayers()) { var playerInventory = player.GetInventory(); // Ensure they don't have a candy bar already if (!playerInventory.Has(CandyBarItem.ID)) { // Give them a candy bar playerInventory.Add(new CandyBarItem()); } } }
public NflDotComGamesImporter(IGameManager gameManager, ITeamRepository teamRepository) { if (gameManager == null) { throw new ArgumentNullException("gameRepository"); } if (teamRepository == null) { throw new ArgumentNullException("teamRepository"); } _gameManager = gameManager; _teamRepository = teamRepository; _games = new List<Game>(); _nflDotComGames = new List<NflDotComGame>(); _connectionString = ConfigurationManager.ConnectionStrings["sportpicksdb"].ConnectionString; }
public GameRunner(Server server, IGameSettingsCore <AppSettingsCore> settings, SIDocument document, IGameManager backLink, IShare share, ComputerAccount[] defaultPlayers, ComputerAccount[] defaultShowmans, bool createHost = true) { _server = server; _settings = settings; _document = document; _backLink = backLink; _share = share; _defaultPlayers = defaultPlayers; _defaultShowmans = defaultShowmans; _createHost = createHost; }
private void Start() { globeManager = interfaceFactory.GlobeManager; errorHandler = interfaceFactory.ErrorHandler; gameManager = interfaceFactory.GameManager; if (globeManager == null || errorHandler == null || gameManager == null) { gameObject.SetActive(false); } else { worldMapGlobe = globeManager.WorldMapGlobe; if (worldMapGlobe == null) { errorHandler.ReportError("World Map Globe missing", ErrorState.restart_scene); } } }
void Start() { gameManager = interfaceFactory.GameManager; globeManager = interfaceFactory.GlobeManager; errorHandler = interfaceFactory.ErrorHandler; if (gameManager == null || globeManager == null || errorHandler == null) { gameObject.SetActive(false); } else { cellCursorInterface = globeManager.CellCursorInterface; if (cellCursorInterface == null) { errorHandler.ReportError("CellCurserInterface no found", ErrorState.restart_scene); } } }
public void Init() { _uiManager = GameClient.Get <IUIManager>(); _loadObjectsManager = GameClient.Get <ILoadObjectsManager>(); _gameManager = GameClient.Get <IGameManager>(); _selfPopup = MonoBehaviour.Instantiate(_loadObjectsManager.GetObjectByPath <GameObject>(Constants.PATH_TO_UI_PREFABS + "Popups/TowerPopup")); _selfPopup.transform.SetParent(_uiManager.PopupsContainer.transform, false); _container = _selfPopup.transform.Find("Container").GetComponent <RectTransform>(); _sellTowerButton = _container.Find("Button_SellTower").GetComponent <Button>(); _sellTowerButton.onClick.AddListener(OnSellTowerButtonClickHandler); _sellTowerButtonLabelText = _sellTowerButton.transform.Find("Text_Label").GetComponent <TextMeshProUGUI>(); Hide(); }
public static void Main(string[] args) { try { /* * Uncomment the following lines to run this project in debug more with following files. */ //args = new string[2]; //args[0] = "game-settings.xml"; //args[1] = "moves.xml"; log4net.Config.XmlConfigurator.Configure(); Logger.InfoFormat("------------------------------------"); Logger.InfoFormat("Turtle challenge game launched."); Logger.InfoFormat("------------------------------------"); TurtleChallengeIoCConfigurator.ConfigureIoC(); IGameManager manager = IoCContainer.Instance().Resolve <IGameManager>(); string gameSettingsFile = args[0]; // assuming the user inputs the game settings file with its extension being xml or json.. string movesFile = args[1]; // assuming the user inputs the moves file with its extension being xml or json. Logger.InfoFormat($"Starting the game with {gameSettingsFile} and {movesFile} files."); IEnumerable <string> sequenceResults = manager.Start(gameSettingsFile, movesFile); foreach (string sequenceResult in sequenceResults) { Console.WriteLine(sequenceResult); Logger.InfoFormat(sequenceResult); } Logger.InfoFormat("------------------------------------"); Logger.InfoFormat("Turtle challenge game exits."); Logger.InfoFormat("------------------------------------"); } catch (Exception ex) { Console.WriteLine("A fatel error occured during the execution of the game. Please check the log file for the detailed error message.\n"); Logger.ErrorFormat($"A fatel error occured during the execution of the game. Details {ex}"); } }
public void Setup() { _hallOfFameRepository = A.Fake <IHallOfFameRepository>(); _gameManager = new GameManager(_hallOfFameRepository); _gameSetup = new GameSetup() { BannedCards = new List <CardValue>() }; _game = new Game(_gameSetup); _game.Direction = Direction.Left; _game.Deck = new Deck(_gameSetup); _game.DiscardedPile = new List <ICard>() { new Charity(), new BlackHole(), new Blackjack() }; _game.LastCardPlayed = new LastCardPlayed(CardColor.Blue, CardValue.Five, "", "", false); var player = new Player(new User("123", "john")); var player2 = new Player(new User("456", "andrew")); player.Cards = new List <ICard>() { new Charity(), new BlackHole(), new Blackjack(), new Charity(), new BlackHole(), new Blackjack() }; player2.Cards = new List <ICard>() { new Charity(), new BlackHole(), new Blackjack(), new Charity(), new BlackHole(), new Blackjack() }; _game.Players = new List <Player>() { player, player2 }; _game.PlayerToPlay = player; _moveParams = new MoveParams(player, player.Cards.First(), player, CardColor.Blue, _game.DiscardedPile.First(), new List <int>() { 1, 2, 3 }, new List <ICard>() { new Charity() }, 10, new List <int>() { 0, 1 }, new BlackHole(), "odd"); }
public MainMenuPresenter( IMainMenuView view, IApplicationController controller, IApplicationService applicationService, IGameManager gameManager) { this.view = view; this.controller = controller; this.applicationService = applicationService; this.gameManager = gameManager; this.view.SetContinueOptionState(CurrentGame.Game != null); this.view.StartGame += View_StartGame; this.view.ContinueGame += View_ContinueGame; this.view.ShowSpellLibrary += View_ShowSpellLibrary; this.view.ShowSettings += View_ShowSettings; this.view.Exit += View_Exit; }
public ShellViewModel(IGameManager gameManager, IDialogService dialogService, IEventAggregator eventAggregator, IPackageManager packageManager, IApplicationCommands applicationCommands ) { PlayCommand = new DelegateCommand(OpenPlaywindow); SelectSavefilePathCommand = new DelegateCommand(SelectSavefilePath); SaveCommand = new DelegateCommand(SaveData); LoadCommand = new DelegateCommand(LoadData); PublishCommand = new DelegateCommand(PublishPackage); ApplicationCommands = applicationCommands; _gameManager = gameManager; _dialogService = dialogService; _eventAggregator = eventAggregator; _packageManager = packageManager; }
public override void _Ready() { this.Parts = new List <StringValueItem>(); this.ListItemPrefab = GD.Load <PackedScene>( GlobalConstants.GODOT_ASSETS_FOLDER + "Scenes/Parts/String List Item.tscn"); IGameManager gameManager = GlobalConstants.GameManager; this.EntityTemplateHandler = gameManager.EntityTemplateHandler; this.CultureHandler = gameManager.CultureHandler; this.GenderHandler = gameManager.GenderHandler; this.BioSexHandler = gameManager.BioSexHandler; this.SexualityHandler = gameManager.SexualityHandler; this.RomanceHandler = gameManager.RomanceHandler; this.JobHandler = gameManager.JobHandler; this.SetUp(); }
void IInputEvent.ButtonEvent(int input, IGameManager igameManager) { if (input == 0) { switch (cursor.select) { case 0: SetBattleMenuEnable(false); nextMenu = new StatusMenu(this); nextMenu.CreateCanvas(dataManager); break; case 1: SetBattleMenuEnable(false); nextMenu = new ImageMenu(this, "Other/manual_attack"); nextMenu.CreateCanvas(dataManager); break; case 2: SetBattleMenuEnable(false); nextMenu = new ImageMenu(this, "Other/manual"); nextMenu.CreateCanvas(dataManager); break; case 3: nextMenu = null; MonoBehaviour.Destroy(canvas.gameObject); igameManager.SetEnemyUnitsEnable(true); break; case 4: nextMenu = new WindowMenu(this, "return_title"); nextMenu.CreateCanvas(dataManager); break; } } else if (input == 1) { nextMenu = null; MonoBehaviour.Destroy(canvas.gameObject); igameManager.SetEnemyUnitsEnable(true); } }
public LabirynthGame(Game game) { keys = new List <Key>(); basicEffect = new BasicEffect(game.GraphicsDevice) { TextureEnabled = true, World = Matrix.Identity, PreferPerPixelLighting = true }; basicEffect.EnableDefaultLighting(); basicEffect.DirectionalLight0.Enabled = true; basicEffect.DirectionalLight0.SpecularColor = new Vector3(0, 0, 0); basicEffect.DirectionalLight1.Enabled = true; basicEffect.DirectionalLight2.Enabled = true; //basicEffect.AmbientLightColor = new Vector3(0.2f, 0.2f, 0.2f); //basicEffect.EmissiveColor = new Vector3(1, 0, 0); AssetHolder.Instance.GandalfMusicInstance.IsLooped = true; AssetHolder.Instance.KeyPickupfMusicInstance.IsLooped = false; this.game = game; gameManager = (IGameManager)game.Services.GetService(typeof(IGameManager)); screenManager = (IScreenManager)game.Services.GetService(typeof(IScreenManager)); controlManager = (IControlManager)game.Services.GetService(typeof(IControlManager)); labirynth = new LabirynthCreator(game); player = new Player(new Vector3(), 2.0f, game); finish = new Vector3(); if (gameManager.Type == LabiryntType.Recursive) { CollisionChecker.Instance.Walls = labirynth.ModelMap; } else if (gameManager.Type == LabiryntType.Prim) { CollisionChecker.Instance.VertexWalls = labirynth.VertexMap; } skyBox = new SkyBox(new Vector3((float)DifficultyLevel.Hard / 2, (float)DifficultyLevel.Hard / 2, 0), new Vector3(90, 0, 0), new Vector3(5f)); finishPoint = new Finish(finish, game.GraphicsDevice, game); keys = labirynth.GetKeys(gameManager.Type, game.GraphicsDevice, game); ground = new Ground(game, labirynth.GroundMap); minimap = new Minimap(labirynth.getMap(gameManager.Type), game, screenManager); }
public WebSocketConnection( ILogger logger, IGameManager gameManager, IGamePacketManager packetManager, IGamePacketSerializer packetSerializer, WebSocketConnectionProvider sessionProvider, WebSocket ws, SessionToken sessionToken) { this.receiveLoop = new Thread(ReceiveLoop); this.gameLoop = new Thread(GameUpdateLoop); this.logger = logger; this.gameManager = gameManager; this.packetManager = packetManager; this.packetSerializer = packetSerializer; this.sessionProvider = sessionProvider; this.sessionToken = sessionToken; this.ws = ws; this.killTask = new TaskCompletionSource <object>(); }
protected InputControllerBase(IGameManager gameManager, PlayerIndex playerIndex) : base(gameManager) { PlayerIndex = playerIndex; }
public GamesController(IGameManager manager) { _manager = manager; }
public SettingsViewModel(IScreen screen, ISettingsManager settingsManager, IVersionManager versionManager, IGameManager gameManager, Dictionary<string, string> errors) : this(screen, settingsManager, versionManager, gameManager) { Errors = errors; }
public GameItemViewModel(Game game, IDependencyResolver resolver) { Game = game; _logger = resolver.GetService<ILogger>(); _vpdbClient = resolver.GetService<IVpdbClient>(); _gameManager = resolver.GetService<IGameManager>(); _messageManager = resolver.GetService<IMessageManager>(); var threadManager = resolver.GetService<IThreadManager>(); // release identify IdentifyRelease = ReactiveCommand.CreateAsyncObservable(_ => _vpdbClient.Api.GetReleasesBySize(Game.FileSize, MatchThreshold).SubscribeOn(threadManager.WorkerScheduler)); IdentifyRelease.Select(releases => releases .Select(release => new {release, release.Versions}) .SelectMany(x => x.Versions.Select(version => new {x.release, version, version.Files})) .SelectMany(x => x.Files.Select(file => new GameResultItemViewModel(game, x.release, x.version, file, CloseResults))) ).Subscribe(x => { var releases = x as GameResultItemViewModel[] ?? x.ToArray(); var numMatches = 0; _logger.Info("Found {0} releases for game to identify.", releases.Length); GameResultItemViewModel match = null; foreach (var vm in releases) { if (game.Filename == vm.TableFile.Reference.Name && game.FileSize == vm.TableFile.Reference.Bytes) { numMatches++; match = vm; } } _logger.Info("Found {0} identical match(es).", numMatches); // if file name and file size are identical, directly match. if (numMatches == 1 && match != null) { _logger.Info("File name and size are equal to local release, linking."); _gameManager.LinkRelease(match.Game, match.Release, match.TableFile.Reference.Id); _messageManager.LogReleaseLinked(match.Game, match.Release, match.TableFile.Reference.Id); } else { _logger.Info("View model updated with identified releases."); IdentifiedReleases = releases; HasExecuted = true; } }, exception => _vpdbClient.HandleApiError(exception, "identifying a game by file size")); //SyncToggled // .Where(_ => Game.IsSynced && Game.HasRelease) // .Subscribe(_ => { GameManager.Sync(Game); }); // handle errors IdentifyRelease.ThrownExceptions.Subscribe(e => { _logger.Error(e, "Error matching game."); }); // spinner IdentifyRelease.IsExecuting.ToProperty(this, vm => vm.IsExecuting, out _isExecuting); // result switch IdentifyRelease.Select(r => r.Count > 0).Subscribe(hasResults => { HasResults = hasResults; }); // close button CloseResults.Subscribe(_ => { HasExecuted = false; }); // identify button visibility this.WhenAny( vm => vm.HasExecuted, vm => vm.Game.HasRelease, vm => vm.IsExecuting, (hasExecuted, hasRelease, isExecuting) => !hasExecuted.Value && !hasRelease.Value && !isExecuting.Value ).ToProperty(this, vm => vm.ShowIdentifyButton, out _showIdentifyButton); }
public BallController(IBall spriteEntity, IBallState ballState, IGameManager gameManager) { Ball = spriteEntity; State = ballState; GameManager = gameManager; }
protected TextEntityControllerBase(ITextEntity textEntity, IGameManager gameManager) { Model = textEntity; _gameManager = gameManager; }
public GameHub(IGameManager gameManager, IDiscColorManager discColorManager) { _discColorManager = discColorManager; _gameManager = gameManager; }
protected PadelInputController(IPadelController controller, IGameManager gameManager, PlayerIndex playerIndex) : base(gameManager, playerIndex) { PadelController = controller; }
protected SpriteEntityControllerBase(IGameManager gameManager) { _gameManager = gameManager; }
public override void RemoveFromGameManager(IGameManager gameManager) { gameManager.ReleaseAspectList<LabelAspect>(); OnRemovedFromGameManager(); }
public override void AddToGameManager(IGameManager gameManager) { _labelAspects = gameManager.GetAspectList<LabelAspect>(); OnAddedToGameManager(gameManager); }
public GameManagerProxy(IGameManager gameManager) { _gameManager = gameManager; }