Other question,what is:

1. update(mouseX, mouseY)
   

1.) CircleButton is a class and grid is a double array of type CircleButton.

thank you,i've another question:
How do they work this function?

1) :

1. update(mouseX, mouseY);
     for (int c = 0; c<cols; c++) {
       for (int d = 0; d<rows; d++) {
         grid[c][d].display();
   

2) :

1. boolean checkWin()
     {
       int counter;
       //orizzontal
       for (int a=0; a < rows; a++) {
         for (int b=0; b < cols-3; b++) {
           int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
           if (tCheck == 8 || tCheck == 4)
           {
             winner = tCheck;
             return true;
           }
         }
       }
    
    
       //vertical
       for (int a=0; a < rows-3; a++) {
         for (int b=0; b < cols; b++) {
           int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
           if (tCheck == 8 || tCheck == 4)
           {
             winner = tCheck;
             return true;
           }
         }
       }
    
    
       //diagonal
       for (int a=0; a < rows-3; a++) {
         for (int b=0; b < cols-3; b++) {
           int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
           if (tCheck == 8 || tCheck == 4)
           {
             winner = tCheck;
             return true;
           }
         }
       }
2.   for (int a =0; a < rows-3; a++) {
         for (int b=0; b < cols-3; b++) {
           int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
           if (tCheck == 8 || tCheck == 4)
           {
             winner = tCheck;
             return true;
           }
         }
       }
    
       for (int a=0; a < rows-3; a++) {
         for (int b=3; b < cols; b++) {
           int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
           if (tCheck == 8 || tCheck == 4)
           {
             winner = tCheck;
             return true;
           }
         }
       }
    
       return false;
     }
   

3)

1. void update(int x, int y){
    
       if (mousePressed && gameOn) {
         for (int c = 0; c<cols; c++) {
           for (int d = 0; d<rows; d++) {
             if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
               if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                 grid[c][d].setHighlight();
                 count++;
                 if (count % 2 == 0) {
                   grid[c][d].setColor(color(255, 0, 0));
                   gridChecker[c][d] = 1;
                 }//if
                 else {
                   grid[c][d].setColor(color(0));
                   gridChecker[c][d] = 2;
                 }//else
               }//if
             }//if
           }//for
         }//for
       }//if
       if (locked == false && gameOn) {
         for (int c = 0; c<cols; c++) {
           for (int d = 0; d<rows; d++) {
             //grid[c][d].canHighlight();
             grid[c][d].update();
           }//for
         }//for
       }//if
       else {
         locked = false;
       }//else
     }//void
   

hello!

The whole code manages the game.

So it

• displays the game board,
• checks if somebody won or
• takes the moves made by the mouse.

The game board is realised at a 2D array. This works like a chess board and you say which row and which line your cell in the grid has. E.g.

1.   grid[c][d].display();

displays the cell in the row c and line d of the grid.
This you must fully understand.


To the single points of yours
1)
displays the whole board by going through all rows and inside that through all lines (of each row).
A so called double-for-loop - very handy for 2D arrays

2)
This checks if somebody wins
horizontally, vertically etc.
the values of neighbouring fields are added.
The value of an empty cell is 0, of red 1, of black 2.

• So when red wins there must be 4 as the result of the adding the value (1+1+1+1),
• when black wins, 8 (2+2+2+2).

3)
here we take the mouse input and store it into the grid.
all cells are checked; when the mouse is in them, the cell gets 1 or 2 for red or black.
Depending on count which counts the number of moves.

Greetings, Chrisir   

thank you very much.
One other question, instead of doing player vs player as you change the program to make player vs pc?

You certainly could, but you would have to add some code to the program that would make that happen!
Specifically, I would make the second player be the computer, and I would make it add a second chip after the player adds one.
A stupid computer player could just pick a column to play in at random. This would be easy to code.

the code can also be completely different, is the same.
I have to make a program that, through a menu, the user chooses whether to play player vs player or player vs PC.
Player vs player is already done, I need player vs pc

Hello,

I made this once for tic tac toe
you can play

• human versus human
• human versus pc
• pc versus pc

it was very hard to do.
The sketch has 11 tabs!

http://www.openprocessing.org/sketch/29501


Your approach
You need variables to have control over your program.

When you have a menu you need to know if you play

• human versus human
• human versus pc

What to do
At the begnning of draw() you see

1. void draw()

1. {

1. update(mouseX, mouseY);


OK.
Let's make this


1. void draw()

{    if (humanVersusHuman) {

update(mouseX, mouseY);

1. }
2. else
3. {
4.     if (humanMustMakeHisMove)
5.   updateHumanMoveForHumanVersusPC(mouseX, mouseY);
6.   else
7.   updatePCMoveForHumanVersusPC();
8. } // else



Thus you have a good structure.
Now you have to write the functions


• updateHumanMoveForHumanVersusPC and
• updatePCMoveForHumanVersusPC


The function updateHumanMoveForHumanVersusPC is easy, it's almost like the function update() is now. But you can set only red, not black etc.; some modifications are necessary here.
The function updatePCMoveForHumanVersusPC is also easy, just choose a cell randomly. Let him play black. Later you can write better functions here to let the PC make better moves. That's the hard part.

At the end of both functions say please:


1. humanMustMakeHisMove = !humanMustMakeHisMove;

Greetings, Chrisir     

my idea was to make a new program from scratch player vs pc and then join them together.
The problem is that I do not know how to handle the turn of the pc, how do I tell the computer to move and, above all, let him do the movements?

this is the rough idea

1. //
2. boolean humanVersusHuman = false;
3. boolean humanMustMakeHisMove = true;
4. //
5. int count = 0;
6. int rows = 6;
7. int cols = 7;
8. int winner = 0;
9. CircleButton[][] grid = new CircleButton[cols][rows];
10. int[][] gridChecker = new int[cols][rows];
11. boolean locked = false;
12. boolean gameOn = true;
13. void setup()
14. {
15.   smooth();
16.   for (int a = 0; a<cols; a++) {
17.     for (int b = 0; b<rows; b++) {
18.       gridChecker[a][b] = 10;
19.     }
20.   }
21.   int a;
22.   int b;
23.   for ( a = 0; a<cols; a++) {
24.     for (b = 0; b<rows; b++) {
25.       grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
26.     }
27.   }
28.   color buttoncolor = color(204);
29.   color highlight = color(153);
30.   ellipseMode(CENTER);
31.   size(700, 600);
32.   background(255, 204, 0);
33.   stroke(126);
34.   for ( int c = 1; c <= cols; c++) {
35.     line( c*(width/cols), 0, c*(width/cols), height);
36.   }
37.   for (int c = 1; c<=rows; c++) {
38.     line(0, c*(height/rows), width, c*(height/rows));
39.   }
40. }
41. void draw()
42. {
43.   if (humanVersusHuman) {
44.     update(mouseX, mouseY);
45.   }
46.   else
47.   {
48.     if (humanMustMakeHisMove)
49.       updateHumanMoveForHumanVersusPC(mouseX, mouseY);
50.     else
51.       updatePCMoveForHumanVersusPC();
52.   } // else
53.   //
54.   //
55.   for (int c = 0; c<cols; c++) {
56.     for (int d = 0; d<rows; d++) {
57.       grid[c][d].display();
58.     }
59.   }
60.   if (checkWin() == true) {
61.     gameOn = false;
62.     PFont font = createFont("ARCARTER-78.vlw", 14);
63.     textFont(font, 85);
64.     if (winner == 4) {
65.       shadowtext("Red Wins!", width/4, height/2, 3);
66.     }
67.     else if (winner == 8) {
68.       shadowtext("Black Wins!", width/3.5, height/2, 3);
69.     }
70.     shadowtext("Click to play again", width/5.5, height*.3, 1);
71.   }
72. }
73. void shadowtext (String s, float x, float y, int o) {
74.   fill(100, 100);
75.   text(s, x+o, y+o);
76.   fill(58, 12, 247);
77.   text(s, x, y);
78. }
79. void mousePressed() {
80.   if (gameOn == false) {
81.     gameOn = true;
82.     setup();
83.   }
84. }
85. boolean checkWin()
86. {
87.   int counter;
88.   //horizontal
89.   for (int a=0; a < rows; a++) {
90.     for (int b=0; b < cols-3; b++) {
91.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
92.       if (tCheck == 8 || tCheck == 4)
93.       {
94.         winner = tCheck;
95.         return true;
96.       }
97.     }
98.   }
99.   //vertical
100.   for (int a=0; a < rows-3; a++) {
101.     for (int b=0; b < cols; b++) {
102.       int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
103.       if (tCheck == 8 || tCheck == 4)
104.       {
105.         winner = tCheck;
106.         return true;
107.       }
108.     }
109.   }
110.   //diagonals
111.   for (int a=0; a < rows-3; a++) {
112.     for (int b=0; b < cols-3; b++) {
113.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
114.       if (tCheck == 8 || tCheck == 4)
115.       {
116.         winner = tCheck;
117.         return true;
118.       }
119.     }
120.   }
121.   for (int a =0; a < rows-3; a++) {
122.     for (int b=0; b < cols-3; b++) {
123.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
124.       if (tCheck == 8 || tCheck == 4)
125.       {
126.         winner = tCheck;
127.         return true;
128.       }
129.     }
130.   }
131.   for (int a=0; a < rows-3; a++) {
132.     for (int b=3; b < cols; b++) {
133.       int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
134.       if (tCheck == 8 || tCheck == 4)
135.       {
136.         winner = tCheck;
137.         return true;
138.       }
139.     }
140.   }
141.   return false;
142. }
143. // -------------------------------------------------------------
144. void update(int x, int y)
145. {
146.   if (mousePressed && gameOn) {
147.     for (int c = 0; c<cols; c++) {
148.       for (int d = 0; d<rows; d++) {
149.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
150.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
151.             grid[c][d].setHighlight();
152.             count++;
153.             if (count % 2 == 0) {
154.               grid[c][d].setColor(color(255, 0, 0));
155.               gridChecker[c][d] = 1;
156.             }
157.             else {
158.               grid[c][d].setColor(color(0));
159.               gridChecker[c][d] = 2;
160.             }
161.           }
162.         }
163.       }
164.     }
165.   }
166.   if (locked == false && gameOn) {
167.     for (int c = 0; c<cols; c++) {
168.       for (int d = 0; d<rows; d++) {
169.         //grid[c][d].canHighlight();
170.         grid[c][d].update();
171.       }
172.     }
173.   }
174.   else {
175.     locked = false;
176.   }
177. }
178. // -------------------------------------------------------------
179. void updateHumanMoveForHumanVersusPC(int x, int y)
180. {
181.   if (mousePressed && gameOn) {
182.     for (int c = 0; c<cols; c++) {
183.       for (int d = 0; d<rows; d++) {
184.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
185.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
186.             grid[c][d].setHighlight();
187.             count++;
188.             grid[c][d].setColor(color(255, 0, 0));
189.             gridChecker[c][d] = 1;
190.             humanMustMakeHisMove = !humanMustMakeHisMove;
191.           }
192.         }
193.       }
194.     }
195.   }
196.   if (locked == false && gameOn) {
197.     for (int c = 0; c<cols; c++) {
198.       for (int d = 0; d<rows; d++) {
199.         //grid[c][d].canHighlight();
200.         grid[c][d].update();
201.       }
202.     }
203.   }
204.   else {
205.     locked = false;
206.   }
207. }
208. // -------------------------------------------------------------
209. void updatePCMoveForHumanVersusPC()
210. {
211.   // PC Move
212.   int c=int(random(cols));
213.   if (gameOn) {
214.     for (int d = 0; d<rows; d++) {
215.       if ( (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
216.         if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
217.           grid[c][d].setHighlight();
218.           count++;
219.           grid[c][d].setColor(color(0));
220.           gridChecker[c][d] = 2;
221.         }
222.       }
223.     }
224.   }
225.   if (locked == false && gameOn) {
226.     for (int c2 = 0; c2<cols; c2++) {
227.       for (int d = 0; d<rows; d++) {
228.         //grid[c][d].canHighlight();
229.         grid[c2][d].update();
230.       }
231.     }
232.   }
233.   else {
234.     locked = false;
235.   }
236.   humanMustMakeHisMove = !humanMustMakeHisMove;
237. }
238. // =======================================================================
239. class CircleButton
240. {
241.   color basecolor;
242.   int x, y;
243.   int size;
244.   color highlightcolor;
245.   color currentcolor;
246.   boolean highlight;
247.   boolean over = false;
248.   boolean pressed = false;
249.   CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
250.   {
251.     x = ix;
252.     y = iy;
253.     size = isize;
254.     highlightcolor = ihighlight;
255.     currentcolor = icolor;
256.     highlight = true;
257.   }
258.   void setHighlight() {
259.     highlight = false;
260.   }
261.   void update()
262.   {
263.     if (over() && highlight == true ) {
264.       currentcolor = highlightcolor;
265.     }
266.     else if (currentcolor == highlightcolor && !over()) {
267.       currentcolor = color(255);
268.     }
269.     else {
270.       currentcolor = currentcolor;
271.     }
272.   }
273.   boolean pressed()
274.   {
275.     if (over) {
276.       locked = true;
277.       return true;
278.     }
279.     else {
280.       locked = false;
281.       return false;
282.     }
283.   }
284.   boolean overCircle(int x, int y, int diameter)
285.   {
286.     float disX = x - mouseX;
287.     float disY = y - mouseY;
288.     if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
289.       return true;
290.     }
291.     else {
292.       return false;
293.     }
294.   }
295.   void setColor(color a) {
296.     currentcolor = a;
297.   }
298.   color getColor() {
299.     return currentcolor;
300.   }
301.   boolean over()
302.   {
303.     if ( overCircle(x, y, size) ) {
304.       over = true;
305.       return true;
306.     }
307.     else {
308.       over = false;
309.       return false;
310.     }
311.   }
312.   void display()
313.   {
314.     smooth();
315.     stroke(currentcolor);
316.     fill(currentcolor);
317.     ellipse(x, y, size, size);
318.   }
319. }
320. //

Later you can write better functions here to let the PC make better moves. That's the hard part.

he's playing random.

To make him wiser make a list of all possible positions he can move to.

Then make a virtual board (internally) to make the move.

• Check here if he won. If so make it.
• Then check if the move hinders the opponent to win. Make it.
• Then check if you can make a fork.
• etc.

wooow beautifull program thanks!!
now I have to create three states:
1) Status menu
2) State Player vs. Player
3) State Player vs. PC

and, depending on the choice, I go to the state fair.
Is correct?

well, states 2 and 3 are already covered by my var humanVersusHuman

it remains

• 1) state menu
• 2) state play

you could later add

• a state for help screen and
• a state for game over, play again

I try to finish the program and then place it on the forum, thanks for now!

Go go go!

hello, a request.
you can make sure that your pc, when they get a chance, win?
That is, if the PC has 3 zeros in a row, instead of putting the 4 random, put it in the right place and win

As I said, make a copy of the board.

I do not know where to make the change

I can not make the menu.
I have divided the two programs (Player vs. player and player vs. computer) how do you control the menu if the user chooses player vs player or player vs pc?

Player vs pc

