Example #1
0
 public GameState(IGameDataProvider gameDataProvider, GameStateEvents gameStateEvents)
 {
     gameDataProvider.Reset();
     _gameDataProvider = gameDataProvider;
     _gameStateEvents  = gameStateEvents;
     Entities          = new Dictionary <int, Entity>();
     PlayerEntities    = new Dictionary <int, PlayerEntity>();
     _modifiers        = new List <IGameStateModifier>();
     _creationTags     = new Queue <IGameStateModifier>();
     _initialQueue     = new Queue <IGameStateModifier>();
     _powerLog         = new List <string>();
     CreatedAt         = DateTime.Now;
     Modified         += gameStateEvents.OnGameStateChanged;
     SecretsManager    = new SecretsManager(this, gameStateEvents);
     LocalPlayer       = new Player(this, true);
     OpposingPlayer    = new Player(this, false);
     GameTime          = new GameTime();
     Task.Run(async() =>
     {
         while (MatchInfo == null || ServerInfo == null)
         {
             await Task.Delay(500);
         }
     });
 }
Example #2
0
        public DatabaseInfoForm(IGameDataProvider provider)
        {
            this.provider = provider;

            InitializeComponent();
            BuildLabels();
        }
Example #3
0
        public Manager(HSReplayNetConfig config = null, IGameDataProvider gameDataProvider = null)
        {
            gameDataProvider = gameDataProvider ?? new HearthMirrorDataProvider();

            LogReader = new LogReader(new List <LogWatcherData>
            {
                LogWatcherConfigs.Power,
                LogWatcherConfigs.LoadingScreen,
                LogWatcherConfigs.Decks,
                LogWatcherConfigs.Arena,
                LogWatcherConfigs.Rachelle
            });

            Game = new Game(gameDataProvider);
            Game.HearthstoneExited += () => LogReader.Stop().Forget();

            _gameEventManager = new GameEventManager(Game, LogReader, gameDataProvider);

            _procWatcher          = new ProcessWatcher("Hearthstone");
            _procWatcher.OnStart += ProcessWatcher_OnStart;
            _procWatcher.OnExit  += ProcessWatcher_OnExit;

            LogConfigWatcher.Start();
            LogConfigUpdater.LogConfigUpdated      += Game.OnHearthstoneRestartRequired;
            LogConfigUpdater.LogConfigUpdateFailed += Game.OnLogConfigError;

            if (config != null)
            {
                HSReplayNet = new HSReplayNet(config);
                _hsReplayNetEventManager = new HSReplayNetEventManager(HSReplayNet, Game);
                HSReplayNet.UpdateAccount().Forget();
            }
        }
Example #4
0
 public Game(IGameDataProvider data)
 {
     this._game = data.Data;
     _bank = new Bank(_game.Tables["Properties"]);
     _rules = new Rules();
     _players = new Hashtable();
 }
        public GameEventManager(Game game, ILogInput logInput, IGameDataProvider gameData)
        {
            _game     = game;
            _gameData = gameData;

            _arenaWatcher                 = new ArenaWatcher(gameData);
            _arenaWatcher.RunComplete    += game.Arena.OnArenaRunComplete;
            _arenaWatcher.CardPicked     += game.Arena.OnArenaDraftPick;
            _arenaWatcher.ChoicesChanged += game.Arena.OnArenaDraftChoices;
            _arenaWatcher.DeckComplete   += game.Arena.OnArenaDraftComplete;

            _packWatcher             = new PackWatcher(gameData);
            _packWatcher.PackOpened += game.OnPackOpened;

            _dungeonRunWatcher = new DungeonRunWatcher(new DungeonRunData(game, gameData));
            _dungeonRunWatcher.DungeonRunMatchStarted += game.OnDungeonRunMatchStarted;
            _dungeonRunWatcher.DungeonRunDeckUpdated  += game.OnDungeonRunDeckUpdated;

            _friendlyChallengeWatcher = new FriendlyChallengeWatcher(gameData);
            _friendlyChallengeWatcher.FriendlyChallenge += game.OnFriendlyChallenge;

            var logParserManager = new LogParserManager();

            var powerParser = new PowerParser(new DefaultGameInfoProvider(game));

            powerParser.CreateGame       += () => game.OnCreateGame(null);
            powerParser.PowerTaskListLog += args => game.OnGameTimeChanged(args.Line.Time);
            powerParser.GameStateChange  += mod => game.CurrentGame?.Apply(mod);
            powerParser.BlockStart       += block => game.GameStateEvents.OnBlockStart(block, game.CurrentGame);
            powerParser.BlockEnd         += block => game.GameStateEvents.OnBlockEnd(block, game.CurrentGame);
            powerParser.GameStateLog     += args => game.CurrentGame?.AppendLog(args);
            powerParser.SetupComplete    += game.OnSetupComplete;
            logParserManager.RegisterParser(powerParser);

            var decksParser = new DecksParser();

            decksParser.FindingGame += game.OnQueuedForGame;
            decksParser.EditedDeck  += game.Collection.OnDeckEdited;
            decksParser.FoundDecks  += game.Collection.OnDecksLoaded;
            logParserManager.RegisterParser(decksParser);

            var loadingScreenParser = new LoadingScreenParser();

            loadingScreenParser.ModeChanged += game.OnModeChanged;
            loadingScreenParser.ModeChanged += LoadingScreenParser_OnModeChanged;
            logParserManager.RegisterParser(loadingScreenParser);

            var arenaParser = new ArenaParser();

            arenaParser.ArenaRunComplete += () => _arenaWatcher.Update();
            logParserManager.RegisterParser(arenaParser);

            var rachelleParser = new RachelleParser();

            rachelleParser.DeckDeleted      += game.Collection.OnDeckDeleted;
            rachelleParser.GoldProgressWins += game.OnGoldProgressWins;
            logParserManager.RegisterParser(rachelleParser);

            logInput.NewLines += eventArgs => logParserManager.Parse(eventArgs.Lines);
        }
