gdx-studio

package source;

import com.badlogic.gdx.scenes.scene2d.Actor;
import com.badlogic.gdx.scenes.scene2d.Group;
import com.badlogic.gdx.scenes.scene2d.ui.Image;
import com.badlogic.gdx.scenes.scene2d.InputEvent;
import com.badlogic.gdx.scenes.scene2d.utils.ClickListener;

import java.util.Random;

import scene2d.*;

/** 
 *  A Basic TicTacToe Game
 Scene
 *  
 * @author pyros2097 */
public class TicTacToe extends Scene {

    Box[][] boxes;
    public static int turnCounter = 0;

    /* Game Constants */
    private static GameMode gameMode = GameMode.SINGLE_PLAYER_VS_COMPUTER;
    public static Turn currentTurn = Turn.Player;

    public TicTacToe(){
        boxes = new Box[3][3];
        for(int i = 0;i < 3;i++){
            for(int j = 0;j < 3;j++){
                Box box = new Box(i, j);
                boxes[i][j] = box;
                addActor(box, box.getWidth()*j, box.getHeight()*i);
            }
        }
    }

    /* Check if mode is current return true */
    public static boolean mode(GameMode gm){
        if(gameMode == gm)
            return true;
        else
            return false;
    }
    
    public static void setMode(GameMode gm){
        gameMode = gm;
        log("Game Mode: " + gameMode.toString());
    }
        
    public void reset(){
        log("Reset");
        turnCounter = 0;
        setScene("TicTacToe");
    }

    public void playerWin(){
        log("Player Win");
        reset();
    }
    
    public void computerWin(){
        log("Computer Win");
        reset();
    }

    int random1 = 0;
    int random2 = 0;
    Random rand = new Random();
    void AI(){
        if(mode(GameMode.SINGLE_PLAYER_VS_COMPUTER)){
            if(currentTurn == Turn.Computer){
                log("AI");
                random1 = rand.nextInt(3);
                random2 = rand.nextInt(3);
                if(!boxes[random1][random2].isMarked){
                    boxes[random1][random2].markByComputer();
                    return;
                }
            }
        }
    }
    
    void checkForRowY(int j){
        if(boxes[j][0].type != MarkType.None && boxes[j][1].type != MarkType.None  
                && boxes[j][2].type != MarkType.None )
            if(boxes[j][0].type ==  boxes[j][1].type && boxes[j][0].type == boxes[j][2].type )
                if(boxes[j][0].type == MarkType.X)
                    playerWin();
                else
                    computerWin();
    }
    
    void checkForRowX(int j){
        if(boxes[0][j].type != MarkType.None && boxes[1][j].type != MarkType.None  
                && boxes[2][j].type != MarkType.None )
            if(boxes[0][j].type ==  boxes[1][j].type && boxes[0][j].type == boxes[2][j].type )
                if(boxes[0][j].type == MarkType.X)
                    playerWin();
                else
                    computerWin();
    }
    
    void checkForDiagonal(){
        if(boxes[0][0].type != MarkType.None && boxes[1][1].type != MarkType.None  
                && boxes[2][2].type != MarkType.None )
            if(boxes[0][0].type ==  boxes[1][1].type && boxes[0][0].type == boxes[2][2].type )
                if(boxes[0][0].type == MarkType.X)
                    playerWin();
                else
                    computerWin();
        if(boxes[0][2].type != MarkType.None && boxes[1][1].type != MarkType.None  
                && boxes[2][0].type != MarkType.None )
            if(boxes[0][2].type ==  boxes[1][1].type && boxes[0][2].type == boxes[2][0].type )
                if(boxes[0][2].type == MarkType.X)
                    playerWin();
                else
                    computerWin();
    }

    @Override
    public void act(float delta){
        super.act(delta);
        AI();
        if(turnCounter < 9){
            for(int i=0; i<3;i++){
                checkForRowY(i);
                checkForRowX(i);
            }
            checkForDiagonal();
        }
        else{
            log("Draw Match");
            reset();
        }
    }

    @Override
    public void onClick(Actor actor){}

    @Override
    public void onTouchDown(Actor actor){}

    @Override
    public void onTouchUp(){}

    @Override
    public void onDragged(){}

    @Override
    public void onGesture(GestureType type){}

    @Override
    public void onKeyTyped(char key){
    }
    
    @Override
    public void onKeyUp(int keycode){
    }
    
    @Override
    public void onKeyDown(int keycode){
    }

    @Override
    public void onPause(){
    }
    
    @Override
    public void onResume(){
    }
        
    @Override
    public void onDispose(){
    }
}

class Box extends Group{
    private final int row, col;
    private final Image bg = new Image(Asset.tex("square"));
    private final Image x = new Image(Asset.tex("x"));
    private final Image o = new Image(Asset.tex("o"));
    public boolean isMarked = false;
    public MarkType type = MarkType.None;
    
    Box(int row, int col){
        this.row = row;
        this.col = col;
        bg.setPosition(row*bg.getWidth(), col*bg.getHeight());
        o.setPosition(row*bg.getWidth(), col*bg.getHeight());
        x.setPosition(row*bg.getWidth(), col*bg.getHeight());
        addActor(bg);
        addListener(new ClickListener(){
            @Override
            public void clicked(InputEvent event, float x, float y) {
                super.clicked(event, x, y);
                if(!Box.this.isMarked){
                    if(TicTacToe.mode(GameMode.SINGLE_PLAYER))
                        if(TicTacToe.currentTurn == Turn.Player)
                            markByPlayer();
                        else
                            markByComputer();
                    else if(TicTacToe.mode(GameMode.SINGLE_PLAYER_VS_COMPUTER))
                        if(TicTacToe.currentTurn == Turn.Player)
                            markByPlayer();
                    Scene.log("Box Clicked "+Box.this.row+Box.this.col);
                }
            }
        });
    }
    
    public void markByPlayer(){
        isMarked = true;
        TicTacToe.turnCounter++;
        addActor(x);
        TicTacToe.currentTurn = Turn.Computer;
        type = MarkType.X;
    }
    
    public void markByComputer(){
        isMarked = true;
        TicTacToe.turnCounter++;
        addActor(o);
        TicTacToe.currentTurn = Turn.Player;
        type = MarkType.O;
    }
}

enum MarkType {
    None,
    X,
    O
}

enum Turn {
    Player,
    Computer,
    OtherPlayer
}

enum GameMode {
    SINGLE_PLAYER,
    SINGLE_PLAYER_VS_COMPUTER,
    MULTI_PLAYER,
}