1.     //
       boolean humanVersusHuman = false;
       boolean humanMustMakeHisMove = true;
       //
       int count = 0;
       int rows = 6;
       int cols = 7;
       int winner = 0;
       CircleButton[][] grid = new CircleButton[cols][rows];
       int[][] gridChecker = new int[cols][rows];
       boolean locked = false;
       boolean gameOn = true;
       void setup()
       {
         smooth();
         for (int a = 0; a<cols; a++) {
           for (int b = 0; b<rows; b++) {
             gridChecker[a][b] = 10;
           }
         }
         int a;
         int b;
         for ( a = 0; a<cols; a++) {
           for (b = 0; b<rows; b++) {
             grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
           }
         }
         color buttoncolor = color(204);
         color highlight = color(153);
         ellipseMode(CENTER);
         size(700, 600);
         background(255, 204, 0);
         stroke(126);
         for ( int c = 1; c <= cols; c++) {
           line( c*(width/cols), 0, c*(width/cols), height);
         }
         for (int c = 1; c<=rows; c++) {
           line(0, c*(height/rows), width, c*(height/rows));
         }
       }
       void draw()
       {
         if (humanVersusHuman) {
           update(mouseX, mouseY);
         }
         else
         {
           if (humanMustMakeHisMove)
             updateHumanMoveForHumanVersusPC(mouseX, mouseY);
           else
             updatePCMoveForHumanVersusPC();
         } // else
         //
         //
         for (int c = 0; c<cols; c++) {
           for (int d = 0; d<rows; d++) {
             grid[c][d].display();
           }
         }
         if (checkWin() == true) {
           gameOn = false;
           PFont font = createFont("ARCARTER-78.vlw", 14);
           textFont(font, 85);
           if (winner == 4) {
             shadowtext("Red Wins!", width/4, height/2, 3);
           }
           else if (winner == 8) {
             shadowtext("Black Wins!", width/3.5, height/2, 3);
           }
           shadowtext("Click to play again", width/5.5, height*.3, 1);
         }
       }
       void shadowtext (String s, float x, float y, int o) {
         fill(100, 100);
         text(s, x+o, y+o);
         fill(58, 12, 247);
         text(s, x, y);
       }
       void mousePressed() {
         if (gameOn == false) {
           gameOn = true;
           setup();
         }
       }
       boolean checkWin()
       {
         int counter;
         //horizontal
         for (int a=0; a < rows; a++) {
           for (int b=0; b < cols-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
             if (tCheck == 8 || tCheck == 4)
             {
               winner = tCheck;
               return true;
             }
           }
         }
         //vertical
         for (int a=0; a < rows-3; a++) {
           for (int b=0; b < cols; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               winner = tCheck;
               return true;
             }
           }
         }
         //diagonals
         for (int a=0; a < rows-3; a++) {
           for (int b=0; b < cols-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               winner = tCheck;
               return true;
             }
           }
         }
         for (int a =0; a < rows-3; a++) {
           for (int b=0; b < cols-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               winner = tCheck;
               return true;
             }
           }
         }
         for (int a=0; a < rows-3; a++) {
           for (int b=3; b < cols; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               winner = tCheck;
               return true;
             }
           }
         }
         return false;
       }
       // -------------------------------------------------------------
       void update(int x, int y)
       {
         if (mousePressed && gameOn) {
           for (int c = 0; c<cols; c++) {
             for (int d = 0; d<rows; d++) {
               if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlight();
                   count++;
                   if (count % 2 == 0) {
                     grid[c][d].setColor(color(255, 0, 0));
                     gridChecker[c][d] = 1;
                   }
                   else {
                     grid[c][d].setColor(color(0));
                     gridChecker[c][d] = 2;
                   }
                 }
               }
             }
           }
         }
         if (locked == false && gameOn) {
           for (int c = 0; c<cols; c++) {
             for (int d = 0; d<rows; d++) {
               //grid[c][d].canHighlight();
               grid[c][d].update();
             }
           }
         }
         else {
           locked = false;
         }
       }
       // -------------------------------------------------------------
       void updateHumanMoveForHumanVersusPC(int x, int y)
       {
         if (mousePressed && gameOn) {
           for (int c = 0; c<cols; c++) {
             for (int d = 0; d<rows; d++) {
               if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlight();
                   count++;
                   grid[c][d].setColor(color(255, 0, 0));
                   gridChecker[c][d] = 1;
                   humanMustMakeHisMove = !humanMustMakeHisMove;
                 }
               }
             }
           }
         }
         if (locked == false && gameOn) {
           for (int c = 0; c<cols; c++) {
             for (int d = 0; d<rows; d++) {
               //grid[c][d].canHighlight();
               grid[c][d].update();
             }
           }
         }
         else {
           locked = false;
         }
       }
       // -------------------------------------------------------------
       void updatePCMoveForHumanVersusPC()
       {
         // PC Move
         int c=int(random(cols));
         if (gameOn) {
           for (int d = 0; d<rows; d++) {
             if ( (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
               if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                 grid[c][d].setHighlight();
                 count++;
                 grid[c][d].setColor(color(0));
                 gridChecker[c][d] = 2;
               }
             }
           }
         }
         if (locked == false && gameOn) {
           for (int c2 = 0; c2<cols; c2++) {
             for (int d = 0; d<rows; d++) {
               //grid[c][d].canHighlight();
               grid[c2][d].update();
             }
           }
         }
         else {
           locked = false;
         }
         humanMustMakeHisMove = !humanMustMakeHisMove;
       }
       // =======================================================================
       class CircleButton
       {
         color basecolor;
         int x, y;
         int size;
         color highlightcolor;
         color currentcolor;
         boolean highlight;
         boolean over = false;
         boolean pressed = false;
         CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
         {
           x = ix;
           y = iy;
           size = isize;
           highlightcolor = ihighlight;
           currentcolor = icolor;
           highlight = true;
         }
         void setHighlight() {
           highlight = false;
         }
         void update()
         {
           if (over() && highlight == true ) {
             currentcolor = highlightcolor;
           }
           else if (currentcolor == highlightcolor && !over()) {
             currentcolor = color(255);
           }
           else {
             currentcolor = currentcolor;
           }
         }
         boolean pressed()
         {
           if (over) {
             locked = true;
             return true;
           }
           else {
             locked = false;
             return false;
           }
         }
         boolean overCircle(int x, int y, int diameter)
         {
           float disX = x - mouseX;
           float disY = y - mouseY;
           if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
             return true;
           }
           else {
             return false;
           }
         }
         void setColor(color a) {
           currentcolor = a;
         }
         color getColor() {
           return currentcolor;
         }
         boolean over()
         {
           if ( overCircle(x, y, size) ) {
             over = true;
             return true;
           }
           else {
             over = false;
             return false;
           }
         }
         void display()
         {
           smooth();
           stroke(currentcolor);
           fill(currentcolor);
           ellipse(x, y, size, size);
         }
       }
       //

I first failed to post my entire code - you see the entire code now below.

but the code that is in the draw of the PC vs player and player vs player where to put it?

also, I seprated the menu at the start from the actual game by using states 

here...

see bold in the code

1. // states: here we decide whether to show menu or to play
   
2. final int stateMenu = 0;
3. final int statePlay = 1;
4. int state = stateMenu;
5. //
6. // flags for the game logic
7. boolean humanVersusHuman; // human versus human OR human versus PC ?
8. boolean humanMustMakeHisMove = true; // whose turn is it ?
9. //
10. //
11. int count = 0;
12. int rows = 6;
13. int cols = 7;
14. int winner = 0;
15. CircleButton[][] grid = new CircleButton[cols][rows];
16. int[][] gridChecker = new int[cols][rows];
17. boolean locked = false;
18. boolean gameOn = true;
19. PFont font;
20. void setup()
21. {
22.   // runs only once
23.   size(700, 600);
24.   background(255, 204, 0);
25.   smooth();
26.   font = createFont("ARCARTER-78.vlw", 14);
27.   smallSetup();
28. }
29. void smallSetup() {
30.   // runs every time a new game is started
31.   for (int a = 0; a<cols; a++) {
32.     for (int b = 0; b<rows; b++) {
33.       gridChecker[a][b] = 10;
34.     }
35.   }
36.   int a;
37.   int b;
38.   for ( a = 0; a<cols; a++) {
39.     for (b = 0; b<rows; b++) {
40.       grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
41.     }
42.   }
43.   color buttoncolor = color(204);
44.   color highlight = color(153);
45.   ellipseMode(CENTER);
46.   stroke(126);
47.   //  for ( int c = 1; c <= cols; c++) {
48.   //    line( c*(width/cols), 0, c*(width/cols), height);
49.   //  }
50.   //  for (int c = 1; c<=rows; c++) {
51.   //    line(0, c*(height/rows), width, c*(height/rows));
52.   //  }
53. } // func
54. void draw()
55. {
56.   switch (state) {
57.   case stateMenu:
58.     showMenu();
59.     break;
60.   case statePlay:
61.     playGame();
62.     break;
63.   default:
64.     println ("Unknown state (in draw) "
65.       + state
66.       + " ++++++++++++++++++++++");
67.     exit();
68.     break;
69.   } // switch
70. } // func
71. // ----------------------------------------------------------------
72. void keyPressed() {
73.   switch (state) {
74.   case stateMenu:
75.     keyPressedForStateMenu();
76.     break;
77.   case statePlay:
78.     // do nothing
79.     break;
80.   default:
81.     println ("Unknown state (in keypressed) "+state+ " ++++++++++++++++++++++");
82.     exit();
83.     break;
84.   } // switch
85. }
86. void keyPressedForStateMenu() {
87.   //
88.   switch(key) {
89.   case '1':
90.     humanVersusHuman = true;
91.     state = statePlay;
92.     break;
93.   case '2':
94.     humanVersusHuman = false;
95.     state = statePlay;
96.     break;
97.   case 'x':
98.   case 'X':
99.     // quit
100.     exit();
101.     break;
102.   default:
103.     // do nothing
104.     break;
105.   }// switch
106.   //
107. } // func
108. // ----------------------------------------------------------------
109. void showMenu() {
110.   background(255, 204, 0);
111.   fill(0);
112.   text("Press 1 for human versus human ", 100, 200);
113.   text("Press 2 for PC versus human ", 100, 220);
114.   text("Press x to quit ", 100, 260);
115. }
116. //
117. void playGame() {
118.   //
119.   background(255, 204, 0);
120.   //
121.   if (humanVersusHuman) {
122.     update(mouseX, mouseY);
123.   }
124.   else
125.   {
126.     if (humanMustMakeHisMove)
127.       updateHumanMoveForHumanVersusPC(mouseX, mouseY);
128.     else
129.       updatePCMoveForHumanVersusPC();
130.   } // else
131.   //
132.   //
133.   for (int c = 0; c<cols; c++) {
134.     for (int d = 0; d<rows; d++) {
135.       grid[c][d].display();
136.     }
137.   }
138.   //
139.   if (checkWin() == true) {
140.     gameOn = false;
141.     textFont(font, 65);
142.     if (winner == 4) {
143.       shadowtext("Red Wins!", width/4, height/2, 3);
144.     }
145.     else if (winner == 8) {
146.       shadowtext("Black Wins!", width/3.5, height/2, 3);
147.     }
148.     shadowtext("Click to play again", width/5.5, height*.3, 1);
149.   } // if
150. } // func
151. 
     
152. void shadowtext (String s, float x, float y, int o) {
153.   fill(100, 100);
154.   text(s, x+o, y+o);
155.   fill(58, 12, 247);
156.   text(s, x, y);
157. }
158. void mousePressed() {
159.   // restart
160.   if (gameOn == false) {
161.     gameOn = true;
162.     smallSetup();
163.   } // if
164. }
165. boolean checkWin()
166. {
167.   int counter;
168.   //
169.   //horizontal
170.   for (int a=0; a < rows; a++) {
171.     for (int b=0; b < cols-3; b++) {
172.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
173.       if (tCheck == 8 || tCheck == 4)
174.       {
175.         winner = tCheck;
176.         return true;
177.       }
178.     }
179.   }
180.   //vertical
181.   for (int a=0; a < rows-3; a++) {
182.     for (int b=0; b < cols; b++) {
183.       int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
184.       if (tCheck == 8 || tCheck == 4)
185.       {
186.         winner = tCheck;
187.         return true;
188.       }
189.     }
190.   }
191.   //diagonals
192.   for (int a=0; a < rows-3; a++) {
193.     for (int b=0; b < cols-3; b++) {
194.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
195.       if (tCheck == 8 || tCheck == 4)
196.       {
197.         winner = tCheck;
198.         return true;
199.       }
200.     }
201.   }
202.   for (int a =0; a < rows-3; a++) {
203.     for (int b=0; b < cols-3; b++) {
204.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
205.       if (tCheck == 8 || tCheck == 4)
206.       {
207.         winner = tCheck;
208.         return true;
209.       }
210.     }
211.   }
212.   for (int a=0; a < rows-3; a++) {
213.     for (int b=3; b < cols; b++) {
214.       int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
215.       if (tCheck == 8 || tCheck == 4)
216.       {
217.         winner = tCheck;
218.         return true;
219.       }
220.     }
221.   }
222.   return false;
223. }
224. // -------------------------------------------------------------
225. void update(int x, int y)
226. {
227.   if (mousePressed && gameOn) {
228.     for (int c = 0; c<cols; c++) {
229.       for (int d = 0; d<rows; d++) {
230.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
231.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
232.             grid[c][d].setHighlight();
233.             count++;
234.             if (count % 2 == 0) {
235.               grid[c][d].setColor(color(255, 0, 0));
236.               gridChecker[c][d] = 1;
237.             }
238.             else {
239.               grid[c][d].setColor(color(0));
240.               gridChecker[c][d] = 2;
241.             }
242.           }
243.         }
244.       }
245.     }
246.   }
247.   if (locked == false && gameOn) {
248.     for (int c = 0; c<cols; c++) {
249.       for (int d = 0; d<rows; d++) {
250.         //grid[c][d].canHighlight();
251.         grid[c][d].update();
252.       }
253.     }
254.   }
255.   else {
256.     locked = false;
257.   }
258. }
259. // -------------------------------------------------------------
260. void updateHumanMoveForHumanVersusPC(int x, int y)
261. {
262.   if (mousePressed && gameOn) {
263.     for (int c = 0; c<cols; c++) {
264.       for (int d = 0; d<rows; d++) {
265.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
266.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
267.             grid[c][d].setHighlight();
268.             count++;
269.             grid[c][d].setColor(color(255, 0, 0));
270.             gridChecker[c][d] = 1;
271.             humanMustMakeHisMove = !humanMustMakeHisMove;
272.           }
273.         }
274.       }
275.     }
276.   }
277.   if (locked == false && gameOn) {
278.     for (int c = 0; c<cols; c++) {
279.       for (int d = 0; d<rows; d++) {
280.         //grid[c][d].canHighlight();
281.         grid[c][d].update();
282.       }
283.     }
284.   }
285.   else {
286.     locked = false;
287.   }
288. }
289. // -------------------------------------------------------------
290. void updatePCMoveForHumanVersusPC()
291. {
292.   // PC Move
293.   int c=int(random(cols));
294.   if (gameOn) {
295.     for (int d = 0; d<rows; d++) {
296.       if ( (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
297.         if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
298.           grid[c][d].setHighlight();
299.           count++;
300.           grid[c][d].setColor(color(0));
301.           gridChecker[c][d] = 2;
302.         }
303.       }
304.     }
305.   }
306.   if (locked == false && gameOn) {
307.     for (int c2 = 0; c2<cols; c2++) {
308.       for (int d = 0; d<rows; d++) {
309.         //grid[c][d].canHighlight();
310.         grid[c2][d].update();
311.       }
312.     }
313.   }
314.   else {
315.     locked = false;
316.   }
317.   humanMustMakeHisMove = !humanMustMakeHisMove;
318. }
319. // =======================================================================
320. class CircleButton
321. {
322.   color basecolor;
323.   int x, y;
324.   int size;
325.   color highlightcolor;
326.   color currentcolor;
327.   boolean highlight;
328.   boolean over = false;
329.   boolean pressed = false;
330.   CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
331.   {
332.     //constructor
333.     x = ix;
334.     y = iy;
335.     size = isize;
336.     highlightcolor = ihighlight;
337.     currentcolor = icolor;
338.     highlight = true;
339.   } //constructor
340.   void setHighlight() {
341.     highlight = false;
342.   }
343.   void update()
344.   {
345.     if (over() && highlight == true ) {
346.       currentcolor = highlightcolor;
347.     }
348.     else if (currentcolor == highlightcolor && !over()) {
349.       currentcolor = color(255);
350.     }
351.     else {
352.       currentcolor = currentcolor;
353.     }
354.   }
355.   boolean pressed()
356.   {
357.     if (over) {
358.       locked = true;
359.       return true;
360.     }
361.     else {
362.       locked = false;
363.       return false;
364.     }
365.   }
366.   boolean overCircle(int x, int y, int diameter)
367.   {
368.     float disX = x - mouseX;
369.     float disY = y - mouseY;
370.     if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
371.       return true;
372.     }
373.     else {
374.       return false;
375.     }
376.   }
377.   void setColor(color a) {
378.     currentcolor = a;
379.   }
380.   color getColor() {
381.     return currentcolor;
382.   }
383.   boolean over()
384.   {
385.     if ( overCircle(x, y, size) ) {
386.       over = true;
387.       return true;
388.     }
389.     else {
390.       over = false;
391.       return false;
392.     }
393.   }
394.   void display()
395.   {
396.     smooth();
397.     stroke(currentcolor);
398.     fill(currentcolor);
399.     ellipse(x, y, size, size);
400.   } // method
401.   //
402. } // class
403. //

wow thanks, I'm not there I was succeeding.
There is a problem though, the game when he has the chance to not win

new version, I corrected a few errors

you are right, the PC move is only random play

he can't see when he can win

I told you how to do this

To make him wiser make a list of all possible positions he can move to.

Then make a virtual board (internally) to make the move.

• Check here if he won. If so make it.
• Then check if the move hinders the opponent to win. Make it.
• Then check if you can make a fork.
• etc.