Example #6
0
        static bool UpdateGameData(string gameId, IGameDataProvider gameDataProvider, bool forceUpdate = false)
        {
            if (!forceUpdate &&
                Games[gameId].LastDataUpdate.TryGetValue(gameDataProvider.GetGameDataType(), out DateTime lastUpdate) &&
                lastUpdate.AddDays(Settings.Default.MaxGameDataAge) > DateTime.Now)
            {
                return(false);
            }

            var oldData = Games[gameId].Data.SingleOrDefault(d => d.DataType == gameDataProvider.GetGameDataType());

            // add new data
            if (oldData == null)
            {
                var newData = gameDataProvider.GetGameData(Games[gameId].Title);
                if (newData != null)
                {
                    Games[gameId].Data = Games[gameId].Data.Concat(new GameData[] { newData }).ToArray();

                    // set last update to current time
                    Games[gameId].LastDataUpdate.AddOrUpdate(gameDataProvider.GetGameDataType(), DateTime.UtcNow, (id, oldValue) => DateTime.UtcNow);
                    return(true);
                }
            }
            else
            {
                // TODO merge new data with old
                //oldData.Merge(newData);

                Games[gameId].LastDataUpdate.AddOrUpdate(gameDataProvider.GetGameDataType(), DateTime.UtcNow, (id, oldValue) => DateTime.UtcNow);
            }

            return(false);
        }
Example #7
0
 public RouteFinder(IGameDataProvider gameDataProvider)
 {
     provider = gameDataProvider;
     logger = LogManager.GetCurrentClassLogger();
     graph = new AdjacencyGraph<StarSystem, Edge<StarSystem>>();
     weights = new Dictionary<Edge<StarSystem>, double>();
 }
        private void Awake()
        {
            _dataProvider = MainInstaller.Resolve <IGameDataProvider>();
            _services     = MainInstaller.Resolve <IGameServices>();

            _timer.Init(_services);
        }
Example #9
0
 public Game(IGameDataProvider gameDataProvider)
 {
     GameDataProvider            = gameDataProvider;
     Collection                  = new Collection();
     Account                     = new Account();
     Arena                       = new Arena();
     TavernBrawl                 = new TavernBrawl();
     GameStateEvents             = new GameStateEvents();
     GameStateEvents.BlockStart += OnBlockStart;
 }
Example #10
0
 public GameController(
     IUserContextDataProvider userContextDataProvider,
     IGameDataProvider gameDataProvider,
     IMediator mediator,
     IMapper mapper)
     : base(userContextDataProvider)
 {
     this.gameDataProvider = gameDataProvider;
     this.mediator         = mediator;
     this.mapper           = mapper;
 }
Example #11
0
 /// <summary>
 /// Reload all <see cref="IGameDataProvider"/> objects. This will also clear provider caches.
 /// </summary>
 public void ReloadProvider()
 {
     try
     {
         _dataProvider = new LuminaProvider(_cache);
         FoundSqpack   = true;
     }
     catch (DirectoryNotFoundException)
     {
         _dataProvider = new GithubRawProvider(_http, _cache);
         FoundSqpack   = false;
     }
 }
