public MultiAction(GameAction p_action, int p_count, int p_delay)
 {
     this.action = p_action;
     this.count = p_count;
     this.delay = p_delay;
     this.waiting = false;
 }

    public override bool validate( GameAction gameAction )
    {
        PieceSelection selectionAction = (PieceSelection)gameAction;

        // Verify that the selected piece belongs to player on turn
        return selectionAction.belongsToAttacker == Game.currentPlayer.isAttackerPlayer ;
    }

        public override void TagAndNotify(Player source, List<Player> dests, ICard card, GameAction action = GameAction.Use)
        {
            if (this.IsReforging(source, null, null, dests))
            {
                if (card is CompositeCard)
                {
                    foreach (Card c in (card as CompositeCard).Subcards)
                    {
                        c.Log.Source = source;
                        c.Log.GameAction = GameAction.Reforge;
                    }

                }
                else
                {
                    var c = card as Card;
                    Trace.Assert(card != null);
                    c.Log.Source = source;
                    c.Log.GameAction = GameAction.Reforge;
                }
                Game.CurrentGame.NotificationProxy.NotifyReforge(source, card);
                return;
            }
            base.TagAndNotify(source, dests, card, action);
        }

        /* The keeper will move to a new position depending on the ball's position and direction. */
        public override PlayerAction ActionWithoutBall(Player player, GameAction gameAction)
        {
            Pathfinding pathfinding = new Pathfinding();
            Point ballTarget = GameAI.BallNextRoundLocation();
            bool onOwnSide = GameAI.IsPointOnOwnSide(GameAI.PlayersTeam(player), ballTarget);
            if (onOwnSide)
            {
                if (GameAI.GameBall.IsInShootState)
                {
                    Point ballTargetGridLocation = pathfinding.GetGridLocation(GameAI.GameBall.ExactTargetLocation);

                    Goal ownGoal = GameAI.PlayersTeam(player).TeamGoal;

                    Point? pointBeforeGoalEntry = GameAI.PointBeforeRectangleEntry(ownGoal.GoalRectangle);

                    //true if the ball will go through the goal
                    if (pointBeforeGoalEntry.HasValue)
                    {
                        return GoalKeeperShootDefense(player, pointBeforeGoalEntry.Value);
                    }
                }
                else
                {
                    return GoalKeeperPassDefense(player, ballTarget);
                }
            }

            return null;
        }

        public void SendAction(GameAction gameAction, Dictionary<string, GameData> data)
        {
            var sb = new StringBuilder();

            sb.Append((int) gameAction);

            if (data != null)
            {
                sb.Append(":");
                foreach (var d in data)
                {
                    var valueStr = d.Value.String();
                    if (d.Value.Type == GameDataType.String)
                    {
                        valueStr = "'" + valueStr + "'";
                    }
                    sb.Append($"['{d.Key}':{valueStr}]");
                }
            }
            sb.Append(";\n");

            Console.WriteLine(sb);

            _dataWriter.Write(sb.ToString());
            _dataWriter.Flush();
        }

 public SkeletonAction(GameAction p_jump)
 {
     this.jump = p_jump;
     this.reverse = new Reverse();
     this.facePlayer = new FacePlayer();
     this.wait = new Wait(120);
 }

 private void HandleAction(GameAction action)
 {
     TryHandlePlayCardAction(action);
     TryHandleAttackAction(action);
     TryHandleDeathAction(action);
     TryHandleShowEntity(action);
     TryHandleOtherAction(action);
 }

        public ProcessResult ProcessSubAction(GameAction action)
        {
            var actionResult = ProcessAction(action);

            painter.DrawMessage(Message);

            return actionResult;
        }

 static public void PushActionPool(int actionId, GameAction action)
 {
     RemoveActionPool(actionId);
     SocketPackage package = new SocketPackage();
     package.ActionId = actionId;
     package.Action = action;
     ActionPools.Add(package);
 }

	void Next () {
		if (queue.Count < 1) {
			return;
		}
		currentAction = (GameAction)queue.Dequeue();
		currentAction.behaviour.SendMessage(currentAction.methodName, 
		                                    SendMessageOptions.RequireReceiver);
	}

        public void SetUpInput()
        {
            GameAction timeTravel = new GameAction(
                this, this.GetType().GetMethod("TimeTravel"),
                new object[0]);

            InputManager.AddToKeyboardMap(Keys.X, timeTravel);
            InputManager.AddToButtonsMap(Buttons.X, timeTravel);
        }

 public override bool Update(GameAction action, object p1, object p2)
 {
     if ((int)p1 == 1)
     {
         killcount += (int)p2;
         return killcount <= maxkill;
     }
     return false;
 }

 public DataTransfer(CardIdentifier _cardID, GameAction _gameAction, int _other1, int _other2, int _other3, string _str1)
 {
     cardID = _cardID;
     gameAction = _gameAction;
     other1 = _other1;
     other2 = _other2;
     other3 = _other3;
     str1 = _str1;
 }

    public override bool validate( GameAction gameAction )
    {
        PieceMove moveAction = (PieceMove)gameAction;
        SquareState destinationState = Game.board [(int)moveAction.squareIndex.y,
                                                   (int)moveAction.squareIndex.x].state;

        // Verify that the selected square is a valid destination for the selected piece
        return  destinationState == SquareState.VALID ||
                destinationState == SquareState.VALID_TRACED;
    }

 public override void performAction( GameAction gameAction )
 {
     if( currentPlayer.Equals(player2) ) //  currentPlayer == player2 turn
         gameAction.execute ();
     else if (gameAction.validate ())
     {
         BManager.sendGameMessage(gameAction.getMessage());
         gameAction.execute ();
     }
     else audio.playError ();
 }

        public ProcessResult Process(GameAction action)
        {
            var actionResult = ProcessAction(action);

            var mapPicture = GetMapPicture(Dungeon);

            painter.DrawMap(mapPicture);
            painter.DrawMessage(Message);

            return actionResult;
        }

 public PickAction(GameAction[] p_actions, int[] p_chances, int[] p_delays)
 {
     this.actions = new GameAction[p_actions.Length];
     this.chances = new int[p_chances.Length];
     this.delays = new int[p_chances.Length];
     for (int i = 0; i < p_actions.Length; i++)
     {
         this.actions[i] = p_actions[i];
         this.chances[i] = p_chances[i];
         this.delays[i] = p_delays[i];
     }
 }

        GamePosition IGameRunner.Step(GamePosition currentPosition, GameAction gameAction)
        {
            Contract.Requires<ArgumentNullException>(currentPosition != null);
            Contract.Requires<ArgumentNullException>(gameAction != null);

            Contract.Ensures(Contract.Result<GamePosition>() != null);
            Contract.Ensures(Contract.Result<GamePosition>().FirstTeamPosition != null);
            Contract.Ensures(Contract.Result<GamePosition>().FirstTeamPosition.Count() == currentPosition.FirstTeamPosition.Count());
            Contract.Ensures(Contract.Result<GamePosition>().SecondTeamPosition != null);
            Contract.Ensures(Contract.Result<GamePosition>().SecondTeamPosition.Count() == currentPosition.SecondTeamPosition.Count());

            throw new InvalidOperationException();
        }

        /* The keeper will shoot to the unmarked player who is the closest to the enemy's goal. */
        public override PlayerAction ActionWithBall(Player player, GameAction gameAction)
        {
            if (RoundsWithBall < 5)
            {
                RoundsWithBall++;
                return null;
            }
            else
            {
                /* Sets the middle point of the enemy's goal as the target point*/
                Point targetPoint = GameAI.GetEnemyTeam(GameAI.PlayersTeam(player)).TeamGoal.MiddlePoint;
                /* Searches the nearest unmarked player to the target point */
                Player unmarkedPlayer = SearchPassPlayers(player).ElementAt(0);

                return new PlayerAction(unmarkedPlayer, unmarkedPlayer.Location, ActionType.Pass);
            }
        }

        public GameDataAction(string actionString)
        {
            Data = new Dictionary<string, GameData>();

            var start = actionString.IndexOf(':');
            var enumString = actionString.Substring(0, start);
            Action = (GameAction) Enum.Parse(typeof (GameAction), enumString);

            var i = start;

            while (++i < actionString.Length)
            {
                if (actionString[i] != '[') continue;
                i++;
                var param = GetString(actionString, ref i);
                if (actionString[i] != ':')
                    throw new FormatException($"Was expecting ':' @ {i}, found '{actionString[i]}' instead.");
                i++;
                if (actionString[i] == '\'')
                {
                    Data.Add(param, GetString(actionString, ref i));
                }
                else if (char.IsDigit(actionString[i]) || actionString[i] == '-' || actionString[i] == '.')
                {
                    var numStart = i;
                    while (actionString[++i] != ']') ;
                    var sub = actionString.Substring(numStart, i - numStart);
                    if (sub.EndsWith("f"))
                    {
                        Data.Add(param,
                            float.Parse(sub.Substring(0, sub.Length - 1),
                                NumberStyles.Float | NumberStyles.AllowThousands));
                    }
                    else if (sub.Contains("."))
                    {
                        Data.Add(param, double.Parse(sub, NumberStyles.Float | NumberStyles.AllowThousands));
                    }
                    else
                    {
                        Data.Add(param, int.Parse(sub, NumberStyles.Integer));
                    }
                }
            }
        }