public void LabyrinthMoveUpTest()
        {
            PlayerPosition startPosition = new PlayerPosition(3, 3);
            string[] rawData = new string[Labyrinth.LabyrinthSize]
            {
                "XXXXXXX",
                "X-X---X",
                "X---X-X",
                "X--*--X",
                "X-X----",
                "X-----X",
                "XXXXXXX"
            };
            Cell[,] board = LabyrinthDataFromStringArray(rawData);
            Labyrinth labyrinth = new Labyrinth(startPosition, board);
            var privateObject = new PrivateObject(labyrinth);
            privateObject.Invoke("ProcessMoveUp", 3, 3);
            string result =
                @"X X X X X X X 
X - X - - - X 
X - - * X - X 
X - - - - - X 
X - X - - - - 
X - - - - - X 
X X X X X X X 
";
            string expected = labyrinth.ToString();

            Assert.AreEqual(expected, result);                       
        }

        /// <summary>
        /// Adds all moves to Tree
        /// </summary>
        /// <param name="whitePos">Position of white figures on board</param>
        /// <param name="moves">Pairs of moves and replies e.g. ("e2-e4", "e7-e5")</param>
        public void AddMoves(PlayerPosition whitePos, params string[] moves)
        {
            Move temp = new Move(moves[0]);
            MoveNode tempNode = new MoveNode(temp);

            //iterator, that will add move to tree
            MoveIterator pushingIterator = null;

            MoveNode next = null;

            if (!rootMoves.ContainsKey(tempNode))
            {
                rootMoves.Add(tempNode, tempNode);
                next = rootMoves[tempNode].Add(new Move(moves[1]));
            }
            else
            {
                next = rootMoves[tempNode].Add(new Move(moves[1]));
            }

            pushingIterator = GetIterator(tempNode);
            //next answer
            pushingIterator.CurrentNode = next;

            int i = 2;
            while (i < moves.Length)
            {
                pushingIterator.CurrentNode = pushingIterator.CurrentNode.Add(moves[i], whitePos);
                ++i;
            }
        }

 void CheckPlayer(PlayerPosition pla, float start, float end)
 {
     var p = pla.transform.position.x;
     if( p >= start && p < end ) {
         this.detected_players_.Add(pla);
     }
 }

        public static PlayerPosition GetNextPlayerPosition(PlayerPosition currentSide)
        {
            if (currentSide.Order == 3)
                return PlayerPosition.North;

            return new PlayerPosition(currentSide.Order + 1);
        }

        public PlayerPosition PlayCard(Card card, PlayerPosition playerPosition)
        {
            _nextPlayer = BridgeHelper.GetNextPlayerPosition(playerPosition);

            if (_currentTrick.Deck.Count == 0)
            {
                _currentTrick = new Trick();
                _currentTrick.TrickDealer = playerPosition;
            }


            if (_currentTrick.Deck.Count <= 4)
            {
                card.PlayerPosition = playerPosition;
                _currentTrick.Deck.Cards.Add(card);
            }

            if (_currentTrick.Deck.Count == 4)
            {
                Tricks.Add(_currentTrick);
                var winner = FindWinner(_currentTrick, Contract.Trump);
                _currentTrick.TrickWinner = winner;
                _nextPlayer = winner;
                _currentTrick = new Trick() { TrickDealer = winner };
            }

            GameState[playerPosition].RemoveCard(card);

            return _nextPlayer;
        }

 public PlayerInfo this[PlayerPosition position]
 {
     get
     {
         return new PlayerInfo(this.gameManager[position]);
     }
 }

 public void Init(Action<Square> action, PlayerPosition position, Color color)
 {
     if (position == PlayerPosition.Up)
         this.ShuffleUp(action, color);
     else
         this.ShuffleDown(action, color);
 }

	public void CreatePlayer(PlayerPosition pos)
    {
		GameObject obj = (GameObject) Instantiate(characterModel, new Vector3(pos.x,0,pos.y), Quaternion.identity);

		Character suppo = obj.GetComponent<Character> ();
		suppo.id = pos.id;
		suppo.lastPosition = pos;
    }

	public void AddPosition(PlayerPosition position)
	{

		if (position != null && position.id != null && position.id != "")
		{
			positions [position.id] = position;
		}
	}

 public void SetupOrientation(PlayerPosition pp)
 {
     if (pp == PlayerPosition.Up)
         this.rankMask = rank8;
     else
         if (pp == PlayerPosition.Down)
             this.rankMask = rank1;
 }

        public PlayerBoard(PlayerPosition playerPosition, Color playerColor, MovesArrayAllocator arrayAllocator)
        {
            this.position = playerPosition;
            this.color = playerColor;
            this.allocator = arrayAllocator;

            this.ResetAll();
        }

        public Bidding(GameSession gameSession, PlayerPosition startPosition)
        {
            _gameSession = gameSession;

            Bids = new List<Bid>();

            CurrentTurn = startPosition;
        }

 // --------------------------------------------------------------------------------
 // AccountToPosition
 // --------------------------------------------------------------------------------
 // Set position
 public static Coroutine SetPosition(string accountId, PlayerPosition position, GameDB.ActionOnResult<PlayerPosition> func = null)
 {
     return GameDB.instance.StartCoroutine(GameDB.Set<PlayerPosition>(
         "AccountToPosition",
         accountId,
         position,
         func
     ));
 }

 public BridgeGame(Dictionary<PlayerPosition, Deck> state, PlayerPosition declarer)
 {
     GameState = state;
     Tricks = new List<Trick>();
     Declarer = declarer;
     Dummy = BridgeHelper.GetNextPlayerPosition(BridgeHelper.GetNextPlayerPosition(declarer));
     Contract = new Contract();
     _currentTrick = new Trick() { TrickDealer = Declarer };
 }

        public void IsOnBoarderTest()
        {
            PlayerPosition startPosition = new PlayerPosition(3, 3);
            Labyrinth labyrinth = new Labyrinth(startPosition);
            var privateObject = new PrivateObject(labyrinth);
            var actual = privateObject.Invoke("IsOnBorder", 6, 6);

            Assert.AreEqual(true, actual);
        }

        public void IsGameWonTestFalse()
        {
            PlayerPosition startPosition = new PlayerPosition(3, 3);
            Labyrinth labyrinth = new Labyrinth(startPosition);
            var privateObject = new PrivateObject(labyrinth);
            var actual = privateObject.Invoke("IsGameWon", 3, 3);

            Assert.AreEqual(false, actual);
        }

 public SantaseGame(IPlayer firstPlayer, IPlayer secondPlayer, PlayerPosition firstToPlay)
 {
     this.firstPlayerTotalPoints = 0;
     this.secondPlayerTotalPoints = 0;
     this.roundsCount = 0;
     this.firstPlayer = firstPlayer;
     this.secondPlayer = secondPlayer;
     this.firstToPlay = firstToPlay;
 }

	public void SendPosition(PlayerPosition position)
	{
		channel.BasicPublish(
			exchange: POSITION_EXCHANGE_NAME,
			routingKey: POSITION_TAG_NAME,
			basicProperties: null,
			body: position.ToMessageData()
		);
	}

	IEnumerator Start()
	{
		Application.runInBackground = true;
		id = System.Guid.NewGuid().ToString();
		lastPos = new PlayerPosition (id, 0, 0, 0);
		posQ.AddPosition (new PlayerPosition (id, 0, 0, 0));
		mh = new MessageHandler ();
		yield return StartCoroutine(mh.startListening ());
	}

 public Contract(PlayerPosition playerPosition, ContractType type, bool isDoubled = false, bool isReDoubled = false)
     : this()
 {
     this.IsAvailable = true;
     this.Type = type;
     this.PlayerPosition = playerPosition;
     this.OriginalBidder = playerPosition;
     this.IsDoubled = isDoubled;
     this.IsReDoubled = isReDoubled;
 }