Day 58: To the next step

First of all I want to thank you all that read, comment and send me mails, this gives me a lot of strength to continue with this hard project. Special thanks this time to Xavier and Lic. Sergio that made me see a way to make the code run faster and better.

Here is the way this will continue to start getting less randomization: all the valid moves that the engine have should have a score. There will be a method givePoints that will give points to the move. There I will call all the methods that will have te logic to assign the move some points. Let's say, all moves start with 0 points. To that I will sum a random number from 1 to 5. Then the program will sum and rest points according to the logic that I will give to the program.

Let's start with something simple, then I will make it more and more complex. The first thing I will implement to give points is if the move is in the first turns playing in the corners will give the move 15 points. Closing a Shimari 17 making a kakari 17 (I know in the future I will need to change those values, but let's see).

Day 57: First video and log

As I promised, here is a video of how is the program working so far.

The program is SLOW, this is because I am logging a lot, it is running on an overcharged computer and is running from a pendrive. So, to save this I should:

1. Make less logging (just log the same info but writing less).
2. Sometimes I should run this from a computer that works well, it just plays random moves, it shouldn't take so long to choose a valid move.
3. Run it from a hard disk XD.

But, right now what bothers me is how to continue.

The log (10 moves... 206kb.), that is something impossible to keep.

Day 13: Groups

It's time for the engine to recognize groups!

A little thing I saw as I was coding this: The size of the board and the moves it have should be part of the board class. So, I am changing all the "size" coming from the main loop, and the methods that received the whole board array.

First thing I made is an arraylist that have all the positions of the group. Then I followed this logic:

1. Create a pointer variable with value 0, this variable is simply an integer that have the value of the last visited element of the arraylist.
2. Start a while loop, all what happens now will be done until I reach the end of the array.
3. Search the position to the left in the board, if it have the same value as the first element it adds the position to the arraylist (if it is not in the arraylist yet).
4. Search the position to the right in the board, if it have the same value as the first element it adds the position to the arraylist (if it is not in the arraylist yet).
5. Search the position up in the board, if it have the same value as the first element it adds the position to the arraylist (if it is not in the arraylist yet).
6. Search the position down in the board, if it have the same value as the first element it adds the position to the arraylist (if it is not in the arraylist yet).
7. If the pointer is = to the arraylist size of the arraylist, then all the group was found, so it should exit from the loop.
8. If the pointer < to the arraylist size, then increase the pointer by one.
9. When exits the loop return the arraylist.

After a lot of problems implementing this, I have some code:

public ArrayList<integer> getGroup(int position, Board board){ //This method returns the group from a given position ArrayList<integer> group = new ArrayList<>(); int pointer=0; boolean endOfSearch=false; int color=board.getMove(position); group.add(position); while(endOfSearch==false){ //search to the left if(board.getMove(group.get(pointer)-1)==color){ if(group.contains(group.get(pointer)-1)==false){ group.add(group.get(pointer)-1); } } //search to the right if(board.getMove(group.get(pointer)+1)==color){ if(group.contains(group.get(pointer)+1)==false){ group.add(group.get(pointer)+1); } } //Search up if(board.getMove(group.get(pointer)-(board.getBoardSize()+1))==color){ if(group.contains(group.get(pointer)-(board.getBoardSize()+1))==false){ group.add(group.get(pointer)-(board.getBoardSize()+1)); } } //Search down if(board.getMove(group.get(pointer)+(board.getBoardSize()+1))==color){ if(group.contains(group.get(pointer)+(board.getBoardSize()+1))==false){ group.add(group.get(pointer)+(board.getBoardSize()+1)); } } //If there are more elements redo the search, else the group //is identified if(group.size()>pointer+1){ pointer++; }else{ //the pointer is at the last position of the array //so, the search is over endOfSearch=true; } } return group; }

I also made a method in Console to show the groups and a method in the engine that gets the groups.

Next step: Liberties.

Day 12: Recording moves

I didn't have time this weekend to code, I just started with the game recorder. The class GameWriter takes the integer in the method puthMove and returns a method with getMove. There is also a method with the length of the class.

The main loop class creates a new GameWriter and in every move takes the move. The console writer takes it and writes it translated to coordinates.

Day 3: Board Representation -Coding-

Well, time to code!

Important note: I just changed: "Stone" is not needed as a class right now, if I need it in the future I will change it, for now, there will be an integer in every position: 0-No stone 1-Black Stone 2-White Stone, 3-Unplayable place

Some things about how I will program this:

• Even if inside an IF there is only one line, I will still use the "{"
• Lot's of comments on code.
• Obvious comments mode=on.

First way I thought about creating the board:

package Elements; import java.util.ArrayList; public class Board { private ArrayList<integer> mainBoard=new ArrayList<>(); public Board(int x){ //COnstructor, also intialices the go board. int i; int totalpositions=(x+2)*(x+1)+1; //for example in 19x19 board it will be 21*20+1 for(i=0;i<=x;i++){ //Position 0 to x will contain an non-playable stone this.mainBoard.add(new Integer(3)); } for(i=x+1;i<=(x+1)*(x+1);i++){ //It will go from x+1 (the first element of the "second row" //to the last element of the "penultimate row" of the board //for example in 6x6 it will go from the 7th. element to 49th. //element in the array). if(i%(x+1)==0){ //The borders are in positions where i%(x+1) is 0 //so, there should be a non playable Stone this.mainBoard.add(new Integer(3)); }else{ //if not, empty place. this.mainBoard.add(new Integer(0)); } } for(i=(x+1)*(x+1)+1;i<=(x+2)*(x+1);i++){ //Last row, all unplayable stones this.mainBoard.add(new Integer(3)); } } public ArrayList<integer> getMainBoard(){ //Returns the mainBoard return this.mainBoard; } }
This goes with the math of the last post. Puts the correct "component" in every space of the array.

So, now, just to show it on the console, in the "Console" class:
package Showing; import Elements.Board; import java.util.ArrayList; public class Console { public void showBoard(Board board,int size){ int i,j; int pointer=0; //pointer to know the place in the arraylist. String line=""; ArrayList<integer> b=new ArrayList<>(); b=board.getMainBoard(); for(i=0;i<size+2;i++){ for(j=0;j<=size;j++){ switch(b.get(pointer)){ case 0: line=line+"0"; break; case 1: line=line+"B"; break; case 2: line=line+"W"; break; case 3: line=line+"#"; break; } pointer++; } line=line+"#"; //putting the right border System.out.println(line); line=""; } } }

And in the "Principal" class (main), just start the program creating the board (hardcoded to 9x9 but can be changed to whatever). In the near future I will quit this from main and create a class for the game loop. package Start; import Elements.Board; import Showing.Console; public class Principal { /** * @param args the command line arguments */ public static void main(String[] args) { int boardSize=9; //in the future there will be an input Board board=new Board(boardSize); Console console=new Console(); console.showBoard(board,boardSize); } }

So, that's it for now, runnig this I had:

In 9x9:

In 19x19: