ticTacToe trying to learn object oriented programming

[Sean Paulson]

Junilu Lacar wrote:I just got done facilitating a Global Day of Code Retreat over the weekend so I'm still in kind of a "stretch yourself" mood. I said that I didn't have a compelling reason to refactor the Player.moves() method further. I guess I was wrong. You can do some reification and turn (row, col) into a real object:

boolean moves {
    Position openSpot = inputValidMove();
    game.mark(openSpot, symbol);
    return true;
}

Here, I have reified (row, column), two separate values that when taken together signify a "position" on the game board and made it into a real object of type Position. That causes a lot of ripple refactoring but it can be done slowly and methodically.

You can make that even smaller like this:

boolean moves {
    game.mark(pickAnOpenSpot(), symbol);

    // Always return true so we have tighter code 
    // in the loop where this method is invoked.
    return true;
}

Note that I added a comment to explain WHY the return value is hard-coded to true. To channel The Most Interesting Man in the World, I don't often write comments but when I do, it's to explain WHY I'm doing something.

I see, so you are basically taking all the code i used and just simplifying and then simplifying and then simplifying more, basically like in math. More little methods.

[Junilu Lacar]

And that inRow() method is just my rowMarks() method that I renamed so the code would read better.

// The name rowMarks() didn't work here
private boolean hasAnyOpenSpot() {
    return hasOpenSpot(rowMarks(0)) || hasOpenSpot(rowMarks(1)) || hasOpenSpot(rowMarks(2));
}

// So I refactor RENAMEd it to inRow()
private boolean hasAnyOpenSpot() {
    return hasOpenSpot(inRow(0)) || hasOpenSpot(inRow(1)) || hasOpenSpot(inRow(2));
}

See how a simple RENAME makes the code read a lot better? It's way more expressive after the refactoring.

And just so you know, the inRow() method is a single line of code, too. It takes advantage of the fact that in Java, "multidimensional arrays" are really just nested arrays, arrays whose elements are themselves arrays.

[Junilu Lacar]

Sean Paulson wrote:I see, so you are basically taking all the code i used and just simplifying and then simplifying and then simplifying more, basically like in math. More little methods.

Absolutely. What I have found is that the more I try to simplify, the easier it is for me to wrap my head around the whole problem and the easier I find it is to work with my code.  Huge chunks of code like the ones that you wrote are very difficult to work with and they tend to hide and harbor bugs, mislead you, and trap you in poor design choices. You often find yourself painted into a corner when you write huge methods so I try to avoid them as much as I can. The smaller the better.

The 4 Rules of Simple Design are a great set of guidelines to follow:

