Estoy creando mi primer juego en Java. El juego es el monopolio. Estoy luchando con la forma en que debería diseñar el juego para modelar su estructura por turnos (administrar los turnos de los jugadores). Quiero permitir que un solo jugador controlado por humanos y uno o múltiples jugadores controlados por AI jueguen el juego.

Mi problema específico es que no sé si implementar un bucle de juego o no, es decir, un bucle que puede administrar a los jugadores y las variables directamente relacionadas con el juego de Monopoly (piense en cosas como pedirle a cada jugador su turno, incrementando el turno al siguiente jugador, o obteniendo tiradas de dados de cada jugador (por turno). No me refiero al significado más bajo del término "bucle de juego", que se relaciona más con dibujar marcos en la pantalla, actualizar la física o actualizar la IA a una velocidad específica.

Mi entendimiento es que mis opciones para tratar de implementar lo que necesito son:

Implementar un programa completamente dirigido por eventos que no tenga dicho bucle de juego, oImplemente un bucle de juego, algo que es de larga duración en segundo plano y, básicamente, nunca termina mientras el juego se esté ejecutando. Este sería el enfoque más procesal.

Cuando comencé a tratar de resolver este problema, tuve problemas de congelación de la interfaz de usuario porque el bucle del juego no tenía fin y consumía por completo el subproceso en el que se estaba ejecutando (solo hice un bucle while muy simple para ilustrar esto) . Así que fui al esfuerzo de crear unaSwingWorker para encapsular mi bucle de juego. Eso resolvió el problema de los bloqueos de la interfaz de usuario, pero aún así me dejó preguntándome si iba por el camino equivocado.

Como regla general, encontré que la mayoría de los consejos en la web generalmente parecen favorecer cualquier enfoque basado en eventos, y por lo tanto mi implementación actual utiliza unSwingWorker Podría ser un paso en la dirección equivocada. Pero no puedo comprender completamente cómo implementaría un sistema completamente controlado por eventos para esta tarea específica (lo que significa que no hay un bucle de juego presente). Me parece que debe existir un bucle en algún lugar para gestionar los turnos de los jugadores.

Aquí están mis preguntas específicas:

¿Son apropiados los bucles de juego (como los estoy describiendo) para juegos basados ​​en turnos como Monopoly? Específicamente para poner en cola los turnos de los jugadores y pedirle al jugador adecuado su turno, un jugador a la vez (y poner en cola todo el procedimiento de / secuencia de pasos que comprenden un giro)?Si se creara un sistema puramente basado en eventos para administrar los turnos de jugador, ¿cómo iterar a través de cada jugador para pedirles su turno y seguir iterando hasta que el juego termine?Si se utilizara un bucle de juego para resolver el problema específico descrito anteriormente, ¿debe ejecutarse dentro de su propio hilo (posiblemente utilizandoSwingWorker) para evitar congelar la interfaz de usuario? Mi situación es específica de Java, pero supongo que también me interesarían las respuestas para situaciones no específicas de Java.

Actualmente, tengo mi código organizado usando el patrón MVC. Mi controlador es donde mi bucle de juego (el actualSwingWorker hilo) reside. Está lejos de estar completo, pero ayuda a ilustrar cómo gestiono los giros de los jugadores en lo que llamo un "bucle de juego".

SwingWorker código del controlador:

swingWorker = new SwingWorker<Void, Model>() {
@Override
protected Void doInBackground() throws InterruptedException {
gameLoopRunning = true;
while (gameLoopRunning) {

    //to do: use a timer instead of thread.sleep
    Thread.sleep(1000);

    //user turn prompt
    if (model.getActivePlayer().isUserControlled()) {

        boolean userRolled = false;
        while(!userRolled) {
            System.out.println("Roll the dice please...");
            Thread.sleep(3000);
        }

    }
    //bot turn prompt
    else {
        //insert code for bot rolling dice here
        model.rollDice();
    }

    publish(model);

    Thread.sleep(1000);
    model.incrementPlayerTurn();
    publish(model);

}
return null;
}

@Override
protected void process(List<Model> chunks) {
Model gameModel = chunks.get(chunks.size() - 1);
//hard-coded for 6 players
for (int i = 0; i < 6; i++) {
    view.getPlayerPanel(i).setTurn(gameModel.getPlayers().get(i).isTurn());
}
view.getGamePanel().getDice().setDie1(model.getDie1());
view.getGamePanel().getDice().setDie2(model.getDie2());
}

};
swingWorker.execute();