class Soccer
    {
        private RoomItem[] gates;
        private Room room;
        private List<RoomItem> balls;

        public Soccer(Room room)
        {
            this.room = room;
            this.gates = new RoomItem[4];
            this.balls = new List<RoomItem>();
        }

        internal void OnCycle()
        {
          //  balls.OnCycle();

            foreach (RoomItem ball in balls)
            {
            if (ball != null)
            {
                if (ball.ballIsMoving)
                {
                    MoveBallProcess(ball);
                }
            }
         }
      }
        internal void AddBall(RoomItem item)
        {
            balls.Add( item);
        }

        internal void RemoveBall(RoomItem itemID)
        {
            balls.Remove(itemID);
        }

        internal void OnUserWalk(RoomUser User)
        {
            foreach (RoomItem ball in balls)
            {
                if (User == null)
                    return;

                if (ball == null)
                    return;

            if (User.SetX == ball.GetX && User.SetY == ball.GetY && User.GoalX == ball.GetX && User.GoalY == ball.GetY)
            {
                Point userPoint = new Point(User.X, User.Y);
                ball.ExtraData = "55";
                ball.ballIsMoving = true;
                ball._iBallValue = 1;
                MoveBall(ball, User.GetClient(), userPoint);
            }
            else if (User.X == ball.GetX && User.Y == ball.GetY)
            {
                Point userPoint = new Point(User.SetX, User.SetY);
                ball.ExtraData = "55";
                ball.ballIsMoving = true;
                ball._iBallValue = 1;
                MoveBall(ball, User.GetClient(), userPoint);
            }
            else
            {
                if (User.GoalX == ball.GetX && User.GoalY == ball.GetY)
                    return;

                if (User.SetX == ball.GetX && User.SetY == ball.GetY && User.IsWalking && (User.X != User.GoalX || User.Y != User.GoalY))
                {
                    var _comeDirection = ComeDirection.GetComeDirection(new Point(User.X, User.Y), ball.Coordinate);
                    if (_comeDirection != IComeDirection.Null)
                    {
                        int NewX = User.SetX;
                        int NewY = User.SetY;

                       ComeDirection.GetNewCoords(_comeDirection, ref NewX, ref NewY);
                        if (ball.GetRoom().GetGameMap().ValidTile(NewX, NewY))
                        {
                            ball.ExtraData = "11";
                            MoveBall(ball, User.GetClient(), NewX, NewY);
                        }
                    }
                }
            }
         }
      }

        internal void RegisterGate(RoomItem item)
        {
            if (gates[0] == null)
            {
                item.team = Team.blue;
                gates[0] = item;
            }
            else if (gates[1] == null)
            {
                item.team = Team.red;
                gates[1] = item;
            }
            else if (gates[2] == null)
            {
                item.team = Team.green;
                gates[2] = item;
            }
            else if (gates[3] == null)
            {
                item.team = Team.yellow;
                gates[3] = item;
            }
        }

        internal void UnRegisterGate(RoomItem item)
        {
            switch (item.team)
            {
                case Team.blue:
                    {
                        gates[0] = null;
                        break;
                    }
                case Team.red:
                    {
                        gates[1] = null;
                        break;
                    }
                case Team.green:
                    {
                        gates[2] = null;
                        break;
                    }
                case Team.yellow:
                    {
                        gates[3] = null;
                        break;
                    }
            }
        }

        internal void onGateRemove(RoomItem item)
        {
            switch (item.GetBaseItem().InteractionType)
            {
                case InteractionType.footballgoalred:
                case InteractionType.footballcounterred:
                    {

                        room.GetGameManager().RemoveFurnitureFromTeam(item, Team.red);
                        break;
                    }
                case InteractionType.footballgoalgreen:
                case InteractionType.footballcountergreen:
                    {
                        room.GetGameManager().RemoveFurnitureFromTeam(item, Team.green);
                        break;
                    }
                case InteractionType.footballgoalblue:
                case InteractionType.footballcounterblue:
                    {
                        room.GetGameManager().RemoveFurnitureFromTeam(item, Team.blue);
                        break;
                    }
                case InteractionType.footballgoalyellow:
                case InteractionType.footballcounteryellow:
                    {
                        room.GetGameManager().RemoveFurnitureFromTeam(item, Team.yellow);
                        break;
                    }
            }
        }


       internal bool MoveBall(RoomItem item, GameClient mover, int newX, int newY)
        {
            if (item == null || item.GetBaseItem() == null)
                return false;

            if (item.ballIsMoving)
            {
                if (item.ExtraData == "55" || item.ExtraData == "44")
                {
                    int randomValue = new Random().Next(1, 7);
                    if (randomValue != 5)
                    {
                        if (!room.GetGameMap().itemCanBePlacedHere(newX, newY))
                            return false;
                    }
                }
            }
            else
            {
                if (!room.GetGameMap().itemCanBePlacedHere(newX, newY))
                    return false;
            }

            Point oldRoomCoord = item.Coordinate;
            Double NewZ = room.GetGameMap().Model.SqFloorHeight[newX, newY];


          ServerMessage Message = new ServerMessage(95);
            Message.AppendUInt(item.Id);
            Message.AppendUInt(3508);
            Message.AppendInt32(item.Coordinate.X);
            Message.AppendInt32(item.Coordinate.Y);
            Message.AppendInt32(newX);
            Message.AppendInt32(newY);
            Message.AppendUInt(4);
            Message.AppendStringWithBreak(NewZ.ToString());
            Message.AppendStringWithBreak("H11");
            Message.AppendInt32(-1);
            Message.AppendInt32(0);
            room.SendMessage(Message);

            ServerMessage mMessage = new ServerMessage();
            mMessage.Init(230); // Cf
            mMessage.AppendInt32(item.Coordinate.X);
            mMessage.AppendInt32(item.Coordinate.Y);
            mMessage.AppendInt32(newX);
            mMessage.AppendInt32(newY);
            mMessage.AppendInt32(1);
            mMessage.AppendUInt(item.Id);
            mMessage.AppendStringWithBreak(item.GetZ.ToString().Replace(',', '.'));
            mMessage.AppendStringWithBreak(NewZ.ToString().Replace(',', '.'));
            mMessage.AppendUInt(0);
            room.SendMessage(mMessage);

            if (oldRoomCoord.X == newX && oldRoomCoord.Y == newY)
                return false;

            item.SetState(newX, newY, item.GetZ, Gamemap.GetAffectedTiles(item.GetBaseItem().Length, item.GetBaseItem().Width, newX, newY, item.Rot));

            return false;
        }


        internal void MoveBall(RoomItem item, GameClient client, Point user)
        {
            try
            {
                item.comeDirection = ComeDirection.GetComeDirection(user, item.Coordinate);

                if (item.comeDirection != IComeDirection.Null)
                {
                    // item.ballMover = client;
                    MoveBallProcess(item);
                }
            }
            catch { }
        }

        internal void MoveBallProcess(RoomItem item)
        {
            int tryes = 0;
            int newX = item.Coordinate.X;
            int newY = item.Coordinate.Y;
            int resetX;
            int resetY;

            while (tryes < 3)
            {
                if (room == null)
                {
                    if (room.GetGameMap() == null)
                    {
                        return;
                    }
                }

                //for (int i = 1; i < 7; i++)
                {
                    if (item.comeDirection == IComeDirection.Null)
                    {
                        item.ballIsMoving = false;
                        break;
                    }

                    resetX = newX;
                    resetY = newY;

                    ComeDirection.GetNewCoords(item.comeDirection, ref newX, ref newY);