1. // four in a row .....  http://forum.processing.org/topic/information-about-a-program
2. //
3. // states
4. final int stateMenu = 0;
5. final int statePlay = 1;
6. int state;
7. //
8. // flags for the game logic
9. boolean humanVersusHuman; // human versus human OR human versus PC ?
10. boolean humanMustMakeHisMove = true; // whose turn is it ?
11. //
12. //
13. int count = 0;
14. int rows = 6;
15. int cols = 7;
16. int winner = 0;
17. CircleButton[][] grid = new CircleButton[cols][rows];
18. int[][] gridChecker = new int[cols][rows];
19. boolean locked = false;
20. boolean gameOn = true;
21. PFont font;
22. // ----------------------------------------------------------------------
23. void setup()
24. {
25.   // runs only once
26.   size(700, 600);
27.   smooth();
28.   font = createFont("ARCARTER-78.vlw", 14);
29.   smallSetup();
30. }
31. void smallSetup() {
32.   // runs every time a new game is started
33.   //
34.   state = stateMenu;
35.   //
36.   background(255, 204, 0);
37.   //
38.   for (int a = 0; a<cols; a++) {
39.     for (int b = 0; b<rows; b++) {
40.       gridChecker[a][b] = 10;
41.     }
42.   }
43.   int a;
44.   int b;
45.   for ( a = 0; a<cols; a++) {
46.     for (b = 0; b<rows; b++) {
47.       grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
48.     }
49.   }
50.   color buttoncolor = color(204);
51.   color highlight = color(153);
52.   ellipseMode(CENTER);
53.   println("New game.");
54.   //
55. } // func
56. void draw()
57. {
58.   switch (state) {
59.   case stateMenu:
60.     showMenu();
61.     break;
62.   case statePlay:
63.     playGame();
64.     break;
65.   default:
66.     println ("Unknown state (in draw) "
67.       + state
68.       + " ++++++++++++++++++++++");
69.     exit();
70.     break;
71.   } // switch
72. } // func
73. // ----------------------------------------------------------------
74. void keyPressed() {
75.   switch (state) {
76.   case stateMenu:
77.     keyPressedForStateMenu();
78.     break;
79.   case statePlay:
80.     keyPressedForStatePlay();
81.     break;
82.   default:
83.     println ("Unknown state (in keypressed) "
84.       + state
85.       + " ++++++++++++++++++++++");
86.     exit();
87.     break;
88.   } // switch
89. }
90. void keyPressedForStateMenu() {
91.   //
92.   switch(key) {
93.   case '1':
94.     humanVersusHuman = true;
95.     state = statePlay;
96.     break;
97.   case '2':
98.     humanVersusHuman = false;
99.     state = statePlay;
100.     break;
101.   case 'x':
102.   case 'X':
103.     // quit
104.     exit();
105.     break;
106.   default:
107.     // do nothing
108.     break;
109.   }// switch
110.   //
111. } // func
112. void keyPressedForStatePlay() {
113.   switch(key) {
114.   case 'n':
115.   case 'N':
116.     smallSetup();
117.     break;
118.   default:
119.     // do nothing
120.     break;
121.   } // switch
122.   //
123. } // func
124. // ----------------------------------------------------------------
125. void showMenu() {
126.   background(255, 204, 0);
127.   fill(0);
128.   textSize(32);
129.   shadowtext(" Four in a row ", 150, 100, 3);
130.   textSize(14);
131.   text("Press 1 for human versus human ", 100, 200);
132.   text("Press 2 for PC versus human ", 100, 220);
133.   text("Press x to quit ", 100, 260);
134. }
135. //
136. void playGame() {
137.   //
138.   background(255, 204, 0);
139.   //
140.   if (humanVersusHuman) {
141.     // two humans play
142.     update(mouseX, mouseY);
143.   }
144.   else
145.   {
146.     // human versus PC
147.     // whose move is it?
148.     if (humanMustMakeHisMove) {
149.       // human
150.       updateHumanMoveForHumanVersusPC(mouseX, mouseY);
151.     } // if
152.     else {
153.       // PC
154.       updatePCMoveForHumanVersusPC();
155.     } // else
156.   } // else
157.   //
158.   gameStuff();
159.   //
160. } // func
161. void gameStuff() {
162.   // show board:
163.   // show lines
164.   stroke(126);
165.   for ( int c = 1; c <= cols; c++) {
166.     line( c*(width/cols), 0, c*(width/cols), height);
167.   }
168.   for (int c = 1; c<=rows; c++) {
169.     line(0, c*(height/rows), width, c*(height/rows));
170.   }
171.   //
172.   // show circles
173.   for (int c = 0; c<cols; c++) {
174.     for (int d = 0; d<rows; d++) {
175.       grid[c][d].display();
176.     }
177.   }
178.   //
179.   // show win (if somebody won)
180.   if (checkWin() == true) {
181.     gameOn = false;
182.     textFont(font, 65);
183.     if (winner == 4) {
184.       shadowtext("Red Wins!", width/4, height/2, 3);
185.     }
186.     else if (winner == 8) {
187.       shadowtext("Black Wins!", width/3.5, height/2, 3);
188.     }
189.     shadowtext("Click to play again", width/5.5, height*.3, 1);
190.   } // if
191.   //
192. } // func
193. void shadowtext (String s, float x, float y, int o) {
194.   fill(100, 100);
195.   text(s, x+o, y+o);
196.   fill(58, 12, 247);
197.   text(s, x, y);
198. }
199. void mousePressed() {
200.   // restart
201.   if (gameOn == false) {
202.     gameOn = true;
203.     smallSetup();
204.   } // if
205. }
206. boolean checkWin()
207. {
208.   int counter;
209.   //
210.   //horizontal
211.   for (int a=0; a < rows; a++) {
212.     for (int b=0; b < cols-3; b++) {
213.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
214.       if (tCheck == 8 || tCheck == 4)
215.       {
216.         winner = tCheck;
217.         return true;
218.       }
219.     }
220.   }
221.   //vertical
222.   for (int a=0; a < rows-3; a++) {
223.     for (int b=0; b < cols; b++) {
224.       int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
225.       if (tCheck == 8 || tCheck == 4)
226.       {
227.         winner = tCheck;
228.         return true;
229.       }
230.     }
231.   }
232.   //diagonals
233.   for (int a=0; a < rows-3; a++) {
234.     for (int b=0; b < cols-3; b++) {
235.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
236.       if (tCheck == 8 || tCheck == 4)
237.       {
238.         winner = tCheck;
239.         return true;
240.       }
241.     }
242.   }
243.   for (int a =0; a < rows-3; a++) {
244.     for (int b=0; b < cols-3; b++) {
245.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
246.       if (tCheck == 8 || tCheck == 4)
247.       {
248.         winner = tCheck;
249.         return true;
250.       }
251.     }
252.   }
253.   for (int a=0; a < rows-3; a++) {
254.     for (int b=3; b < cols; b++) {
255.       int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
256.       if (tCheck == 8 || tCheck == 4)
257.       {
258.         winner = tCheck;
259.         return true;
260.       }
261.     }
262.   }
263.   return false;
264. }
265. // -------------------------------------------------------------
266. void update(int x, int y)
267. {
268.   // enter human move for human versus human
269.   if (mousePressed && gameOn) {
270.     for (int c = 0; c<cols; c++) {
271.       for (int d = 0; d<rows; d++) {
272.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
273.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
274.             grid[c][d].setHighlight();
275.             count++;
276.             if (count % 2 == 0) {
277.               grid[c][d].setColor(color(255, 0, 0));
278.               gridChecker[c][d] = 1;
279.             }
280.             else {
281.               grid[c][d].setColor(color(0));
282.               gridChecker[c][d] = 2;
283.             }
284.           }
285.         }
286.       }
287.     }
288.   }
289.   if (locked == false && gameOn) {
290.     for (int c = 0; c<cols; c++) {
291.       for (int d = 0; d<rows; d++) {
292.         grid[c][d].update();
293.       }
294.     }
295.   }
296.   else {
297.     locked = false;
298.   }
299. }
300. // -------------------------------------------------------------
301. void updateHumanMoveForHumanVersusPC(int x, int y)
302. {
303.   // enter human move for human versus PC
304.   if (mousePressed && gameOn) {
305.     for (int c = 0; c<cols; c++) {
306.       for (int d = 0; d<rows; d++) {
307.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
308.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
309.             grid[c][d].setHighlight();
310.             count++;
311.             grid[c][d].setColor(color(255, 0, 0));
312.             gridChecker[c][d] = 1;
313.             humanMustMakeHisMove = !humanMustMakeHisMove;
314.           }
315.         }
316.       }
317.     }
318.   }
319.   if (locked == false && gameOn) {
320.     for (int c = 0; c<cols; c++) {
321.       for (int d = 0; d<rows; d++) {
322.         grid[c][d].update();
323.       }
324.     }
325.   }
326.   else {
327.     locked = false;
328.   }
329. }
330. // -------------------------------------------------------------
331. void updatePCMoveForHumanVersusPC()
332. {
333.   // PC Move for human versus PC
334.   boolean donePC = false;
335.   // try 50 times to find a position
336.   for (int i=0; i<50; i++) {
337.     // choose a position via random
338.     int c=int(random(cols));
339.     if (gameOn) {
340.       for (int d = 0; d<rows; d++) {
341.         if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
342.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
343.             grid[c][d].setHighlight();
344.             count++;
345.             grid[c][d].setColor(color(0));
346.             gridChecker[c][d] = 2;
347.             donePC = true;
348.           }
349.         }
350.       }
351.     } // if
352.     if (donePC)
353.       break;
354.   } // for
355.   //
356.   // in the unlikely case he didn't find any position via random
357.   if (!donePC) 
358.   {
359.     println ("couldn't find PC Move - now try linear. ");
360.     for (int c=0; c<cols; c++) {
361.       if (gameOn) {
362.         for (int d = 0; d<rows; d++) {
363.           if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
364.             if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
365.               grid[c][d].setHighlight();
366.               count++;
367.               grid[c][d].setColor(color(0));
368.               gridChecker[c][d] = 2;
369.               donePC = true;
370.             }
371.           }
372.         }
373.       } // if
374.       if (donePC)
375.         break;
376.     } // for
377.   } // if
378.   //
379.   // in the very unlikely case he didn't find any position at all
380.   if (!donePC)
381.     println ("couldn't find PC Move. ");
382.   //
383.   if (locked == false && gameOn) {
384.     for (int c2 = 0; c2<cols; c2++) {
385.       for (int d = 0; d<rows; d++) {
386.         grid[c2][d].update();
387.       }
388.     }
389.   }
390.   else {
391.     locked = false;
392.   }
393.   humanMustMakeHisMove = !humanMustMakeHisMove;
394. }
395. // =======================================================================
396. class CircleButton
397. {
398.   // class for the cells in the grid
399.   color basecolor;
400.   int x, y;
401.   int size;
402.   color highlightcolor;
403.   color currentcolor;
404.   boolean highlight;
405.   boolean over = false;
406.   boolean pressed = false;
407.   CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
408.   {
409.     //constructor
410.     x = ix;
411.     y = iy;
412.     size = isize;
413.     highlightcolor = ihighlight;
414.     currentcolor = icolor;
415.     highlight = true;
416.   } //constructor
417.   void setHighlight() {
418.     highlight = false;
419.   }
420.   void update()
421.   {
422.     if (over() && highlight) {
423.       currentcolor = highlightcolor;
424.     }
425.     else if (currentcolor == highlightcolor && !over()) {
426.       currentcolor = color(255);
427.     }
428.     else {
429.       // currentcolor = currentcolor;
430.     }
431.   }
432.   boolean pressed()
433.   {
434.     if (over) {
435.       locked = true;
436.       return true;
437.     }
438.     else {
439.       locked = false;
440.       return false;
441.     }
442.   }
443.   boolean overCircle(int x, int y, int diameter)
444.   {
445.     float disX = x - mouseX;
446.     float disY = y - mouseY;
447.     if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
448.       return true;
449.     }
450.     else {
451.       return false;
452.     }
453.   }
454.   void setColor(color a) {
455.     currentcolor = a;
456.   }
457.   color getColor() {
458.     return currentcolor;
459.   }
460.   boolean over()
461.   {
462.     if ( overCircle(x, y, size) ) {
463.       over = true;
464.       return true;
465.     }
466.     else {
467.       over = false;
468.       return false;
469.     }
470.   }
471.   void display()
472.   {
473.     smooth();
474.     stroke(currentcolor);
475.     fill(currentcolor);
476.     ellipse(x, y, size, size);
477.   } // method
478.   //
479. } // class
480. //

thank you, now I look if I can make the change

hello,

in the meantime I made this:

• PC can now see when he can win
• PC can see when human (opponent) can win and blocks that win

It was fairly easy:

1. PC tries all possible moves (use a for-loop) on the normal board and checks for each move if PC wins (with the normal win-function of the program); if he wins, just move on (outside the for-loop) and keep the move you've made; if he does not win, take the move back (for-loop continues).
2. When no move has been made, check whether the human can win in a similar way and block that move
   
3. When no move has been made, just make a normal random move

This provides a kind of pipeline with priorities:

• What comes first has the highest priority.
• When he can't find something, make a random move.

Maybe after step 2 I will insert a function :

• "try to make 3 in a row with two free cells" or
• "try to make 3 in a row"
• also rows in the middle are better than those more outside
• also try to let him make a fork

Another approach instead of having all those rules would be to use (the crazy complicated) Minimax algorithm
http://en.wikipedia.org/wiki/Minimax#Minimax_algorithm_with_alternate_moves
or (closely related)
Alpha–beta pruning
http://en.wikipedia.org/wiki/Alpha%E2%80%93beta_pruning

Worth reading

http://en.wikipedia.org/wiki/Four-in-a-row


Greetings, Chrisir    

hello!
I can not, for two days I try but I can not.
Tomorrow I have to deliver the program and do not know how to do, can you give me a hand Chrisis??

you are in a class?
You didn't tell.
You wanna cheat?

Show your current code.

The code is what you've posted above, and this program I can not, last I succeeded but not this: (
You can help yourself to make sure that the PC when it can win?

the original code wasn't yours.
Then you asked a lot of questions.
Now you come up with my code.

And you want to hand it in in your class? What is your own contribution to the program? How far do you really understand it?

The other programs I have always done alone, this nno I could and yet I still do not understand anything, which is why I wanted to know how was completed.
Missing only the move of the PC when it can win, but I did not succeed.

Anyway, thank you, if you will not help no matter, I thank you too

Never mind.
I am not at home at the moment, but
I can post the code tonight (European time).

this is how I did it.

weakness: He doesn't see when the board is full (when it's a draw).

