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);
}
private void OnClientGameEndedMessageHandler(GameEndedMessage msg)
{
UI_FinActive(msg.Puesto);
}
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();
}
}