예제 #1
0
 /// <summary>
 /// Comprueba si los jugadores están conectados y si no es así los elimina de la sala.
 /// Si la sala está vacia, la cierra y elimina.
 /// </summary>
 /// <param name="room">Sala a comprobar.</param>
 /// <param name="rooms">Coleccion de salas</param>
 public static void refreshGameConectedPeople(Room room, Dictionary <int, Room> rooms)
 {
     while (!room.GameFinished)
     {
         lock (room)
         {
             int initialClients = room.Clients.Count;
             foreach (var client in room.Clients.ToList())
             {
                 if (!client.Value.isConected())
                 {
                     room.deletePlayer(client.Key);
                     client.Value.disconnect();
                 }
             }
             if (initialClients != room.Clients.Count)
             {
                 sendData(room);
                 if (room.Clients.Count <= 1)
                 {
                     room.GameFinished = true;
                     finishPlayer(room, true);
                     WaitingRoom.closeRoom(room, rooms);
                 }
             }
         }
         Thread.Sleep(100);
     }
 }
예제 #2
0
        /// <summary>
        /// Crea una sala, añade al host y lanza un hilo para la sala de espera.
        /// Una vez creada, aumenta el número de la sala disponible.
        /// </summary>
        /// <param name="client">Creador de la sala.</param>
        /// <param name="rooms">Coleccion de salas.</param>
        /// <param name="roomsCount">Número de la nueva sala.</param>
        /// <returns></returns>
        public static bool createRoom(Client client, Dictionary <int, Room> rooms, ref int roomsCount)
        {
            string name = client.getData();

            if (name.Trim().Length >= 3)
            {
                //Creo la nueva sala
                lock (rooms)
                {
                    Room room = new Room(roomsCount, name, client);
                    client.sendData(roomsCount.ToString());
                    //Aumento el identificador para evitar repetir salas
                    roomsCount++;
                    //Añado la sala a la colección
                    rooms.Add(room.IdRoom, room);
                    Thread hiloSala = new Thread(() => WaitingRoom.waitingRoom(room, rooms));
                    hiloSala.Start();
                    Console.WriteLine($"El usuario {name} ha creado la sala {roomsCount-1}");
                }
                return(true);
            }
            return(false);
        }
예제 #3
0
        /// <summary>
        /// Función principal que gestiona el juego. Se encarga de generar una baraja base aleatoria y
        /// repartir a cada jugador la suya.
        /// Mientras haya al menos 2 jugadores, la partida continúa existiendo. En cada turno, el servidor
        /// espera respuesta unicamente del jugador cuyo nombre coincida con el turno. En función de su acción, añade
        /// o elimina cartas a la baraja del jugador.
        /// Si el jugador se queda sin cartas, gana la partida, por lo que se le borra de la sala.
        /// En todo momento se comprueba la conexion del jugador del turno mediante el hilo lanzado.
        /// Si acaba la partida, cierra la sala.
        /// </summary>
        /// <param name="room">Sala actual.</param>
        /// <param name="rooms">Coleccion de salas.</param>
        public static void partida(Room room, Dictionary <int, Room> rooms)
        {
            room.Match = new Match();
            Thread refreshClientsThread = new Thread(() => refreshGameConectedPeople(room, rooms));

            refreshClientsThread.Start();
            int playersInGame = room.Clients.Count;
            int maxCards      = 8;

            foreach (var cl in room.Clients)
            {
                List <Card> deck = new List <Card>();
                for (int i = 0; i < maxCards; i++)
                {
                    deck.Add(randomCard());
                }
                room.Match.PlayersDeck.Add(cl.Key, deck);
            }
            room.Match.Turn = room.PlayersNames[0];

            do
            {
                sendData(room);
                Card cardPlayed = null;
                if (room.PlayersNames.Count < 2)
                {
                    room.GameFinished = true;
                }
                else
                {
                    try
                    {
                        switch (room.Clients[room.Match.Turn].getData())
                        {
                        case "jugar":
                            cardPlayed = room.Clients[room.Match.Turn].getCard();
                            //Borro de su baraja la carta jugada
                            room.Match.PlayersDeck[room.Match.Turn].Remove(searchCard(cardPlayed, room.Match.PlayersDeck[room.Match.Turn]));
                            //La carta realiza su función en mesa
                            switch (cardPlayed.Type)
                            {
                            case Card.eType.Number:
                                int  dif       = 0;
                                bool overLimit = false;
                                //En función del sentido de la mesa, sumamos o restamos su valor
                                if (room.Match.TableWay)
                                {
                                    dif = room.Match.TableValue + cardPlayed.Value;
                                    if (dif >= room.Match.Limit)
                                    {
                                        overLimit = true;
                                        dif      -= room.Match.Limit;
                                    }
                                }
                                else
                                {
                                    dif = room.Match.TableValue - cardPlayed.Value;
                                    if (dif <= -room.Match.Limit)
                                    {
                                        overLimit = true;
                                        dif      += room.Match.Limit;
                                    }
                                }
                                Console.WriteLine("Table limit: " + room.Match.Limit);
                                Console.WriteLine($"Operation in this last turn: {room.Match.TableValue}+{cardPlayed.Value}={cardPlayed.Value + room.Match.TableValue}");
                                room.Match.TableValue = dif;
                                //Si el jugador sobrepasa el límite, se reinicia el valor de mesa y se
                                //añaden 3 cartas a su baraja.
                                if (overLimit)
                                {
                                    for (int i = 0; i < 3; i++)
                                    {
                                        room.Match.PlayersDeck[room.Match.Turn].Add(randomCard());
                                    }
                                }
                                break;

                            case Card.eType.Way:
                                //Se cambia la operación de la mesa
                                room.Match.TableWay = cardPlayed.Way;
                                break;

                            case Card.eType.Effect:
                                //Cada jugador recibe 2 cartas a excepción del que ha jugado último
                                foreach (var cl in room.Match.PlayersDeck)
                                {
                                    if (cl.Key != room.Match.Turn)
                                    {
                                        for (int i = 0; i < 2; i++)
                                        {
                                            cl.Value.Add(randomCard());
                                        }
                                    }
                                }
                                break;
                            }
                            break;

                        case "pasar":
                            room.Match.PlayersDeck[room.Match.Turn].Add(randomCard());
                            break;

                        default:
                            room.Clients[room.Match.Turn].sendData("You must play or pass");
                            continue;
                        }
                        if (room.Match.PlayersDeck[room.Match.Turn].Count <= 0)
                        {
                            finishPlayer(room, false);
                        }
                        else
                        {
                            room.nextTurn();
                        }
                    }
                    catch (IOException)
                    {
                        if (!room.GameFinished)
                        {
                            deleteDisconnectedPlayer(room.Match.Turn, room);
                        }
                    }
                }
            } while (!room.GameFinished);
            if (room.PlayersNames.Count > 0)
            {
                finishPlayer(room, true);
                WaitingRoom.closeRoom(room, rooms);
            }
        }