1. // four in a row
2. //
3. // this version: not only random, but also a function updatePCMoveForHumanVersusPC_WinFinder()
4. // that finds a win.
5. //
6. //
7. // states
8. final int stateMenu = 0;
9. final int statePlay = 1;
10. int state;
11. //
12. // flags for the game logic
13. boolean humanVersusHuman; // human versus human OR human versus PC ?
14. boolean humanMustMakeHisMove = true; // whose turn is it ?
15. boolean PC_AI_is_Random = false;     // set this false to use win finder
16. //
17. //
18. int count = 0; // moves count for human versus human mainly 
19. final int rows = 6;
20. final int cols = 7;
21. // who won?
22. int winner = 0;
23. // the board
24. CircleButton[][] grid = new CircleButton[cols][rows];
25. int[][] gridChecker = new int[cols][rows];
26. // smaller vars
27. boolean locked = false; 
28. boolean gameOn = true;   // gets false when somebody wins
29. PFont font;
30. // ----------------------------------------------------------------------
31. void setup()
32. {
33.   // runs only once
34.   //
35.   size(700, 600);
36.   smooth();
37.   font = createFont("ARCARTER-78.vlw", 14);
38.   smallSetup();
39. }
40. void smallSetup() {
41.   // runs every time a new game is started
42.   //
43.   state = stateMenu;
44.   //
45.   background(255, 204, 0);
46.   //
47.   for (int a = 0; a<cols; a++) {
48.     for (int b = 0; b<rows; b++) {
49.       gridChecker[a][b] = 10;
50.     }
51.   }
52.   int a;
53.   int b;
54.   for ( a = 0; a<cols; a++) {
55.     for (b = 0; b<rows; b++) {
56.       grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
57.     }
58.   }
59.   color buttoncolor = color(204);
60.   color highlight = color(153);
61.   ellipseMode(CENTER);
62.   println("New game.");
63.   count = 0;
64.   winner = 0;
65.   gameOn = true;
66.   locked = false;
67.   //
68. } // func
69. void draw()
70. {
71.   // the main routine. It handles the states.
72.   switch (state) {
73.   case stateMenu:
74.     showMenu();
75.     break;
76.   case statePlay:
77.     playGame();
78.     break;
79.   default:
80.     println ("Unknown state (in draw) "
81.       + state
82.       + " ++++++++++++++++++++++");
83.     exit();
84.     break;
85.   } // switch
86. } // func
87. // ----------------------------------------------------------------
88. void keyPressed() {
89.   // keyboard. Also different depending on the state.
90.   switch (state) {
91.   case stateMenu:
92.     keyPressedForStateMenu();
93.     break;
94.   case statePlay:
95.     keyPressedForStatePlay();
96.     break;
97.   default:
98.     println ("Unknown state (in keypressed) "
99.       + state
100.       + " ++++++++++++++++++++++");
101.     exit();
102.     break;
103.   } // switch
104. }
105. void keyPressedForStateMenu() {
106.   //
107.   switch(key) {
108.   case '1':
109.     humanVersusHuman = true;
110.     state = statePlay;
111.     break;
112.   case '2':
113.     humanVersusHuman = false;
114.     state = statePlay;
115.     break;
116.   case 'x':
117.   case 'X':
118.     // quit
119.     exit();
120.     break;
121.   default:
122.     // do nothing
123.     break;
124.   }// switch
125.   //
126. } // func
127. void keyPressedForStatePlay() {
128.   switch(key) {
129.   case 'n':
130.   case 'N':
131.     smallSetup();
132.     break;
133.   default:
134.     // do nothing
135.     break;
136.   } // switch
137.   //
138. } // func
139. // ----------------------------------------------------------------
140. void mousePressed() {
141.   // mouse input. Also different depending on the state.
142.   // only for restart
143.   switch (state) {
144.   case stateMenu:
145.     // do nothing
146.     break;
147.   case statePlay:
148.     if (gameOn == false) {
149.       gameOn = true;
150.       smallSetup();
151.     } // if
152.     break;
153.   default:
154.     println ("Unknown state (in mousePressed) "
155.       + state
156.       + " ++++++++++++++++++++++");
157.     exit();
158.     break;
159.   } // switch
160. } // func
161. // ----------------------------------------------------------------
162. void showMenu() {
163.   background(255, 204, 0);
164.   fill(0);
165.   textSize(32);
166.   shadowtext(" Four in a row ", 150, 100, 3);
167.   textSize(14);
168.   text("Press 1 for human versus human ", 100, 200);
169.   text("Press 2 for PC versus human ", 100, 220);
170.   text("Press x to quit ", 100, 260);
171. }
172. //
173. void playGame() {
174.   //
175.   background(255, 204, 0);
176.   //
177.   // Is it human versus human OR human versus PC?
178.   if (humanVersusHuman) {
179.     // two humans play
180.     update(mouseX, mouseY);
181.   } // if
182.   else
183.   {
184.     // The mode is human versus PC
185.     // whose move is it?
186.     if (humanMustMakeHisMove) {
187.       // human move
188.       updateHumanMoveForHumanVersusPC(mouseX, mouseY);
189.     } // if
190.     else {
191.       // PC move
192.       if (PC_AI_is_Random)
193.         updatePCMoveForHumanVersusPC_Random();
194.       else
195.         updatePCMoveForHumanVersusPC_WinFinder();
196.     } // else
197.   } // else
198.   //
199.   gameStuff();
200.   //
201. } // func
202. // -------------------------------------------------------------
203. void gameStuff() {
204.   // this function is for minor game stuff.
205.   //
206.   // show board:
207.   // show lines
208.   stroke(126);
209.   for ( int c = 1; c <= cols; c++) {
210.     line( c*(width/cols), 0, c*(width/cols), height);
211.   }
212.   for (int c = 1; c<=rows; c++) {
213.     line(0, c*(height/rows), width, c*(height/rows));
214.   }
215.   //
216.   // show circles
217.   for (int c = 0; c<cols; c++) {
218.     for (int d = 0; d<rows; d++) {
219.       grid[c][d].display();
220.     }
221.   }
222.   //
223.   // show win (if somebody won) :
224.   if (checkWin() == true) {
225.     gameOn = false;
226.     textFont(font, 65);
227.     if (winner == 4) {
228.       shadowtext("Red Wins!", width/4, height/2, 3);
229.     }
230.     else if (winner == 8) {
231.       shadowtext("Black Wins!", width/3.5, height/2, 3);
232.     }
233.     shadowtext("Click to play again", width/5.5, height*.3, 1);
234.   } // if
235.   //
236. } // func
237. void shadowtext (String s, float x, float y, int o) {
238.   fill(100, 100);
239.   text(s, x+o, y+o);
240.   fill(58, 12, 247);
241.   text(s, x, y);
242. }
243. // -------------------------------------------------------------
244. boolean checkWin()
245. {
246.   // did somebody win?
247.   int counter;
248.   //
249.   //horizontal
250.   for (int a=0; a < rows; a++) {
251.     for (int b=0; b < cols-3; b++) {
252.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
253.       if (tCheck == 8 || tCheck == 4)
254.       {
255.         winner = tCheck;
256.         return true;
257.       }
258.     }
259.   }
260.   //vertical
261.   for (int a=0; a < rows-3; a++) {
262.     for (int b=0; b < cols; b++) {
263.       int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
264.       if (tCheck == 8 || tCheck == 4)
265.       {
266.         winner = tCheck;
267.         return true;
268.       }
269.     }
270.   }
271.   //diagonals
272.   for (int a=0; a < rows-3; a++) {
273.     for (int b=0; b < cols-3; b++) {
274.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
275.       if (tCheck == 8 || tCheck == 4)
276.       {
277.         winner = tCheck;
278.         return true;
279.       }
280.     }
281.   }
282.   for (int a =0; a < rows-3; a++) {
283.     for (int b=0; b < cols-3; b++) {
284.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
285.       if (tCheck == 8 || tCheck == 4)
286.       {
287.         winner = tCheck;
288.         return true;
289.       }
290.     }
291.   }
292.   for (int a=0; a < rows-3; a++) {
293.     for (int b=3; b < cols; b++) {
294.       int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
295.       if (tCheck == 8 || tCheck == 4)
296.       {
297.         winner = tCheck;
298.         return true;
299.       }
300.     }
301.   }
302.   return false;
303. }
304. // -------------------------------------------------------------
305. void update(int x, int y)
306. {
307.   // enter human move for human versus human mode
308.   if (mousePressed && gameOn) {
309.     for (int c = 0; c<cols; c++) {
310.       for (int d = 0; d<rows; d++) {
311.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
312.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
313.             grid[c][d].setHighlightOff();
314.             count++;
315.             if (count % 2 == 0) {
316.               grid[c][d].setColor(color(255, 0, 0));
317.               gridChecker[c][d] = 1;
318.             }
319.             else {
320.               grid[c][d].setColor(color(0));
321.               gridChecker[c][d] = 2;
322.             }
323.           }
324.         }
325.       }
326.     }
327.   }
328.   if (locked == false && gameOn) {
329.     for (int c = 0; c<cols; c++) {
330.       for (int d = 0; d<rows; d++) {
331.         grid[c][d].update();
332.       }
333.     }
334.   }
335.   else {
336.     locked = false;
337.   }
338. }
339. // -------------------------------------------------------------
340. void updateHumanMoveForHumanVersusPC(int x, int y)
341. {
342.   // enter human move for human versus PC mode
343.   if (mousePressed && gameOn) {
344.     for (int c = 0; c<cols; c++) {
345.       for (int d = 0; d<rows; d++) {
346.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
347.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
348.             grid[c][d].setHighlightOff();
349.             count++;
350.             grid[c][d].setColor(color(255, 0, 0));
351.             gridChecker[c][d] = 1;
352.             humanMustMakeHisMove = !humanMustMakeHisMove;
353.           }
354.         }
355.       }
356.     }
357.   }
358.   if (locked == false && gameOn) {
359.     for (int c = 0; c<cols; c++) {
360.       for (int d = 0; d<rows; d++) {
361.         grid[c][d].update();
362.       }
363.     }
364.   }
365.   else {
366.     locked = false;
367.   }
368. }
369. // -------------------------------------------------------------
370. void updatePCMoveForHumanVersusPC_Random()
371. {
372.   // PC Move for human versus PC mode - random
373.   boolean donePC = false;
374.   //
375.   if (gameOn) {
376.     // try 50 times to find a position
377.     for (int i=0; i<50; i++) {
378.       // choose a position via random
379.       int c=int(random(cols));
380.       for (int d = 0; d<rows; d++) {
381.         if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
382.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
383.             grid[c][d].setHighlightOff();
384.             count++;
385.             grid[c][d].setColor(color(0));
386.             gridChecker[c][d] = 2;
387.             donePC = true;
388.           }
389.         }
390.       } // for
391.       if (donePC)
392.         break;
393.     } // for
394.     //
395.     // in the unlikely case he didn't find any position via random
396.     // we search from left to right
397.     if (!donePC) 
398.     {
399.       println ("couldn't find PC Move - now try linear. ");
400.       for (int c=0; c<cols; c++) {
401.         for (int d = 0; d<rows; d++) {
402.           if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
403.             if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
404.               grid[c][d].setHighlightOff();
405.               count++;
406.               grid[c][d].setColor(color(0));
407.               gridChecker[c][d] = 2;
408.               donePC = true;
409.             }
410.           }
411.         } // for
412.         if (donePC)
413.           break;
414.       } // for
415.     } // if
416.     //
417.     // in the very unlikely case he didn't find any position at all
418.     if (!donePC)
419.       println ("couldn't find PC Move. ");
420.     //
421.     if (locked == false && gameOn) {
422.       for (int c2 = 0; c2<cols; c2++) {
423.         for (int d = 0; d<rows; d++) {
424.           grid[c2][d].update();
425.         }
426.       }
427.     }
428.     else {
429.       locked = false;
430.     }
431.   }
432.   humanMustMakeHisMove = true;
433. }
434. // -------------------------------------------------------------
435. void updatePCMoveForHumanVersusPC_WinFinder()
436. {
437.   // PC Move for human versus PC mode - win finder
438.   boolean donePC = false;
439.   //
440.   if (gameOn) {
441.     // AI
442.     //
443.     int [] possiblemoves = new int [cols];
444.     // choose a position via going from left to right
445.     // and check if it wins
446.     for (int c=0; c<cols; c++) {
447.       if (!donePC) {
448.         for (int d = 0; d<rows; d++) {
449.           if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
450.             if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
451.               // save
452.               int oldgridChecker = gridChecker[c][d];
453.               // make move
454.               grid[c][d].setHighlightOff();
455.               grid[c][d].setColor(color(0));
456.               gridChecker[c][d] = 2;
457.               // Is it a win?
458.               if (checkWin() == true) {
459.                 if (winner==8) {
460.                   // yes, keep the move
461.                   donePC = true;
462.                   winner = 0;
463.                   count++;
464.                   println ("AI winning move found");
465.                 } // if
466.               } // if
467.               if (!donePC) {
468.                 // No, it's not a win. Take move back.
469.                 // restore
470.                 gridChecker[c][d] = oldgridChecker;
471.                 grid[c][d].highlight=true;
472.                 grid[c][d].setColor(color(255));
473.               }
474.               else
475.                 break;
476.             }
477.           }
478.         } // for
479.         if (donePC)
480.           break;
481.       } // if
482.     } // for
483.     // ------
484.     // when he didn't find a win, just make a random move 
485.     if (!donePC) {
486.       updatePCMoveForHumanVersusPC_Random();
487.     } // if
488.   } // if
489. } // func
490. // =======================================================================
491. class CircleButton
492. {
493.   // class for the cells in the grid
494.   color basecolor;
495.   int x, y;
496.   int size;
497.   color highlightcolor;
498.   color currentcolor;
499.   boolean highlight;
500.   boolean over = false;
501.   boolean pressed = false;
502.   CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
503.   {
504.     //constructor
505.     x = ix;
506.     y = iy;
507.     size = isize;
508.     highlightcolor = ihighlight;
509.     currentcolor = icolor;
510.     highlight = true;
511.   } //constructor
512.   void setHighlightOff() {
513.     highlight = false;
514.   }
515.   void update()
516.   {
517.     if (over() && highlight) {
518.       currentcolor = highlightcolor;
519.     }
520.     else if (currentcolor == highlightcolor && !over()) {
521.       currentcolor = color(255);
522.     }
523.     else {
524.       // currentcolor = currentcolor;
525.     }
526.   }
527.   boolean pressed()
528.   {
529.     if (over) {
530.       locked = true;
531.       return true;
532.     }
533.     else {
534.       locked = false;
535.       return false;
536.     }
537.   }
538.   boolean overCircle(int x, int y, int diameter)
539.   {
540.     float disX = x - mouseX;
541.     float disY = y - mouseY;
542.     if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
543.       return true;
544.     }
545.     else {
546.       return false;
547.     }
548.   }
549.   void setColor(color a) {
550.     currentcolor = a;
551.   }
552.   color getColor() {
553.     return currentcolor;
554.   }
555.   boolean over()
556.   {
557.     if ( overCircle(x, y, size) ) {
558.       over = true;
559.       return true;
560.     }
561.     else {
562.       over = false;
563.       return false;
564.     }
565.   }
566.   void display()
567.   {
568.     smooth();
569.     stroke(currentcolor);
570.     fill(currentcolor);
571.     ellipse(x, y, size, size);
572.   } // method
573.   //
574. } // class
575. //

this is only one small step towards a PC that plays good.
As I said there are lots of other things to think of, e.g. block a win of the opponent, make forks etc.

you're really an angel, I do not know how to thank you

I tried the code but could not place any piece, i mean how can i mark a spot?

@ v.k. :

the original code is not by me (it's from openprocessing, see 1st post in this thread)

you use the mouse but you have to place it on the lowest possible spot in each column to set a piece / coin / circle

that's because in the game because of the gravity the pieces / coins / circles / pegs fall down in each column as far as possible until they hit the lower border or another piece / coin

http://en.wikipedia.org/wiki/Four-in-a-row

@ jyciap11 : Thank you !

thans i get it now duh :P

Great!   

Yep, not hard to beat 

Sure, I liked to see this rudimentary begin of an AI. :)

my own version is more advanced

I bet it won :) Can it beat you?

hello, I have a question.
What does this function?

1.     void keyPressedForStatePlay() {
         switch(key) {
         case 'n':
         case 'N':
           smallSetup();
           break;
         default:
           //
           break;
         } // switch
         //
       } // func
   

you should understand this on your own

Thank's.
I'm editing the code to insert an option which, if pressed 3 shows the rules.
The code is this, but it does not work
Where am I wrong?

