//La coleccion de nombres que le llega debe ser del activeD o de la interfaz
//Si es de la interfaz debe haber alguna clase o forma para agregar los nuevos
//jugadores
public Juego(coleccionJugador nombres)
{
//Coleccion de jugadores con la lista que le llega...
jugadores = new coleccionJugador(nombres.obtenerCantidad());
for (int i = 0; i < nombres.obtenerCantidad(); i++)
{
jugador j = nombres.obtenerJugador(i);
jugadores.agregarJugador(j);
}
//Se crea el mazo
m_baraja = new Mazo();
//Se crea el jugador casa...
m_casa = new Casa("Casa");
//Se llena el mazo
m_baraja.llenarMazo();
//Se baraja el mazo
m_baraja.barajar();
//Se prepara el mazo general el Juego
}
//data manager
static void DataManager(Packet p)
{
switch (p.packetType)
{
case Packet.PacketType.Chat:
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
break;
case Packet.PacketType.Mensaje:
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
break;
case Packet.PacketType.autentificar:
if (cj.VerificarJugador(p.clave)) //Si existe en el juego
{
if (game.getJugadores().obtenerCantidad() < 7 && (!bloquearJuego))
{
game.getJugadores().agregarJugador(new jugador(p.nombre, p.clave));
p.packetType = Packet.PacketType.darAcceso;
p.estado = "Acceso aprobado";
Console.WriteLine("Jugadores actuales:");
game.getJugadores().imprimirColeccion();
Console.WriteLine("\n");
}
else
{
listaEspera.agregarJugador(new jugador(p.nombre, p.clave));
Console.WriteLine("Jugador en espera: " + p.nombre);
p.packetType = Packet.PacketType.enEspera;
p.estado = "Ha sido puesta en lista de espera...\nEsperando....";
}
}
else
{
p.packetType = Packet.PacketType.denegarAcceso;
p.estado = "Acceso denegado";
}
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
Console.WriteLine("Estado de acceso del jugador recien agregado: " + p.estado);
break;
case Packet.PacketType.registrar:
if (game.getJugadores().obtenerCantidad() < 7 && (!bloquearJuego))
{
game.getJugadores().agregarJugador(new jugador(p.nombre, p.clave));
p.packetType = Packet.PacketType.darAcceso;
p.estado = "Acceso aprobado";
Console.WriteLine("Jugadores actuales:");
game.getJugadores().imprimirColeccion();
Console.WriteLine("\n");
}
else
{
//Se agrega a la lista de espera
listaEspera.agregarJugador(new jugador(p.nombre, p.clave));
Console.WriteLine("Jugador en espera: " + p.nombre);
p.packetType = Packet.PacketType.enEspera;
p.estado = "Ha sido puesta en lista de espera...\nEsperando....";
}
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
Console.WriteLine("Estado de acceso de registro: " + p.estado);
break;
case Packet.PacketType.iniciarJuego: //Se recibe la señal de iniciar juego del jugador
bloquearJuego = true; //No acepta más jugadores en el juego
//repartir primeras 2 cartas a todos los jugadores
p.cartaCasa1 = game.getBaraja().darCarta(game.getCasa().obtenerMano());
p.cartaCasa2 = game.getBaraja().darCarta(game.getCasa().obtenerMano());
for (int i = 0; i < game.getJugadores().cantidadJugadores(); i++)
{
p.packetType = Packet.PacketType.primerasCartas;
p.carta1 = game.getBaraja().darCarta(game.getJugadores().obtenerJugador(i).obtenerMano());
p.carta2 = game.getBaraja().darCarta(game.getJugadores().obtenerJugador(i).obtenerMano());
p.nombre = game.getJugadores().obtenerJugador(i).getNombre();//obtiene el nombre del jugador
p.packetType = Packet.PacketType.iniciarJuego;
Console.WriteLine("Asignar-> Jugador: " + p.nombre + ", C1: " + p.carta1 + ", C2: " + p.carta2);
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
}
if (numTurno < game.getJugadores().obtenerCantidad())
{
p.packetType = Packet.PacketType.comunicarTurno; //Comunica el primer turno
p.turno = game.getJugadores().obtenerJugador(numTurno).getNombre();
Console.WriteLine("Turno de jugador: " + p.turno);
numTurno++; //Va al turno del jugador 0
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
} //Comunica el primer turno
}
break; //Envia todas las primeras dos cartas a todos los jugadores identificados con el nombre
case Packet.PacketType.pedirCarta:
string idJugador = p.id;
int j = game.getJugadores().posJugadorEspecifico(idJugador);//Busca posicion del jugador
if (j != -1)
{
p.numeroCarta = game.getBaraja().cartaAdicional(game.getJugadores().obtenerJugador(j));
//Console.WriteLine("Carta pedida: " + p.numeroCarta);//Imprimo la carta pedido
}
if (p.numeroCarta != -1)
{ //Si aun no se ha pasado de 21
p.packetType = Packet.PacketType.darCarta; //Da la carta al jugador
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
}
else
{ //Pasa al jugador siguiente
numTurno++;
if (numTurno < game.getJugadores().obtenerCantidad())
{
p.packetType = Packet.PacketType.comunicarTurno;
p.turno = game.getJugadores().obtenerJugador(numTurno).getNombre();
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
}
else
{
//Turno de jugar la casa y terminar el juego
int aux = game.getBaraja().cartaAdicionalCasa(game.getCasa());
while (aux != -1)
{
p.numeroCarta = aux;
p.packetType = Packet.PacketType.turnoCasa; //Pasa el numero de carta adicional de la casa a los clientes
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
aux = game.getBaraja().cartaAdicionalCasa(game.getCasa());
//Después de enviar todos los valores de la casa, hay que hacer la comparación
}
p.packetType = Packet.PacketType.casaAcabo;
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
//Anuncia los ganadores y las cartas que obtuvo la casa
//Actualiza las apuestas
}
}
Console.WriteLine("Turno de jugador: " + p.turno);
break;
case Packet.PacketType.quedarse:
//Acá se tacha al jugador como que ya se quedó
// ......
//Comunica el turno del siguiente jugador
if (numTurno < game.getJugadores().obtenerCantidad())
{
p.packetType = Packet.PacketType.comunicarTurno; //Comunica el primer turno
p.turno = game.getJugadores().obtenerJugador(numTurno).getNombre();
Console.WriteLine("Turno de jugador: " + p.turno);
numTurno++; //Guarda el turno del proximo jugador
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
} //Comunica el siguiente turno
//DataManager(p);//Pasa a comunicarSiguiente turno
}
else
{
//Turno de jugar la casa y terminar el juego
int aux = game.getBaraja().cartaAdicionalCasa(game.getCasa());
while (aux != -1)
{
p.numeroCarta = aux;
p.packetType = Packet.PacketType.turnoCasa; //Pasa el numero de carta adicional de la casa a los clientes
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
aux = game.getBaraja().cartaAdicionalCasa(game.getCasa());
//Después de enviar todos los valores de la casa, hay que hacer la comparación
}
p.packetType = Packet.PacketType.casaAcabo;
numTurno = 0;
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
if (game.getCasa().pasoDe21())
{
for (int i = 0; i < game.getJugadores().obtenerCantidad(); ++i)
{
if (!(game.getJugadores().obtenerJugador(i).pasoDe21()))
{
game.getJugadores().obtenerJugador(i).gana();
p.estado = "Ganador";
}
else
{ //Casa y jugador pasaron de 21
game.getJugadores().obtenerJugador(i).pierde();
p.estado = "Perdedor";
}
}
}
else
{
for (int i = 0; i < game.getJugadores().obtenerCantidad(); ++i)
{
if (!game.getJugadores().obtenerJugador(i).pasoDe21())
{
if (game.getJugadores().obtenerJugador(i).obtenerMano().ObtenerTotal() > game.getCasa().obtenerMano().ObtenerTotal())
{
game.getJugadores().obtenerJugador(i).gana();
p.estado = "Ganador";
}
else if (game.getJugadores().obtenerJugador(i).obtenerMano().ObtenerTotal() < game.getCasa().obtenerMano().ObtenerTotal())
{
// ganador(IdJugador, 1 -> perdió, saldoActualizado);
//Se verifica si el saldo es 0 entonces hay que desconectar el socket de ese jugador
game.getJugadores().obtenerJugador(i).pierde();
p.estado = "Perdedor";
}
else
{
// ganador(IdJugador, 2-> push, saldoActualizado);
//Se verifica también el saldo
game.getJugadores().obtenerJugador(i).push();
p.estado = "Push";
}
}
p.id = game.getJugadores().obtenerJugador(i).getId();
p.nombre = game.getJugadores().obtenerJugador(i).getNombre();
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
//Anuncia los ganadores y las cartas que obtuvo la casa
//Actualiza las apuestas
//Envia mensaje
}
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//Anuncia los ganadores y las cartas que obtuvo la casa
//Actualiza las apuestas
}
break;
//Si el tipo es de autentificacion se add a la lista de sockets
//una vez autentificado y se crea un nuevo jugador asociado a
//ese id.
case Packet.PacketType.salir:
Console.WriteLine("**************************************");
Console.WriteLine("Id recibido: " + p.id);
game.getJugadores().imprimirColeccion();
game.getJugadores().eliminarJugador(p.id);
Console.WriteLine("- - - - - - - - - - - - - - - - - - - -");
game.getJugadores().imprimirColeccion();
Console.WriteLine("**************************************");
bloquearJuego = false;
if (listaEspera.obtenerCantidad() > 0)
{
jugador jug = listaEspera.obtenerJugador(0);
listaEspera.eliminarJugador(jug.getId()); //Sale de la lista de espera
game.getJugadores().agregarJugador(jug); //Entra al juego
p.packetType = Packet.PacketType.darAcceso;
p.estado = "Acceso aprobado";
Console.WriteLine("Jugadores actuales:");
game.getJugadores().imprimirColeccion();
Console.WriteLine("\n");
//Envia el paquete con el acceso
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
Console.WriteLine("Estado de acceso de registro: " + p.estado);
}
break;
case Packet.PacketType.seguir:
Console.WriteLine("Bien! El jugador " + p.nombre + " va a seguir jugando!");
p.packetType = Packet.PacketType.darAcceso;
p.estado = "Acceso aprobado";
Console.WriteLine("Jugadores actuales:");
game.getJugadores().imprimirColeccion();
Console.WriteLine("\n");
foreach (ClientData c in _clients)
{
c.clientSocket.Send(p.ToBytes());
}
Console.WriteLine("Estado de acceso de registro: " + p.estado);
break;
}
}
public void jugar()
{
//Estos dos for dan las primeras dos cartas a todos los jugadores y a la casa...
for (int j = 0; j < 2; j++)
{
for (int i = 0; i < jugadores.obtenerCantidad(); i++)
{
m_baraja.darCarta(jugadores.obtenerJugador(i).obtenerMano());
//****Acá al repartir la mano a cada jugador se debe también enviar los valores
//*** de las cartas obtenidas a la interfaz
//(numCarta1, numCarta2, idJugador (y quizá baraja de cada una también))
}
//*** Se debe enviar también los valores obtenidos por la casa a la interfaz
//*** estos valores se envían a todos los sockets conectados
m_baraja.darCarta(m_casa.obtenerMano());
}
//La casa voltea sus cartas
//m_casa.voltearPrimero();
//Cada jugador muestra sus cartas
//***Este metodo no iría a la interfaz dado que en esta
//***ya los valores de las cartas se mostrarían de una vez
for (int i = 0; i < jugadores.obtenerCantidad(); i++)
{
jugadores.obtenerJugador(i).toString();
}
//La casa muestra sus cartas
m_casa.toString();
//Cada jugador pide o se queda
//**En la interfaz, por turnos, se pide al jugador si quiere seguir o quedarse
for (int i = 0; i < jugadores.obtenerCantidad(); ++i)
{
//**Hay que modificar este método para que al llegar un de la interfaz:
// 1-> Se queda
// 0-> Sigue
//Entonces se le pasaria al método un int
//Acá se pide a la interfaz por algún método de socket
// pedirCarta(idJugador) y recibe un 1 o un 0
//Al tener la carta nueva el valor de esta se envía al
//jugador a la interfaz, y vuelve a pedirCarta() del sig Jugador.
m_baraja.cartaAdicional(jugadores.obtenerJugador(i));
//Acá el jugador va a pedir hasta que decida quedarse o se
//haya pasado de 21 pts.
}
//Muestra la casa
m_casa.toString();
//Si mano de casa <= 16, pide carta
//**Tiene que enviar los valores de la casa a la interfaz
//para actualizar valores de la misma allá
m_baraja.cartaAdicionalCasa(m_casa);
//Para este punto del Juego la casa ya debería haberse quedado o
//pasado de puntos, así que se va a comparar.
//Compara valores de casa y jugadores
/*
* Si la casa se pasó de 21 se tiene que informar a la interfaz que
* todos los jugadores ganan, por lo que el monto de sus apuestas también sube
* y se manda luego una lista de jugadores y de montos de apuestas.
*/
if (m_casa.pasoDe21())
{
for (int i = 0; i < jugadores.obtenerCantidad(); ++i)
{
if (!(jugadores.obtenerJugador(i).pasoDe21()))
{
jugadores.obtenerJugador(i).gana();
}
}
}
/*
* En cada uno de los if se debe informar a los clientes los jugadores que pierden, ganan
* o quedan empatados. Si quedan empatados igual pierden la apuesta.
*/
else
{
for (int i = 0; i < jugadores.obtenerCantidad(); ++i)
{
if (!jugadores.obtenerJugador(i).pasoDe21())
{
if (jugadores.obtenerJugador(i).obtenerMano().ObtenerTotal() > m_casa.obtenerMano().ObtenerTotal())
{
//Se llama acá un socket que envía el id de jugador y el mensaje de ganador.
// ganador(IdJugador y 0 -> ganó, saldoActualizado)
jugadores.obtenerJugador(i).gana();
}
else if (jugadores.obtenerJugador(i).obtenerMano().ObtenerTotal() < m_casa.obtenerMano().ObtenerTotal())
{
// ganador(IdJugador, 1 -> perdió, saldoActualizado);
//Se verifica si el saldo es 0 entonces hay que desconectar el socket de ese jugador
jugadores.obtenerJugador(i).pierde();
}
else
{
// ganador(IdJugador, 2-> push, saldoActualizado);
//Se verifica también el saldo
jugadores.obtenerJugador(i).push();
}
}
}
}
//Se limpian las colecciones que hayan.
//En la interfaz esto simula un reseteo de valores también.
//En la interfaz se pregunta a los jugadores si quieren desconectarse o seguir jugando
//Los valores de las respuestas vienen al servidor, si se recibe de un clientSocket que
//este se quiere desconectar hay que desconectarlo del servidor.
//for (int i = 0; i < jugadores.obtenerCantidad(); ++i)
//Va la funcion de limpiar
//funcion de limpiar de la casa
}