1. All tests pass
2. Clearly expresses intent
3. No duplication of knowledge/representation (DRY - Don't Repeat Yourself)
4. Small (methods, classes, interfaces, APIs, # of dependencies, # of parameters, etc.)

[Sean Paulson]

Junilu Lacar wrote:. . . It's straightforward, expressive, and simple.

well thanks a lot for the help, really just awesome stuff.

I will for sure check out that book and any other theory type books you can recommend.
I think i just kinda understood obo a little but obviously did not take it far enough. Im planning on using this code again soon so i will probaly try and fix it up a lot because, i am wanting to learn to make a gui right now and will use the tick tack toe game code.

Also i will study those concepts you mentioned and some more.

If you wanna see the other code ill post it.

[Sean Paulson]

Junilu Lacar wrote:. . . in Java, "multidimensional arrays" are really just nested arrays, arrays whose elements are themselves arrays.

so two single arrays put together?

[Sean Paulson]

Junilu Lacar wrote:. . . The 4 Rules of Simple Design . . .

yeah i had to rewrite the while loop in my game class and part of my  checkWin() function from scratch almost because it had some bug i could not figure out...that sucked.

[Sean Paulson]

Junilu Lacar wrote:

Sean Paulson wrote:im not sure if i know what you mean by using reference equality.

Please don't quote the entire response. It makes the thread much longer than it needs to be and more difficult to read. Delete the parts of the quote that are not directly relevant to your response. Thanks.

lol sorry about that just seen this post

[Campbell Ritchie]

Sean Paulson wrote:

Junilu Lacar wrote:. . . in Java, "multidimensional arrays" are really just nested arrays, arrays whose elements are themselves arrays.

so two single arrays put together?

Better to say one array containing two other arrays. The outer array is probably best called an array of arrays.

[Junilu Lacar]

Campbell Ritchie wrote:

Sean Paulson wrote:...so two single arrays put together?

Better to say one array containing two other arrays. The outer array is probably best called an array of arrays.

Sorry to nitpick but I think you left out "for example" in that first sentence. One array containing two other arrays is a specific example of "nested arrays" or "array of arrays". Here are some more examples:

   // an array containing two 2-element arrays
   int[][] twoNested = { { 0, 1 }, { 2, 3 } };

   // an array containing two empty arrays
   int[][] alsoTwoNested = { {}, {} };  

   // an array containing 1-, 2-, 3-, and 4-element arrays
   int[][] triangular = { { 0 }, { 1, 2 }, { 3, 4, 5 }, { 6, 7, 8, 9 } };

   // an array containing 2-, 1-, 4-, and 3-element arrays
   int[][] jagged = { { 0, 1 }, { 2 }, { 3, 4, 5, 6}, { 7, 8, 9 } };

The same declarations, formatted differently:

   // an array containing two 2-element arrays
   int[][] twoNested = 
      { { 0, 1 }, 
        { 2, 3 } };
   
   // an array containing two empty arrays
   int[][] alsoTwoNested =  
      { {},
        {} };

   // an array containing 1-, 2-, 3-, and 4-element arrays
   int[][] triangular = 
      { { 0 }, 
        { 1, 2 }, 
        { 3, 4, 5 }, 
        { 6, 7, 8, 9 } };

   // an array containing 2-, 1-, 4-, and 3-element arrays
   int[][] jagged = 
      { { 0, 1 }, 
        { 2 }, 
        { 3, 4, 5, 6}, 
        { 7, 8, 9 } };

[Campbell Ritchie]

Junilu Lacar wrote:. . . Sorry to nitpick but I think you left out "for example" in that first sentence.  . . .

Sorry for not being clear, but I was responding to the OP saying, “two single arrays put together.”

[Junilu Lacar]

Campbell Ritchie wrote:Sorry for not being clear, but I was responding to the OP saying, “two single arrays put together.”

No problem, I was wondering why OP would think it's just two arrays.

@OP, in the Tic Tac Toe game, the board is actually an array that contains three arrays:

    private static final char NONE = ' ';

    char[][] emptyBoard = 
    { {NONE, NONE, NONE},
      {NONE, NONE, NONE},
      {NONE, NONE, NONE} } ;

[Junilu Lacar]

Sean Paulson wrote:Im planning on using this code again soon so i will probaly try and fix it up a lot because, i am wanting to learn to make a gui right now and will use the tick tack toe game code.

Also i will study those concepts you mentioned and some more.

If you're going to create a GUI, a well-factored program that separates display concerns from non-display concerns will make it much easier for you. In my program, I know exactly which methods need to be overridden: the pickAnOpenSpot() method and the drawBoard() method. That's it, nothing else should need to be changed to add a GUI.

This would be an example of the adhering to the Open-Closed Principle (OCP) that states that a class should be open for extension but closed for modification.

Another exercise you might want to try is to make your Game class more intelligent. There are states of the game where it can be determined with 100% certainty that the game will end in a draw, even when there are still more moves available for the players to make. I was thinking of implementing something like an isWinnable() method that can be tacked on to the check made by the boolean gameNotOver() method.  Something like this:

public class SmarterTicTacToe extends TicTacToe {
   ...

   @Override
   protected boolean gameNotOver() {
       return super.gameNotOver() && isWinnable();
   }

   /**
    * Checks if this game can progress from its current
    * state to one where either of the players will win.
    */
   private boolean isWinnable() {
       ...

       return hasWinningFuture;
   }
   ...
}

I'd have to modify the original game code slightly to make the gameNotOver() method protected instead of private. Implementing this would require creating a game tree.

[Sean Paulson]

Junilu Lacar wrote:

Sean Paulson wrote:Im planning on using this code again soon so i will probaly try and fix it up a lot because, i am wanting to learn to make a gui right now and will use the tick tack toe game code.

Also i will study those concepts you mentioned and some more.

If you're going to create a GUI, a well-factored program that separates display concerns from non-display concerns will make it much easier for you. In my program, I know exactly which methods need to be overridden: the pickAnOpenSpot() method and the drawBoard() method. That's it, nothing else should need to be changed to add a GUI.

This would be an example of the adhering to the Open-Closed Principle (OCP) that states that a class should be open for extension but closed for modification.

Another exercise you might want to try is to make your Game class more intelligent. There are states of the game where it can be determined with 100% certainty that the game will end in a draw, even when there are still more moves available for the players to make. I was thinking of implementing something like .

that could be pretty fun. I am wanting to make the snake game next with a gui and after i study up on some of the stuff you mentioned and some other subjects.

[Sean Paulson]

Forgot to post this....i wouldnt say im happy with it but i learned allot...and get that basically why you factor is so if you need to add a new feature you can just add a method or class or w/e instead of searching through a whole application written in linear code. I was able to lower the lines in this game buy over half

Here it is for anyone who wants to check it out. Still have allot to learn...but i had allot of fun.

Game Class

class Game{
	private TestPlayer playerOne = new TestPlayer('x', "player One");
	private TestPlayer playerTwo = new TestPlayer('o', "player Two");
	private TestPlayer activePlayer = new TestPlayer();
	private	int[][] playerMove = new int[1][1];
	private	TestBoard newBoard = new TestBoard();
	private	int row, col;
	private Boolean wasWon = false;
	private Boolean validMark = false;

public void initiate(){
		
	activePlayer = playerOne;
	playerOne.setName();
	playerTwo.setName();
		
	System.out.println(playerOne.getName() + " VS " + playerTwo.getName());	
	newBoard.showBoard();		
}


	public void startGame(){
		while(!wasWon){
			do{playerMark();}
			while(!isValidMark());
				if(!wasWon){
					markSpot();
					wasWon = returnResult();
				}
		nextTurn();
		}
	}		
		
	private void markSpot(){
		newBoard.markBoard(row, col, activePlayer.getPlayerSymbol());
		newBoard.showBoard();
	}
		
	private void playerMark(){
		activePlayer.setPlayerMove();
		row = activePlayer.rowMark();
		col = activePlayer.colMark();
	}
		
	private Boolean isValidMark(){
		validMark = newBoard.isOpenSpot(row, col);
		if(validMark == false){gameEndByError(); }
	return validMark;
	}
	
	private Boolean returnResult(){
		wasWon = newBoard.checkWin();
		if(wasWon == true){
			System.out.println(activePlayer.getName() + " WINS!!!!!");
			newBoard.showBoard();
		}
		return wasWon;
	}
	
	private Boolean gameEndByError(){
		wasWon = newBoard.error();
		if(wasWon == true){validMark = true; System.out.println("You ran out of trys Game Over.");}
		return wasWon;
	}
	
	private void nextTurn(){
		activePlayer = (activePlayer == playerOne) ? playerTwo : playerOne;
	}
	
}

Player Class

class TestPlayer{

	private String playerName, userInput, outPut, StngToInt;
	private char playerSymbol;
	private int row, col;
	
	public TestPlayer(){}
	
	public TestPlayer(char playerChar, String name){
		playerName = name;
		playerSymbol = playerChar;
	}
	
	public void setName(){
		playerName = getUserInput("Enter your Name: ");
		System.out.println();
	}
	
	public String getName(){
		return playerName;
	}
	
	public char getPlayerSymbol(){
		return playerSymbol;
	}
	
	public void setPlayerMove(){
		row = Integer.parseInt(StngToInt = getUserInput(playerName + "Enter Row Position: "));
		col = Integer.parseInt(StngToInt = getUserInput("Enter col Position: "));
		
	}
	
	public int rowMark(){
		return row;
	}
	
	public int colMark(){
		return col;
	}
	
	private String getUserInput(String instruction){
		String outPut = instruction;
		System.out.println(outPut);
		Scanner input = new Scanner(System.in);
		userInput = input.nextLine();
		return userInput;
	}
}

Board Class

class TestBoard{

	private char[][] newBoard = new char[3][3];
	private int rowMark, colMark, rowCheck, colCheck;
	private int retriesCounter = 3;
	private Boolean openSpot = false;
	private Boolean wasWon = false;
	private int[] col = new int[3];
	private int[] row = new int[3];
	private char markSymbol;
	
	TestBoard(){
		for(int i = 0; i <= 2; ++i){
			for(int x = 0; x <= 2; ++x){
				newBoard[i][x] = '-';
			}
		}
	}
		
	public void markBoard(int row, int col,char playerSymbol){
		
		markSymbol = playerSymbol;
		rowMark = row;
		colMark = col;
		newBoard[rowMark][colMark] = markSymbol;	
	}		
		
	public Boolean isOpenSpot(int row, int col){
		rowMark = row;
		colMark = col;
				if(newBoard[rowMark][colMark] == '-'){
					openSpot = true;
				}else{openSpot = false;}
	return openSpot;	
	}
		
	public Boolean checkWin(){
		/****************** CHECK rows & cols FOR WIN*******************/
			int[] row = {0,0,0};
			int[] col = {0,0,0};
			for(int r = 0; r < 3; ++r){
				for(int c = 0; c < 3; ++c){
					if (newBoard[r][c] == markSymbol){
						++row[r];
					}
					if(newBoard[c][r] == markSymbol){
						++col[c];
						if(col[c] == 3 || row[r] == 3){wasWon = true; System.out.println("return win");}
					}
				}
			}
			/****************** CHECK diag AND anti diag FOR WIN*******************/
		if(newBoard[0][0] == markSymbol && newBoard[1][1] == markSymbol && newBoard[2][2] == markSymbol){
			wasWon = true;
			}else if (newBoard[0][2] == markSymbol && newBoard[1][1] == markSymbol && newBoard[2][0] == markSymbol){
			 wasWon = true;}
	return wasWon;
	}
		
	public void showBoard(){
		System.out.println("     0           1           2");
		for(int r = 0; r < 3 ; ++r){
			System.out.print(r);
			for(int c = 0; c < 3; ++c){
				System.out.print("    " + newBoard[r][c] + "        ");
			}
			System.out.println();
		}
	}
	
	public Boolean error(){
		--retriesCounter;
		System.out.println("Error you did not enter a valid move: \nplease try again you have " + retriesCounter + " attempts left.");
		if(retriesCounter == 0){
			wasWon = true;
		}else{wasWon = false;}
		return wasWon;
	}

}

[Junilu Lacar]

There are still a number of things you can improve but good job breaking things down into smaller, more manageable chunks. Keep practicing and don't forget: try to refactor often. Rename, extract and Compose method are the main techniques you want to use 80% or more of the time. Follow the four rules of simple design, KISS, DRY, SLAP, SOLID. No, that's not anything kinky, those are acronyms for design principles that you should get familiar with and learn to apply as you write code. Good luck.