1. 
       // stati
       final int statoMenu = 0;
       final int statoGioco = 1;
     final int statoRegole = 2;
       int stato;
       //
       // Bandiera per la logica di gioco
       boolean Player_vs_Player; // Player vs Player oppure Player vs PC ?
       boolean Player_deve_fare_mossa = true; // A chi tocca ?
       boolean PC_Random = false;     // Impostare questa variabile false per trovare chi ha vinto
       //
       //
       int conta = 0; // conteggio mosse per Player vs Player
       final int righe = 6;  // 6 righe
       final int colonne = 7; // 7 colonne
       // Chi ha vinto?
       int vincitore = 0;
       // Griglia,CircleButton è una classe e la griglia è una doppia matrice di tipo CircleButton
       CircleButton[][] grid = new CircleButton[colonne][righe];
     // gridCheck è un array di numeri interi.Le variabili righe e colonne determinano quanto sia grande l'array
       int[][] gridChecker = new int[colonne][righe];
       // piccole variabili
       boolean locked = false;
       boolean gameOn = true;   //Diventa falso quando qualcuno vince
       PFont font;
       // ----------------------------------------------------------------------
       void setup()
       {
         //viene eseguito solo una volta
         //
       //dimensione dello schermo
         size(700, 600);
         smooth(); //richiama quella geometria che arrotonda i bordi
         font = createFont("ARCARTER-78.vlw", 14);//font "carino"
         smallSetup();//chiama
       }
       void smallSetup() {
         //
       //Questa funzione viene eseguita ogni volta che un nuovo gioco viene avviato
         //
         stato = statoMenu;
         //
         background(255, 204, 0);
         //
         for (int a = 0; a<colonne; a++) {
           for (int b = 0; b<righe; b++) {
             gridChecker[a][b] = 10;
           }
         }
         int a;
         int b;
         for ( a = 0; a<colonne; a++) {
           for (b = 0; b<righe; b++) {
             grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
           }
         }
         color buttoncolor = color(204);
         color highlight = color(153);
         ellipseMode(CENTER);
         println("New game.");
         conta = 0;
         vincitore = 0;
         gameOn = true;
         locked = false;
         //
       } //
       void draw()
       {
         // Questa è la routine princiapale,cioè quella che gestisce gli stati
         switch (stato) {
         case statoMenu: //caso Menù
           showMenu();
           break;
         case statoGioco: //caso Stato gioco
           playGame();
           break;
       case statoRegole: //caso Stato regole
       showRegole();
         default: //stato di default
           println ("Stato sconosciuto ! "
             + stato
             + " ++++++++++++++++++++++");
           exit();
           break;
         } //
       } //
       // ----------------------------------------------------------------
       void keyPressed() {
         // tastiera,differente a seconda dello stato
         switch (stato) {
         case statoMenu:
           keyPressedPerstatoMenu();
           break;
         case statoGioco:
           keyPressedPerstatoGioco();
           break;
       case statoRegole:
       keyPressedPerstatoRegole();
       break;
         default: //stato di default
           println ("Stato sconosciuto ! "
             + stato
             + " ++++++++++++++++++++++");
           exit();
           break;
         } //
       } //
     //
     void keyPressedPerstatoRegole() {
       switch(key){
         case 'x':
         case 'X':
           exit();
         break;
       }
     }
     //
       void keyPressedPerstatoMenu() {
         // funzione che si occupa di gestire il tasto premuto
         switch(key) {
         case '1': //nel caso primo uno
           Player_vs_Player = true; //Player vs Player = true,ovvero ho scelto Player vs Player
           stato = statoGioco;
           break;
         case '2': //nel caso premo due
           Player_vs_Player = false; //Player vs Player = false,ovvero non ho scelto Player vs Player
           stato = statoGioco;
           break;
       case '3':
       stato = statoRegole;
       break;
         case 'x':
         case 'X':
           // se premo x oppure X esci
           exit();
           break;
         default:
           // non fare niente
           break;
         }//
         //
       } //
       void keyPressedPerstatoGioco() {
         switch(key) {
         case 'n':
         case 'N':
           smallSetup();
           break;
         default:
           // non fare niente
           break;
         } //
         //
       } //
       // ----------------------------------------------------------------
       void mousePressed() {
         // Input mouse.Differente a seconda dello stato
         // Solo per riavviare
         switch (stato) {
         case statoMenu:
           // fai niente
           break;
         case statoGioco:
           if (gameOn == false) { //qualcuno ha vinto
             gameOn = true;
             smallSetup();
           } //
           break;
         default:
           println ("Stato sconosciuto ! "
             + stato
             + " ++++++++++++++++++++++");
           exit();
           break;
         } //
       } //
       // ----------------------------------------------------------------
       void showMenu() {
         background(255, 204, 0);
         fill(0);
         textSize(50);
         shadowtext(" Forza 4 ", 250, 100, 3);
         textSize(20);
         text("Premi 1 per Player vs Player ", 100, 200);
         text("Premi 2 per Player vs PC ", 100, 240);
       text("Premi 3 per le regole ", 100, 280);
         text("Premi x per uscire dal gioco ", 100, 320);
       }
       //
     void showRegole(){
       background(255, 204, 0);
         fill(0);
         textSize(50);
         shadowtext(" Regole ", 250, 100, 3);
     }
     //
       void playGame() {
         //
         background(255, 204, 0);
         //
         // E' Player vs Player oppure Player vs PC ?
         if (Player_vs_Player) {
           // Player vs Player
           update(mouseX, mouseY);
         } //
         else
         {
           // Player vs PC
           // Qual'è la mossa?
           if (Player_deve_fare_mossa) {
             // mossa umana
             updatePlayerMuovePerPlayervsPC(mouseX, mouseY);
           } //
           else {
             // mossa pc
             if (PC_Random)
               updatePCMuovePerPlayervsPC_Random();
             else
               updatePCMuovePerPlayervsPC_TrovaVincitore();
           } //
         } //
         //
         gameStuff();
         //
       } //
       // -------------------------------------------------------------
       void gameStuff() {
         // this function is for minor game stuff.
         //
         // show board:
         // show lines
         stroke(126);
         for ( int c = 1; c <= colonne; c++) {
           line( c*(width/colonne), 0, c*(width/colonne), height);
         }
         for (int c = 1; c<=righe; c++) {
           line(0, c*(height/righe), width, c*(height/righe));
         }
         //
         // show circles
         for (int c = 0; c<colonne; c++) {
           for (int d = 0; d<righe; d++) {
             grid[c][d].display();
           }
         }
         //
         // mostra messaggio di vittoria,nel caso qualcuno vinca
         if (checkWin() == true) {
           gameOn = false;
           textFont(font, 45);
           if (vincitore == 4) {
             shadowtext("ROSSO VINCE!", width/4, height/2, 3);
           }
           else if (vincitore == 8) {
             shadowtext("NERO VINCE!", width/3.5, height/2, 3);
           }
           shadowtext("Clicca per giocare di nuovo", width/5.5, height*.3, 1);
         } // if
         //
       } // func
       void shadowtext (String s, float x, float y, int o) {
         fill(100, 100);
         text(s, x+o, y+o);
         fill(58, 12, 247);
         text(s, x, y);
       }
       // -------------------------------------------------------------
       boolean checkWin()
       {
         // Qualcuno ha vinto?
         int contatore;
         //
         //Orizzontale
         for (int a=0; a < righe; a++) {
           for (int b=0; b < colonne-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         //verticale
         for (int a=0; a < righe-3; a++) {
           for (int b=0; b < colonne; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         //diagonale
         for (int a=0; a < righe-3; a++) {
           for (int b=0; b < colonne-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         for (int a =0; a < righe-3; a++) {
           for (int b=0; b < colonne-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         for (int a=0; a < righe-3; a++) {
           for (int b=3; b < colonne; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         return false;
       }
       // -------------------------------------------------------------
       void update(int x, int y)
       {
         // Inserimento mossa Player per la modalità Player vs Player
         if (mousePressed && gameOn) {
           for (int c = 0; c<colonne; c++) {
             for (int d = 0; d<righe; d++) {
               if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlightOff();
                   conta++;
                   if (conta % 2 == 0) {
                     grid[c][d].setColor(color(255, 0, 0));
                     gridChecker[c][d] = 1;
                   }
                   else {
                     grid[c][d].setColor(color(0));
                     gridChecker[c][d] = 2;
                   }
                 }
               }
             }
           }
         }
         if (locked == false && gameOn) {
           for (int c = 0; c<colonne; c++) {
             for (int d = 0; d<righe; d++) {
               grid[c][d].update();
             }
           }
         }
         else {
           locked = false;
         }
       }
       // -------------------------------------------------------------
       void updatePlayerMuovePerPlayervsPC(int x, int y)
       {
         // Inserimento mossa Player per la modalità Player vs PC
         if (mousePressed && gameOn) {
           for (int c = 0; c<colonne; c++) {
             for (int d = 0; d<righe; d++) {
               if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlightOff();
                   conta++;
                   grid[c][d].setColor(color(255, 0, 0));
                   gridChecker[c][d] = 1;
                   Player_deve_fare_mossa = !Player_deve_fare_mossa;
                 }
               }
             }
           }
         }
         if (locked == false && gameOn) {
           for (int c = 0; c<colonne; c++) {
             for (int d = 0; d<righe; d++) {
               grid[c][d].update();
             }
           }
         }
         else {
           locked = false;
         }
       }
       // -------------------------------------------------------------
       void updatePCMuovePerPlayervsPC_Random()
       {
         // PC Move for human versus PC mode - random
         boolean donePC = false;
         //
         if (gameOn) {
           // prova 50 volte per trovare la posizione
           for (int i=0; i<50; i++) {
             // scegli la posizione random
             int c=int(random(colonne));
             for (int d = 0; d<righe; d++) {
               if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlightOff();
                   conta++;
                   grid[c][d].setColor(color(0));
                   gridChecker[c][d] = 2;
                   donePC = true;
                 }
               }
             }
             if (donePC)
               break;
           }
           //
           // Nel caso (improbabile) che non abbia trovato alcuna posizione in modo casuale
           // cerca da sinistra a destra
           if (!donePC)
           {
             println ("Non è possibile trovare una mossa del PC,ora prova da sinistra a destra ");
             for (int c=0; c<colonne; c++) {
               for (int d = 0; d<righe; d++) {
                 if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
                   if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                     grid[c][d].setHighlightOff();
                     conta++;
                     grid[c][d].setColor(color(0));
                     gridChecker[c][d] = 2;
                     donePC = true;
                   }
                 }
               } //
               if (donePC)
                 break;
             } //
           } //
           //
           // Nel caso (molto improbabile) che non abbia trovato NESSUNA posizione
           if (!donePC)
             println ("Non è possibile trovare una mossa del PC ");
           //
           if (locked == false && gameOn) {
             for (int c2 = 0; c2<colonne; c2++) {
               for (int d = 0; d<righe; d++) {
                 grid[c2][d].update();
               }
             }
           }
           else {
             locked = false;
           }
         }
         Player_deve_fare_mossa = true;
       }
       // -------------------------------------------------------------
       void updatePCMuovePerPlayervsPC_TrovaVincitore()
       {
         // Mossa pc per la modalità PC vs Player,per sapere se esiste la mossa vincente per il PC.
       // il PC controlla se può fare una mossa vincente,altrimenti fa una mossa casuale
         boolean donePC = false;
         //
         if (gameOn) {
           //
           //
           int [] mossepossibili = new int [colonne];
           // scegli una posizione che vada da sinistra a destra
           // e cerca se vince
           for (int c=0; c<colonne; c++) {
             if (!donePC) {
               for (int d = 0; d<righe; d++) {
                 if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
                   if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                     // salva
                     int oldgridChecker = gridChecker[c][d];
                     // fare mossa
                     grid[c][d].setHighlightOff();
                     grid[c][d].setColor(color(0));
                     gridChecker[c][d] = 2;
                     // E' una vittoria?
                     if (checkWin() == true) {
                       if (vincitore==8) {
                         // Si,mantieni la mossa
                         donePC = true;
                         vincitore = 0;
                         conta++;
                         println ("AI winning move found");
                       } //
                     } //
                     if (!donePC) {
                       // No,non è una vittoria
             // torna indietro
                       gridChecker[c][d] = oldgridChecker;
                       grid[c][d].highlight=true;
                       grid[c][d].setColor(color(255));
                     }
                     else
                       break;
                   }
                 }
               } //
               if (donePC)
                 break;
             } //
           } //
           //
           // Quando non trova una vittoria,il PC fa una mossa casuale
           if (!donePC) {
             updatePCMuovePerPlayervsPC_Random();
           } //
         } //
       } //
       // =======================================================================
       class CircleButton
       {
         // Classe per le celle della griglia
         color basecolor;
         int x, y;
         int size;
         color highlightcolor;
         color currentcolor;
         boolean highlight;
         boolean over = false;
         boolean pressed = false;
         CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
         {
           //
           x = ix;
           y = iy;
           size = isize;
           highlightcolor = ihighlight;
           currentcolor = icolor;
           highlight = true;
         } //
         void setHighlightOff() {
           highlight = false;
         }
         void update()
         {
           if (over() && highlight) {
             currentcolor = highlightcolor;
           }
           else if (currentcolor == highlightcolor && !over()) {
             currentcolor = color(255);
           }
           else {
             // currentcolor = currentcolor;
           }
         }
         boolean pressed()
         {
           if (over) {
             locked = true;
             return true;
           }
           else {
             locked = false;
             return false;
           }
         }
         boolean overCircle(int x, int y, int diameter)
         {
           float disX = x - mouseX;
           float disY = y - mouseY;
           if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
             return true;
           }
           else {
             return false;
           }
         }
         void setColor(color a) {
           currentcolor = a;
         }
         color getColor() {
           return currentcolor;
         }
         boolean over()
         {
           if ( overCircle(x, y, size) ) {
             over = true;
             return true;
           }
           else {
             over = false;
             return false;
           }
         }
         void display()
         {
           smooth();
           stroke(currentcolor);
           fill(currentcolor);
           ellipse(x, y, size, size);
         } //
         //
       } //
       //
   

Solved!
I did so

