Sin más explicaciones... asumo que no mantienes referencias de turnos.
Lo primero es que debes mantener la ronda, tanda.
Una ronda es una fase donde cada jugador hace 'su apuesta', jugada, etc... cuando todos la han hecho, se pasa a la siguiente ronda, etc...
En una ronda, según el juego, cada jugador puede o bien jugar siempre en un orden concreto o no. Sea como sea, a cada jugador se le otorga su 'turno', indistintamente de que jueguen en un orden específico o no.
Una ronda entonces se compone de un simple array del tamaño del número de jugadores. Si juegan 6, ronda tiene 6 elementos, si juegan 8 jugadores ronda tiene 8 elementos.
Cada elemento de la ronda mantiene una referencia a cada jugador... dicha referencia puede ser a un objeto jugador, o como mínimo a un índice que relaciona únivocamente a un jugador con (por ejemplo), un array de jugadores...
Entonces cuando quieras conocer el estado de cada uno, basta consultar el objeto ronda, recorrerlo, para tener acceso a cada jugador.
Ronda puede se rmás o menos sencillo o complejo, según lo que necesites y quiera shacer desde ese objeto... lo mínimo sería.
Ronda() array de bytes //string, objetos jugador, etc..
Turno, Numjugadores byte
evento NuevaRonda
evento SuTurno(byte jugador) // string, objeto jugador, etc...
byte = Propiedad lectura TurnoJugador
devolver Turno
fin propiedad
byte = Propiedad lectura CantidadJugadores
devolver NumJugadores
fin propiedad
buleano = Funcion FinRonda
devolver (turno = (NumJugadores-1))
fin funcion
// Creando una nueva instancia del objeto.
funcion Nuevo(byte jugadores)
NumJugadores = jugadores
Redimencionar array Ronda(0 a NumJugadores -1)
Turno = 0
fin funcion
// Se reclama que se permita jugar al siguiente jugador
funcion SiguienteTurno
Si (turno < (NumJugadores-1))
Turno + =1
Sino
Turno = 0
disparar evento NuevaRonda
Fin si
disparar evento SuTurno(Turno)
Fin funcion
Como ves en el ejemplo, no hacemos uso del array... si solo se guía el objeto por un valor que señala un índice, y ese es siempre incremental, esto es sucede siempre en orden, no se precisa.
En tal caso este objeto lo instancia la 'base del juego' (podría ser o llamarse objeto 'banca'). Así cuando se dispara el evento turno, la base del juego recibe el evento y como mantiene referencia a cada jugador sabrá derivar el turno al jugador que corresponda.
Esto es sencillo, si se la forma de interacción fuera más complejo, porque os jugadores no precisan jugar por turnos, es cuando se precisa hacer uso del array... También en este caso quizás sea preferible que no sea el objeto banca quien utilice este objeto directamente, simplemente lo crea y luego pasa una referencia del mismo a cada jugador que se 'inscribe' en el juego, y es luego el jugador quien directamente haga su juego y lo anuncia a este objeto...
No haré algo exhausitvo ni muy grande, solo lo suficiente para reflejar esta última idea...
Ronda() array de bytes //string, objetos jugador, etc..
Turno, Numjugadores byte
evento NuevaRonda
//evento SuTurno(byte jugador) // string, objeto jugador, etc...
byte = Propiedad lectura TurnosJugados // en la Ronda actual
devolver Turno
fin propiedad
byte = Propiedad lectura CantidadJugadores
devolver NumJugadores
fin propiedad
buleano = Funcion FinRonda
devolver (Turno = (NumJugadores-1))
fin funcion
// Creando una nueva instancia del objeto.
funcion Nuevo(byte jugadores)
NumJugadores = jugadores
Redimencionar array Ronda(0 a NumJugadores -1)
Turno = 0
fin funcion
// Un jugador reclama su turno de jugada...
// solo será posible si no ha jugado ya su turno en esta ronda...
buleano = funcion TurnoJugador(byte Jugador)
Si (Turno = (NumJugadores-1)) // se acabó la ronda actual?, si sí, siguiente ronda
Turno = 0
bucle para k desde a NumJugadores -1
Ronda(k) = 0
siguiente
disparar evento NuevaRonda
Fin si
Si (Ronda(jugador)= 0) // si no ha jugado en esta ronda, se le permite
Ronda(Jugador) = 1 // ma
Turno + =1
// disparar evento SuTurno(Turno)
Devolver True // el evento queda remplazado por la devolución de la llamada.
Sino // este jugador ya jugó en esta ronda.
devolver FALSE
Fin si
Fin funcion
Como ves, el código es casi el mismo, estos son las diferencias:
- Se ha cambiado el nombre de la propiedad: TurnoJugador por TurnosJugados
- el evento SuTurno, no se requiere.
- La funcion TurnoJugador:
----- Ahora devuelve un bulenao en vez de dispara el evento 'suTurno'
----- Recibe como parámetro el índice del jugador que pretende jugar.
----- El array Rondas, mantiene quien ha jugado en esta ronda y quien no, sea cual sea el orden en que jueguen.
Finalmente puedes usar un sencillo negociado con este objeto, en vez de usarlo solamente para obtener turno y recordar que jugadores jugaron ya en la ronda, también puedes añadir un método que recuerde 'la apuesta' del jugador... así la consulta como debe hacerse sí sí aquí, ya se tiene la respuesta sin una consulta posterior al jugador...
En el siguiente pseudocodigo, solo pongo las ideas, los cambios que fueren precisos al resto queda a tu esfuerzo...
verás (por ejemplo) que ahora el array en vez de ser de tipo byte es del tipo de una estructura de 'datos'...
enumeracion EstadoDeTurno
TURNO_NO_JUGADO = 0
TURNO_JUGANDO = 1
TURNO_YA_JUGADO =2
Fin enumeracion
estructura Datos
EstadoDeTurno Estado // del tipo de la enumeración justo recién declarada.
byte Carta
fin estructura
Ronda() array de Datos // de la estructura recién declarada.
// ofrecer el turno de juego a un jugador...
buleano = funcion TurnoJugador(byte Jugador)
Si (Ronda(jugador).Estado = TURNO_NO_JUGADO) // si no ha jugado en esta ronda, se le permite
Ronda(Jugador).Estado = TURNO_JUGANDO
//Turno + =1
// disparar evento SuTurno(Turno)
Devolver True // el evento queda remplazado por la devolución de la llamada.
Sino // este jugador ya jugó en esta ronda.
devolver FALSE
Fin si
Fin funcion
// jugador comunica su apuesta en esta ronda...
funcion ApuestaJugador(byte Jugador, byte Carta)
Si (Ronda(jugador).Estado = TURNO_JUGANDO)
Ronda(Jugador).Estado = TURNO_YA_JUGADO
Ronda(Jugador).Carta = Carta
Turno + =1
Si (Turno = (NumJugadores-1)) // se acabó la ronda actual?, si sí, siguiente ronda
disparar evento RondaTerminada // Último momento para consultar, luego se borrarán los datos...
Turno = 0
bucle para k desde a NumJugadores -1
Ronda(k).Estado = TURNO_NO_JUGADO
Ronda(k).Carta = 0 //equivale a ninguna
siguiente
fin si
Fin si
Fin funcion
// Devuelve la apuesta dle jugador, (0 si todavía no apostó/jugó su turno...
// la consulta se puede hacer en cualquier momento, pero mejor cuando se lanza el evento RondaTerminada
byte = funcion ConsultarApuesta(byte Jugador)
devolver Ronda(Jugador).Carta
fin funcion
Ahora el evento cambio de nombre, porque sucede justo al término de la ronda... pero antes de borrar los datos de la ronda, para dar ocasión a consultar la jugada de cada jugador...
Si carta = 0 es para señalar que no ha jugado, los valores de cartas deberán comenzar de 1 en adelante, si es forzado que deba empezar en 0, usar el valor 255 para indicar que el jugador no ha apostado aún...
Nota que ahora ase ha añadido además un método de consulta, y que el array Ronda ahora tiene pleno sentido... frente al primer pseudocódigo, quersultaba inútil, o en el segundo, que permitía ya liberar el orden de juego de los turnos, ahora... es más útil mantiendo info de la ronda actual... si eres inquieto, sabrás darle más utilidad.
Un objeto ronda, pués puede ser muy útil para mantener los datos de la ronda actual...
...y bueno, para tú no haber puesto ni una línea de código, creo que yo ya he puesto suficiente pseudocódigo para aclarar alguna de tus dudas...
Autor
En línea
