public bool consumeEvent(IEvent e)
        {
            if (currentState.getTransitionableState().Keys.Contains(e.getEventName()))
            {
                LOG.Info("Consuming game event name=" + e.getEventName());
                this.currentState = (IGameState)this.currentState.getTransitionableState()[e.getEventName()];
                this.currentState.run(e);
                return true;
            }
            else if (currentState.isSubmachineEvent(e))
            {
                // Transport event to submachine like PlayerMachine or BoardMachine
                LOG.Info("Transport submachine event with name=" + e.getEventName());
                try
                {
                    currentState.submachineConsumeEvent(e);
                }
                catch (EventNotAcceptableException ex)
                {
                    return false;
                }
                return true;
            }
            else
            {
                // Reject unvalid event
                LOG.Info("Unvalid event in current state (" + this.currentState.getStateName() + ") event name=" + e.getEventName());
                return false;
            }

        }

        public override void SpecificHandle(IGameState previous, IGameState next)
        {
            //if (!_optionMenuControls.IsCheckBoxAvailable())
            //    return;

            var checkboxCopy = _optionMenuControls.CreateCheckboxCopy();
        }

        protected override void execute()
        {
            _log = Context.Get<IScriptLog>();
            _gameState = Context.Get<IGameState>();

            Pause(Token);
        }

        public override void SpecificHandle(IGameState previous, IGameState next)
        {
            //if (!_optionMenuControls.IsSliderAvailable())
            //    return;

            var sliderCopy = _optionMenuControls.CreateSliderCopy();
        }

 public DoublePipe(IGameState gameState, Game1 game)
 {
     myGame = game;
     pipeSprite = TileSpriteFactory.CreateDoublePipeSprite();
     isWarpPipe = true;
     this.gameState = gameState;
 }

 /// <summary>
 /// Removes the current running state and insert the state provide.
 /// </summary>
 /// <param name="gameState">State of the game.</param>
 public void ChangeState(IGameState gameState)
 {
     PopStack();
     
     gameState.LoadContent();
     _gameStates.Push(gameState);
 }

        public RoomState(IGameState previousState, IGameStateService gameStateService, IGuiService guiService,
                        IInputService inputService, GraphicsDeviceManager graphics,
                        ContentManager content)
        {
            this.gameStateService = gameStateService;
            this.guiService = guiService;
            this.inputService = inputService;
            this.graphics = graphics;
            this.content = content;

            this.previousState = previousState;
            this.mouseMove = new MouseMoveDelegate(mouseMoved);

            this.teamA = new List<Peer>();
            this.teamB = new List<Peer>();

            playerIDLabels = new List<LabelControl>();
            panelVisibility = new List<bool>();
            roomScreen = new Screen(1184, 682);

            Game1.main_console.StartEvent += Start;

            spriteBatch = new SpriteBatch(graphics.GraphicsDevice);

            LoadContent(roomScreen, content);
        }

        public AGSInteractions (IInteractions defaultInteractions, IObject obj, IGameState state)
		{
            _events = new ConcurrentDictionary<string, IEvent<ObjectEventArgs>>();
            _inventoryEvents = new ConcurrentDictionary<string, IEvent<InventoryInteractEventArgs>>();
            var defaultInteractionEvent = new AGSInteractionEvent<ObjectEventArgs>(
                new List<IEvent<ObjectEventArgs>>(), DEFAULT, obj, state);
            var defaultInventoryEvent = new AGSInteractionEvent<InventoryInteractEventArgs>(
                new List<IEvent<InventoryInteractEventArgs>>(), DEFAULT, obj, state);
            _events.TryAdd(DEFAULT, defaultInteractionEvent);
            _inventoryEvents.TryAdd(DEFAULT, defaultInventoryEvent);

            _factory = verb =>
            {
                List<IEvent<ObjectEventArgs>> interactions = new List<IEvent<ObjectEventArgs>> { defaultInteractionEvent };
                if (defaultInteractions != null)
                {
                    interactions.Add(defaultInteractions.OnInteract(verb));
                    if (verb != DEFAULT) interactions.Add(defaultInteractions.OnInteract(DEFAULT));
                }
                return new AGSInteractionEvent<ObjectEventArgs>(interactions, verb, obj, state);
            };
            _inventoryFactory = verb =>
            {
                List<IEvent<InventoryInteractEventArgs>> interactions = new List<IEvent<InventoryInteractEventArgs>> { defaultInventoryEvent };
                if (defaultInteractions != null)
                {
                    interactions.Add(defaultInteractions.OnInventoryInteract(verb));
                    if (verb != DEFAULT) interactions.Add(defaultInteractions.OnInventoryInteract(DEFAULT));
                }
                return new AGSInteractionEvent<InventoryInteractEventArgs>(interactions, verb, obj, state);
            };
		}

        public ITrade HandleTrade(IGameState state, ITrade offer, int proposingPlayerId)
        {
            // accept if convert extras to needed and opponent < 7 points
            List<Resource> extras = new List<Resource>();
            foreach (Resource r in Enum.GetValues(typeof(Resource)))
            {
                int extra = state.GetOwnResources().Count(res => res == r) - 1;
                for (int i = 0; i < extra; i++) extras.Add(r);
            }

            // good offer?
            var valid = offer.Give.Where(o => o.All(r => o.Count(cur => cur == r) <= extras.Count(e => e == r)));

            if (valid.Count() == 0) return offer.Decline();

            // take the one with least cards to give, and then by most duplicates
            List<Resource> bestGive = valid.OrderBy(o => o.Count)
                .ThenByDescending(o => state.GetOwnResources().Sum(r => state.GetOwnResources().Count(res => res == r)))
                .First();

            // find best "take" (cards we get) kind of the opposite of above
            List<Resource> bestTake = offer.Take.OrderBy(o => o.Count)
                .ThenBy(o => state.GetOwnResources().Sum(r => state.GetOwnResources().Count(res => res == r)))
                .First();

            return offer.Respond(bestGive, bestTake);
        }

		public AGSDialogFactory(IContainer resolver, IGameState gameState, IUIFactory ui, IObjectFactory obj)
		{
			_resolver = resolver;
			_gameState = gameState;
			_ui = ui;
			_object = obj;
		}

        public override TankUpdate Update(IGameState gameState)
        {
            TankUpdate tankUpdate = new TankUpdate();
            tankUpdate.TankColor = ConvertColorToHexString(Color.Blue);

            if (gameState.Foes.Any() && gameState.Goals.Any())
            {
                var target = gameState.Foes
                    .Where(foe => 1000 / GetDistanceFromTank(foe) >= 2)
                    .OrderBy(foe => GetDistanceToGoal(foe, gameState.Goals) + GetTimeToGoal(foe, gameState.Goals) + GetDistanceFromTank(foe))
                    .FirstOrDefault();

                if (target != null)
                {
                    tankUpdate.ShotTarget = target.Center;
                    ChangeBulletPower(target);
                    tankUpdate.Bullet = Bullet;
                }

                var x = (gameState.Foes.Max(foe => foe.X) + 9 * gameState.Goals.Last().X) / 10;
                var y = (gameState.Foes.Max(foe => foe.Y) + 9 * gameState.Goals.Last().Y) / 10;
                tankUpdate.MovementTarget = LocationProvider.GetLocation(x, y);
            }

            return tankUpdate;
        }

        public GameStateManager( Game game )
        {
            _game = game;

            _gameStates = new Dictionary<string,IGameState>();
            _currentGameState = null;
        }

 public override void Rollback(IGameState state)
 {
     var s = state as ChessState;
     s.Castling = _Castling;
     RollbackMovePiece(From, To, state);
     RollbackMovePiece(RookFrom, RookTo, state);
 }

        public State CalculateState(Location a, IGameState state)
        {
            State s = new State();
            Location l;
            Tile t;
            for (int x = -radius; x <= radius; x++)
            {
                for (int y = -radius; y <= radius; y++)
                {
                    if (x == 0 && y == 0)
                        continue;

                    l = (a + new Location(y, x)) % new Location(state.Height, state.Width);
                    t = state[l];
                    if (t == Tile.Ant)
                    {
                        if(state.MyAnts.Contains(new Ant(l.Row, l.Col, state.MyAnts[0].Team)))
                            s.MyAnt = true;
                        else
                            s.EnemyAnt = true;
                    }
                    else if (t == Tile.Food)
                        s.Food = true;
                    else if (t == Tile.Hill)
                    {
                        if (state.MyHills.Contains(new AntHill(l.Row, l.Col, state.MyHills[0].Team)))
                            s.MyHill = true;
                        else
                            s.EnemyHill = true;
                    }
                }
            }
            s.AirSuperiority = state.MyAnts.Count > state.EnemyAnts.Count;
            return s;
        }

 public InformState(string message, IGameState nextstate, Color color, bool isCard = false)
 {
     this.message = message;
     this.nextState = nextstate;
     this.color = color;
     this.isCard = isCard;
 }

 public override void Become(IGameState prevState)
 {
     PuzzleBoardViewModel.StartPauseButtonCaption = "Game Over :-)";
     PuzzleBoardViewModel.PauseTimer();
     PuzzleBoardViewModel.FireGameCompleteMessage();
     base.Become(prevState);
 }

        private static void DrawGridCells(IGameState state)
        {
            GL.LineWidth(5.0f);
            var deltaX = 2.0f / (float)state.GridWidth;
            var deltaY = 2.0f / (float)state.GridHeight;
            var cell = new Box2D(0, 0, deltaX, deltaY);
            for (int u = 0; u < state.GridWidth; ++u)
            {
                for (int v = 0; v < state.GridHeight; ++v)
                {
                    cell.X = deltaX * u - 1.0f;
                    cell.Y = 1.0f - deltaY * (v + 1);
                    switch (state[u, v])
                    {
                        case FieldType.DIAMONT:
                            DrawDiamont(cell);
                            break;
                        case FieldType.CROSS:
                            DrawCross(cell);
                            break;
                        default: break;
                    }

                }
            }
        }

        public override TankUpdate Update(IGameState gameState)
        {
            TankUpdate tankUpdate = new TankUpdate();

            if (gameState.Foes.Any() && gameState.Goals.Any())
            {
                tankUpdate.ShotTarget = LocationProvider.GetLocation(_xTarget, _yTarget);
                ChangeBulletPower(tankUpdate.ShotTarget, gameState);

                var range = GetDistanceFromTank(LocationProvider.GetLocation(_xTarget, _yTarget)) + 1;
                if (Bullet.GetReloadTime((int)range) < 1000 || range < 100)
                {
                    tankUpdate.Bullet = Bullet;
                }
                else
                {
                    tankUpdate.Bullet = new Bullet();
                }

                UpdateMovementTarget(tankUpdate, gameState);
            }

            tankUpdate.TankColor = ConvertColorToHexString(Color.CornflowerBlue);

            return tankUpdate;
        }

		public AGSInventoryWindowComponent(IGameState state, IGameEvents gameEvents)
		{
			_state = state;
			_inventoryItems = new List<IObject> (20);
			_gameEvents = gameEvents;
			_gameEvents.OnRepeatedlyExecute.Subscribe(onRepeatedlyExecute);
		}

 public PauseMenu(IGameState prevGameState, Game1 game)
 {
     this.game = game;
     this.prevGameState = prevGameState;
     currentSelection = Selections.Resume;
     font = MenuSpriteFactory.CreateHUDFont();
 }