private void TurnHeadofDragon(DirectionOfHead NextDirection)
    {
        while (true)
        {
            if (NextDirection == _Dragon.CurrentDirectionOfHead)
            {
                break;
            }
            switch (_Dragon.CurrentDirectionOfHead)
            {
            case DirectionOfHead.Top:
                _Dragon.ListOfParts[0].GetComponent <RectTransform>().Rotate(new Vector3(0, 0, 90));
                _Dragon.CurrentDirectionOfHead = DirectionOfHead.Left;
                break;

            case DirectionOfHead.Left:
                _Dragon.ListOfParts[0].GetComponent <RectTransform>().Rotate(new Vector3(0, 0, 90));
                _Dragon.CurrentDirectionOfHead = DirectionOfHead.Bottom;
                break;

            case DirectionOfHead.Bottom:
                _Dragon.ListOfParts[0].GetComponent <RectTransform>().Rotate(new Vector3(0, 0, 90));
                _Dragon.CurrentDirectionOfHead = DirectionOfHead.Right;
                break;

            case DirectionOfHead.Right:
                _Dragon.ListOfParts[0].GetComponent <RectTransform>().Rotate(new Vector3(0, 0, 90));
                _Dragon.CurrentDirectionOfHead = DirectionOfHead.Top;
                break;
            }
        }
    }
 public Dragon()
 {
     CurrentDirectionOfHead = DirectionOfHead.Top;
 }
    private IEnumerator Move()
    {
        var width  = Panel.GetComponent <RectTransform>().sizeDelta.x;
        var height = Panel.GetComponent <RectTransform>().sizeDelta.y;

        var  PictureSize = width / 20;
        bool IsFinish    = true;

        while (IsFinish)
        {
            DirectionOfHead NextDirection = _Dragon.CurrentDirectionOfHead;

            if (Input.GetKey(KeyCode.UpArrow) && _Dragon.CurrentDirectionOfHead != DirectionOfHead.Bottom)
            {
                NextDirection = DirectionOfHead.Top;
            }

            if (Input.GetKey(KeyCode.DownArrow) && _Dragon.CurrentDirectionOfHead != DirectionOfHead.Top)
            {
                NextDirection = DirectionOfHead.Bottom;
            }

            if (Input.GetKey(KeyCode.RightArrow) && _Dragon.CurrentDirectionOfHead != DirectionOfHead.Left)
            {
                NextDirection = DirectionOfHead.Right;
            }

            if (Input.GetKey(KeyCode.LeftArrow) && _Dragon.CurrentDirectionOfHead != DirectionOfHead.Right)
            {
                NextDirection = DirectionOfHead.Left;
            }

            var x = 0;
            var y = 0;
            if (NextDirection == DirectionOfHead.Top)
            {
                y += 1;
            }
            if (NextDirection == DirectionOfHead.Bottom)
            {
                y += -1;
            }
            if (NextDirection == DirectionOfHead.Right)
            {
                x += 1;
            }
            if (NextDirection == DirectionOfHead.Left)
            {
                x += -1;
            }

            TurnHeadofDragon(NextDirection);

            System.Tuple <int, int> NextPosition = null;
            var Position_x = _Dragon.Tuples[_Dragon.ListOfParts[0]].Item1;
            var Position_y = _Dragon.Tuples[_Dragon.ListOfParts[0]].Item2;
            NextPosition = new System.Tuple <int, int>(Position_x + x, Position_y + y);

            if (NextPosition.Item1 == 0 || NextPosition.Item1 == 19 || NextPosition.Item2 == 0 || NextPosition.Item2 == 19)
            {
                IsFinish = false;
                GameOver();
            }
            if (_Dragon._DragonParts.ContainsKey(NextPosition))
            {
                IsFinish = false;
                GameOver();
            }
            if (IsFinish)
            {
                List <Image> LastPositions = new List <Image>();
                foreach (var item in _Dragon.ListOfParts)
                {
                    LastPositions.Add(item);
                }
                bool HasTreasure = false;
                if (TreasureDictionary.ContainsKey(NextPosition))
                {
                    HasTreasure = true;
                }

                Dictionary <System.Tuple <int, int>, Image>  NewDragonParts = new Dictionary <System.Tuple <int, int>, Image>();
                Dictionary <Image, System.Tuple <int, int> > NewTuples      = new Dictionary <Image, System.Tuple <int, int> >();

                Image NewPart = null;
                for (int k = 0; k < 6f; k++)
                {
                    yield return(new WaitForSeconds(0));

                    for (int i = 0; i < _Dragon.ListOfParts.Count; i++)
                    {
                        if (i == 0)
                        {
                            _Dragon.ListOfParts[0].transform.position = Vector2.MoveTowards(_Dragon.ListOfParts[0].transform.position,
                                                                                            _Positions[NextPosition], 10f);
                            if (k == 0 && HasTreasure)
                            {
                                TreasureDictionary[NextPosition].gameObject.SetActive(false);
                                TreasureDictionary.Clear();
                            }
                            if (k == 0)
                            {
                                NewDragonParts.Add(NextPosition, _Dragon.ListOfParts[0]);
                                NewTuples.Add(_Dragon.ListOfParts[0], NextPosition);
                            }
                        }
                        else
                        {
                            _Dragon.ListOfParts[i].transform.position = Vector2.MoveTowards(_Dragon.ListOfParts[i].transform.position,
                                                                                            _Positions[_Dragon.Tuples[LastPositions[i - 1]]], 10f);
                            if (k == 1 && HasTreasure && i == _Dragon.ListOfParts.Count - 1)
                            {
                                NewPart = Instantiate <Image>(ImagePrefab, Panel.transform);
                                NewPart.GetComponent <RectTransform>().sizeDelta = new Vector2(PictureSize, PictureSize);
                                NewPart.sprite = Sprites["Dragonbody"];
                                var PositionOfNewPart = _Dragon.Tuples[_Dragon.ListOfParts.Last()];
                                NewPart.GetComponent <RectTransform>().position = (_Positions[PositionOfNewPart]);
                            }
                            if (k == 0)
                            {
                                NewDragonParts.Add(_Dragon.Tuples[LastPositions[i - 1]], _Dragon.ListOfParts[i]);
                                NewTuples.Add(_Dragon.ListOfParts[i], _Dragon.Tuples[LastPositions[i - 1]]);
                            }
                        }
                    }
                }
                if (NewPart != null)
                {
                    NewTuples.Add(NewPart, _Dragon.Tuples[LastPositions.Last()]);
                    NewDragonParts.Add(_Dragon.Tuples[LastPositions.Last()], NewPart);
                    _Dragon.ListOfParts.Add(NewPart);
                }

                _Dragon._DragonParts = NewDragonParts;
                _Dragon.Tuples       = NewTuples;

                //Add Treasure
                CreateTreasure();
            }
        }
    }