public HardBall(IGame game, Vector2 position)
     : base(game, game.ContentProvider.GetBallSprite(0), position, 5)
 {
     Velocity = 2;
     var target = new Vector2(Game.Random.Next() - Game.Random.Next(), Game.Random.Next() - Game.Random.Next());
     MoveTo(target);
 }

        public bool TryGetGame(string hash, out IGame game)
        {
            GameSetup _setup;
            Game _game;

            if (setups.TryGetValue(hash, out _setup))
            {
                game = _setup;
                return true;
            }
            else if (games.TryGetValue(hash, out _game))
            {
                game = _game;
                return true;
            }
            else
            {
                string filepath = getFilePath(hash);
                if (!File.Exists(filepath))
                {
                    game = null;
                    return false;
                }
                else
                {
                    _game = Game.FromFile(filepath);
                    games.Add(hash, _game);
                    game = _game;
                    return true;
                }
            }
        }

            private void HealOneDamageOnCharacter(IGame game, IEffectHandle handle, IPlayer player, ICharacterInPlay glorfindel, ICharacterInPlay character)
            {
                glorfindel.Resources -= 1;
                character.Damage -= 1;

                handle.Resolve(string.Format("{0} chose to heal 1 damage on '{1}'", player.Name, character.Title));
            }

        public override void Update(Unit unit, IGame game)
        {
            base.Update(unit, game);

            if ((game.Time - unit.BirthTime) > FleeTime)
                unit.setState(UnitFactories.States.Create(unit.Name, "fleeing"), game);
        }

        public PlayerActionWindow(IGame game, IPlayer player)
            : base("Player Action Window", GetDescription(player), game)
        {
            this.player = player;

            player.IsActivePlayer = true;
        }

 public void Handle(string logLine, IHsGameState gameState, IGame game)
 {
     if (HsLogReaderConstants.CardAlreadyInCacheRegex.IsMatch(logLine))
     {
         var id = HsLogReaderConstants.CardAlreadyInCacheRegex.Match(logLine).Groups["id"].Value;
         if (game.CurrentGameMode == GameMode.Arena)
             gameState.GameHandler.HandlePossibleArenaCard(id);
         else
             gameState.GameHandler.HandlePossibleConstructedCard(id, false);
     }
     else if (HsLogReaderConstants.GoldProgressRegex.IsMatch(logLine)
              && (DateTime.Now - gameState.LastGameStart) > TimeSpan.FromSeconds(10)
              && game.CurrentGameMode != GameMode.Spectator)
     {
         int wins;
         var rawWins = HsLogReaderConstants.GoldProgressRegex.Match(logLine).Groups["wins"].Value;
         if (int.TryParse(rawWins, out wins))
         {
             TimeZoneInfo timeZone = null;
             switch (game.CurrentRegion)
             {
                 case Region.EU:
                     timeZone = TimeZoneInfo.FindSystemTimeZoneById("Central European Standard Time");
                     break;
                 case Region.US:
                     timeZone = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
                     break;
                 case Region.ASIA:
                     timeZone = TimeZoneInfo.FindSystemTimeZoneById("Korea Standard Time");
                     break;
             }
             if (timeZone != null)
             {
                 var region = (int)game.CurrentRegion - 1;
                 var date = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, timeZone).Date;
                 if (Config.Instance.GoldProgressLastReset[region].Date != date)
                 {
                     Config.Instance.GoldProgressTotal[region] = 0;
                     Config.Instance.GoldProgressLastReset[region] = date;
                 }
                 Config.Instance.GoldProgress[region] = wins == 3 ? 0 : wins;
                 if (wins == 3)
                     Config.Instance.GoldProgressTotal[region] += 10;
                 Config.Save();
             }
         }
     }
     else if (HsLogReaderConstants.DustRewardRegex.IsMatch(logLine))
     {
         int amount;
         if (int.TryParse(HsLogReaderConstants.DustRewardRegex.Match(logLine).Groups["amount"].Value, out amount))
             gameState.GameHandler.HandleDustReward(amount);
     }
     else if (HsLogReaderConstants.GoldRewardRegex.IsMatch(logLine))
     {
         int amount;
         if (int.TryParse(HsLogReaderConstants.GoldRewardRegex.Match(logLine).Groups["amount"].Value, out amount))
             gameState.GameHandler.HandleGoldReward(amount);
     }
 }

 public SourceCodeListViewModel(IGame game)
 {
     this.game = game;
     List<DirectoryListing> baseListings = new List<DirectoryListing>();
     foreach (ISourceCode source in game.Sources)
     {
         string dn = Path.GetDirectoryName(source.RelativeName);
         string[] dirs = Regex.Split(dn, @"[\\/]");
         DirectoryListing d = null;
         foreach (var baseListing in baseListings)
         {
             if (baseListing.Name == dirs[0])
             {
                 d = baseListing;
             }
         }
         if (d == null)
         {
             d = new DirectoryListing();
             d.Name = dirs[0];
             baseListings.Add(d);
         }
         d.GetOrCreateDirectoryListing(dirs).Sources.Add(source);
     }
     DirectoryListings = baseListings;
 }

 public override void RemoveFromGame(IGame game)
 {
     players = null;
     asteroids = null;
     bullets = null;
     games = null;
 }

        /// <summary>
        /// Initialize this system to a working state.
        /// </summary>
        /// <param name="game">
        /// The <see cref="IGame"/> game, that requested the initialization. That is the game,
        /// the system will be running in.
        /// </param>
        public override void Initialize(IGame game)
        {
            base.Initialize(game);
            this.Game.ComponentSystem.RegisterComponentType<DestructableComponent>();

            this.Game.EventManager.RegisterListener(CollisionEvents.CollisionEntered, this.OnCollisionEntered);
        }

        public override bool CanBeAttachedTo(IGame game, ICanHaveAttachments cardInPlay)
        {
            if (cardInPlay == null)
                throw new ArgumentNullException("cardInPlay");

            return (cardInPlay is IHeroCard);
        }

 public GameEngine(IGame game, IBatBowlDecision batBowlDecision, ICoinToss coinToss, IDeliveryEngine deliveryEngine )
 {
     _game = game;
     _batBowlDecision = batBowlDecision;
     _coinToss = coinToss;
     _deliveryEngine = deliveryEngine;
 }

		public void Handle(string logLine, IHsGameState gameState, IGame game)
		{
			if(HsLogReaderConstants.CardAlreadyInCacheRegex.IsMatch(logLine))
			{
				var id = HsLogReaderConstants.CardAlreadyInCacheRegex.Match(logLine).Groups["id"].Value;
				if(game.CurrentGameMode == GameMode.Arena)
					gameState.GameHandler.HandlePossibleArenaCard(id);
				else
					gameState.GameHandler.HandlePossibleConstructedCard(id, false);
			}
			else if(HsLogReaderConstants.GoldProgressRegex.IsMatch(logLine) && (DateTime.Now - gameState.LastGameStart) > TimeSpan.FromSeconds(10)
			        && game.CurrentGameMode != GameMode.Spectator)
			{
				int wins;
				var rawWins = HsLogReaderConstants.GoldProgressRegex.Match(logLine).Groups["wins"].Value;
				if(int.TryParse(rawWins, out wins))
				{
					var timeZone = GetTimeZoneInfo(game.CurrentRegion);
					if(timeZone != null)
						UpdateGoldProgress(wins, game, timeZone);
				}
			}
			else if(HsLogReaderConstants.DustRewardRegex.IsMatch(logLine))
			{
				int amount;
				if(int.TryParse(HsLogReaderConstants.DustRewardRegex.Match(logLine).Groups["amount"].Value, out amount))
					gameState.GameHandler.HandleDustReward(amount);
			}
			else if(HsLogReaderConstants.GoldRewardRegex.IsMatch(logLine))
			{
				int amount;
				if(int.TryParse(HsLogReaderConstants.GoldRewardRegex.Match(logLine).Groups["amount"].Value, out amount))
					gameState.GameHandler.HandleGoldReward(amount);
			}
		}

            private IGame m_gameState; // Game state variable

            public FormGame()
            {
                InitializeComponent();

                try
                {
                // Load the remoting configuration file
                RemotingConfiguration.Configure("remoting.config", false);

                // TODO: Remove this for the remoting.config
                m_gameState = (IGame)Activator.GetObject(typeof(IGame),
                    "http://localhost:10000/gamestate.soap");

                // Register callback
                m_gameState.RegisterClientCallback(new Callback(this));

                // TEST CODE
                m_gameState.revealCell(2, 2);
                foreach (Cell cell in m_gameState.Board.ClientCells)
                {
                    MessageBox.Show("Is Mine? " + cell.IsMine.ToString() + "\nPerimitive Mines: " + cell.PerimitiveMines + "\nLocation: " + cell.LocX + "," + cell.LocY);
                }
                }
                catch (Exception ex)
                {
                MessageBox.Show(ex.Message);
                }
            }

 public void Handle(string logLine, IHsGameState gameState, IGame game)
 {
     if (gameState.AwaitingRankedDetection)
     {
         gameState.LastAssetUnload = DateTime.Now;
         gameState.WaitingForFirstAssetUnload = false;
     }
     if (logLine.Contains("Medal_Ranked_"))
     {
         var match = Regex.Match(logLine, "Medal_Ranked_(?<rank>(\\d+))");
         if (match.Success)
         {
             int rank;
             if (int.TryParse(match.Groups["rank"].Value, out rank))
                 gameState.GameHandler.SetRank(rank);
         }
     }
     else if (logLine.Contains("rank_window"))
     {
         gameState.FoundRanked = true;
         gameState.GameHandler.SetGameMode(GameMode.Ranked);
     }
     else if (HsLogReaderConstants.UnloadCardRegex.IsMatch(logLine))
     {
         var id = HsLogReaderConstants.UnloadCardRegex.Match(logLine).Groups["id"].Value;
         if (game.CurrentGameMode == GameMode.Arena)
             gameState.GameHandler.HandlePossibleArenaCard(id);
         else
             gameState.GameHandler.HandlePossibleConstructedCard(id, true);
     }
 }

 public void Handle(string logLine, IHsGameState gameState, IGame game)
 {
     if (HsLogReaderConstants.CardAlreadyInCacheRegex.IsMatch(logLine))
     {
         var id = HsLogReaderConstants.CardAlreadyInCacheRegex.Match(logLine).Groups["id"].Value;
         if (game.CurrentGameMode == GameMode.Arena)
             gameState.GameHandler.HandlePossibleArenaCard(id);
         else
             gameState.GameHandler.HandlePossibleConstructedCard(id, false);
     }
     else if ((DateTime.Now - gameState.LastGameStart) > TimeSpan.FromSeconds(10)
              && game.CurrentGameMode != GameMode.Spectator)
     {
         GoldTracking(logLine, game);
     }
     else if (HsLogReaderConstants.DustRewardRegex.IsMatch(logLine))
     {
         int amount;
         if (int.TryParse(HsLogReaderConstants.DustRewardRegex.Match(logLine).Groups["amount"].Value,
             out amount))
             gameState.GameHandler.HandleDustReward(amount);
     }
     else if (HsLogReaderConstants.GoldRewardRegex.IsMatch(logLine))
     {
         int amount;
         if (int.TryParse(HsLogReaderConstants.GoldRewardRegex.Match(logLine).Groups["amount"].Value,
             out amount))
             gameState.GameHandler.HandleGoldReward(amount);
     }
 }

        public void Handle(string logLine, IHsGameState gameState, IGame game)
        {
            if (logLine[9] != 'R' && logLine[16] != 'r') // [Bob] ---Register
                return;

            if (logLine.Length == 29 && logLine[23] == 'B' && logLine[25] == 'x') // ---RegisterScreenBox---
            {
                if (game.CurrentGameMode == GameMode.Spectator)
                    gameState.GameEnd();
            }
            else if (logLine.Length == 31 && logLine[23] == 'F' && logLine[27] == 'e') // ---RegisterScreenForge---
            {
                gameState.GameHandler.SetGameMode(GameMode.Arena);
                game.ResetArenaCards();
            }
            else if (logLine.Length == 34)
            {
                if (logLine[23] == 'P' && logLine[30] == 'e') // ---RegisterScreenPractice---
                    gameState.GameHandler.SetGameMode(GameMode.Practice);
                else if (logLine[23] == 'T' && logLine[30] == 's') // ---RegisterScreenTourneys---
                    gameState.GameHandler.SetGameMode(GameMode.Casual);
                else if (logLine[23] == 'F' && logLine[30] == 'y') // ---RegisterScreenFriendly---
                    gameState.GameHandler.SetGameMode(GameMode.Friendly);
                else if (logLine[23] == 'e' && logLine[24] == 'N' && logLine[30] == 's') // RegisterProfileNotices
                    gameState.GameLoaded = true;
            }
            else if (logLine.Length == 35 && logLine[17] == 'F' && logLine[22] == 'd' && logLine[23] == 'C') // RegisterFriendChallenge
            {
                gameState.GameHandler.HandleInMenu();
            }
            else if (logLine.Length == 43 && logLine[23] == 'C' && logLine[32] == 'n' && logLine[33] == 'M' && logLine[39] == 'r')// ---RegisterScreenCollectionManager---
                gameState.GameHandler.ResetConstructedImporting();
        }

        public void Initialize(IGame game, int starCount)
        {
            rand = new Random();
            this.game = game;

            int starCount1 = starCount;
            int starCount2 = starCount / Star2Divisor;
            int starCount3 = starCount / Star3Divisor;

            stars1 = new List<Vector2>(starCount1);
            stars2 = new List<Vector2>(starCount2);
            stars3 = new List<Vector2>(starCount3);

            for (int i = 0; i < starCount1; ++i)
            {
                int x = rand.Next(game.Width);
                int y = rand.Next(game.Height);
                stars1.Add(new Vector2(x, y));
            }

            for (int i = 0; i < starCount2; ++i)
            {
                int x = rand.Next(game.Width);
                int y = rand.Next(game.Height);
                stars2.Add(new Vector2(x, y));
            }

            for (int i = 0; i < starCount3; ++i)
            {
                int x = rand.Next(game.Width);
                int y = rand.Next(game.Height);
                stars3.Add(new Vector2(x, y));
            }
        }

        public virtual void Travel(IGame game)
        {
            if (game.QuestArea.ActiveLocation != null)
                return;

            game.AddEffect(this);
        }

 public override void AddToGame(IGame game)
 {
     games = game.GetNodeList<GameNode>();
     players = game.GetNodeList<PlayerCollisionNode>();
     asteroids = game.GetNodeList<AsteroidCollisionNode>();
     bullets = game.GetNodeList<BulletCollisionNode>();
 }

 public override void RemoveFromGame(IGame game)
 {
     spaceships = null;
     asteroids = null;
     bullets = null;
     games = null;
 }