Game loop of a turn-based game

Question

Currently, I'm working on an AI for a simple turn-based game. The way I have the game set up is as following (in pseudo-code):

players = [User, AI];
(for player : players){
    player.addEventlistener(MoveListener (moveData)->move(moveData));
}

players[game.getTurn()].startTurn();

the move function:

move(data){
    game.doStuff(data);
    if(game.isOver())
        return;

    game.nextTurn();
    players[game.getTurn()].startTurn();
}

This results in the following recursion:

• start turn
• player/AI makes a move
• move function gets called
• the next player starts their turn
• ...

This repeats until the game is over - note that the game is of finite length and doesn't go past ~50 moves. Now, even though the recursion is finite, I get a stackoverflow error. My question is: is there any way to fix this? Is there something wrong with the recursion after all? Or should I implement a game loop instead? I understand how this would work if AIs were to play against each other, but how would this work if the program had to wait for user input?

EDIT
Here are the relevant classes to the recursion:

Connect4 class:

package connect4;

import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.text.Text;
import javafx.stage.Stage;

public class Connect4 extends Application {
    Group root = new Group();
    GameSquare[][] squares;
    GameButton[] buttons;
    int currentTurn;
    int columns = 7;
    int rows = 6;
    Text gameState;
    Player[] players;
    Game game;

    @Override
    public void start(Stage primaryStage) {        
        int size = 50;
        int padding = 10;

        gameState = new Text();
        gameState.setX(padding);
        gameState.setY((rows+1)*size+(rows+3)*padding);
        root.getChildren().add(gameState);

        buttons = new GameButton[columns];
        for(int i = 0; i < buttons.length; i++){
            buttons[i] = new GameButton(i);
            buttons[i].setMaxWidth(size);
            buttons[i].setMaxHeight(size);
            buttons[i].setLayoutX(i*size+(i+1)*padding);
            buttons[i].setLayoutY(padding);

            buttons[i].setMouseTransparent(true);                
            buttons[i].setVisible(false); 

            root.getChildren().add(buttons[i]);
        }

        players = new Player[2];

        players[0] = new UserControlled(buttons);
        players[1] = new AI();

        MoveListener listener = (int i) -> {move(i);};

        for(Player player : players)
            player.addListener(listener);

        game = new Game(columns, rows, players.length);

        squares = new GameSquare[columns][rows];

        for(int x = 0; x < columns; x++){
            for(int y = 0; y < rows; y++){
                squares[x][y] = new GameSquare(
                        x*size+(x+1)*padding, 
                        (y+1)*size+(y+2)*padding,
                        size,
                        size,
                        size,
                        size
                );
                root.getChildren().add(squares[x][y]);
            }
        }

        players[game.getTurn()].startTurn(game);
        updateTurn();
        updateSquares();

        draw(primaryStage);
    }

    public void move(int i){
        game.move(i);
        updateSquares();

        if(game.isGameOver()){
            if(game.isTie()){
                tie();
                return;
            } else {
                win();
                return;
            }
        }

        updateTurn();
        players[game.getTurn()].startTurn(game);
    }

    private void updateSquares(){
        int[][] board = game.getBoard();
        for(int x = 0; x < columns; x++){
            for(int y = 0; y < rows; y++){
                squares[x][y].setOwner(board[x][y]);
            }
        }
    }

    private void updateTurn(){
        gameState.setText("Player " + game.getTurn() + "'s turn");
    }

    public static void main(String[] args) {
        launch(args);
    }

    private void draw(Stage primaryStage){
        Scene scene = new Scene(root, 500, 500);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    private void win(){
        gameState.setText("Player " + game.getWinner() + " has won the game!");
    }

    private void tie(){
        gameState.setText("It's a tie!");
    }
}

Game class: package connect4;

public class Game {
    private int turn = 0;
    private int[][] board;
    private int columns;
    private int rows;
    private int players;
    private boolean gameOver = false;
    private boolean tie = false;
    private int winner = -1;

    public Game(int columns, int rows, int playerCount){
        this.columns = columns;
        this.rows = rows;
        board = new int[columns][rows];

        for(int x = 0; x < columns; x++){
            for(int y = 0; y < rows; y++){
                board[x][y] = -1;
            }
        }

        players = playerCount;
    }

    public int[][] getBoard(){
        return board;
    }

    public int getTurn(){
        return turn;
    }

    private void updateTurn(){
        turn++;
        if(turn >= players)
            turn = 0;
    }

    public boolean isGameOver(){
        return gameOver;
    }

    private void win(int player){
        gameOver = true;
        winner = player;
    }

    public int getWinner(){
        return winner;
    }

    private void tie(){
        gameOver = true;
        tie = true;
    }

    public boolean isTie(){
        return tie;
    }

    public void move(int i){
        if(gameOver)
            return;

        if(columnSpaceLeft(i) == 0){
            return;
        }

        board[i][columnSpaceLeft(i)-1] = turn;
        checkWin(turn);        
        checkFullBoard();        

        if(gameOver)
            return;

        updateTurn();
    }

    private void checkFullBoard(){
        for(int i = 0; i < columns; i++){
            if(columnSpaceLeft(i) != 0)
                return;
        }
        tie();
    }

    public int columnSpaceLeft(int column){
        for(int i = 0; i < board[column].length; i++){
            if(board[column][i] != -1)
                return i;
        }
        return board[column].length;
    }

    public int[] getAvailableColumns(){        
        int columnCount = 0;
        for(int i = 0; i < board.length; i++){
            if(columnSpaceLeft(i) != 0)
                columnCount++;
        }

        int[] columns = new int[columnCount];
        int i = 0;
        for(int j = 0; j < board.length; j++){
            if(columnSpaceLeft(i) != 0){
                columns[i] = j;
                i++;
            }
        }

        return columns;
    }