1. 
       // stati
       final int statoMenu = 0;
       final int statoGioco = 1;
       final int statoRegole = 2;
       int stato;
       //
       // Bandiera per la logica di gioco
       boolean Player_vs_Player; // Player vs Player oppure Player vs PC ?
       boolean Player_deve_fare_mossa = true; // A chi tocca ?
       boolean PC_Random = false;     // Impostare questa variabile false per trovare chi ha vinto
       //
       //
       int conta = 0; // conteggio mosse per Player vs Player
       final int righe = 6;    // 6 righe
       final int colonne = 7; // 7 colonne
       // Chi ha vinto?
       int vincitore = 0;
       // Griglia,CircleButton è una classe e la griglia è una doppia matrice di tipo CircleButton
       CircleButton[][] grid = new CircleButton[colonne][righe];
       // gridCheck è un array di numeri interi.Le variabili righe e colonne determinano quanto sia grande l'array
       int[][] gridChecker = new int[colonne][righe];
       // piccole variabili
       boolean locked = false;
       boolean gameOn = true;   //Diventa falso quando qualcuno vince
       PFont font;
       // ----------------------------------------------------------------------
       void setup()
       {
         //viene eseguito solo una volta
         //
         //dimensione dello schermo
         size(700, 600);
         smooth(); //richiama quella geometria che arrotonda i bordi
         font = createFont("ARCARTER-78.vlw", 14);//font "carino"
         smallSetup();//chiama
       }
       void smallSetup() {
         //
         //Questa funzione viene eseguita ogni volta che un nuovo gioco viene avviato
         //
         stato = statoMenu;
         //
         background(255, 204, 0);
         //
         for (int a = 0; a<colonne; a++) {
           for (int b = 0; b<righe; b++) {
             gridChecker[a][b] = 10;
           }
         }
         int a;
         int b;
         for ( a = 0; a<colonne; a++) {
           for (b = 0; b<righe; b++) {
             grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
           }
         }
         color buttoncolor = color(204);
         color highlight = color(153);
         ellipseMode(CENTER);
         println("New game.");
         conta = 0;
         vincitore = 0;
         gameOn = true;
         locked = false;
         //
       } //
       void draw()
       {
         // Questa è la routine princiapale,cioè quella che gestisce gli stati
         switch (stato) {
         case statoMenu:     //caso Menù
           showMenu();          //vai a visualizzare il Menù
           break;
         case statoGioco: //caso Stato gioco
           playGame();        //vai alla funzione PlayGame
           break;
         case statoRegole:
           // fai niente
           break;
         default: //stato di default
           println ("Stato sconosciuto ! "
             + stato
             + " ++++++++++++++++++++++");
           exit();
           break;
         } //
       } //
       // ----------------------------------------------------------------
       void keyPressed() {
         // tastiera,differente a seconda dello stato
         switch (stato) {
         case statoMenu:
           keyPressedPerstatoMenu();
           break;
         case statoGioco:
           keyPressedPerstatoGioco();
           break;
         case statoRegole:
           keyPressedPerstatoRegole();
           break;
         default: //stato di default
           println ("Stato sconosciuto ! "
             + stato
             + " ++++++++++++++++++++++");
           exit();
           break;
         } //
       } //
       void keyPressedPerstatoRegole(){
         switch(key){
         case 'x':
           stato = statoMenu;
         }
       }
       void keyPressedPerstatoMenu() {
         // funzione che si occupa di gestire il tasto premuto
         switch(key) {
         case '1': //nel caso primo uno
           Player_vs_Player = true; //Player vs Player = true,ovvero ho scelto Player vs Player
           stato = statoGioco;
           break;
         case '2': //nel caso premo due
           Player_vs_Player = false; //Player vs Player = false,ovvero non ho scelto Player vs Player
           stato = statoGioco;
           break;
         case '3':
           background(255, 204, 0);
           fill(0);
           textSize(50);
           shadowtext(" Regole ", 250, 100, 3);
           stato = statoRegole;
           break;
         case 'x':
         case 'X':
           // se premo x oppure X esci
           exit();
           break;
         default:
           // non fare niente
           break;
         }//
         //
       } //
       //viene chiamato da keyPressed quando stato = gioco
       //se si preme n durante il gioco (nuovo) si riavvia il programma
       void keyPressedPerstatoGioco() {
         switch(key) {
         case 'n':
         case 'N':
           smallSetup();
           break;
         default:
           // non fare niente
           break;
         } //
         //
       } //
       // ----------------------------------------------------------------
       void mousePressed() {
         // Input mouse.Differente a seconda dello stato
         // Solo per riavviare
         switch (stato) {
         case statoMenu:
           // fai niente
           break;
         case statoGioco:
           if (gameOn == false) { //qualcuno ha vinto
             gameOn = true;
             smallSetup();
           } //
           break;
         default:
           println ("Stato sconosciuto ! "
             + stato
             + " ++++++++++++++++++++++");
           exit();
           break;
         } //
       } //
       // ----------------------------------------------------------------
       void showMenu() {
         background(255, 204, 0);
         fill(0);
         textSize(50);
         shadowtext(" Forza 4 ", 250, 100, 3);
         textSize(20);
         text("Premi 1 per Player vs Player ", 100, 200);
         text("Premi 2 per Player vs PC ", 100, 240);
         text("Premi 3 per Player vs PC ", 100, 280);
         text("Premi x per uscire dal gioco ", 100, 320);
       }
       //
       void playGame() {
         //
         background(255, 204, 0);
         //
         // E' Player vs Player oppure Player vs PC ?
         if (Player_vs_Player) {
           // Player vs Player
           update(mouseX, mouseY);
         } //
         else
         {
           // Player vs PC
           // Qual'è la mossa?
           if (Player_deve_fare_mossa) {
             // mossa umana
             updatePlayerMuovePerPlayervsPC(mouseX, mouseY);
           } //
           else {
             // mossa pc
             if (PC_Random)
               updatePCMuovePerPlayervsPC_Random();
             else
               updatePCMuovePerPlayervsPC_TrovaVincitore();
           } //
         } //
         //
         gameStuff();
         //
       } //
       // -------------------------------------------------------------
       void gameStuff() {
         // this function is for minor game stuff.
         //
         // show board:
         // show lines
         stroke(126);
         for ( int c = 1; c <= colonne; c++) {
           line( c*(width/colonne), 0, c*(width/colonne), height);
         }
         for (int c = 1; c<=righe; c++) {
           line(0, c*(height/righe), width, c*(height/righe));
         }
         //
         // show circles
         for (int c = 0; c<colonne; c++) {
           for (int d = 0; d<righe; d++) {
             grid[c][d].display();
           }
         }
         //
         // mostra messaggio di vittoria,nel caso qualcuno vinca
         if (checkWin() == true) {
           gameOn = false;
           textFont(font, 45);
           if (vincitore == 4) {
             shadowtext("ROSSO VINCE!", width/4, height/2, 3);
           }
           else if (vincitore == 8) {
             shadowtext("NERO VINCE!", width/3.5, height/2, 3);
           }
           shadowtext("Clicca per giocare di nuovo", width/5.5, height*.3, 1);
         } // if
         //
       } // func
       void shadowtext (String s, float x, float y, int o) {
         fill(100, 100);
         text(s, x+o, y+o);
         fill(58, 12, 247);
         text(s, x, y);
       }
       // -------------------------------------------------------------
       boolean checkWin()
       {
         // Qualcuno ha vinto?
         int contatore;
         //
         //Orizzontale
         for (int a=0; a < righe; a++) {
           for (int b=0; b < colonne-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         //verticale
         for (int a=0; a < righe-3; a++) {
           for (int b=0; b < colonne; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         //diagonale
         for (int a=0; a < righe-3; a++) {
           for (int b=0; b < colonne-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         for (int a =0; a < righe-3; a++) {
           for (int b=0; b < colonne-3; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         for (int a=0; a < righe-3; a++) {
           for (int b=3; b < colonne; b++) {
             int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
             if (tCheck == 8 || tCheck == 4)
             {
               vincitore = tCheck;
               return true;
             }
           }
         }
         return false;
       }
       // -------------------------------------------------------------
       void update(int x, int y)
       {
         // Inserimento mossa Player per la modalità Player vs Player
         if (mousePressed && gameOn) {
           for (int c = 0; c<colonne; c++) {
             for (int d = 0; d<righe; d++) {
               if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlightOff();
                   conta++;
                   if (conta % 2 == 0) {
                     grid[c][d].setColor(color(255, 0, 0));
                     gridChecker[c][d] = 1;
                   }
                   else {
                     grid[c][d].setColor(color(0));
                     gridChecker[c][d] = 2;
                   }
                 }
               }
             }
           }
         }
         if (locked == false && gameOn) {
           for (int c = 0; c<colonne; c++) {
             for (int d = 0; d<righe; d++) {
               grid[c][d].update();
             }
           }
         }
         else {
           locked = false;
         }
       }
       // -------------------------------------------------------------
       void updatePlayerMuovePerPlayervsPC(int x, int y)
       {
         // Inserimento mossa Player per la modalità Player vs PC
         if (mousePressed && gameOn) {
           for (int c = 0; c<colonne; c++) {
             for (int d = 0; d<righe; d++) {
               if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlightOff();
                   conta++;
                   grid[c][d].setColor(color(255, 0, 0));
                   gridChecker[c][d] = 1;
                   Player_deve_fare_mossa = !Player_deve_fare_mossa;
                 }
               }
             }
           }
         }
         if (locked == false && gameOn) {
           for (int c = 0; c<colonne; c++) {
             for (int d = 0; d<righe; d++) {
               grid[c][d].update();
             }
           }
         }
         else {
           locked = false;
         }
       }
       // -------------------------------------------------------------
       void updatePCMuovePerPlayervsPC_Random()
       {
         // PC Move for human versus PC mode - random
         boolean donePC = false;
         //
         if (gameOn) {
           // prova 50 volte per trovare la posizione
           for (int i=0; i<50; i++) {
             // scegli la posizione random
             int c=int(random(colonne));
             for (int d = 0; d<righe; d++) {
               if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlightOff();
                   conta++;
                   grid[c][d].setColor(color(0));
                   gridChecker[c][d] = 2;
                   donePC = true;
                 }
               }
             }
             if (donePC)
               break;
           }
           //
           // Nel caso (improbabile) che non abbia trovato alcuna posizione in modo casuale
           // cerca da sinistra a destra
           if (!donePC)
           {
             println ("Non è possibile trovare una mossa del PC,ora prova da sinistra a destra ");
             for (int c=0; c<colonne; c++) {
               for (int d = 0; d<righe; d++) {
                 if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
                   if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                     grid[c][d].setHighlightOff();
                     conta++;
                     grid[c][d].setColor(color(0));
                     gridChecker[c][d] = 2;
                     donePC = true;
                   }
                 }
               } //
               if (donePC)
                 break;
             } //
           } //
           //
           // Nel caso (molto improbabile) che non abbia trovato NESSUNA posizione
           if (!donePC)
             println ("Non è possibile trovare una mossa del PC ");
           //
           if (locked == false && gameOn) {
             for (int c2 = 0; c2<colonne; c2++) {
               for (int d = 0; d<righe; d++) {
                 grid[c2][d].update();
               }
             }
           }
           else {
             locked = false;
           }
         }
         Player_deve_fare_mossa = true;
       }
       // -------------------------------------------------------------
       void updatePCMuovePerPlayervsPC_TrovaVincitore()
       {
         // Mossa pc per la modalità PC vs Player,per sapere se esiste la mossa vincente per il PC.
         // il PC controlla se può fare una mossa vincente,altrimenti fa una mossa casuale
         boolean donePC = false;
         //
         if (gameOn) {
           //
           //
           int [] mossepossibili = new int [colonne];
           // scegli una posizione che vada da sinistra a destra
           // e cerca se vince
           for (int c=0; c<colonne; c++) {
             if (!donePC) {
               for (int d = 0; d<righe; d++) {
                 if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
                   if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                     // salva
                     int oldgridChecker = gridChecker[c][d];
                     // fare mossa
                     grid[c][d].setHighlightOff();
                     grid[c][d].setColor(color(0));
                     gridChecker[c][d] = 2;
                     // E' una vittoria?
                     if (checkWin() == true) {
                       if (vincitore==8) {
                         // Si,mantieni la mossa
                         donePC = true;
                         vincitore = 0;
                         conta++;
                         println ("AI winning move found");
                       } //
                     } //
                     if (!donePC) {
                       // No,non è una vittoria
                       // torna indietro
                       gridChecker[c][d] = oldgridChecker;
                       grid[c][d].highlight=true;
                       grid[c][d].setColor(color(255));
                     }
                     else
                       break;
                   }
                 }
               } //
               if (donePC)
                 break;
             } //
           } //
           //
           // Quando non trova una vittoria,il PC fa una mossa casuale
           if (!donePC) {
             updatePCMuovePerPlayervsPC_Random();
           } //
         } //
       } //
       // =======================================================================
       class CircleButton
       {
         // Classe per le celle della griglia
         color basecolor;
         int x, y;
         int size;
         color highlightcolor;
         color currentcolor;
         boolean highlight;
         boolean over = false;
         boolean pressed = false;
         CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
         {
           //
           x = ix;
           y = iy;
           size = isize;
           highlightcolor = ihighlight;
           currentcolor = icolor;
           highlight = true;
         } //
         void setHighlightOff() {
           highlight = false;
         }
         void update()
         {
           if (over() && highlight) {
             currentcolor = highlightcolor;
           }
           else if (currentcolor == highlightcolor && !over()) {
             currentcolor = color(255);
           }
           else {
             // currentcolor = currentcolor;
           }
         }
         boolean pressed()
         {
           if (over) {
             locked = true;
             return true;
           }
           else {
             locked = false;
             return false;
           }
         }
         boolean overCircle(int x, int y, int diameter)
         {
           float disX = x - mouseX;
           float disY = y - mouseY;
           if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
             return true;
           }
           else {
             return false;
           }
         }
         void setColor(color a) {
           currentcolor = a;
         }
         color getColor() {
           return currentcolor;
         }
         boolean over()
         {
           if ( overCircle(x, y, size) ) {
             over = true;
             return true;
           }
           else {
             over = false;
             return false;
           }
         }
         void display()
         {
           smooth();
           stroke(currentcolor);
           fill(currentcolor);
           ellipse(x, y, size, size);
         } //
         //
       } //
       //
   

in draw() after showRegole 

good!

there is an error in the menu : pos 3 comes twice!

yes, I saw, I corrected him!

ok...

I like that you read everything and translate it into Italian

I studied all of the code, to understand it, it was really hard!

hello,

this new version comes with a complete help screen.

you reach the help screen when pressing h or H in the menu.

It is programmed with a new state called stateHelp.

This state is present

• in function keyPressedForStateMenu() where h/H can start the state "stateHelp",
• in function draw() calling showHelp() (executing the state),
• in function keyPressed() calling keyPressedForStateHelp() (ending the state) and
• in function mousePressed() doing nothing.

Those spots are marked bold below.

So when you want a new state, these are the steps you have to do in order to make the state work.

Greetings, Chrisir       

1. // four in a row
   
2. //
3. // this version: not only random, but also a function updatePCMoveForHumanVersusPC_WinFinder()
4. // that finds a win.
5. // with help screen.
   
6. //
7. //
8. // states
9. final int stateMenu = 0;
10. final int statePlay = 1;
11. final int stateHelp = 2;
12. int state;
13. //
14. // flags for the game logic
15. boolean humanVersusHuman; // human versus human OR human versus PC ?
16. boolean humanMustMakeHisMove = true; // whose turn is it ?
17. boolean PC_AI_is_Random = false;     // set this false to use win finder
18. //
19. //
20. int count = 0; // moves count for human versus human mainly 
21. final int rows = 6;
22. final int cols = 7;
23. // who won?
24. int winner = 0;
25. // the board
26. CircleButton[][] grid = new CircleButton[cols][rows];
27. int[][] gridChecker = new int[cols][rows];
28. // smaller vars
29. boolean locked = false; 
30. boolean gameOn = true;   // gets false when somebody wins
31. PFont font;
32. // ----------------------------------------------------------------------
33. void setup()
34. {
35.   // runs only once
36.   //
37.   size(700, 600);
38.   smooth();
39.   font = createFont("ARCARTER-78.vlw", 14);
40.   smallSetup();
41. }
42. void smallSetup() {
43.   // runs every time a new game is started
44.   //
45.   state = stateMenu;
46.   //
47.   background(255, 204, 0);
48.   //
49.   for (int a = 0; a<cols; a++) {
50.     for (int b = 0; b<rows; b++) {
51.       gridChecker[a][b] = 10;
52.     }
53.   }
54.   int a;
55.   int b;
56.   for ( a = 0; a<cols; a++) {
57.     for (b = 0; b<rows; b++) {
58.       grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
59.     }
60.   }
61.   color buttoncolor = color(204);
62.   color highlight = color(153);
63.   ellipseMode(CENTER);
64.   println("New game.");
65.   count = 0;
66.   winner = 0;
67.   gameOn = true;
68.   locked = false;
69.   //
70. } // func
71. 
    
72. void draw()
73. {
74.   // the main routine. It handles the states.
75.   switch (state) {
76.   case stateMenu:
77.     showMenu();
78.     break;
79.   case statePlay:
80.     playGame();
81.     break;
82.   case stateHelp:
83.     showHelp();
84.     break;
85.   default:
86.     println ("Unknown state (in draw) "
87.       + state
88.       + " ++++++++++++++++++++++");
89.     exit();
90.     break;
91.   } // switch
92. } // func
93. // ----------------------------------------------------------------
94. void keyPressed() {
95.   // keyboard. Also different depending on the state.
96.   switch (state) {
97.   case stateMenu:
98.     keyPressedForStateMenu();
99.     break;
100.   case statePlay:
101.     keyPressedForStatePlay();
102.     break;
103.   case stateHelp:
104.     keyPressedForStateHelp();
105.     break;
106.   default:
107.     println ("Unknown state (in keypressed) "
108.       + state
109.       + " ++++++++++++++++++++++");
110.     exit();
111.     break;
112.   } // switch
113. }
114. void keyPressedForStateMenu() {
115.   //
116.   switch(key) {
117.   case '1':
118.     humanVersusHuman = true;
119.     state = statePlay;
120.     break;
121.   case '2':
122.     humanVersusHuman = false;
123.     state = statePlay;
124.     break;
125.   case 'H':
126.   case 'h':
127.     state = stateHelp;
128.     break;
129.   case 'x':
130.   case 'X':
131.     // quit
132.     exit();
133.     break;
134.   default:
135.     // do nothing
136.     break;
137.   }// switch
138.   //
139. } // func
140. void keyPressedForStatePlay() {
141.   switch(key) {
142.   case 'n':
143.   case 'N':
144.     smallSetup();
145.     break;
146.   default:
147.     // do nothing
148.     break;
149.   } // switch
150.   //
151. } // func
152. void keyPressedForStateHelp() {
153.   // any key is possible
154.   switch(key) {
155.   default:
156.     state = stateMenu;
157.     break;
158.   } // switch
159.   //
160. } // func
161. // ----------------------------------------------------------------
162. void mousePressed() {
163.   // mouse input. Also different depending on the state.
164.   // only for restart
165.   switch (state) {
166.   case stateMenu:
167.     // do nothing
168.     break;
169.   case statePlay:
170.     if (gameOn == false) {
171.       gameOn = true;
172.       smallSetup();
173.     } // if
174.     break;
175.   case stateHelp:
176.     // do nothing
177.     break;
178.   default:
179.     println ("Unknown state (in mousePressed) "
180.       + state
181.       + " ++++++++++++++++++++++");
182.     exit();
183.     break;
184.   } // switch
185. } // func
186. // ----------------------------------------------------------------
187. void showMenu() {
188.   background(255, 204, 0);
189.   fill(0);
190.   textSize(32);
191.   shadowtext(" Four in a row ", 150, 100, 3);
192.   textSize(14);
193.   text("Press 1 for human versus human ", 100, 200);
194.   text("Press 2 for PC versus human ", 100, 220);
195.   text("Press H for help ", 100, 240);
196.   text("Press x to quit ", 100, 280);
197. }
198. //
199. void showHelp() {
200.   int posY = 100; // y-position for each line of text
201.   //
202.   background(255, 204, 0);
203.   fill(0);
204.   textSize(32);
205.   shadowtext(" Help for Four in a row ", 150, posY, 3);
206.   posY+=100;
207.   textSize(14);
208.   text("You can play against a friend ", 100, posY );
209.   posY+=20;
210.   text("or against the PC.  ", 100, posY );
211.   posY+=20;
212.   text("In the game, press N for a new game.", 100, posY );
213.   posY+=20;
214.   text("To place a piece, click on the lowest empty cell in a column", 100, posY);
215.   posY+=20;
216.   text("with the mouse.", 100, posY);
217.   posY+=20;
218.   text("Your goal is to get four pieces in a row ", 100, posY);
219.   posY+=20;
220.   text("horizontal, vertical or diagonal.", 100, posY);
221.   //
222.   posY+=60;
223.   text("Press any key. ", 100, posY);
224. } // func
     
