import java.util.Random;
import java.util.Scanner;
/**
* @author DW
*/
public class Connect4AI {
byte[][] myArray = new byte[][]{
{0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 0, 0},};
int nextLocation = -1;
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
Connect4AI connect4AI = new Connect4AI();
if (new Random().nextInt(2) == 0) {
System.out.println("Du bist dran! Mach schon.");
connect4AI.opponent();
}
connect4AI.display();
connect4AI.place(3, (byte) 1);
connect4AI.display();
OUTER:
OUTER_1:
while (true) {
connect4AI.opponent();
connect4AI.display();
int result = connect4AI.result();
switch (result) {
case 1:
System.out.println("AI Wins!");
break OUTER;
case 2:
System.out.println("You Win!");
break OUTER;
case 0:
System.out.println("Draw!");
break OUTER;
default:
break;
}
connect4AI.nextLocation = -1;
connect4AI.minimax(0, 1, Integer.MIN_VALUE, Integer.MAX_VALUE);
connect4AI.place(connect4AI.nextLocation, (byte) 1);
connect4AI.display();
result = connect4AI.result();
switch (result) {
case 1:
System.out.println("AI Wins!");
break OUTER_1;
case 2:
System.out.println("You Win!");
break OUTER_1;
case 0:
System.out.println("Draw!");
break OUTER_1;
default:
break;
}
}
}
boolean isLegal(int column) {
return myArray[0][column] == 0;
}
boolean place(int column, byte player) {
if (!isLegal(column)) {
System.out.println("Illegal move!");
return false;
}
for (int i = 5; i >= 0; --i) {
if (myArray[i][column] == 0) {
myArray[i][column] = player;
return true;
}
}
return false;
}
void undo(int column) {
for (int i = 0; i <= 5; ++i) {
if (myArray[i][column] != 0) {
myArray[i][column] = 0;
break;
}
}
}
void display() {
System.out.println();
for (int i = 0; i <= 5; ++i) {
for (int j = 0; j <= 6; ++j) {
System.out.print(myArray[i][j] + " ");
}
System.out.println();
}
System.out.println();
}
void opponent() {
System.out.println("Your move (1-7): ");
int move = new Scanner(System.in).nextInt();
while (move < 1 || move > 7 || !isLegal(move - 1)) {
System.out.println("Invalid move.\n\nYour move (1-7): ");
move = new Scanner(System.in).nextInt();
}
//Assume 2 is the opponent
place(move - 1, (byte) 2);
}
int result() {
int aiScore = 0, humanScore = 0;
for (int i = 5; i >= 0; --i) {
for (int j = 0; j <= 6; ++j) {
if (myArray[i][j] == 0) {
continue;
}
//Checking cells to the right
if (j <= 3) {
OUTER:
for (int k = 0; k < 4; ++k) {
switch (myArray[i][j + k]) {
case 1:
aiScore++;
break;
case 2:
humanScore++;
break;
default:
break OUTER;
}
}
if (aiScore == 4) {
return 1;
} else if (humanScore == 4) {
return 2;
}
aiScore = 0;
humanScore = 0;
}
//Checking cells up
if (i >= 3) {
OUTER_1:
for (int k = 0; k < 4; ++k) {
switch (myArray[i - k][j]) {
case 1:
aiScore++;
break;
case 2:
humanScore++;
break;
default:
break OUTER_1;
}
}
if (aiScore == 4) {
return 1;
} else if (humanScore == 4) {
return 2;
}
aiScore = 0;
humanScore = 0;
}
//Checking diagonal up-right
if (j <= 3 && i >= 3) {
OUTER_2:
for (int k = 0; k < 4; ++k) {
switch (myArray[i - k][j + k]) {
case 1:
aiScore++;
break;
case 2:
humanScore++;
break;
default:
break OUTER_2;
}
}
if (aiScore == 4) {
return 1;
} else if (humanScore == 4) {
return 2;
}
aiScore = 0;
humanScore = 0;
}
//Checking diagonal up-left
if (j >= 3 && i >= 3) {
OUTER_3:
for (int k = 0; k < 4; ++k) {
switch (myArray[i - k][j - k]) {
case 1:
aiScore++;
break;
case 2:
humanScore++;
break;
default:
break OUTER_3;
}
}
if (aiScore == 4) {
return 1;
} else if (humanScore == 4) {
return 2;
}
aiScore = 0;
humanScore = 0;
}
}
}
for (int j = 0; j < 7; ++j) {
//Game has not ended yet
if (myArray[0][j] == 0) {
return -1;
}
}
//Game draw!
return 0;
}
int calculate(int aiScore, int moreMoves) {
int moveScore = 4 - moreMoves;
switch (aiScore) {
case 0:
return 0;
case 1:
return 1 * moveScore;
case 2:
return 10 * moveScore;
case 3:
return 100 * moveScore;
default:
return 1000;
}
}
int evaluate() {
int aiScore = 1;
int score = 0;
int blanks = 0;
int k, moreMoves;
for (int i = 5; i >= 0; --i) {
for (int j = 0; j <= 6; ++j) {
if (myArray[i][j] == 0 || myArray[i][j] == 2) {
continue;
}
if (j <= 3) {
OUTER:
for (k = 1; k < 4; ++k) {
switch (myArray[i][j + k]) {
case 1:
aiScore++;
break;
case 2:
aiScore = 0;
blanks = 0;
break OUTER;
default:
blanks++;
break;
}
}
moreMoves = 0;
if (blanks > 0) {
for (int c = 1; c < 4; ++c) {
int column = j + c;
for (int m = i; m <= 5; m++) {
if (myArray[m][column] == 0) {
moreMoves++;
} else {
break;
}
}
}
}
if (moreMoves != 0) {
score += calculate(aiScore, moreMoves);
}
aiScore = 1;
blanks = 0;
}
if (i >= 3) {
for (k = 1; k < 4; ++k) {
if (myArray[i - k][j] == 1) {
aiScore++;
} else if (myArray[i - k][j] == 2) {
aiScore = 0;
break;
}
}
moreMoves = 0;
if (aiScore > 0) {
int column = j;
for (int m = i - k + 1; m <= i - 1; m++) {
if (myArray[m][column] == 0) {
moreMoves++;
} else {
break;
}
}
}
if (moreMoves != 0) {
score += calculate(aiScore, moreMoves);
}
aiScore = 1;
blanks = 0;
}
if (j >= 3) {
OUTER_1:
for (k = 1; k < 4; ++k) {
switch (myArray[i][j - k]) {
case 1:
aiScore++;
break;
case 2:
aiScore = 0;
blanks = 0;
break OUTER_1;
default:
blanks++;
break;
}
}
moreMoves = 0;
if (blanks > 0) {
for (int c = 1; c < 4; ++c) {
int column = j - c;
for (int m = i; m <= 5; m++) {
if (myArray[m][column] == 0) {
moreMoves++;
} else {
break;
}
}
}
}
if (moreMoves != 0) {
score += calculate(aiScore, moreMoves);
}
aiScore = 1;
blanks = 0;
}
if (j <= 3 && i >= 3) {
OUTER_2:
for (k = 1; k < 4; ++k) {
switch (myArray[i - k][j + k]) {
case 1:
aiScore++;
break;
case 2:
aiScore = 0;
blanks = 0;
break OUTER_2;
default:
blanks++;
break;
}
}
moreMoves = 0;
if (blanks > 0) {
for (int c = 1; c < 4; ++c) {
int column = j + c, row = i - c;
OUTER_3:
for (int m = row; m <= 5; ++m) {
switch (myArray[m][column]) {
case 0:
moreMoves++;
break;
case 1:
;
break;
default:
break OUTER_3;
}
}
}
if (moreMoves != 0) {
score += calculate(aiScore, moreMoves);
}
aiScore = 1;
blanks = 0;
}
}
if (i >= 3 && j >= 3) {
OUTER_4:
for (k = 1; k < 4; ++k) {
switch (myArray[i - k][j - k]) {
case 1:
aiScore++;
break;
case 2:
aiScore = 0;
blanks = 0;
break OUTER_4;
default:
blanks++;
break;
}
}
moreMoves = 0;
if (blanks > 0) {
for (int c = 1; c < 4; ++c) {
int column = j - c, row = i - c;
OUTER_5:
for (int m = row; m <= 5; ++m) {
switch (myArray[m][column]) {
case 0:
moreMoves++;
break;
case 1:
;
break;
default:
break OUTER_5;
}
}
}
if (moreMoves != 0) {
score += calculate(aiScore, moreMoves);
}
aiScore = 1;
blanks = 0;
}
}
}
}
return score;
}
int minimax(int depth, int turn, int alpha, int beta) {
if (beta <= alpha) {
if (turn == 1) {
return Integer.MAX_VALUE;
} else {
return Integer.MIN_VALUE;
}
}
int gameResult = result();
switch (gameResult) {
case 1:
return Integer.MAX_VALUE / 2;
case 2:
return Integer.MIN_VALUE / 2;
case 0:
return 0;
default:
break;
}
if (depth == 9) {
return evaluate();
}
int maxScore = Integer.MIN_VALUE, minScore = Integer.MAX_VALUE;
for (int j = 0; j <= 6; ++j) {
int currentScore = 0;
if (!isLegal(j)) {
continue;
}
if (turn == 1) {
place(j, (byte) 1);
currentScore = minimax(depth + 1, 2, alpha, beta);
if (depth == 0) {
System.out.println("Score for location " + j + " = " + currentScore);
if (currentScore > maxScore) {
nextLocation = j;
}
if (currentScore == Integer.MAX_VALUE / 2) {
undo(j);
break;
}
}
maxScore = Math.max(currentScore, maxScore);
alpha = Math.max(currentScore, alpha);
} else if (turn == 2) {
place(j, (byte) 2);
currentScore = minimax(depth + 1, 1, alpha, beta);
minScore = Math.min(currentScore, minScore);
beta = Math.min(currentScore, beta);
}
undo(j);
if (currentScore == Integer.MAX_VALUE || currentScore == Integer.MIN_VALUE) {
break;
}
}
return turn == 1 ? maxScore : minScore;
}
}