Example #12
0
        public GoldsourceEnvironment()
        {
            _wadProvider    = Container.Get <ITexturePackageProvider>("Wad3");
            _spriteProvider = Container.Get <ITexturePackageProvider>("Spr");
            _fgdProvider    = Container.Get <IGameDataProvider>("Fgd");

            _textureCollection = new Lazy <Task <TextureCollection> >(MakeTextureCollectionAsync);
            _gameData          = new Lazy <Task <GameData> >(MakeGameDataAsync);
            _data    = new List <IEnvironmentData>();
            FgdFiles = new List <string>();
            AdditionalTextureFiles             = new List <string>();
            ExcludedWads                       = new List <string>();
            IncludeToolsDirectoryInEnvironment = IncludeToolsDirectoryInEnvironment = true;
        }
Example #13
0
        public GamePlayProcessor(IGame _game, IFieldBuilder _fieldBuilder, IGameDataProvider _gameDataProvider)
        {
            if (_game == null)
            {
                throw new ArgumentNullException(nameof(_game) + " should be passed");
            }
            if (_gameDataProvider == null)
            {
                throw new ArgumentNullException(nameof(_gameDataProvider) + "should be passed");
            }
            if (_fieldBuilder == null)
            {
                throw new ArgumentNullException(nameof(_fieldBuilder) + "should be passed");
            }

            game = _game;
        }
Example #14
0
        public SplashForm(ref IGameDataProvider gdProvider)
        {
            InitializeComponent();

            progressBar1.Value = 0;
            progressBar1.Minimum = 0;
            progressBar1.Maximum = 0;
            progressBar1.Style = ProgressBarStyle.Marquee;

            provider = gdProvider;
            provider.DownloadStarted += Provider_DownloadStarted;
            provider.DownloadComplete += Provider_DownloadComplete;
            provider.DataLoadCompleted += Provider_DataLoadCompleted;

            Shown += SplashForm_Shown;

            label1.Text = "Loading data...";
        }
 public static IGameDataProvider GetGameDataProvider()
 {
     if (_provider != null)
         return _provider;
     Lock.EnterReadLock();
     try
     {
         if (_provider == null)
         {
             _provider = new GameDataProvider();
         }
     }
     finally
     {
         Lock.ExitReadLock();
     }
     return _provider;
 }
Example #16
0
 public GameApiController(IGameDataProvider gameDataProvider)
 {
     _gameDataProvider = gameDataProvider;
 }
Example #17
0
 private void Awake()
 {
     gameDataProvier = ScriptableObject.CreateInstance <LocalGameDataProvider>();
 }
Example #18
0
 public GameController(IGameDataProvider dataProvider)
 {
     _dataProvider = dataProvider;
 }
 private void Awake()
 {
     gameDataProvider = ScriptableObject.CreateInstance <LocalGameDataProvider>();
     cardsArray       = Enumerable.Range(0, gameDataProvider.GetGameCardsCount()).ToArray();
 }
Example #20
0
 public LessSimpleGameBookmaker(IGameDataProvider gameDataProvider)
 {
     GameDataProvider = gameDataProvider;
 }
Example #21
0
 public RatingApiController(IGameDataProvider gameDataProvider)
 {
     _gameDataProvider = gameDataProvider;
 }
Example #22
0
 public ArenaWatcher(IGameDataProvider gameDataProvider = null, int delay = 500) : base(delay)
 {
     _gameDataProvider = gameDataProvider ?? throw new ArgumentNullException(nameof(gameDataProvider));
 }
Example #23
0
 public GameProvider(ICacheProvider cacheProvider, IGameDataProvider gameDataProvider, IMovesDataProvider movesDataProvider)
 {
     _cacheProvider = cacheProvider;
     _gameDataProvider = gameDataProvider;
     _movesDataProvider = movesDataProvider;
 }
Example #24
0
 public Coach()
 {
     _gameDataProvider = Container.GetService <IGameDataProvider>();
 }
Example #25
0
 public DungeonRunData(Game game, IGameDataProvider gameData)
 {
     _game     = game;
     _gameData = gameData;
 }
 public InvalidSessionExceptionHandler(IGameDataProvider gameDataProvider)
 {
     _gameDataProvider = gameDataProvider;
 }
Example #27
0
 public DungeonRunWatcher(IGameDataProvider dataProvider, int delay = 500)
 {
     _dataProvider = dataProvider;
     _delay        = delay;
 }
 public FriendlyChallengeWatcher(IGameDataProvider provider, int delay = 500) : base(delay)
 {
     _provider = provider;
 }
Example #29
0
 public HomeController(IGameDataProvider gameDataProvider)
 {
     _gameDataProvider = gameDataProvider;
 }