225. //
226. void playGame() {
227.   //
228.   background(255, 204, 0);
229.   //
230.   // Is it human versus human OR human versus PC?
231.   if (humanVersusHuman) {
232.     // two humans play
233.     update(mouseX, mouseY);
234.   } // if
235.   else
236.   {
237.     // The mode is human versus PC
238.     // whose move is it?
239.     if (humanMustMakeHisMove) {
240.       // human move
241.       updateHumanMoveForHumanVersusPC(mouseX, mouseY);
242.     } // if
243.     else {
244.       // PC move
245.       if (PC_AI_is_Random)
246.         updatePCMoveForHumanVersusPC_Random();
247.       else
248.         updatePCMoveForHumanVersusPC_WinFinder();
249.     } // else
250.   } // else
251.   //
252.   gameStuff();
253.   //
254. } // func
255. // -------------------------------------------------------------
256. void gameStuff() {
257.   // this function is for minor game stuff.
258.   //
259.   // show board:
260.   // show lines
261.   stroke(126);
262.   for ( int c = 1; c <= cols; c++) {
263.     line( c*(width/cols), 0, c*(width/cols), height);
264.   }
265.   for (int c = 1; c<=rows; c++) {
266.     line(0, c*(height/rows), width, c*(height/rows));
267.   }
268.   //
269.   // show circles
270.   for (int c = 0; c<cols; c++) {
271.     for (int d = 0; d<rows; d++) {
272.       grid[c][d].display();
273.     }
274.   }
275.   //
276.   // show win (if somebody won) :
277.   if (checkWin() == true) {
278.     gameOn = false;
279.     textFont(font, 65);
280.     if (winner == 4) {
281.       shadowtext("Red Wins!", width/4, height/2, 3);
282.     }
283.     else if (winner == 8) {
284.       shadowtext("Black Wins!", width/3.5, height/2, 3);
285.     }
286.     shadowtext("Click to play again", width/5.5, height*.3, 1);
287.   } // if
288.   //
289. } // func
290. void shadowtext (String s, float x, float y, int o) {
291.   fill(100, 100);
292.   text(s, x+o, y+o);
293.   fill(58, 12, 247);
294.   text(s, x, y);
295. }
296. // -------------------------------------------------------------
297. boolean checkWin()
298. {
299.   // did somebody win?
300.   int counter;
301.   //
302.   //horizontal
303.   for (int a=0; a < rows; a++) {
304.     for (int b=0; b < cols-3; b++) {
305.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
306.       if (tCheck == 8 || tCheck == 4)
307.       {
308.         winner = tCheck;
309.         return true;
310.       }
311.     }
312.   }
313.   //vertical
314.   for (int a=0; a < rows-3; a++) {
315.     for (int b=0; b < cols; b++) {
316.       int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
317.       if (tCheck == 8 || tCheck == 4)
318.       {
319.         winner = tCheck;
320.         return true;
321.       }
322.     }
323.   }
324.   //diagonals
325.   for (int a=0; a < rows-3; a++) {
326.     for (int b=0; b < cols-3; b++) {
327.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
328.       if (tCheck == 8 || tCheck == 4)
329.       {
330.         winner = tCheck;
331.         return true;
332.       }
333.     }
334.   }
335.   for (int a =0; a < rows-3; a++) {
336.     for (int b=0; b < cols-3; b++) {
337.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
338.       if (tCheck == 8 || tCheck == 4)
339.       {
340.         winner = tCheck;
341.         return true;
342.       }
343.     }
344.   }
345.   for (int a=0; a < rows-3; a++) {
346.     for (int b=3; b < cols; b++) {
347.       int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
348.       if (tCheck == 8 || tCheck == 4)
349.       {
350.         winner = tCheck;
351.         return true;
352.       }
353.     }
354.   }
355.   return false;
356. }
357. // -------------------------------------------------------------
358. void update(int x, int y)
359. {
360.   // enter human move for human versus human mode
361.   if (mousePressed && gameOn) {
362.     for (int c = 0; c<cols; c++) {
363.       for (int d = 0; d<rows; d++) {
364.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
365.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
366.             grid[c][d].setHighlightOff();
367.             count++;
368.             if (count % 2 == 0) {
369.               grid[c][d].setColor(color(255, 0, 0));
370.               gridChecker[c][d] = 1;
371.             }
372.             else {
373.               grid[c][d].setColor(color(0));
374.               gridChecker[c][d] = 2;
375.             }
376.           }
377.         }
378.       }
379.     }
380.   }
381.   if (locked == false && gameOn) {
382.     for (int c = 0; c<cols; c++) {
383.       for (int d = 0; d<rows; d++) {
384.         grid[c][d].update();
385.       }
386.     }
387.   }
388.   else {
389.     locked = false;
390.   }
391. }
392. // -------------------------------------------------------------
393. void updateHumanMoveForHumanVersusPC(int x, int y)
394. {
395.   // enter human move for human versus PC mode
396.   if (mousePressed && gameOn) {
397.     for (int c = 0; c<cols; c++) {
398.       for (int d = 0; d<rows; d++) {
399.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
400.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
401.             grid[c][d].setHighlightOff();
402.             count++;
403.             grid[c][d].setColor(color(255, 0, 0));
404.             gridChecker[c][d] = 1;
405.             humanMustMakeHisMove = !humanMustMakeHisMove;
406.           }
407.         }
408.       }
409.     }
410.   }
411.   if (locked == false && gameOn) {
412.     for (int c = 0; c<cols; c++) {
413.       for (int d = 0; d<rows; d++) {
414.         grid[c][d].update();
415.       }
416.     }
417.   }
418.   else {
419.     locked = false;
420.   }
421. }
422. // -------------------------------------------------------------
423. void updatePCMoveForHumanVersusPC_Random()
424. {
425.   // PC Move for human versus PC mode - random
426.   boolean donePC = false;
427.   //
428.   if (gameOn) {
429.     // try 50 times to find a position
430.     for (int i=0; i<50; i++) {
431.       // choose a position via random
432.       int c=int(random(cols));
433.       for (int d = 0; d<rows; d++) {
434.         if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
435.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
436.             grid[c][d].setHighlightOff();
437.             count++;
438.             grid[c][d].setColor(color(0));
439.             gridChecker[c][d] = 2;
440.             donePC = true;
441.           }
442.         }
443.       } // for
444.       if (donePC)
445.         break;
446.     } // for
447.     //
448.     // in the unlikely case he didn't find any position via random
449.     // we search from left to right
450.     if (!donePC) 
451.     {
452.       println ("couldn't find PC Move - now try linear. ");
453.       for (int c=0; c<cols; c++) {
454.         for (int d = 0; d<rows; d++) {
455.           if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
456.             if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
457.               grid[c][d].setHighlightOff();
458.               count++;
459.               grid[c][d].setColor(color(0));
460.               gridChecker[c][d] = 2;
461.               donePC = true;
462.             }
463.           }
464.         } // for
465.         if (donePC)
466.           break;
467.       } // for
468.     } // if
469.     //
470.     // in the very unlikely case he didn't find any position at all
471.     if (!donePC)
472.       println ("couldn't find PC Move. ");
473.     //
474.     if (locked == false && gameOn) {
475.       for (int c2 = 0; c2<cols; c2++) {
476.         for (int d = 0; d<rows; d++) {
477.           grid[c2][d].update();
478.         }
479.       }
480.     }
481.     else {
482.       locked = false;
483.     }
484.   }
485.   humanMustMakeHisMove = true;
486. }
487. // -------------------------------------------------------------
488. void updatePCMoveForHumanVersusPC_WinFinder()
489. {
490.   // PC Move for human versus PC mode - win finder
491.   boolean donePC = false;
492.   //
493.   if (gameOn) {
494.     // AI
495.     //
496.     int [] possiblemoves = new int [cols];
497.     // choose a position via going from left to right
498.     // and check if it wins
499.     for (int c=0; c<cols; c++) {
500.       if (!donePC) {
501.         for (int d = 0; d<rows; d++) {
502.           if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
503.             if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
504.               // save
505.               int oldgridChecker = gridChecker[c][d];
506.               // make move
507.               grid[c][d].setHighlightOff();
508.               grid[c][d].setColor(color(0));
509.               gridChecker[c][d] = 2;
510.               // Is it a win?
511.               if (checkWin() == true) {
512.                 if (winner==8) {
513.                   // yes, keep the move
514.                   donePC = true;
515.                   winner = 0;
516.                   count++;
517.                   println ("AI winning move found");
518.                 } // if
519.               } // if
520.               if (!donePC) {
521.                 // No, it's not a win. Take move back.
522.                 // restore
523.                 gridChecker[c][d] = oldgridChecker;
524.                 grid[c][d].highlight=true;
525.                 grid[c][d].setColor(color(255));
526.               }
527.               else
528.                 break;
529.             }
530.           }
531.         } // for
532.         if (donePC)
533.           break;
534.       } // if
535.     } // for
536.     // ------
537.     // when he didn't find a win, just make a random move 
538.     if (!donePC) {
539.       updatePCMoveForHumanVersusPC_Random();
540.     } // if
541.   } // if
542. } // func
543. // =======================================================================
544. class CircleButton
545. {
546.   // class for the cells in the grid
547.   color basecolor;
548.   int x, y;
549.   int size;
550.   color highlightcolor;
551.   color currentcolor;
552.   boolean highlight;
553.   boolean over = false;
554.   boolean pressed = false;
555.   CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
556.   {
557.     //constructor
558.     x = ix;
559.     y = iy;
560.     size = isize;
561.     highlightcolor = ihighlight;
562.     currentcolor = icolor;
563.     highlight = true;
564.   } //constructor
565.   void setHighlightOff() {
566.     highlight = false;
567.   }
568.   void update()
569.   {
570.     if (over() && highlight) {
571.       currentcolor = highlightcolor;
572.     }
573.     else if (currentcolor == highlightcolor && !over()) {
574.       currentcolor = color(255);
575.     }
576.     else {
577.       // currentcolor = currentcolor;
578.     }
579.   }
580.   boolean pressed()
581.   {
582.     if (over) {
583.       locked = true;
584.       return true;
585.     }
586.     else {
587.       locked = false;
588.       return false;
589.     }
590.   }
591.   boolean overCircle(int x, int y, int diameter)
592.   {
593.     float disX = x - mouseX;
594.     float disY = y - mouseY;
595.     if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
596.       return true;
597.     }
598.     else {
599.       return false;
600.     }
601.   }
602.   void setColor(color a) {
603.     currentcolor = a;
604.   }
605.   color getColor() {
606.     return currentcolor;
607.   }
608.   boolean over()
609.   {
610.     if ( overCircle(x, y, size) ) {
611.       over = true;
612.       return true;
613.     }
614.     else {
615.       over = false;
616.       return false;
617.     }
618.   }
619.   void display()
620.   {
621.     smooth();
622.     stroke(currentcolor);
623.     fill(currentcolor);
624.     ellipse(x, y, size, size);
625.   } // method
626.   //
627. } // class
628. //

wow thank you

I made the new spots bold now above.

what changes were made?
Why is the program needed to those changes?

Other questions.
Which means "try 50 times to find a position"
why is it done?

1. if (gameOn) {
           // try 50 times to find a position
           for (int i=0; i<50; i++) {
             // choose a position via random
             int c=int(random(cols));
             for (int d = 0; d<rows; d++) {
               if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
                   grid[c][d].setHighlightOff();
                   count++;
                   grid[c][d].setColor(color(0));
                   gridChecker[c][d] = 2;
                   donePC = true;
                 }
               }
             } // for
             if (donePC)
               break;
           } // for
           //
   

normally he is doing a random move, but when column is full, it won't work.

thank you

one last thing, to increase the inteligente computer, PC vs. Player mode, how can I do?

Now it's just too easy to win

Hello,

AI is still very bad.

But this new version can now

• PC detects not only if it can win but also if human can win and blocks this move
• PC plays against PC (fast auto play)
• detect if board is full (it is a draw, nobody wins)

Greetings, Chrisir

