Tammet – 1. detsember 2007, kell 08:55

2007-12-01T08:55:36Z

Uus lehekülg

<pre>
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

/**
*
* The program stub for playing Kalah against a computer.
*
* Computer performs only trivial moves: always the first available move.
*
* This program is intended to be used as a basis for building a sensibly playing
* computer opponent: see the end part of the file.
*
* Copyright Tanel Tammet, 2007
* This code is in public domain: do whatever you like with this code.
*
* Uses some UI visual design ideas (colors, button settings) for checkers by D.Eck
*
*/

/* Some assumptions/observations:

The position in a game is stored in an integer array from 0 to 13, with stores being 6 and 13:

12 11 10 9 8 7
13 6
0 1 2 3 4 5

Several options are selected by the human player and then stored in the variables:

int nrInHouse : the initial nr of seeds in houses
lowerSmaller : whether the position array is visualised as above, or vice versa
humanLower : human has the lower array of houses
humanStarts : human starts the game
nextHuman : the next move is done by human, not computer

*/

public class Kalah {

// UI variables

JFrame window;
JPanel mainPanel;
JPanel messagePanel;
Board board;
JPanel buttonPanel;
JButton newGameButton;
JButton resignButton;
JLabel message;
JLabel bmessage1;
JLabel bmessage2;
JLabel bmessage3;
JComboBox nrCombo;
JComboBox humanCombo;
JComboBox rowCombo;
JCheckBox houseNrsBox;

// convenient global variables

int nrInHouse = 0;
boolean lowerSmaller=true;
boolean humanLower=true;
boolean humanStarts=true;

// ongoing game variables

boolean gameInProgress=true;
boolean nextHuman=true;
int[] position;
String compMoveText;
String humanMoveText;
String lastMoveText;

public static void main(String[] args) {

Kalah kalah = new Kalah(); // create an instance of Kalah, just to keep everything non-static
kalah.initGame(); // create position and fill it
kalah.makeUserInterface(); // make user interface components and show out

}

public void initGame() {
int i;

position = new int[14]; // create the position to be filled
for(i=0;i<position.length;i++) position[i]=0; // initially fill position with zeros
}

public void makeUserInterface() {
/* Create the window, then components and add them to the window */

Color bgColor = new Color(0,150,0);

window = new JFrame("Kalah");

mainPanel = new JPanel();
mainPanel.setLayout(new BorderLayout());
mainPanel.setPreferredSize( new Dimension(500,300) );
mainPanel.setBackground(bgColor); // Dark green background.

board = new Board();

buttonPanel = new JPanel();
buttonPanel.setLayout(new FlowLayout());
buttonPanel.setBackground(bgColor);

messagePanel = new JPanel();
messagePanel.setLayout(new FlowLayout());
messagePanel.setBackground(bgColor);

resignButton = new JButton("Resign");
resignButton.addActionListener(board);
newGameButton = new JButton("New");
newGameButton.addActionListener(board);

String[] numberInHouse = { "3", "4", "5", "6" };
nrCombo= new JComboBox(numberInHouse);
String[] humanStart = { "You", "Comp" };
humanCombo= new JComboBox(humanStart);
String[] rowStart = { "Lower", "Upper" };
rowCombo= new JComboBox(rowStart);

bmessage1 = new JLabel("start on",JLabel.CENTER);
bmessage1.setFont(new Font("Serif", Font.BOLD, 12));
bmessage1.setForeground(Color.black);

bmessage2 = new JLabel("row with seeds",JLabel.CENTER);
bmessage2.setFont(new Font("Serif", Font.BOLD, 12));
bmessage2.setForeground(Color.black);

buttonPanel.add(humanCombo);
buttonPanel.add(bmessage1);
buttonPanel.add(rowCombo);
buttonPanel.add(bmessage2);
buttonPanel.add(nrCombo);

buttonPanel.add(newGameButton);
buttonPanel.add(resignButton);

houseNrsBox = new JCheckBox("show nrs");
houseNrsBox.setSelected(false);
houseNrsBox.setBackground(bgColor);
houseNrsBox.addActionListener(board);
messagePanel.add(houseNrsBox);

message = new JLabel(" ",JLabel.CENTER);
message.setFont(new Font("Serif", Font.BOLD, 14));
message.setForeground(Color.green);
message.setBounds(10,160,300,30);
messagePanel.add(message);

mainPanel.add(BorderLayout.CENTER,board);
mainPanel.add(BorderLayout.NORTH,messagePanel);
mainPanel.add(BorderLayout.SOUTH,buttonPanel);

// initialise UI

board.gameOver("Press 'New' to start the game!");

// set window dimensions and properties

window.setContentPane(mainPanel);
window.pack();
Dimension screensize = Toolkit.getDefaultToolkit().getScreenSize();
window.setLocation( (screensize.width - window.getWidth())/2,
(screensize.height - window.getHeight())/2 );
window.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
window.setResizable(false);
window.setVisible(true);
}

/**
*
* This (internal) panel displays a kalah board and handles mouse- and keypresses
*
*/

class Board extends Canvas implements ActionListener, MouseListener {

/**
* Constructor. Basic initialisation.
*/

Board() {
Color bgColor = new Color(0,150,0);
setBackground(bgColor);
addMouseListener(this);
}

/**
* Respond to user's click on one of the two buttons.
*/
public void actionPerformed(ActionEvent evt) {
Object src = evt.getSource();
if (src == newGameButton)
doNewGame();
else if (src == resignButton)
doResign();
else if (src == houseNrsBox)
repaint();
}

/**
* Start a new game
*/
void doNewGame() {
if (gameInProgress == true) {
// This should not be possible, but it doens't hurt to check.
message.setText("Finish the current game first!");
return;
}

message.setText("Make your move.");
gameInProgress = true;

nrInHouse=3+nrCombo.getSelectedIndex();
if (humanCombo.getSelectedIndex()==0) humanStarts=true;
else humanStarts=false;
if (rowCombo.getSelectedIndex()==0) {
humanLower=humanStarts;
} else {
humanLower=!humanStarts;
}

newGameButton.setEnabled(false);
nrCombo.setEnabled(false);
humanCombo.setEnabled(false);
rowCombo.setEnabled(false);
resignButton.setEnabled(true);

lastMoveText=null;

initPosition(nrInHouse);
if (houseNrsBox.isSelected()) System.out.println("------");
if (houseNrsBox.isSelected()) printPosition();

if (humanStarts) {
nextHuman=true;
} else {
nextHuman=false;
doMachineMove();
}
repaint();
}

/*
* Initialise position array to correct nr
*
*/

void initPosition(int n) {
int i;

position[6]=0;
position[13]=0;
for(i=0;i<6;i++) position[i]=n;
for(i=7;i<13;i++) position[i]=n;
}

/**
* Human player resigns. Game ends. Machine wins.
*/

void doResign() {
if (gameInProgress == false) {
message.setText("There is no game in progress!");
return;
}
gameOver("You resign. Computer wins.");
}

/**
* The game ends.
*/

void gameOver(String str) {
message.setText(str);
newGameButton.setEnabled(true);
nrCombo.setEnabled(true);
humanCombo.setEnabled(true);
rowCombo.setEnabled(true);
resignButton.setEnabled(false);
gameInProgress = false;
if (houseNrsBox.isSelected()) printPosition();
if (houseNrsBox.isSelected()) System.out.println(str);
}

/**
* This is called by mousePressed() when a player clicks on the
* house.
*/

void doClickHouse(int n) {

//message.setText("Click the house you want to move from.");
//System.out.println(n);
if (position[n]>0) doHumanMove(n);
else message.setText("You cannot move from the empty house!");
repaint();

}

/**
* This does all the position drawing
*
*/

public void paint(Graphics g) {

int x,n;
Color inside = new Color(255,255,255);
Color bground = new Color(210,210,210);
Color numColor = new Color(20,20,20);
Font numFont = new Font("SansSerif", Font.BOLD, 20);
Font numSmallFont = new Font("SansSerif", Font.BOLD, 16);
Font numMicroFont = new Font("SansSerif", Font.PLAIN, 10);

// create empty board

g.setColor(bground);
g.fillRoundRect(30,50,440,100,10,10);

g.setColor(inside);
g.fillOval(47,75,50,50);
g.fillOval(400,75,50,50);
for(x=117,n=0; n<6; n++, x=x+46) {
g.fillOval(x,59,35,35);
g.fillOval(x,105,35,35);
}

// fill board with numbers, show house nrs if required

g.setColor(numColor);
g.setFont(numFont);
if (lowerSmaller) {
g.drawString(nrToStr(position[13]),62,107);
g.drawString(nrToStr(position[6]),415,107);
for(x=129,n=0; n<6; n++, x=x+46) {
g.setFont(numSmallFont);
g.drawString(nrToStr(position[n]),x,129);
g.setFont(numMicroFont);
if (houseNrsBox.isSelected()) g.drawString(n+"",x,150);
}
for(x=129,n=12; n>6; n--, x=x+46) {
g.setFont(numSmallFont);
g.drawString(nrToStr(position[n]),x,83);
g.setFont(numMicroFont);
if (houseNrsBox.isSelected()) g.drawString(n+"",x,60);
}
} else {
g.drawString(nrToStr(position[6]),62,107);
g.drawString(nrToStr(position[13]),415,107);
g.setFont(numSmallFont);
for(x=129,n=7; n<13; n++, x=x+46) {
g.setFont(numSmallFont);
g.drawString(nrToStr(position[n]),x,129);
g.setFont(numMicroFont);
if (houseNrsBox.isSelected()) g.drawString(n+"",x,150);
}
for(x=129,n=5; n>=0; n--, x=x+46) {
g.setFont(numSmallFont);
g.drawString(nrToStr(position[n]),x,83);
g.setFont(numMicroFont);
if (houseNrsBox.isSelected()) g.drawString(n+"",x,60);
}
}

//System.out.println("gameInProgress: "+gameInProgress+" nextHuman:"+nextHuman+" lastMoveText:"+lastMoveText );

if (gameInProgress && nextHuman && lastMoveText!=null) {
if (houseNrsBox.isSelected())
message.setText("Last move was "+lastMoveText);
else
message.setText("Make your move");
} else if (gameInProgress && !nextHuman) {
message.setText("Computer thinking ...");
message.revalidate();
}

}

/**
* Small helper fun used by paint()
*
*/

public String nrToStr(int n) {
if (n<1) return "";
else return n+"";
}

/*
* Position printing on console
*
*/

void printPosition() {
int i;

System.out.println("Position: ");
for(i=13;i>6;i--) {
System.out.print(nrToPrintStr(position[i])+" ");
}
System.out.println();
System.out.print(" ");
for(i=0;i<7;i++) {
System.out.print(nrToPrintStr(position[i])+" ");
}
System.out.println();
}

/**
* Small helper fun used by printPosition()
*
*/

public String nrToPrintStr(int n) {
if (n<10) return " "+n;
else return ""+n;
}

/**
* Respond to a user click on the board. If no game is in progress, show
* an error message. Otherwise, find the house that the user
* clicked and call doClickHouse(n) to handle it.
*/

/* position array visualisation:

lowerSmaller:
12 11 10 9 8 7
13 6
0 1 2 3 4 5

!lowerSmaller:
5 4 3 2 1 0
6 13
7 8 9 10 11 12

*/

public void mousePressed(MouseEvent evt) {
if (gameInProgress == false)
message.setText("Click on the 'New' button to start a new game.");
else if (!nextHuman) {
message.setText("Computer's turn!");
} else {
int col = (evt.getX() - 113) / 46;
//System.out.println(evt.getX()+"|"+evt.getY()+"|"+col);
if (humanLower && col>=0 && col<6 && evt.getY()>100 && evt.getY()<150) {
if (lowerSmaller) { doClickHouse(col); }
else { doClickHouse(col+7); }
} else if (!humanLower && col>=0 && col<6 && evt.getY()>50 && evt.getY()<100) {
if (lowerSmaller) { doClickHouse(12-col); }
else { doClickHouse(5-col); }
}
}
}

/**
* No actions registered
*
*/

public void mouseReleased(MouseEvent evt) { }
public void mouseClicked(MouseEvent evt) { }
public void mouseEntered(MouseEvent evt) { }
public void mouseExited(MouseEvent evt) { }

/* ***************************************************
*
* Making human and machine moves: improve here!!
*
* calcMove() below is the actual function to be improved
*
*****************************************************/

/**
* doHumanMove performs the move of the user (mouse click)
* and then calls doMachineMove() which computes machine move
*
* NB! In case the next move should also be done by human,
* doMachineMove() is not called: instead the human should click again
*
*/

void doHumanMove(int n) {
boolean onemore;
int res;

if (!gameInProgress) return;

humanMoveText=n+"("+position[n]+")";
lastMoveText=humanMoveText;

onemore=doMove(n);
if (houseNrsBox.isSelected()) System.out.println("Human: "+humanMoveText);
if (houseNrsBox.isSelected()) printPosition();
if (!onemore) nextHuman=false;
else nextHuman=true;
if (checkEnd()) {
res=humanResult();
if (res==0) gameOver("Game ended with a draw");
else if (res>0) gameOver("You won the game with "+res+" points!");
else {
gameOver("I won the game with "+(0-res)+" points!");
}
}
repaint();
if (!nextHuman) doMachineMove(); // here the machine calculates its move!
}

/**
* doMachineMove() performs machine move. It first checks the position,
* then calls the calcMove() which actually calculates the machine move, then performs the move,
* does printout etc.
*
* NB! If the machine can (should) make several moves in a row, then all these moves
* are performed separately inside a loop here. calcMove() will always just give one single move,
* not a sequence of moves!
*
*/

void doMachineMove() {
boolean onemore=true;
int i;
int res;
int n=0;

if (!gameInProgress) return;

// check if game already ended: just in case

if (checkEnd()) {
res=humanResult();
if (res==0) { gameOver("Game ended with a draw"); onemore=false; }
else if (res>0) { gameOver("You won the game with "+res+" points!"); onemore=false; }
else {
gameOver("I won the game with "+(0-res)+" points!");
onemore=false;
}
}

// Show that computer is thinking

if (houseNrsBox.isSelected()) System.out.println("Computer thinking ...");
nextHuman=false;
message.setText("Computer thinking ...");
message.revalidate();
repaint();

// calculate one or more moves: currently just the first legal move is taken

compMoveText=null;
while(onemore) {

// find a possible move (one must be available, otherwise game should have ended)
n = calcMove();

if (compMoveText==null) compMoveText="";
else compMoveText=compMoveText+"-";
compMoveText=compMoveText+n+"("+position[n]+")";

// actually do the move

onemore=doMove(n);
if (checkEnd()) {
res=humanResult();
if (res==0) { gameOver("Game ended with a draw"); onemore=false; }
else if (res>0) { gameOver("You won the game with "+res+" points!"); onemore=false; }
else {
gameOver("I won the game with "+(0-res)+" points!");
onemore=false;
}
}
}

// print and show the move

nextHuman=true;
lastMoveText=compMoveText;
if (houseNrsBox.isSelected()) System.out.println("Comp : "+compMoveText);
if (houseNrsBox.isSelected()) printPosition();
repaint();
// after machine calcs move, this is simply painted, after that system waits
// for human to make a move by clicking
}

/** =======================================
* This is the function you have to improve: currently it
* just takes the first legal move.
*
* NB! calcMove() should give a single move, not a sequence of moves:
* if new machine moves should be performed immediately after calcMove();
* then these are taken care of by doMachineMove(), which will repeatedly call
* calcMove() and then perform the move found.
* =========================================
*/

int calcMove() {
int i;
int n=-1; // if no moves available, returns -1

// do a fake thinking pause: DO NOT DO THIS FOR REAL COMPUTATION!

try {
Thread.sleep(500);
} catch (InterruptedException e) {
}

// find a possible move for the machine, assuming game has not ended

if (humanLower) {
for(i=7;i<13;i++) {
if (position[i]!=0) { n=i; break; }
}
} else {
for(i=0;i<6;i++) {
if (position[i]!=0) { n=i; break; }
}
}
return n;
}

/**
* This is a general move-performer for both sides (human and comp)
*
*/

boolean doMove(int n) {
int i,s,j,d;
int oppStore;

//System.out.println("called doMove "+n);
s=position[n];
if (s<1) {
message.setText("Cannot move from empty house!");
repaint();
return false;
}
if (n<6) oppStore=13; // lower row player has store 6 and oppStore 13
else oppStore=6; // upper row player vice versa
//System.out.println("oppStore: "+oppStore);
// do the normal move: seed following houses, incl own store
position[n]=0;
for(i=n+1; s>0; i++) {
if (i>13) i=0;
if (i!=oppStore) {
position[i]++;
s--;
}
}
i--; // now i is the house where the last seed was dropped
//for(d=0;d<14;d++) System.out.print(d+":"+position[d]+" ");
if (i==6 || i==13) { // cannot land in oppStore anyway
// landed in store: new move!
//System.out.println("new move!");
return true;
} else {
// normal case: no more moves
//System.out.println("normal case, no more moves");
// check for capture!!
if (position[i]==1) {
// last seed landed in an empty house
if (oppStore==13 && i<6) {
// ... of the player, who has lower row, capture!
//System.out.println("capture by lower row");
position[i]=0;
j=12-i; // opposite house
position[6]=position[6]+1+position[j];
position[j]=0;
} else if (oppStore==6 && i>6) {
// ... of the player, who has upper row, capture!
//System.out.println("capture by upper row");
position[i]=0;
j=12-i; // opposite house
position[13]=position[13]+1+position[j];
position[j]=0;
}
}
// we did not land in a store, no more moves
return false;
}
}

/**
* This checks whether game has ended
*
*/

boolean checkEnd() {

if (position[0]==0 && position[1]==0 && position[2]==0 &&
position[3]==0 && position[4]==0 && position[5]==0) return true;
if (position[7]==0 && position[8]==0 && position[9]==0 &&
position[10]==0 && position[11]==0 && position[12]==0) return true;
return false;
}

/**
* This calcs a human score, assuming game has ended
* (checks this and otherwise gives -1000)
*
*/

int humanResult() {
int lr=0;
int ur=0;
int hum=0;
int opp=0;

if (!checkEnd()) return -1000;
lr=position[0]+position[1]+position[2]+position[3]+
position[4]+position[5]+position[6];
ur=position[7]+position[8]+position[9]+position[10]+
position[11]+position[12]+position[13];
if (lr==ur) return 0;
if (humanLower) return lr-ur;
else return (ur-lr);
}

} // end class Board

} // end class

</pre>

Kalahiprogramm - Redigeerimiste ajalugu

Tammet – 1. detsember 2007, kell 08:55