达州做网站
大橙子网站建设，新征程启航
为企业提供网站建设、域名注册、服务器等服务
java军棋人机对战代码 c语言五子棋人机对战代码
现有21根火柴，两人轮流取，每人每次可取1到3根。不可多取，也不能不取，谁取最后一根火柴谁输 java 代码
1、按照题目的游戏规则，先拿第一根的人（先手）必输无疑。
成都创新互联公司是专业的岑巩网站建设公司，岑巩接单;提供网站设计制作、成都网站建设,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行岑巩网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!
把顺次取的每一根火柴都编上序号（1—21），因为21=（4+1）×4+1，而每次拿的火柴数是1—4根，这样，计算机作为后手就能控制游戏进程：计算机根据刚才先手拿走的数目，凑成5，拿到第5根火柴且只拿到第5根为止，就逼迫先手去拿第6根。6=5+1。以此类推，后手总是最后拿第5k根（k是自然数），先手总是被逼先拿第5k+1根，以致第21根落在自己手中而失败。
2、欲想获胜，只能修改游戏规则。例如
①、人先拿，每次1—4根，谁取最后一根谁输，但火柴总根数改作22根或27根。这时先手一旦拿到第5k+1根立刻暂停，让机器去拿那第5k+2根。
或者②、人先拿，每次1—5根，谁取最后一根谁输，火柴总根数21不变。这时，人的制胜方案是把2、8、14、20号火柴抢到手而把第3、9、15、21号火柴让给对方。
求JAVA人机猜拳的代码，类似一下界面。
自己纯手打，老半天才弄出来啊
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.util.Random;
import javax.swing.AbstractAction;
import javax.swing.Box;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;
public class Demo2 extends JFrame {
private JLabel lb1, lb2, lb3, lb4; // 提示标签
private JTextField ta1, ta2;// 两个文本框
private JButton b1, b2, b3; // 三个按钮
private JPanel p1, p2; // 两个JPanel面板
public Demo2() {
// 初始化所有组件
lb1 = new JLabel("欢迎使用人机猜拳程序");
lb2 = new JLabel("你出拳： ");
lb3 = new JLabel("电脑出拳：");
lb4 = new JLabel("结果");
ta1 = new JTextField();
ta1.setPreferredSize(new Dimension(60, 60)); // 设置大小
ta1.setEditable(false);//设置不可编辑
ta2 = new JTextField();
ta2.setPreferredSize(new Dimension(60, 60));
ta2.setEditable(false);//设置不可编辑
b1 = new JButton("剪刀");
b2 = new JButton("石头");
b3 = new JButton("布");
p1 = new JPanel();
p2 = new JPanel();
// 设置第一个面板内容
Box box = Box.createVerticalBox();
Box box1 = Box.createHorizontalBox();
box1.add(lb2);
box1.add(ta1);
box1.add(lb3);
box1.add(ta2);
box.add(lb1);
box.add(Box.createVerticalStrut(40));
box.add(box1);
box.add(Box.createVerticalStrut(10));
box.add(lb4);
box.add(new JLabel());
p1.add(box);
// 设置第二个面板
p2.setLayout(new GridBagLayout()); // 使用GridBagLayout布局管理器
p2.setPreferredSize(new Dimension(0, 60));
GridBagConstraints g2 = new GridBagConstraints();
g2.fill = GridBagConstraints.BOTH;
g2.weightx = 1.0;
g2.weighty = 1.0;
g2.gridx = 0;
g2.gridy = 0;
p2.add(b1, g2);
g2.gridx = 1;
p2.add(b2, g2);
g2.gridx = 2;
p2.add(b3, g2);
//为3个按钮添加事件
b1.addActionListener(new buttonAction());
b2.addActionListener(new buttonAction());
b3.addActionListener(new buttonAction());
this.getContentPane().add(p1);
this.getContentPane().add(p2, BorderLayout.SOUTH);
this.setTitle("机器人猜拳游戏");
this.setSize(300, 300);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
//事件类
class buttonAction extends AbstractAction{
@Override
public void actionPerformed(ActionEvent e) {
if(e.getSource()==b1){
ta1.setText("剪刀");
init(ta1.getText());
}else if(e.getSource()==b2){
ta1.setText("石头");
init(ta1.getText());
}else if(e.getSource()==b3){
ta1.setText("布");
init(ta1.getText());
}
}
// 模拟电脑出拳，产生三个随机数。0代表剪刀，1代表石头，2代表布
public String getQuan(){
String str="";
int num=new Random().nextInt(3) ;
if(num==0){
str="剪刀";
}else if(num==1){
str="石头";
}else if(num==2){
str="布";
}
return str;
}
// 判断输赢方法
public String isying(String s1,String s2){
String s="";
if(s1.equals(s2)){
s="平局";
}else if(s1.equals("剪刀")s2.equals("布")){
s="你赢";
}else if(s1.equals("石头")s2.equals("剪刀")){
s="你赢";
}else if(s1.equals("布")s2.equals("石头")){
s="你赢";
}else{
s="电脑赢";
}
return s;
}
public void init(String wo){
String sy=""; // 保存输赢结果
String dncq=getQuan(); //电脑出拳
if(wo.equals(dncq)){
sy="平局";
}else if(wo.equals("剪刀")dncq.equals("布")){
sy="你赢";
}else if(wo.equals("石头")dncq.equals("剪刀")){
sy="你赢";
}else if(wo.equals("布")dncq.equals("石头")){
sy="你赢";
}else{
sy="电脑赢";
}
ta2.setText(dncq);// 电脑出拳
lb4.setText("结果："+sy);
}
}
public static void main(String[] args) {
new Demo2();
}
}
求一个简单的JAVA五子棋代码！！ 网上复制的别来了！
以下是现写的 实现了两人对战 自己复制后运行把 没什么难度 类名 Games
import java.util.Scanner;
public class Games {
private String board[][];
private static int SIZE = 17;
private static String roles = "A玩家";
//初始化数组
public void initBoard() {
board = new String[SIZE][SIZE];
for (int i = 0; i SIZE; i++) {
for (int j = 0; j SIZE; j++) {
// if(i==0){
// String str = "";
// str += j+" ";
// board[i][j]= str;
// }else if(i!=0j==0){
// String str = "";
// str += i+" ";
// board[i][j]= str;
// }else{
board[i][j] = "╋";
// }
}
}
}
//输出棋盘
public void printBoard() {
for (int i = 0; i SIZE; i++) {
for (int j = 0; j SIZE; j++) {
System.out.print(board[i][j]);
}
System.out.println();
}
}
//判断所下棋子位置是否合理
public boolean isOk(int x, int y) {
boolean isRight = true;
if (x = 16 || x 1 || y = 16 | y 1) {
//System.out.println("输入错误，请从新输入");
isRight = false;
}
if (board[x][y].equals("●") || board[x][y].equals("○")) {
isRight = false;
}
return isRight;
}
//判断谁赢了
public void whoWin(Games wz) {
// 从数组挨个查找找到某个类型的棋子就从该棋子位置向右，向下，斜向右下 各查找5连续的位置看是否为5个相同的
int xlabel;// 记录第一次找到某个棋子的x坐标
int ylabel;// 记录第一次找到某个棋子的y坐标
// ●○╋
// 判断人是否赢了
for (int i = 0; i SIZE; i++) {
for (int j = 0; j SIZE; j++) {
if (board[i][j].equals("○")) {
xlabel = i;
ylabel = j;
// 横向找 x坐标不变 y坐标以此加1连成字符串
String heng = "";
if (i + 5 SIZE j + 5 SIZE) {
for (int k = j; k j + 5; k++) {
heng += board[i][k];
}
if (heng.equals("○○○○○")) {
System.out.println(roles+"赢了！您输了！");
System.exit(0);
}
// 向下判断y不变 x逐增5 连成字符串
String xia = "";
for (int l = j; l i + 5; l++) {
xia += board[l][j];
// System.out.println(xia);
}
if (xia.equals("○○○○○")) {
System.out.println(roles+"赢了！您输了！");
System.exit(0);
}
// 斜向右下判断
String youxia = "";
for (int a = 1; a = 5; a++) {
youxia += board[xlabel++][ylabel++];
}
if (youxia.equals("○○○○○")) {
System.out.println(roles+"赢了！您输了！");
System.exit(0);
}
}
}
}
}
// 判断电脑是否赢了
for (int i = 0; i SIZE; i++) {
for (int j = 0; j SIZE; j++) {
if (board[i][j].equals("●")) {
xlabel = i;
ylabel = j;
// 横向找 x坐标不变 y坐标以此加1连成字符串
String heng = "";
if (j + 5 SIZE i + 5 SIZE) {
for (int k = j; k j + 5; k++) {
heng += board[i][k];
}
if (heng.equals("●●●●●")) {
System.out.println(roles+"赢输了！您输了！");
System.exit(0);
}
// 向下判断y不变 x逐增5 连成字符串
String xia = "";
for (int l = i; l i + 5; l++) {
xia += board[l][ylabel];
// System.out.println(xia);
}
if (xia.equals("●●●●●")) {
System.out.println(roles+"赢了！您输了！");
System.exit(0);
}
// 斜向右下判断
String youxia = "";
for (int a = 1; a = 5; a++) {
youxia += board[xlabel++][ylabel++];
}
if (youxia.equals("●●●●●")) {
System.out.println(roles+"赢了！您输了！");
System.exit(0);
}
}
}
}
}
}
public static void main(String[] args) {
Games wz = new Games();
Scanner sc = new Scanner(System.in);
wz.initBoard();
wz.printBoard();
while (true) {
System.out.print("请"+roles+"输入X，Y坐标，必须在0－15范围内，xy以空格隔开,输入16 16结束程序");
int x = sc.nextInt();
int y = sc.nextInt();
if (x == SIZE y == SIZE) {
System.out.println("程序结束");
System.exit(0);
}
if (x SIZE || x 0 || y SIZE | y 0) {
System.out.println("输入错误，请从新输入");
continue;
}
//如果roles是A玩家 就让A玩家下棋，否则就让B玩家下棋。
if (wz.board[x][y].equals("╋")roles.equals("A玩家")) {
wz.board[x][y] = "○";
wz.printBoard();
//判断输赢
wz.whoWin(wz);
}else if(wz.board[x][y].equals("╋")roles.equals("B玩家")){
wz.board[x][y] = "●";
wz.printBoard();
//判断输赢
wz.whoWin(wz);
} else {
System.out.println("此处已经有棋子,从新输入");
continue;
}
if(roles.equals("A玩家")){
roles = "B玩家";
}else if(roles.equals("B玩家")){
roles = "A玩家";
}
}
}
}
java编程人机猜拳类和对象做求代码
先建立个Game包
然后我做的是分了5个类来做的
TestStartGuess 类
package com.game.guess;
public class TestStartGuess {
/**
* 人机互动版猜拳游戏
* 程序入口
*/
public static void main(String[] args) {
Game game=new Game();
game.initial();
game.startGame();
}
}
2.Person 类
package com.game.guess;
import java.util.Scanner;
/**
* 用户类
*阶段1完成
* @param Scanner
*/
public class Person {
String name ="匿名";//名字
int score =0;//积分
/**
* 出拳
*@return出拳结果：1.剪刀 2.石头 3.布
*/
public int showFist(){
//接收用户的选择
Scanner input =new Scanner(System.in);
System.out.print("\n请出拳:1.剪刀 2.石头 3.布 (输入相应数字):");
int show=input.nextInt();
//输出出拳结果，并返回
switch(show){
case 1:
System.out.println("你出拳：剪刀");
break;
case 2:
System.out.println("你出拳：石头");
break;
case 3:
System.out.println("你出拳：布");
break;
}
return show;
}
}
3.Computer 类
package com.game.guess;
/**
*计算机类
*阶段2完成
*/
public class Computer{
String name="电脑";//名字
int score = 0;;//积分
/**
*出拳
*@return 出拳结果：1.剪刀 2.石头 3.布
*/
public int showFist(){
//产生随机数
int show =(int)(Math.random()*10)%3+1;//产生随机数，表示电脑出拳
//输出出拳结果并返回
switch(show){
case 1:
System.out.println(name+"你出拳：剪刀");
break;
case 2:
System.out.println(name+"你出拳：石头");
break;
case 3:
System.out.println(name+"你出拳：布");
break;
}
return show;
}
}
4.Game 类
package com.game.guess;
import java.util.Scanner;
/**
* 游戏类类完全版
* 阶段7：功能扩展
* @param computer
*
*/
public class Gamecomputer {
Person person; //甲方
Computer computer; //乙方
int count;//对战次数
/**
* 初始化
*/
public void initial(){
person=new Person();
computer=new Computer();
count=0;
}
/**
* 开始游戏
*/
@SuppressWarnings("resource")
public void startGame(){
System.out.println("-------欢迎进入游戏世界-------\n");
System.out.println("\n\t\t***************");
System.out.println("\t\t**猜拳,开始 **");
System.out.println("\t\t***************");
System.out.println("\n\n出拳规则：1.剪刀，2.石头，3.布");
Scanner input=new Scanner(System.in);
String exit="n"; //退出系统
do{
initial();//初始化
/*选择对方角色*/
System.out.print("请选择对方角色:（1：刘备，2：孙权，3：曹操）：");
int role=input.nextInt();
if(role==1){
computer.name="刘备";
}else if(role==2){
computer.name="孙权";
}else if(role==3){
computer.name="曹操";
}
//扩展功能1：输入用户姓名
/*输入用户姓名*/
System.out.print("请输入你的姓名：");
person.name=input.next();
System.out.println(person.name+"VS"+computer.name+"对战\n");
//扩展功能1结束
System.out.print("要开始吗？(y/n)");
String start=input.next();//开始每一局游戏
int perFist; //用户出的拳
int compFist; //计算机出的拳
while(start.equals("y")){
/*出拳*/
perFist=person.showFist();
compFist=computer.showFist();
/*裁决*/
if((perFist==1compFist==1)||(perFist==2compFist==2)||(perFist==3compFist==3)){
System.out.println("结果：和局，真衰！嘿嘿，等着瞧吧！\n"); //平局
}else if((perFist==1compFist==3)||(perFist==2compFist==1)||(perFist==3compFist==2)){
System.out.println("结果：恭喜，你赢了！"); //用户赢
person.score++;
}else{
System.out.println("结果说：^_^，你输了，真笨！\n"); //计算机赢
computer.score++;
}
count++;
System.out.println("\n是否开始下一轮(y/n):");
start=input.next();
}
/*显示结果*/
showResult();
//扩展功能3：循环游戏，知道退出系统
System.out.print("\n要开始下一局吗？(y/n):");
exit=input.next();
System.out.println();
//扩展功能3结束
}while(!exit.equals("n"));
System.out.println("系统退出！");
}
/**
* 显示比赛结果
*/
public void showResult(){
/*显示对战次数*/
System.out.println("-------------------------------");
System.out.println(computer.name+"VS"+person.name);
System.out.println("对战次数："+count);
//扩展功能2：显示最终的得分
System.out.println("\n姓名\t得分");
System.out.println(person.name+"\t"+person.score);
System.out.println(computer.name+"\t"+computer.score+"\n");
//扩展功能2结束
/*显示对战结果*/
int result=calcResult();
if(result==1){
System.out.println("结果：打成平手，下次再和你一分高下！");
}else if(result==2){
System.out.println("结果：恭喜恭喜！"); //用户获胜
}else{
System.out.println("结果：呵呵，笨笨，下次加油啊！"); //计算机获胜
}
System.out.println("--------------------------------");
}
/**
* 计算比赛结果
* @return1：战平； 2：用户赢； 3：电脑赢
*/
public int calcResult(){
if(person.score==computer.score){
return 1;//战平
}else if(person.scorecomputer.score){
return 2;//用户赢
}else{
return 3;//电脑赢
}
}
}
5.Start 类
package com.game.guess;
public class StartGuess {
public static void main (String[] args){
Game c = new Game();
c.initial();
c.startGame();
}
}
然后编译执行就OK了
希望能帮到你
求java编写的五子棋代码，要有电脑AI的
java网络五子棋
下面的源代码分为4个文件；
chessClient.java:客户端主程序。
chessInterface.java:客户端的界面。
chessPad.java:棋盘的绘制。
chessServer.java:服务器端。
可同时容纳50个人同时在线下棋，聊天。
没有加上详细注释，不过绝对可以运行，j2sdk1.4下通过。
/*********************************************************************************************
1.chessClient.java
**********************************************************************************************/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;
class clientThread extends Thread
{
chessClient chessclient;
clientThread(chessClient chessclient)
{
this.chessclient=chessclient;
}
public void acceptMessage(String recMessage)
{
if(recMessage.startsWith("/userlist "))
{
StringTokenizer userToken=new StringTokenizer(recMessage," ");
int userNumber=0;
chessclient.userpad.userList.removeAll();
chessclient.inputpad.userChoice.removeAll();
chessclient.inputpad.userChoice.addItem("所有人");
while(userToken.hasMoreTokens())
{
String user=(String)userToken.nextToken(" ");
if(userNumber0 !user.startsWith("[inchess]"))
{
chessclient.userpad.userList.add(user);
chessclient.inputpad.userChoice.addItem(user);
}
userNumber++;
}
chessclient.inputpad.userChoice.select("所有人");
}
else if(recMessage.startsWith("/yourname "))
{
chessclient.chessClientName=recMessage.substring(10);
chessclient.setTitle("Java五子棋客户端 "+"用户名:"+chessclient.chessClientName);
}
else if(recMessage.equals("/reject"))
{
try
{
chessclient.chesspad.statusText.setText("不能加入游戏");
chessclient.controlpad.cancelGameButton.setEnabled(false);
chessclient.controlpad.joinGameButton.setEnabled(true);
chessclient.controlpad.creatGameButton.setEnabled(true);
}
catch(Exception ef)
{
chessclient.chatpad.chatLineArea.setText("chessclient.chesspad.chessSocket.close无法关闭");
}
chessclient.controlpad.joinGameButton.setEnabled(true);
}
else if(recMessage.startsWith("/peer "))
{
chessclient.chesspad.chessPeerName=recMessage.substring(6);
if(chessclient.isServer)
{
chessclient.chesspad.chessColor=1;
chessclient.chesspad.isMouseEnabled=true;
chessclient.chesspad.statusText.setText("请黑棋下子");
}
else if(chessclient.isClient)
{
chessclient.chesspad.chessColor=-1;
chessclient.chesspad.statusText.setText("已加入游戏，等待对方下子...");
}
}
else if(recMessage.equals("/youwin"))
{
chessclient.isOnChess=false;
chessclient.chesspad.chessVictory(chessclient.chesspad.chessColor);
chessclient.chesspad.statusText.setText("对方退出，请点放弃游戏退出连接");
chessclient.chesspad.isMouseEnabled=false;
}
else if(recMessage.equals("/OK"))
{
chessclient.chesspad.statusText.setText("创建游戏成功，等待别人加入...");
}
else if(recMessage.equals("/error"))
{
chessclient.chatpad.chatLineArea.append("传输错误：请退出程序，重新加入 \n");
}
else
{
chessclient.chatpad.chatLineArea.append(recMessage+"\n");
chessclient.chatpad.chatLineArea.setCaretPosition(
chessclient.chatpad.chatLineArea.getText().length());
}
}
public void run()
{
String message="";
try
{
while(true)
{
message=chessclient.in.readUTF();
acceptMessage(message);
}
}
catch(IOException es)
{
}
}
}
public class chessClient extends Frame implements ActionListener,KeyListener
{
userPad userpad=new userPad();
chatPad chatpad=new chatPad();
controlPad controlpad=new controlPad();
chessPad chesspad=new chessPad();
inputPad inputpad=new inputPad();
Socket chatSocket;
DataInputStream in;
DataOutputStream out;
String chessClientName=null;
String host=null;
int port=4331;
boolean isOnChat=false; //在聊天？
boolean isOnChess=false; //在下棋？
boolean isGameConnected=false; //下棋的客户端连接？
boolean isServer=false; //如果是下棋的主机
boolean isClient=false; //如果是下棋的客户端
Panel southPanel=new Panel();
Panel northPanel=new Panel();
Panel centerPanel=new Panel();
Panel westPanel=new Panel();
Panel eastPanel=new Panel();
chessClient()
{
super("Java五子棋客户端");
setLayout(new BorderLayout());
host=controlpad.inputIP.getText();
westPanel.setLayout(new BorderLayout());
westPanel.add(userpad,BorderLayout.NORTH);
westPanel.add(chatpad,BorderLayout.CENTER);
westPanel.setBackground(Color.pink);
inputpad.inputWords.addKeyListener(this);
chesspad.host=controlpad.inputIP.getText();
centerPanel.add(chesspad,BorderLayout.CENTER);
centerPanel.add(inputpad,BorderLayout.SOUTH);
centerPanel.setBackground(Color.pink);
controlpad.connectButton.addActionListener(this);
controlpad.creatGameButton.addActionListener(this);
controlpad.joinGameButton.addActionListener(this);
controlpad.cancelGameButton.addActionListener(this);
controlpad.exitGameButton.addActionListener(this);
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(false);
southPanel.add(controlpad,BorderLayout.CENTER);
southPanel.setBackground(Color.pink);
addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent e)
{
if(isOnChat)
{
try
{
chatSocket.close();
}
catch(Exception ed)
{
}
}
if(isOnChess || isGameConnected)
{
try
{
chesspad.chessSocket.close();
}
catch(Exception ee)
{
}
}
System.exit(0);
}
public void windowActivated(WindowEvent ea)
{
}
});
add(westPanel,BorderLayout.WEST);
add(centerPanel,BorderLayout.CENTER);
add(southPanel,BorderLayout.SOUTH);
pack();
setSize(670,548);
setVisible(true);
setResizable(false);
validate();
}
public boolean connectServer(String serverIP,int serverPort) throws Exception
{
try
{
chatSocket=new Socket(serverIP,serverPort);
in=new DataInputStream(chatSocket.getInputStream());
out=new DataOutputStream(chatSocket.getOutputStream());
clientThread clientthread=new clientThread(this);
clientthread.start();
isOnChat=true;
return true;
}
catch(IOException ex)
{
chatpad.chatLineArea.setText("chessClient:connectServer:无法连接,建议重新启动程序 \n");
}
return false;
}
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==controlpad.connectButton)
{
host=chesspad.host=controlpad.inputIP.getText();
try
{
if(connectServer(host,port))
{
chatpad.chatLineArea.setText("");
controlpad.connectButton.setEnabled(false);
controlpad.creatGameButton.setEnabled(true);
controlpad.joinGameButton.setEnabled(true);
chesspad.statusText.setText("连接成功，请创建游戏或加入游戏");
}
}
catch(Exception ei)
{
chatpad.chatLineArea.setText("controlpad.connectButton:无法连接,建议重新启动程序 \n");
}
}
if(e.getSource()==controlpad.exitGameButton)
{
if(isOnChat)
{
try
{
chatSocket.close();
}
catch(Exception ed)
{
}
}
if(isOnChess || isGameConnected)
{
try
{
chesspad.chessSocket.close();
}
catch(Exception ee)
{
}
}
System.exit(0);
}
if(e.getSource()==controlpad.joinGameButton)
{
String selectedUser=userpad.userList.getSelectedItem();
if(selectedUser==null || selectedUser.startsWith("[inchess]") ||
selectedUser.equals(chessClientName))
{
chesspad.statusText.setText("必须先选定一个有效用户");
}
else
{
try
{
if(!isGameConnected)
{
if(chesspad.connectServer(chesspad.host,chesspad.port))
{
isGameConnected=true;
isOnChess=true;
isClient=true;
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName);
}
}
else
{
isOnChess=true;
isClient=true;
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/joingame "+userpad.userList.getSelectedItem()+" "+chessClientName);
}
}
catch(Exception ee)
{
isGameConnected=false;
isOnChess=false;
isClient=false;
controlpad.creatGameButton.setEnabled(true);
controlpad.joinGameButton.setEnabled(true);
controlpad.cancelGameButton.setEnabled(false);
chatpad.chatLineArea.setText("chesspad.connectServer无法连接 \n"+ee);
}
}
}
if(e.getSource()==controlpad.creatGameButton)
{
try
{
if(!isGameConnected)
{
if(chesspad.connectServer(chesspad.host,chesspad.port))
{
isGameConnected=true;
isOnChess=true;
isServer=true;
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/creatgame "+"[inchess]"+chessClientName);
}
}
else
{
isOnChess=true;
isServer=true;
controlpad.creatGameButton.setEnabled(false);
controlpad.joinGameButton.setEnabled(false);
controlpad.cancelGameButton.setEnabled(true);
chesspad.chessthread.sendMessage("/creatgame "+"[inchess]"+chessClientName);
}
}
catch(Exception ec)
{
isGameConnected=false;
isOnChess=false;
isServer=false;
controlpad.creatGameButton.setEnabled(true);
controlpad.joinGameButton.setEnabled(true);
controlpad.cancelGameButton.setEnabled(false);
ec.printStackTrace();
chatpad.chatLineArea.setText("chesspad.connectServer无法连接 \n"+ec);
}
}
if(e.getSource()==controlpad.cancelGameButton)
{
if(isOnChess)
{
chesspad.chessthread.sendMessage("/giveup "+chessClientName);
chesspad.chessVictory(-1*chesspad.chessColor);
controlpad.creatGameButton.setEnabled(true);
controlpad.joinGameButton.setEnabled(true);
controlpad.cancelGameButton.setEnabled(false);
chesspad.statusText.setText("请建立游戏或者加入游戏");
}
if(!isOnChess)
{
controlpad.creatGameButton.setEnabled(true);
controlpad.joinGameButton.setEnabled(true);
controlpad.cancelGameButton.setEnabled(false);
chesspad.statusText.setText("请建立游戏或者加入游戏");
}
isClient=isServer=false;
}
}
public void keyPressed(KeyEvent e)
{
TextField inputWords=(TextField)e.getSource();
if(e.getKeyCode()==KeyEvent.VK_ENTER)
{
if(inputpad.userChoice.getSelectedItem().equals("所有人"))
{
try
{
out.writeUTF(inputWords.getText());
inputWords.setText("");
}
catch(Exception ea)
{
chatpad.chatLineArea.setText("chessClient:KeyPressed无法连接,建议重新连接 \n");
userpad.userList.removeAll();
inputpad.userChoice.removeAll();
inputWords.setText("");
controlpad.connectButton.setEnabled(true);
}
}
else
{
try
{
out.writeUTF("/"+inputpad.userChoice.getSelectedItem()+" "+inputWords.getText());
inputWords.setText("");
}
catch(Exception ea)
{
chatpad.chatLineArea.setText("chessClient:KeyPressed无法连接,建议重新连接 \n");
userpad.userList.removeAll();
inputpad.userChoice.removeAll();
inputWords.setText("");
controlpad.connectButton.setEnabled(true);
}
}
}
}
public void keyTyped(KeyEvent e)
{
}
public void keyReleased(KeyEvent e)
{
}
public static void main(String args[])
{
chessClient chessClient=new chessClient();
}
}
/******************************************************************************************
下面是：chessInteface.java
******************************************************************************************/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
class userPad extends Panel
{
List userList=new List(10);
userPad()
{
setLayout(new BorderLayout());
for(int i=0;i50;i++)
{
userList.add(i+"."+"没有用户");
}
add(userList,BorderLayout.CENTER);
}
}
class chatPad extends Panel
{
TextArea chatLineArea=new TextArea("",18,30,TextArea.SCROLLBARS_VERTICAL_ONLY);
chatPad()
{
setLayout(new BorderLayout());
add(chatLineArea,BorderLayout.CENTER);
}
}
class controlPad extends Panel
{
Label IPlabel=new Label("IP",Label.LEFT);
TextField inputIP=new TextField("localhost",10);
Button connectButton=new Button("连接主机");
Button creatGameButton=new Button("建立游戏");
Button joinGameButton=new Button("加入游戏");
Button cancelGameButton=new Button("放弃游戏");
Button exitGameButton=new Button("关闭程序");
controlPad()
{
setLayout(new FlowLayout(FlowLayout.LEFT));
setBackground(Color.pink);
add(IPlabel);
add(inputIP);
add(connectButton);
add(creatGameButton);
add(joinGameButton);
add(cancelGameButton);
add(exitGameButton);
}
}
class inputPad extends Panel
{
TextField inputWords=new TextField("",40);
Choice userChoice=new Choice();
inputPad()
{
setLayout(new FlowLayout(FlowLayout.LEFT));
for(int i=0;i50;i++)
{
userChoice.addItem(i+"."+"没有用户");
}
userChoice.setSize(60,24);
add(userChoice);
add(inputWords);
}
}
/**********************************************************************************************
下面是：chessPad.java
**********************************************************************************************/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import java.util.*;
class chessThread extends Thread
{
chessPad chesspad;
chessThread(chessPad chesspad)
{
this.chesspad=chesspad;
}
public void sendMessage(String sndMessage)
{
try
{
chesspad.outData.writeUTF(sndMessage);
}
catch(Exception ea)
{
System.out.println("chessThread.sendMessage:"+ea);
}
}
public void acceptMessage(String recMessage)
{
if(recMessage.startsWith("/chess "))
{
StringTokenizer userToken=new StringTokenizer(recMessage," ");
String chessToken;
String[] chessOpt={"-1","-1","0"};
int chessOptNum=0;
while(userToken.hasMoreTokens())
{
chessToken=(String)userToken.nextToken(" ");
if(chessOptNum=1 chessOptNum=3)
{
chessOpt[chessOptNum-1]=chessToken;
}
chessOptNum++;
}
chesspad.netChessPaint(Integer.parseInt(chessOpt[0]),Integer.parseInt(chessOpt[1]),Integer.parseInt(chessOpt[2]));
}
else if(recMessage.startsWith("/yourname "))
{
chesspad.chessSelfName=recMessage.substring(10);
}
else if(recMessage.equals("/error"))
{
chesspad.statusText.setText("错误:没有这个用户，请退出程序，重新加入");
}
else
{
//System.out.println(recMessage);
}
}
public void run()
{
String message="";
try
{
while(true)
{
message=chesspad.inData.readUTF();
acceptMessage(message);
}
}
catch(IOException es)
{
}
}
}
class chessPad extends Panel implements MouseListener,ActionListener
{
int chessPoint_x=-1,chessPoint_y=-1,chessColor=1;
int chessBlack_x[]=new int[200];
int chessBlack_y[]=new int[200];
int chessWhite_x[]=new int[200];
int chessWhite_y[]=new int[200];
int chessBlackCount=0,chessWhiteCount=0;
int chessBlackWin=0,chessWhiteWin=0;
boolean isMouseEnabled=false,isWin=false,isInGame=false;
TextField statusText=new TextField("请先连接服务器");
Socket chessSocket;
DataInputStream inData;
DataOutputStream outData;
String chessSelfName=null;
String chessPeerName=null;
String host=null;
int port=4331;
chessThread chessthread=new chessThread(this);
chessPad()
{
setSize(440,440);
setLayout(null);
setBackground(Color.pink);
addMouseListener(this);
add(statusText);
statusText.setBounds(40,5,360,24);
statusText.setEditable(false);
}
public boolean connectServer(String ServerIP,int ServerPort) throws Exception
{
try
{
chessSocket=new Socket(ServerIP,ServerPort);
inData=new DataInputStream(chessSocket.getInputStream());
outData=new DataOutputStream(chessSocket.getOutputStream());
chessthread.start();
return true;
}
catch(IOException ex)
{
statusText.setText("chessPad:connectServer:无法连接 \n");
}
return false;
}
public void chessVictory(int chessColorWin)
{
this.removeAll();
for(int i=0;i=chessBlackCount;i++)
{
chessBlack_x[i]=0;
chessBlack_y[i]=0;
}
for(int i=0;i=chessWhiteCount;i++)
{
chessWhite_x[i]=0;
chessWhite_y[i]=0;
}
chessBlackCount=0;
chessWhiteCount=0;
add(statusText);
statusText.setBounds(40,5,360,24);
if(chessColorWin==1)
{ chessBlackWin++;
statusText.setText("黑棋胜,黑:白为"+chessBlackWin+":"+chessWhiteWin+",重新开局,等待白棋下子...");
}
else if(chessColorWin==-1)
{
chessWhiteWin++;
statusText.setText("白棋胜,黑:白为"+chessBlackWin+":"+chessWhiteWin+",重新开局,等待黑棋下子...");
}
}
public void getLocation(int a,int b,int color)
{
if(color==1)
{
chessBlack_x[chessBlackCount]=a*20;
chessBlack_y[chessBlackCount]=b*20;
chessBlackCount++;
}
else if(color==-1)
{
chessWhite_x[chessWhiteCount]=a*20;
chessWhite_y[chessWhiteCount]=b*20;
chessWhiteCount++;
}
}
public boolean checkWin(int a,int b,int checkColor)
{
int step=1,chessLink=1,chessLinkTest=1,chessCompare=0;
if(checkColor==1)
{
chessLink=1;
for(step=1;step=4;step++)
{
for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)
{
if(((a+step)*20==chessBlack_x[chessCompare]) ((b*20)==chessBlack_y[chessCompare]))
{
chessLink=chessLink+1;
if(chessLink==5)
{
return(true);
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
break;
}
for(step=1;step=4;step++)
{
for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)
{
if(((a-step)*20==chessBlack_x[chessCompare]) (b*20==chessBlack_y[chessCompare]))
{
chessLink++;
if(chessLink==5)
{
return(true);
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
break;
}
chessLink=1;
chessLinkTest=1;
for(step=1;step=4;step++)
{
for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)
{
if((a*20==chessBlack_x[chessCompare]) ((b+step)*20==chessBlack_y[chessCompare]))
{
chessLink++;
if(chessLink==5)
{
return(true);
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
break;
}
for(step=1;step=4;step++)
{
for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)
{
if((a*20==chessBlack_x[chessCompare]) ((b-step)*20==chessBlack_y[chessCompare]))
{
chessLink++;
if(chessLink==5)
{
return(true);
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
break;
}
chessLink=1;
chessLinkTest=1;
for(step=1;step=4;step++)
{
for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)
{
if(((a-step)*20==chessBlack_x[chessCompare]) ((b+step)*20==chessBlack_y[chessCompare]))
{
chessLink++;
if(chessLink==5)
{
return(true);
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
break;
}
for(step=1;step=4;step++)
{
for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)
{
if(((a+step)*20==chessBlack_x[chessCompare]) ((b-step)*20==chessBlack_y[chessCompare]))
{
chessLink++;
if(chessLink==5)
{
return(true);
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
break;
}
chessLink=1;
chessLinkTest=1;
for(step=1;step=4;step++)
{
for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)
{
if(((a+step)*20==chessBlack_x[chessCompare]) ((b+step)*20==chessBlack_y[chessCompare]))
{
chessLink++;
if(chessLink==5)
{
return(true);
}
}
}
if(chessLink==(chessLinkTest+1))
chessLinkTest++;
else
break;
}
for(step=1;step=4;step++)
{
for(chessCompare=0;chessCompare=chessBlackCount;chessCompare++)
{
if(((a-step)*20==chessBlack_x[chessCompare]) ((b-step)*20==chessBlack_y[chessCompare]))
{
chessLink++;
if(chessLink==5)
{
return(true);
}
}
系统框图如下 java实现五子棋程序 可以实现人人对战 人机对战 简单功能 悔棋 认输
一、实验题目
五子棋游戏。
二、问题分析
五子棋是双人博弈棋类益智游戏，由围棋演变而来，属纯策略型。棋盘通常15*15，即15行，15列，共225个交叉点，即棋子落点；棋子由黑白两色组成，黑棋123颗，白棋122颗。游戏规则为黑先白后，谁先五子连成一条直线谁赢，其中直线可以是横的、纵的、45度、135度。
本次Java编程我的目的是现实人机对战，即游戏者一方是人，另一方计算机。这就要求程序不仅要具备五子棋的基本界面，还要编程指导计算机与人进行对弈。为了使程序尽可能智能，我采用了贪心策略、传统搜索算法、极大极小博弈树算法，对应游戏玩家的3个等级：简单、中等、困难。
三、功能设计
我的程序基本功能是实现人机对弈五子棋。人和电脑交替下棋，谁先五子连成一条直线谁就赢。下面是我程序的功能模块：
1.等级设置
核心功能是实现不同策略与算法的对比运用，纯贪心策略实现简单等级对手，直接搜索算法实现中等等级对手，极大极小博弈树算法实现困难等级对手。对应程序中的3选1单选按钮。
2.悔棋功能
模拟栈机制实现人悔棋，不限步长的悔棋。对应程序中的悔棋按钮。
3.棋面绘制
根据不同机计算机的屏幕分辨率，绘制逼真的棋盘。
4.图片引入
两张古典的人物图片，生动模拟对弈双方。人物图片旁的黑白棋钵图片显示黑白棋归属。
5.背景设置
支持用户选择背景，包括棋盘、棋盘边框、窗口边框，彰显个性。
6.音乐播放
下棋时有棋子落地的声音，一方胜利时有五子连成一片的声音。同时在设置背景时相应的改变整个对弈过程中的背景音乐。
7.时间显示
在棋盘正上方有一模拟文本框显示当前棋局用时。
8.其他小功能
支持和棋、认输、开启新游戏、退出游戏等操作。
四、数据结构与算法设计
数据结构部分
1.当前棋局的存储结构
我的五子棋程序选择通常用到的15行*15列棋盘，可以开二维数组PositionFlag = new int[15][15]，PositionFlag[i][j]为0表示(i,j)点尚无棋，为1表示(i,j)点是人的棋子，为2表示(i,j)点是机器的棋子。之所以选择二维数组，主要原因有两点：
1.本程序需要频繁随机访问15*15的交叉点，对应查询该点状态以及改变该点状态，随机访问是数组的特点。
2.15*15=225开二维数组的内存需求相对现在内存为2G及以上的计算机完全可以接受，且数组实现简单、操作方便。
基于以上两点，尽管创建动态的顺序表—链表可能可以节省少量内存（可以只存当前有棋的点，原数组对应位置为0的点可以不存），但选择数组的优势完全在上述两点体现了出来。
2.实现悔棋操作的数据结构
由于每次悔棋只需回退当前几步，后进先出原则，这正是栈这种典型数据结构的设计思想，于是我选择栈。我自己先写了用自定义数组模拟的栈，但由于是学Java语言且由于悔棋的存储空间需要随当前步数增大而增大（由于每局最多下225步，即最多要悔225步，所以自己开个225的数组完全可以避免存储空间自增长的问题且内存完全可以接受，之所以不用自定义数组而用ArrayList类主要是为了尝试Java中STL的用法），所有我最终改为用Java类库中的ArrayList类。
确定用ArrayList类实现栈机制后就必须考虑每个ArrayList单元具体存储什么。刚开始我存储的是当前的棋局，即整个局面，而每个局面对应一个二维数组，这样是很占用内存的。试想一下，在最坏情况下，225个ArrayList单元，每个单元存放一个15*15的二维数组，尽管225*15*15在Java的内存管理机制下不会爆栈，但也是极不划算的。之所以说不划算，是因为有更好的解决方案。由于每次悔棋只是在回退倒数一步，多步悔棋只需循环回退，所以可以只存储当前棋局最后一步的下法，对应一个二维点，完全可以自定义一个二维坐标类chessOneStep。
算法设计部分
Java语言是面向对象的语言。我在进行五子棋游戏编程是总共传创建了11个自定义的类。在编写程序的过程中，我有一个明显的体验就是面向对象编程就是一项有关对象设计和对象接口技术，很多关键的技术就是如何设计自定义的对象。
下面我先概括给出我的所有类的作用：
1.mainFrame类：主框架类，我应用程序的入口；
2.chessPositon类：主控类，这个类是我程序的核心类，负责控制双方的下棋，以及调用其他的类完成当前棋局的显示绘制；
3.chessPanel类：面板类，调用其他底层类完成当前棋局的显示绘制；
4.chessBoard类：棋盘绘制类，负责棋盘的绘制；
5.chessImage类：文件类，包含各种资源（背景图片、背景音乐）以及静态全局变量（public static Type）；
6.chessButton类：组件类，定义各种组件，包括按钮、单选按钮、文本框等；
7.chessMusic类：音乐类，负责调用Java库类完成背景音乐、下棋音乐、取胜音乐等的播放；
8.chessPiece类：棋局类，定义棋局二维数组数据结构并完成相关操作；
9.chessList类：栈类，完成悔棋等操作；
10. chessOneStep类：棋子类，定义每步坐标以及下在该处获得的估价值；
11.myCompare类：排序类，完成chessOneStep类的自定义排序
详细设计
1.mainFrame类
作为我的五子棋程序的主类，mainFrame类主要实例化相关的对象，如chessbutton,chessborad等，从而完成框架的创建。更重要的是实例化chessposition，这是本程序的核心类，控制游戏双方行棋过程完成人机互动下棋，然后将MyChessPosition与鼠标响应addMouseListener（）关联起来。
2.chessMusic类
一个好的游戏必须给人一种身临其境的感觉，而声音是营造这种氛围的重要因素。参照网上各游戏运行商的音乐配置，我选择相关逼真的声音。包括背景音乐、下棋棋子落到棋盘发出的声音以及一方胜出的配乐。所有这些功能的实现，依赖于自定义的chessMusic类，采用AudioInputStream配合Clip的方式完成音乐播放的软硬件工作，然后定义两个接口chessmusic(String Name)和Stop(),前者完成播放功能，后者完成关闭当前音乐功能。因为音频文件相对较大，而我的程序提供在不同背景乐之间切换的功能，所以在打开另一个音频文件之前必须关闭前一个正在播放的音频文件，防止出现溢出。
3.chessImage类
适当的动画或图片能给游戏玩家带来美的体验。所以我的五子棋程序界面在不失和谐的前提下引入了尽可能多的图片，包括对弈双方、棋钵等。图片引入的具体工作通过语句import javax.imageio.ImageIO完成。同时，由于图片要在用到它的类中被访问，为了避免频繁调用函数，我直接将图片相关联的对象定义为public static，表明是公用的、静态的。进一步引申开去，我将程序中用到的静态全局变量都定义在chessImage类中。具体如下：
public static Date begin;//每局开始时间
public static Date cur;//每局结束时间
public static chessOneStep LineLeft;//结束端点1
public static chessOneStep LineRight;//结束端点2
public static boolean IsGameOver;//是否只有一方获胜
public static int ColorOfBackGround[][]= {{255, 227, 132},{0,255,127},{218,165,32}};//背景颜色
public static int ColorOfWindows[][]= {{ 60,179,113},{245,245,245},{122,122,122}};//背景颜色
public static int WitchMatch;//背景搭配
public static String MusicOfBackGround;//背景音乐
public static int CurrentStep;//记录当前步数
public static int Rank;//设置难度等级
public static boolean IsSurrender;//判断是否认输
public static boolean IsTie;//判断是否认输
public static String Message;//输出提示信息
public static Image IconImage;// 图标
public static Image blackBoard;//白棋盘
public static Image whiteBoard;//黑棋盘
public static Image blackChess;// 白棋棋子图片
public static Image whiteChess;// 白棋棋子图片
public static Image RightPlayer;//白棋棋罐图片
public static Image LeftPlayer;//白棋玩家头像图片
public static String path = "src/";// 图片的保存路径
4.chessButton类
这个是程序的组件类。定义了各种功能键，完善程序功能，营造逼真的人机对战游戏效果。分为3类：效果。。
(1)、按钮组件
本程序有5个按钮，支持和棋、认输、新游戏、退出、悔棋等。认输和和棋按钮终止当前的棋局，给出相应的提示信息；退出按钮调用系统System.exit(0)的函数正常返回；悔棋按钮调用后面要介绍的chessList类实现悔棋；新游戏按钮则刷新当前棋局准备下一轮，要将记录当前棋局的二维数组全部置0，刷新当前棋局开始时间等。
(2)、单选按钮组件
游戏界面支持设置个性化界面，包括背景颜色与背景音乐，跟重要的一点是设置难度（简单、中等、困难）。单选按钮只能多选一。背景颜色主要是存储相关颜色搭配方案的RGB颜色，开2维数组，即对应RGB3原色数组的一维数组，然后通过改变WitchMatch全局变量的值来有用户自己选择颜色搭配，不同的颜色搭配对应不同的背景音乐表达一致的主题。难度设置主要是改变计算机的下棋算法，不同难度通过Rank判断进入不同的程序分支，实现不同智能等级的计算机下棋水平。
(3)、文本框
在不同的单选按钮前添加相应的文本框，提示用户可以实现的功能。同时我用颜色模拟出显示当前棋局耗用时间的文本框。
不论按钮还是单选按钮都要关联相应的消息，把相应功能的实现放在消息响应处理函数理。这些主要是实现Java库提供的消息响应接口里的方法。
5.chessPiece类
主要完成当前棋面的存储，存储棋面的数据结构为二维数组int[][] PositionFlag；然后定义获取、设置某点以及整个棋面的状态的方法。
(1)、SetPositionFlag(int x, int y, int flag)//设置（x,y）处的状态为flag
(2)、GetPositionFlag(int x, int y)//获取（x,y）处的状态
(3)、SetAllFlag(int [][]NewFlag)//设置当前整个棋面的状态为NewFlag
(4)、GetAllFlag()//获取当前整个棋面的状态
(5)、DrawChessPiece(Graphics g)//绘制当前局面的棋子
由于本类比较重要，所以附上了代码，见源代码1。
6.chessBoard类
功能为绘制棋盘线。由于围棋的棋盘比较复杂，横线、竖线较多，且为了使棋盘美观，还要自定义窗口边框、棋盘边框、对弈双方边框等，对线宽、线型也有一定要求。有时要单像素线条，有时要多像素线条。对于多像素线条，我主要用了2种方法。
方法一：
在需要绘制多像素线条处首先绘制一条单像素线，然后根据线宽要求上下平移适当像素达到绘制多像素的目的。这样的方法适合绘制水平线或竖直线，绘制其他斜率的线条容易造成走样。在没有想到比较好的反走样编程思想后我选择了调用Java库中已经封装好的函数。
方法二：
为了克服方法一绘制非水平或竖直线时造成的走样，同时也为了更进一步学习Java语言，我猜想肯定会有类似OpenGL中设置线宽的画刷，于是上网百度找到了相应的画刷Stroke类。通过Java库实现绘制不同线宽的直线，达到了反走样效果。
7.chessOneStep类
这个类是为了配合chessList类实现悔棋以及在计算机下棋算法实现返回有效状态点而设计的。主要数据成员为
private int x,y,weight；//其中x,y表示点坐标，weight表示将棋下到该点获得的估价值。
主要方法如下：
(1)、GetX()//获得当前对象的x坐标
(2)、GetY()//获得当前对象的y坐标
(3)、GetWeight()//获得当前对象的(x,y)处的估价值
8.chessList类
程序支持悔棋功能，为了实现悔棋，自定义了chessList类。这个类主要通过引入java.util.ArrayList和java.util.List实现集合的数据类型。然后自定义一些方法，如下：
（1）、AddStep(chessOneStep OneStep)//添加一步棋到List中
（2）、GetSize()//获得当前List的大小
（3）、ClearList()//清空List
（4）、RemoveLast()//删去List中的最后元素
由于每次删除当前List中的最后一个元素，实现后进先出，所以可以模拟栈的功能实现悔棋。
9.myCompare类
由于在计算机下棋的极大极小博弈树算法中需要对自定义对象chessOneStep按weight进行排序，所以引入了myCompare类，通过实现Comparator接口中的compare方法完成自定义对象排序。
10.chessPanel类
程序的自定义面板类，主要负责完成当前框架内容的显示。这是一个重要的与框架和图形显示密切相关的类。主要数据成员为
private chessboard MyChessBoard;//当前显示棋盘
private chesspiece MyChessPiece;//当前显示整个棋面的状态
主要方法如下：
（1）、chesspanel(chessboard MyChessBoard1, chesspiece MyChessPiece1)//构造函数，分别用MyChessBoard1和MyChessPiece1初始化MyChessBoard和MyChessPiece
（2）display(chessboard MyChessBoard1, chesspiece MyChessPiece1)//自定义显示回调函数，调用repaint()完成重新绘制游戏界面
（3）、paintComponent(Graphics g)//核心方法，调用各种函数完成具体的绘制工作
11.chessPositon类
程序算法核心类，总的功能是控制人和计算机轮流下棋，以及调用chessPanel类中的display(chessboard , chesspiece )方法完成界面的实时刷新。关于chessPositon类，我在此将重点介绍。chessPosition类的主要数据成员如下：
private static chessboard MyChessBoard;//当前显示棋盘
public static chesspiece MyChessPiece;//当前显示整个棋面的状态
private static chesspanel Mychesspanel;////当前显示面板
public static chesslist MyChessList=new chesslist();//当前下棋集合，用于悔棋
final private static int INF = (1 30); // 表示正无穷大的常量，用于极大极小博弈数搜索算法
public static boolean CanGo;//控制当前下棋一方
类的设计集中体现在成员方法的设计上。实现人机对战，只有语言是远远不够的，还要加入算法，用算法引导计算机下棋。下面介绍该类的方法成员：
（1）、chessposition(chesspanel , chessboard ,chesspiece ) //带有参数的构造函数
（2）、chessposition()
不带参数的构造函数
（3）、mouseClicked(MouseEvent event)
鼠标响应函数，负责人的下棋，根据鼠标点击的位置转换得到所在棋盘的相对位置。如果该位置不合法，即超出棋盘有效范围，点击无响应；如果该位置上已有棋，弹出消息框给出提示。这二者都要求重新给出下棋位置，即当前鼠标响应无效…直到点击到棋盘有效区域。
（4）、IsOver(int[][] Array,int x,int y)
判断当前int[][]Array对应的棋局是否结束，即一方五子连成一条直线。此处有两种思路，一种对当前棋面上的所有棋子都进行一次判断，具体为水平方向、竖直方向、与水平线成45度方向、与水平线成135度方向，只要有一个方向五子连成一条直线就说明有一方获胜，游戏结束；另一种思路为只在当前下棋的4个方向进行判断，我的程序采用的是第二种，所以IsOver方法除了int[][]Array参数外，还有x,y参数，（x,y）表示当前下棋的坐标点。
（5）display()
通过调用自定义面板类的显示回调函数用于重新显示游戏界面，达到每下一步棋及时更新游戏界面的目的。
（6）、GetValue(int flag, int num)
估值函数，根据经验把棋局分成只有1颗棋相连，2颗棋相连且两端被封死，2颗棋相连且一端封死另一端活的，2颗棋相连且两端都是活的，同理3颗棋、4颗棋也各自可分3种情况。不同的情况对应不同的估价值。估价值的设定是决定计算机一方是否智能的一个关键因素。
（7）、GetPredictValue(int flag, int num)
对未连成一片但通过再下一颗子就能连成一片的局面进行估值，这在双方下棋的有限步骤内是能产生重要影响的。如果每局棋仅考虑当前一步，是不可取的。
（8）、Evaluate(int[][] Array, int x, int y)
根据棋面具体情况以及预先设定的估值函数，对某个点对应的局面进行评估。由于每次双方只能下一颗棋，所以可以每次取当前局面的所有点中对应估值最大值点的估值作为整个局面的估值。
（9）、GetGreedNext()
计算机下棋方法1，对应难度等级为简单，采用贪心思想。每次下棋前在求得最有利点下棋，而是否最有利只是通过一步评估。算法伪码描述为：
Max取负无穷大
for(行i从0到15)
{
For(列j从0到15)
{
If((i，j)对应的位置无棋)
{
a.假设放上一颗由人控制的棋，求估价值；
b.假设放上一颗由计算机控制的棋，求估价值；
c.取二者中较大值作为(i,j）处的估价值tmp；
d.取tmp与Max较大值赋值给Max.
}
}
}
最终Max对应的点就是当前整个局面中最大的估值点。至于上述为什么要考虑双方都在该点下棋的情况呢？主要原因为下五子棋是个攻防兼备的过程，不仅要考虑自己对自己最有利，还要考虑对对手最不利，通俗来讲就是在自己赢的时候不能让对手先赢。
（10）、GetSearchNext(int LookLength)
derectSearch(int [][]Array,boolean who,int deepth)
计算机下棋方法2：直接搜索法,对应难度等级为中等。
每步棋最多有225个不同下法，若采用直接搜索法则对应的孩子节点有225个（在下棋过程中会逐渐减少），即每层有最多225个节点待扩展，这就决定了直接搜索进行不超过2次—主要原因有两点：
a.采用深度优先搜索需要递归，递归中状态过多可能会爆栈，我们知道递归是用栈机制来实现的；采用宽度优先搜索又需要存储为扩展的节点，这对内存容量要求很高。
b.不管深搜还是广搜，在时间复杂度为O(N^m)的情况下都是不能接受的。其中N为当前棋局的待扩展节点，最大225;m为搜索的深度。
综上所述，在采用直接搜索法时搜索深度不能太深，严格来说是应该控制在2层以内，在计算机运算速度在10^7次每秒的情况下，理论和实验都表明超过2层就会变得很慢且这种趋势成指数级增长。
直接搜索算法伪代码为
GetSearch(boolean flag，int deep)
{
如果deep等于0，返回当前棋局估值；
for(行i从0到15)
{
For(列j从0到15)
{
If((i，j)对应的位置无棋)
{
如果轮到计算机下棋，置标志位为2
GetSearch(！flag，deep-1)；
如果轮到人下棋，置标志位为1；
GetSearch(！flag，deep-1)；
}
}
}
}
（11）、GetMinMaxsearchNext(int LookLength)
MinMaxsearch(int [][]Array,boolean who, int deepth)
计算机下棋算法3：极大极小博弈树法,对应难度等级为困难。五子棋是个博弈游戏，当前在寻找对自己最有利的下棋点时要尽可能保证对对手最不利，这种思想可以用极大极小博弈树
网页名称：java军棋人机对战代码 c语言五子棋人机对战代码
URL标题：http://dzwzjz.com/article/hpodcj.html