    private Boolean checkWin(int player){
        //vertical
        for(int x = 0; x < columns; x++){
            int count = 0;
            for(int y = 0; y < rows; y++){
                if(board[x][y] == player)
                    count++;
                else
                    count = 0;
                if(count >= 4){
                    win(player);
                    return true;
                }
            }
        }

        //horizontal
        for(int y = 0; y < rows; y++){
            int count = 0;
            for(int x = 0; x < columns; x++){
                if(board[x][y] == player)
                    count++;
                else
                    count = 0;
                if(count >= 4){
                    win(player);
                    return true;
                }
            }
        }

        //diagonal
        for(int x = 0; x < columns; x++){
            for(int y = 0; y < rows; y++){
                int count = 0;
                //diagonaal /
                if(!(x > columns-4 || y < 3) && board[x][y] == player){
                    count ++;
                    for(int i = 1; i <= 3; i++){
                        if(board[x+i][y-i] == player){
                            count++;
                            if(count >= 4){
                                win(player);
                                return true;
                            }
                        } else {
                            count = 0;
                            break;
                        }
                    }
                }

                //diagonal \                
                if(!(x > columns-4 || y > rows-4) && board[x][y] == player){
                    count ++;
                    for(int i = 1; i <= 3; i++){
                        if(board[x+i][y+i] == player){
                            count++;                            
                            if(count >= 4){
                                win(player);
                                return true;
                            }
                        } else {
                            count = 0;
                            break;
                        }
                    }
                }
            }
        }

        return false;
    }
}

UserControlled class:

package connect4;

import java.util.ArrayList;
import java.util.List;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;

public class UserControlled implements Player  {
    private List<MoveListener> listeners = new ArrayList<MoveListener>();
    private GameButton[] buttons;
    private boolean active = false;

    public UserControlled(GameButton[] buttons){
        this.buttons = buttons;
    }

    @Override
    public void addListener(MoveListener listener){
        listeners.add(listener);
    }

    @Override
    public void startTurn(Game game){
        System.out.println(0);
        active = true;
        for(int i = 0; i < buttons.length; i++){
            if(game.columnSpaceLeft(i) != 0){
                setButton(i, true);
                buttons[i].setOnAction(new EventHandler<ActionEvent>() {
                    @Override public void handle(ActionEvent e) {
                        move(( (GameButton) e.getTarget()).getColumn());
                    }
                });
            }
        }
    }

    private void move(int i){
        if(!active)
            return;
        active = false;
        disableButtons();
        for(MoveListener listener : listeners)
            listener.onMove(i);
    }

    private void disableButtons(){
        for(int i = 0; i < buttons.length; i++){
            setButton(i, false);  
        }
    }

    private void setButton(int i, boolean enable){
        if(enable){
            buttons[i].setMouseTransparent(false);                
            buttons[i].setVisible(true);
        } else {
            buttons[i].setMouseTransparent(true);                
            buttons[i].setVisible(false);              
        }
    }
}

The AI class is basically the same as a stripped down UserControlled class, except the startTurn method:

int[] columns = game.getAvailableColumns();
move(columns[rng.nextInt(columns.length)]);

The MoveListener interface is very simple:

public interface MoveListener {
    void onMove(int i);
}

The stack trace:

Exception in thread "JavaFX Application Thread" java.lang.StackOverflowError
    at javafx.beans.property.StringPropertyBase.set(StringPropertyBase.java:142)
    at javafx.beans.property.StringPropertyBase.set(StringPropertyBase.java:49)
    at javafx.scene.text.Text.setText(Text.java:370)
    //note that the three lines above this are different every time
    //as the application crashes at a different point
    at connect4.Connect4.updateTurn(Connect4.java:107)
    at connect4.Connect4.move(Connect4.java:93)
    at connect4.Connect4.lambda$start$0(Connect4.java:49)
    at connect4.AI.move(AI.java:13)
    at connect4.AI.startTurn(AI.java:24)
    at connect4.Connect4.move(Connect4.java:94)
    at connect4.Connect4.lambda$start$0(Connect4.java:49)
    at connect4.AI.move(AI.java:13)
    ...etc

Answer 1

In general, you shouldn't use a recursion except you are pretty sure about what you are doing.

Think this, every time you call the next step, you are saving all the context, with all the local variables in the stack. In a game, it could be a lot of stuff.

A common game loop in a turn based game would be something like:

while(!gameFinished()){
    for(player in players){
         player.doTurn();
    }
}

Take into account too, that recursion is slow, because it has to save all the context and it takes time, so, in general, think three times before trying to use a recursion.

EDIT

To process the input you could use something like this:

CompletableFuture.supplyAsync(this::waitUserInput)  
             .thenAccept(this::processUserInput)

Here you can find how it works:

http://www.deadcoderising.com/java8-writing-asynchronous-code-with-completablefuture/

With this, your code keeps running, so keep in mind that in the next line of code you won't have the input. When it gets the input, it will call the proccessUserInput method.

Another way to do this, is to check every frame if any key was pressed, and that's okay too.

Here you can find a way to do that:

How do I check if the user is pressing a key?

The way you should do things depends on the size of your project. If you will be checking for key presses all the time, maybe it's a good idea to build some sort of event system for that.

In the other hand, I recommend you to use a game engine like Unreal or Unity. If you want to keep with Java, there are a lot of libraries for games that handle a lot of common problems like this.

For example:

https://www.lwjgl.org/

You can find a lot of tutorials of turn-based games made with that library.

Good luck!