1. // four in a row .....  http://forum.processing.org/topic/information-about-a-program
2. //
3. // this version: not only random, but also updatePCMoveForHumanVersusPC_WinFinder()
4. //               PC plays against PC
5. //
6. //
7. // states
8. final int stateMenu = 0;
9. final int statePlay = 1;
10. int state;
11. //
12. // vars for the game logic
13. // human versus human OR human versus PC OR PC vs. PC?
14. final int humanversushuman = 0;
15. final int humanversusPC = 1;
16. final int PCversusPC = 2;
17. int modeWhoVersusWho = humanversushuman; 
18. //
19. // speed For Auto Play (when playing PCversusPC) 
20. int speedForAutoPlay = 92; // can be 1, 92 or 2000 or so
21. //
22. // flags for the game logic
23. boolean humanMustMakeHisMove = true; // whose turn is it ? human / black = true
24. boolean PC_AI_is_Random = false;
25. //
26. //
27. int count = 0; // moves count for human versus human mainly 
28. final int rows = 6;
29. final int cols = 7;
30. // who won?
31. int winner = 0;
32. // the board
33. CircleButton[][] grid = new CircleButton[cols][rows];
34. int[][] gridChecker = new int[cols][rows];
35. // smaller vars
36. boolean locked = false; 
37. boolean gameOn = true;   // gets false when somebody wins
38. PFont font;
39. int timer;
40. int countRed;
41. int countBlack;
42. int countDraw;
43. // ----------------------------------------------------------------------
44. void setup()
45. {
46.   // runs only once
47.   //
48.   size(700, 600);
49.   smooth();
50.   font = createFont("ARCARTER-78.vlw", 14);
51.   smallSetup();
52. }
53. void smallSetup() {
54.   // runs every time a new game is started
55.   //
56.   state = stateMenu;
57.   //
58.   background(255, 204, 0);
59.   //
60.   for (int a = 0; a<cols; a++) {
61.     for (int b = 0; b<rows; b++) {
62.       gridChecker[a][b] = 10;
63.     }
64.   }
65.   int a;
66.   int b;
67.   for ( a = 0; a<cols; a++) {
68.     for (b = 0; b<rows; b++) {
69.       grid[a][b] = new CircleButton(100*a + 50, 100*b + 50, 80, color(255), color(153));
70.     }
71.   }
72.   color buttoncolor = color(204);
73.   color highlight = color(153);
74.   ellipseMode(CENTER);
75.   println("New game.");
76.   count = 0;
77.   timer=millis();
78.   //
79. } // func
80. void draw()
81. {
82.   // the main routine. It handels the states.
83.   switch (state) {
84.   case stateMenu:
85.     showMenu();
86.     break;
87.   case statePlay:
88.     playGame();
89.     break;
90.   default:
91.     println ("Unknown state (in draw) "
92.       + state
93.       + " ++++++++++++++++++++++");
94.     exit();
95.     break;
96.   } // switch
97.   // println (humanMustMakeHisMove);
98. } // func
99. // ----------------------------------------------------------------
100. void keyPressed() {
101.   // keyboard. Also different depending on the state.
102.   switch (state) {
103.   case stateMenu:
104.     keyPressedForStateMenu();
105.     break;
106.   case statePlay:
107.     keyPressedForStatePlay();
108.     break;
109.   default:
110.     println ("Unknown state (in keypressed) "
111.       + state
112.       + " ++++++++++++++++++++++");
113.     exit();
114.     break;
115.   } // switch
116. }
117. void keyPressedForStateMenu() {
118.   //
119.   switch(key) {
120.   case '1':
121.     modeWhoVersusWho = humanversushuman;
122.     state = statePlay;
123.     break;
124.   case '2':
125.     modeWhoVersusWho = humanversusPC;
126.     state = statePlay;
127.     break;
128.   case '3':
129.     modeWhoVersusWho = PCversusPC;
130.     state = statePlay;
131.     break;
132.   case 'x':
133.   case 'X':
134.     // quit
135.     exit();
136.     break;
137.   default:
138.     // do nothing
139.     break;
140.   }// switch
141.   //
142. } // func
143. void keyPressedForStatePlay() {
144.   switch(key) {
145.   case 'n':
146.   case 'N':
147.     smallSetup();
148.     break;
149.   default:
150.     // do nothing
151.     break;
152.   } // switch
153.   //
154. } // func
155. // ----------------------------------------------------------------
156. void mousePressed() {
157.   // mouse input. Also different depending on the state.
158.   // only for restart
159.   switch (state) {
160.   case stateMenu:
161.     // do nothing
162.     break;
163.   case statePlay:
164.     if (gameOn == false) {
165.       gameOn = true;
166.       smallSetup();
167.     } // if
168.     break;
169.   default:
170.     println ("Unknown state (in keypressed) "
171.       + state
172.       + " ++++++++++++++++++++++");
173.     exit();
174.     break;
175.   } // switch
176. } // func
177. // ----------------------------------------------------------------
178. void showMenu() {
179.   background(255, 204, 0);
180.   fill(0);
181.   textSize(32);
182.   shadowtext(" Four in a row ", 150, 100, 3);
183.   textSize(14);
184.   text("Press 1 for human versus human ", 100, 200);
185.   text("Press 2 for PC versus human ", 100, 220);
186.   text("Press 3 for PC versus PC ", 100, 240); 
187.   text("Press x to quit ", 100, 290);
188. }
189. //
190. void playGame() {
191.   //
192.   background(255, 204, 0);
193.   //
194.   switch (modeWhoVersusWho) {
195.   case humanversushuman:
196.     // two humans play
197.     update(mouseX, mouseY);
198.     break;
199.   case humanversusPC:
200.     // human versus PC
201.     // whose move is it?
202.     if (humanMustMakeHisMove) {
203.       // human
204.       updateHumanMoveForHumanVersusPC(mouseX, mouseY);
205.     } // if
206.     else {
207.       // PC
208.       if (PC_AI_is_Random)
209.         updatePCMoveForHumanVersusPC_Random();
210.       else
211.         updatePCMoveForHumanVersusPC_WinFinder();
212.     } // else
213.     break;
214.   case PCversusPC:
215.     // PC versus PC
216.     if (gameOn)
217.     {
218.       if (timer+speedForAutoPlay < millis())
219.       {
220.         timer=millis();
221.         // ----
222.         if (count % 2 == 0)
223.         {
224.           humanMustMakeHisMove=true; // red
225.           PC_AI_is_Random=false;  // AI
226.           //println(stringFromPlayer(humanMustMakeHisMove) + " has AI: " + !PC_AI_is_Random  + ", "+humanMustMakeHisMove);
227.         } // if
228.         else
229.         {
230.           humanMustMakeHisMove=false; // black
231.           PC_AI_is_Random=true;   // no AI
232.           //println(stringFromPlayer(humanMustMakeHisMove) + " has AI: " + !PC_AI_is_Random + ", "+humanMustMakeHisMove);
233.         } // else
234.         // ---- make move
235.         if (PC_AI_is_Random)
236.           updatePCMoveForHumanVersusPC_Random();
237.         else
238.           updatePCMoveForHumanVersusPC_WinFinder();
239.         //
240.       } // if timer
241.     } // if gameOn
242.     if (!gameOn) {
243.       if (timer+speedForAutoPlay < millis())
244.       {
245.         smallSetup();
246.         // auto play
247.         state            = statePlay;
248.         modeWhoVersusWho = PCversusPC;
249.         gameOn           = true;
250.         timer            = millis();
251.       }
252.     }
253.     break;
254.   default:
255.     // error
256.     break;
257.   } // switch
258.   //
259.   gameStuff();
260.   //
261. } // func
262. // -------------------------------------------------------------
263. void gameStuff() {
264.   // show board:
265.   // show lines
266.   stroke(126);
267.   for ( int c = 1; c <= cols; c++) {
268.     line( c*(width/cols), 0, c*(width/cols), height);
269.   }
270.   for (int c = 1; c<=rows; c++) {
271.     line(0, c*(height/rows), width, c*(height/rows));
272.   }
273.   //
274.   // show circles
275.   for (int c = 0; c<cols; c++) {
276.     for (int d = 0; d<rows; d++) {
277.       grid[c][d].display();
278.     }
279.   }
280.   //
281.   // show score
282.   fill(0);
283.   textSize(10);
284.   text(countRed+":"+countBlack+" and draws: "+countDraw, width-200, 30);
285.   //
286.   // draw
287.   if (checkDraw ()) {
288.     println ("Draw");
289.     countDraw++;
290.     gameOn = false;
291.   }
292.   //
293.   // show win (if somebody won) :
294.   if (checkWin() == true) {
295.     if (gameOn)
296.       timer=millis();
297.     textFont(font, 65);
298.     if (winner == 4) {
299.       shadowtext("Red Wins!", width/4, height/2, 3);
300.       if (gameOn) println ("Red Wins!");
301.       if (gameOn) countRed++;
302.     }
303.     else if (winner == 8) {
304.       shadowtext("Black Wins!", width/3.5, height/2, 3);
305.       if (gameOn) println ("Black Wins!");
306.       if (gameOn) countBlack++;
307.     }
308.     shadowtext("Click to play again", width/5.5, height*.3, 1);
309.     gameOn = false;
310.   } // if
311.   //
312. } // func
313. void shadowtext (String s, float x, float y, int o) {
314.   fill(100, 100);
315.   text(s, x+o, y+o);
316.   fill(58, 12, 247);
317.   text(s, x, y);
318. }
319. // -------------------------------------------------------------
320. boolean checkDraw() {
321.   int test=0;
322.   for (int a=0; a < rows; a++) {
323.     for (int b=0; b < cols; b++) {
324.       if (gridChecker[b][a] == 1 ||  gridChecker[b][a] == 2)
325.         test++;
326.     }
327.   }
328.   return (test>=rows*cols);
329. }
330. boolean checkWin()
331. {
332.   // int counter;
333.   //
334.   //horizontal
335.   for (int a=0; a < rows; a++) {
336.     for (int b=0; b < cols-3; b++) {
337.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a]) + (gridChecker[b+2][a]) + (gridChecker[b+3][a]);
338.       if (tCheck == 8 || tCheck == 4)
339.       {
340.         winner = tCheck;
341.         return true;
342.       }
343.     }
344.   }
345.   //vertical
346.   for (int a=0; a < rows-3; a++) {
347.     for (int b=0; b < cols; b++) {
348.       int tCheck = (gridChecker[b][a]) + (gridChecker[b][a+1]) + (gridChecker[b][a+2]) + (gridChecker[b][a+3]);
349.       if (tCheck == 8 || tCheck == 4)
350.       {
351.         winner = tCheck;
352.         return true;
353.       }
354.     }
355.   }
356.   //diagonals
357.   for (int a=0; a < rows-3; a++) {
358.     for (int b=0; b < cols-3; b++) {
359.       int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
360.       if (tCheck == 8 || tCheck == 4)
361.       {
362.         winner = tCheck;
363.         return true;
364.       }
365.     }
366.   }
367.   //  for (int a =0; a < rows-3; a++) {
368.   //    for (int b=0; b < cols-3; b++) {
369.   //      int tCheck = (gridChecker[b][a]) + (gridChecker[b+1][a+1]) + (gridChecker[b+2][a+2]) + (gridChecker[b+3][a+3]);
370.   //      if (tCheck == 8 || tCheck == 4)
371.   //      {
372.   //        winner = tCheck;
373.   //        println ("test421 ++++++++++++++++++++++++++++++++++++++++++++");
374.   //        exit();
375.   //        return true;
376.   //      }
377.   //    }
378.   //  }
379.   for (int a=0; a < rows-3; a++) {
380.     for (int b=3; b < cols; b++) {
381.       int tCheck = (gridChecker[b][a]) + (gridChecker[b-1][a+1]) + (gridChecker[b-2][a+2]) + (gridChecker[b-3][a+3]);
382.       if (tCheck == 8 || tCheck == 4)
383.       {
384.         winner = tCheck;
385.         return true;
386.       }
387.     }
388.   }
389.   return false;
390. }
391. // -------------------------------------------------------------
392. void update(int x, int y)
393. {
394.   // enter human move for human versus human
395.   if (mousePressed && gameOn) {
396.     for (int c = 0; c<cols; c++) {
397.       for (int d = 0; d<rows; d++) {
398.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
399.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
400.             grid[c][d].setHighlightOff();
401.             count++;
402.             if (count % 2 == 1) {
403.               grid[c][d].setColor(color(255, 0, 0));
404.               gridChecker[c][d] = 1;
405.             }
406.             else {
407.               grid[c][d].setColor(color(0));
408.               gridChecker[c][d] = 2;
409.             }
410.           }
411.         }
412.       }
413.     }
414.   }
415.   if (locked == false && gameOn) {
416.     for (int c = 0; c<cols; c++) {
417.       for (int d = 0; d<rows; d++) {
418.         grid[c][d].update();
419.       }
420.     }
421.   }
422.   else {
423.     locked = false;
424.   }
425. }
426. // -------------------------------------------------------------
427. void updateHumanMoveForHumanVersusPC(int x, int y)
428. {
429.   // enter human move for human versus PC
430.   if (mousePressed && gameOn) {
431.     for (int c = 0; c<cols; c++) {
432.       for (int d = 0; d<rows; d++) {
433.         if (grid[c][d].pressed() && (grid[c][d].getColor() == color(255)|| grid[c][d].getColor() == color(153)) ) {
434.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
435.             grid[c][d].setHighlightOff();
436.             count++;
437.             grid[c][d].setColor(color(255, 0, 0));
438.             gridChecker[c][d] = 1;
439.             humanMustMakeHisMove = !humanMustMakeHisMove;
440.           }
441.         }
442.       }
443.     }
444.   }
445.   if (locked == false && gameOn) {
446.     for (int c = 0; c<cols; c++) {
447.       for (int d = 0; d<rows; d++) {
448.         grid[c][d].update();
449.       }
450.     }
451.   }
452.   else {
453.     locked = false;
454.   }
455. }
456. // -------------------------------------------------------------
457. void updatePCMoveForHumanVersusPC_Random()
458. {
459.   // PC Move for human versus PC - random
460.   boolean donePC = false;
461.   //
462.   if (gameOn) {
463.     // try 50 times to find a position
464.     for (int i=0; i<50; i++) {
465.       // choose a position via random
466.       int c=int(random(cols));
467.       for (int d = 0; d<rows; d++) {
468.         if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
469.           if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
470.             grid[c][d].setHighlightOff();
471.             count++;
472.             grid[c][d].setColor(colorFromPlayer(humanMustMakeHisMove));
473.             gridChecker[c][d] = intFromPlayer(humanMustMakeHisMove);
474.             donePC = true;
475.           }
476.         }
477.       } // for
478.       if (donePC)
479.         break;
480.     } // for
481.     //
482.     // in the unlikely case he didn't find any position via random
483.     if (!donePC) 
484.     {
485.       println ("couldn't find PC Move - now try linear. ");
486.       for (int c=0; c<cols; c++) {
487.         for (int d = 0; d<rows; d++) {
488.           if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
489.             if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
490.               grid[c][d].setHighlightOff();
491.               count++;
492.               grid[c][d].setColor(colorFromPlayer(humanMustMakeHisMove));
493.               gridChecker[c][d] = intFromPlayer(humanMustMakeHisMove);
494.               donePC = true;
495.             }
496.           }
497.         } // for
498.         if (donePC)
499.           break;
500.       } // for
501.     } // if
502.     //
503.     // in the very unlikely case he didn't find any position at all
504.     if (!donePC)
505.       println ("couldn't find PC Move. ");
506.     //
507.     if (locked == false && gameOn) {
508.       for (int c2 = 0; c2<cols; c2++) {
509.         for (int d = 0; d<rows; d++) {
510.           grid[c2][d].update();
511.         }
512.       }
513.     }
514.     else {
515.       locked = false;
516.     }
517.   }
518.   humanMustMakeHisMove = true;
519. }
520. // -------------------------------------------------------------
521. void updatePCMoveForHumanVersusPC_WinFinder()
522. {
523.   // PC Move for human versus PC - win finder 
524.   boolean donePC = false;
525.   //
526.   if (gameOn) {
527.     // AI
528.     //
529.     // choose a position via going from left to right
530.     // simulate move of the PC
531.     for (int c=0; c<cols; c++) {
532.       if (!donePC) {
533.         for (int d = 0; d<rows; d++) {
534.           if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
535.             if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
536.               // save
537.               int oldgridChecker = gridChecker[c][d];
538.               // make move
539.               grid[c][d].setHighlightOff();
540.               grid[c][d].setColor(colorFromPlayer(humanMustMakeHisMove));
541.               gridChecker[c][d] = intFromPlayer(humanMustMakeHisMove);
542.               // win?
543.               if (checkWin() == true) {
544.                 if (winner==winnerFromPlayer(humanMustMakeHisMove)) {
545.                   //
546.                   donePC = true;
547.                   winner = 0;
548.                   count++;
549.                   println ("AI winning move found");
550.                 } // if
551.               } // if
552.               if (!donePC) {
553.                 // restore
554.                 gridChecker[c][d] = oldgridChecker;
555.                 grid[c][d].highlight=true;
556.                 grid[c][d].setColor(color(255)); // white
557.               }
558.               else {
559.                 break;
560.               }
561.             }
562.           }
563.         } // for
564.         if (donePC)
565.           break;
566.       } // if
567.     } // for
568.     // ---
569.     if (!donePC) {
570.       // choose a position via going from left to right
571.       // simulate move of the opponent
572.       for (int c=0; c<cols; c++) {
573.         if (!donePC) {
574.           for (int d = 0; d<rows; d++) {
575.             if (!donePC) {
576.               if ( (grid[c][d].getColor() == color(255) || grid[c][d].getColor() == color(153)) ) {
577.                 if (d == 5 || (gridChecker[c][d + 1] == 1 || gridChecker[c][d+1] == 2)) {
578.                   // save
579.                   int oldgridChecker = gridChecker[c][d];
580.                   // make move
581.                   grid[c][d].setHighlightOff();
582.                   grid[c][d].setColor(colorFromPlayer( !  humanMustMakeHisMove ) );
583.                   gridChecker[c][d] = intFromPlayer( ! humanMustMakeHisMove );   // simulate move of the opponent
584.                   // win?
585.                   if (checkWin() == true) {
586.                     if (winner==winnerFromPlayer( ! humanMustMakeHisMove )) {
587.                       if (!donePC) {
588.                         //
589.                         // this is the move - success
590.                         donePC = true;
591.                         winner = 0;
592.                         count++;
593.                         gridChecker[c][d] = intFromPlayer( humanMustMakeHisMove );  // set move to PC move
594.                         grid[c][d].setColor(colorFromPlayer( humanMustMakeHisMove ));
595.                         println ("AI winning move found for opponent. " + humanMustMakeHisMove);
596.                       } // if
597.                     } // if
598.                   } // if
599.                   if (!donePC) {
600.                     // restore
601.                     gridChecker[c][d] = oldgridChecker;
602.                     grid[c][d].highlight=true;
603.                     grid[c][d].setColor(color(255)); // white
604.                   }
605.                 } // if
606.               } // if
607.             } // if
608.           } // for
609.         } // if
610.       } // for
611.     } // if
612.     // ------
613.     // the last possibility
614.     if (!donePC) {
615.       updatePCMoveForHumanVersusPC_Random();
616.     } // if
617.     humanMustMakeHisMove = true;
618.   } // if
619. } // func
620. // -----------------------------------------------------------------------
621. // minor tools
622. color colorFromPlayer(boolean humanMustMakeHisMove) {
623.   if (humanMustMakeHisMove)
624.     return color(255, 0, 0); // red
625.   else
626.     return color(0, 0, 0); // black
627. }
628. int intFromPlayer(boolean humanMustMakeHisMove) {
629.   if (humanMustMakeHisMove)
630.     return 1; // 1
631.   else
632.     return 2; // 2
633. }
634. String stringFromPlayer(boolean humanMustMakeHisMove) {
635.   if (humanMustMakeHisMove)
636.     return "red"; //  1
637.   else
638.     return "black"; // 2
639. }
640. int winnerFromPlayer(boolean humanMustMakeHisMove) {
641.   if (humanMustMakeHisMove)
642.     return 4; // red
643.   else
644.     return 8; // black
645. }
646. // =======================================================================
647. class CircleButton
648. {
649.   // class for the cells in the grid
650.   color basecolor;
651.   int x, y;
652.   int size;
653.   color highlightcolor;
654.   color currentcolor;
655.   boolean highlight;
656.   boolean over = false;
657.   boolean pressed = false;
658.   CircleButton(int ix, int iy, int isize, color icolor, color ihighlight)
659.   {
660.     //constructor
661.     x = ix;
662.     y = iy;
663.     size = isize;
664.     highlightcolor = ihighlight;
665.     currentcolor = icolor;
666.     highlight = true;
667.   } //constructor
668.   void setHighlightOff() {
669.     highlight = false;
670.   }
671.   void update()
672.   {
673.     if (over() && highlight) {
674.       currentcolor = highlightcolor;
675.     }
676.     else if (currentcolor == highlightcolor && !over()) {
677.       currentcolor = color(255);
678.     }
679.     else {
680.       // currentcolor = currentcolor;
681.     }
682.   }
683.   boolean pressed()
684.   {
685.     if (over) {
686.       locked = true;
687.       return true;
688.     }
689.     else {
690.       locked = false;
691.       return false;
692.     }
693.   }
694.   boolean overCircle(int x, int y, int diameter)
695.   {
696.     float disX = x - mouseX;
697.     float disY = y - mouseY;
698.     if (sqrt(sq(disX) + sq(disY)) < diameter/2 ) {
699.       return true;
700.     }
701.     else {
702.       return false;
703.     }
704.   }
705.   void setColor(color a) {
706.     currentcolor = a;
707.   }
708.   color getColor() {
709.     return currentcolor;
710.   }
711.   boolean over()
712.   {
713.     if ( overCircle(x, y, size) ) {
714.       over = true;
715.       return true;
716.     }
717.     else {
718.       over = false;
719.       return false;
720.     }
721.   }
722.   void display()
723.   {
724.     smooth();
725.     stroke(currentcolor);
726.     fill(currentcolor);
727.     ellipse(x, y, size, size);
728.   } // method
729.   //
730. } // class
731. //