Esempio n. 1
0
        private void BroadcastEnd(GameEndedMessage endMessage)
        {
            var hub            = _connectionManager.GetHubContext <GameHub>();
            var orderedRegions = endMessage.FinalState.Regions.OrderByDescending(x => x.BlockCount);
            var topScore       = orderedRegions.First().BlockCount;
            var winners        = orderedRegions.Where(x => x.BlockCount == topScore).ToList();

            var message = "";

            if (winners.Count == 1)
            {
                message = $"The {winners.First().Name} region has won!";
            }
            else
            {
                var tiedRegions = string.Join(" and ", winners.Select(x => x.Name));
                message = $"It's a tie between {tiedRegions}!";
            }

            hub.Clients.All.onGameEnd(message);
        }
Esempio n. 2
0
 private void OnClientGameEndedMessageHandler(GameEndedMessage msg)
 {
     UI_FinActive(msg.Puesto);
 }
Esempio n. 3
0
    private IEnumerator OnServerTokenMessageCoroutine(NetworkConnection conn, TokenMessage msg)
    {
        if (tokens.Contains(msg.Token)) // Si el token coincide con uno que nos hayan pasado
        {
            if (modoServidor == ServidorPartida)
            {
                ChangeUIMessage uimsg = new ChangeUIMessage(UI_Prepartida);
                conn.Send <ChangeUIMessage>(uimsg);

                KeyValuePair <string, NetworkConnection> dupla = new KeyValuePair <string, NetworkConnection>(msg.Token, conn);
                tokenConnection.Add(dupla);

                // Esto lo hago aquí porque es individual para cada uno
                // if (rondaAJugar == maxRondas) // Si toca el combate final
                // {
                //     int i = 0;
                //     while (!clasificacionActualizada && i < intentosConexion)
                //     {
                //         ++i;
                //         yield return new WaitForSeconds(tiempoEsperaConexion);
                //     }

                //     if (!clasificacionActualizada)
                //     {
                //         print("Agotado tiempo de espera, mensaje de clasificación no recibido");
                //     }
                //     else
                //     {
                //         int index = clasificacionOrdenada.FindIndex(p => p.Key == msg.Token);
                //         if (index >= 2) // Si no entra en la final
                //         {
                //             GameEndedMessage result = new GameEndedMessage();
                //             result.Puesto = index;
                //             conn.Send<GameEndedMessage>(result);
                //         }
                //     }
                // }

                // if(clasificacionActualizada)
                // {
                //     clasificacionOrdenada = managerClasification.GetClasificacionOrdenada();
                //     List<string> tokensOrdenados = new List<string>();
                //     List<int[]> resultados = new List<int[]>();
                //     foreach (var kvp in clasificacionOrdenada)
                //     {
                //         tokensOrdenados.Add(kvp.Key);
                //         resultados.Add(kvp.Value);
                //     }

                //     TablaClasificacionMessage result = new TablaClasificacionMessage();
                //     result.Tokens = tokensOrdenados;
                //     result.Resultados = resultados;
                //     conn.Send<TablaClasificacionMessage>(result);
                //     print("Mandamos mensaje de tablaclasificacion");
                // }

                /*
                 * ¿POR QUÉ HAGO ESTO?
                 *
                 * " O sea, me da igual que estén todos, no tengo que actualizarlos a todos a la vez.
                 * Si tengo la clasificación actualizada, puedo mandársela a cada uno cuando venga y ya está.
                 *
                 * Si me espero a todos, es "peor" porque va a haber un momento en el que tenga la clasificación toh mal. "
                 *
                 * MAL - Los primeros que lleguen no van a tener la clasificacion bien, se quedan en prepartida, necesito
                 * hacerlo de esta forma para asegurarme que les llega a todos.
                 *
                 * Curiosidad: Lo de antes funcionaba porque en el while de maxrondas==rondaajugar no habia un ++i
                 * así que esperaba para siempre en todos los clientes, por lo que siempre llegaba bien.
                 */
                serverPlayers++;
                print("OnServerTokenMessage: serverPlayers: " + serverPlayers + " --- MaxPlayers: " + maxPlayers);
                if (serverPlayers == maxPlayers) // Si estamos todos los jugadores
                {
                    int i = 0;
                    while (!clasificacionActualizada && i < intentosConexion) // Esperar a la clasificacion es mejor que esperar a los jugadores
                    {
                        ++i;
                        yield return(new WaitForSeconds(tiempoEsperaConexion));
                    }

                    if (!clasificacionActualizada)
                    {
                        print("Agotado tiempo de espera, mensaje de clasificación no recibido");
                        rondaAJugar--; // ¿Repetir la ronda?
                    }

                    clasificacionOrdenada = managerClasification.GetClasificacionOrdenada();
                    TablaClasificacionMessage clasificacionMessage = new TablaClasificacionMessage();
                    List <string>             tokensOrdenados      = new List <string>();
                    List <int[]> resultados = new List <int[]>();
                    foreach (var kvp in clasificacionOrdenada)
                    {
                        tokensOrdenados.Add(kvp.Key);
                        resultados.Add(kvp.Value);
                    }
                    clasificacionMessage.Tokens     = tokensOrdenados;
                    clasificacionMessage.Resultados = resultados;

                    if (rondaAJugar == maxRondas) // Toca la final
                    {
                        foreach (var tk in tokens)
                        {
                            int index = clasificacionOrdenada.FindIndex(p => p.Key == tk);
                            if (index >= 2) // Si no entra en la final
                            {
                                GameEndedMessage result = new GameEndedMessage();
                                result.Puesto = index;
                                NetworkConnection connection = tokenConnection.Find(p => p.Key == tk).Value;
                                connection.Send <GameEndedMessage>(result);
                            }
                            else if (index >= 0) //Entra en la final
                            {
                                NetworkConnection connection = tokenConnection.Find(p => p.Key == tk).Value;
                                connection.Send <TablaClasificacionMessage>(clasificacionMessage);
                            }
                            else
                            {
                                print("Usuario no encontrado");
                            }
                        }
                    }
                    else if (rondaAJugar > maxRondas) // Si estamos todos y ya no toca nada más, pasamos mensaje a los de la final
                    {
                        GameEndedMessage gameEndedMessage = new GameEndedMessage();
                        for (i = 0; i < maxPlayers; ++i) // maxPlayers es el maxPlayers original dividido por 2
                        {
                            gameEndedMessage.Puesto = i;
                            string            tk         = clasificacionOrdenada[i].Key;
                            NetworkConnection connection = tokenConnection.Find(p => p.Key == tk).Value;
                            connection.Send <GameEndedMessage>(gameEndedMessage);
                        }

                        partidaFinalizada = true; // Oficialmente hemos acabado la partida
                    }
                    else
                    {
                        NetworkServer.SendToAll <TablaClasificacionMessage>(clasificacionMessage);
                        print("Se envía mensaje de tabla de clasificación");
                    }
                }
            }
            else if (modoServidor == ServidorCombate)
            {
                KeyValuePair <string, NetworkConnection> dupla = new KeyValuePair <string, NetworkConnection>(msg.Token, conn);
                tokenConnection.Add(dupla);

                CombatUsersMessage cumsg = new CombatUsersMessage();
                cumsg.Users = users;
                conn.Send <CombatUsersMessage>(cumsg);
            }
        }
        else // Si no es correcto, conn.Disconnect()
        {
            print("Token no encontrado");
            conn.Disconnect();
        }
    }