五子棋java源码
Ⅰ java 五子棋 源代码 在我的基础上加个悔棋 判断胜负后把胜利的一方显示在屏幕上 或别的标明胜利一方的 谢
我的设计是：
allChess[19][19] ;//19 * 19 的棋盘 存放所有的棋子
0 --> 当前没有棋子
1 --> 黑子
2 --> 白子
比如： allChess[2][3]=2 --> 第3行第4列为白子
如果想要悔棋的话，我的理解是这样的：
拿白子举例：
每下一个白子后，保存两个数组，连续下两次白子之后的数组，如果想悔棋，黑方确认之后，返回到上一次白子下后的数组。
楼主这样试试
Ⅱ 求五子棋代码（要java写的），有界面
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
import java.awt.Color;
public class WuZhiqi extends Applet implements ActionListener, MouseListener,
MouseMotionListener, ItemListener {
int color = 0;// 旗子的颜色标识 0:白子 1:黑子
boolean isStart = false;// 游戏开始标志
int bodyArray[][] = new int[16][16]; // 设置棋盘棋子状态 0 无子 1 白子 2 黑子
Button b1 = new Button("游戏开始");
Button b2 = new Button("重置游戏");
Label lblWin = new Label(" ");
Checkbox ckbHB[] = new Checkbox[2];
CheckboxGroup ckgHB = new CheckboxGroup();
public void init() {
setLayout(null);
addMouseListener(this);
add(b1);
b1.setBounds(330, 50, 80, 30);
b1.addActionListener(this);
add(b2);
b2.setBounds(330, 90, 80, 30);
b2.addActionListener(this);
ckbHB[0] = new Checkbox("白子先", ckgHB, false);
ckbHB[0].setBounds(320, 20, 60, 30);
ckbHB[1] = new Checkbox("黑子先", ckgHB, false);
ckbHB[1].setBounds(380, 20, 60, 30);
add(ckbHB[0]);
add(ckbHB[1]);
ckbHB[0].addItemListener(this);
ckbHB[1].addItemListener(this);
add(lblWin);
lblWin.setBounds(330, 130, 80, 30);
gameInit();
this.resize(new Dimension(450,350));
}
public void itemStateChanged(ItemEvent e) {
if (ckbHB[0].getState()) // 选择黑子先还是白子先
{
color = 0;
} else {
color= 1;
}
}
public void actionPerformed(ActionEvent e) {
if (e.getSource() == b1) {
gameStart();
} else {
reStart();
}
}
public void mousePressed(MouseEvent e) {
}
public void mouseClicked(MouseEvent e) {
int x1, y1;
x1 = e.getX();
y1 = e.getY();
if (e.getX() < 20 || e.getX() > 300 || e.getY() < 20 || e.getY() > 300) {
return;
}
if (x1 % 20 > 10) {
x1 += 20;
}
if (y1 % 20 > 10) {
y1 += 20;
}
x1 = x1 / 20 * 20;
y1 = y1 / 20 * 20;
setDown(x1, y1);
}
public void mouseEntered(MouseEvent e) {
}
public void mouseExited(MouseEvent e) {
}
public void mouseReleased(MouseEvent e) {
}
public void mouseDragged(MouseEvent e) {
}
public void mouseMoved(MouseEvent e) {
}
public void paint(Graphics g) {
g.setColor(Color.lightGray);
g.fill3DRect(10, 10, 300, 300, true);
g.setColor(Color.black);
for (int i = 1; i < 16; i++) {
g.drawLine(20, 20 * i, 300, 20 * i);
g.drawLine(20 * i, 20, 20 * i, 300);
}
}
public void setDown(int x, int y) // 落子
{
if (!isStart) // 判断游戏未开始
{
return;
}
if (bodyArray[x / 20][y / 20] != 0) {
return;
}
Graphics g = getGraphics();
if (color == 1)// 判断黑子还是白子
{
g.setColor(Color.black);
color = 0;
} else {
g.setColor(Color.white);
color = 1;
}
g.fillOval(x - 10, y - 10, 20, 20);
bodyArray[x / 20][y / 20] = color + 1;
if (gameWin1(x / 20, y / 20)) // 判断输赢
{
lblWin.setText(startColor(color) + "赢了!");
isStart = false;
}
if (gameWin2(x / 20, y / 20)) // 判断输赢
{
lblWin.setText(startColor(color) + "赢了!");
isStart = false;
}
if (gameWin3(x / 20, y / 20)) // 判断输赢
{
lblWin.setText(startColor(color) + "赢了!");
isStart = false;
}
if (gameWin4(x / 20, y / 20)) // 判断输赢
{
lblWin.setText(startColor(color) + "赢了!");
isStart = false;
}
}
public String startColor(int x) {
if (x == 0) {
return "黑子";
} else {
return "白子";
}
}
public void gameStart() // 游戏开始
{
isStart = true;
enableGame(false);
b2.setEnabled(true);
}
public void gameInit() // 游戏开始初始化
{
isStart = false;
enableGame(true);
b2.setEnabled(false);
ckbHB[0].setState(true);
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
bodyArray[i][j] = 0;
}
}
lblWin.setText("");
}
public void reStart() // 游戏重新开始
{
repaint();
gameInit();
}
public void enableGame(boolean e) // 设置组件状态
{
b1.setEnabled(e);
b2.setEnabled(e);
ckbHB[0].setEnabled(e);
ckbHB[1].setEnabled(e);
}
public boolean gameWin1(int x, int y) // 判断输赢 横
{
int x1, y1, t = 1;
x1 = x;
y1 = y;
for (int i = 1; i < 5; i++) {
if (x1 > 15) {
break;
}
if (bodyArray[x1 + i][y1] == bodyArray[x][y]) {
t += 1;
} else {
break;
}
}
for (int i = 1; i < 5; i++) {
if (x1 < 1) {
break;
}
if (bodyArray[x1 - i][y1] == bodyArray[x][y]) {
t += 1;
} else {
break;
}
}
if (t > 4) {
return true;
} else {
return false;
}
}
public boolean gameWin2(int x, int y) // 判断输赢 竖
{
int x1, y1, t = 1;
x1 = x;
y1 = y;
for (int i = 1; i < 5; i++) {
if (x1 > 15) {
break;
}
if (bodyArray[x1][y1 + i] == bodyArray[x][y]) {
t += 1;
} else {
break;
}
}
for (int i = 1; i < 5; i++) {
if (x1 < 1) {
break;
}
if (bodyArray[x1][y1 - i] == bodyArray[x][y]) {
t += 1;
} else {
break;
}
}
if (t > 4) {
return true;
} else {
return false;
}
}
public boolean gameWin3(int x, int y) // 判断输赢 左斜
{
int x1, y1, t = 1;
x1 = x;
y1 = y;
for (int i = 1; i < 5; i++) {
if (x1 > 15) {
break;
}
if (bodyArray[x1 + i][y1 - i] == bodyArray[x][y]) {
t += 1;
} else {
break;
}
}
for (int i = 1; i < 5; i++) {
if (x1 < 1) {
break;
}
if (bodyArray[x1 - i][y1 + i] == bodyArray[x][y]) {
t += 1;
} else {
break;
}
}
if (t > 4) {
return true;
} else {
return false;
}
}
public boolean gameWin4(int x, int y) // 判断输赢 左斜
{
int x1, y1, t = 1;
x1 = x;
y1 = y;
for (int i = 1; i < 5; i++) {
if (x1 > 15) {
break;
}
if (bodyArray[x1 + i][y1 + i] == bodyArray[x][y]) {
t += 1;
} else {
break;
}
}
for (int i = 1; i < 5; i++) {
if (x1 < 1) {
break;
}
if (bodyArray[x1 - i][y1 - i] == bodyArray[x][y]) {
t += 1;
} else {
break;
}
}
if (t > 4) {
return true;
} else {
return false;
}
}
}
Ⅲ 求一个简单的JAVA五子棋代码！！ 网上复制的别来了！
我有一个，刚刚做的。可以实现人机对战，人人对战，悔棋，禁手等操作。机器方主要采用的是a-b剪枝算法。功能很强大，代码很多。
Ⅳ 跪求JAVA五子棋源代码
很sb的电脑五子棋：
import java.io.*;
import java.util.*;
public class Gobang {
// 定义一个二维数组来充当棋盘
private String[][] board;
// 定义棋盘的大小
private static int BOARD_SIZE = 15;
public void initBoard() {
// 初始化棋盘数组
board = new String[BOARD_SIZE][BOARD_SIZE];
// 把每个元素赋为"╋"，用于在控制台画出棋盘
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
// windows是一行一行来打印的。坐标值为(行值, 列值)
board[i][j] = "╋";
}
}
}
// 在控制台输出棋盘的方法
public void printBoard() {
// 打印每个数组元素
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
// 打印数组元素后不换行
System.out.print(board[i][j]);
}
// 每打印完一行数组元素后输出一个换行符
System.out.print("\n");
}
}
// 该方法处理电脑下棋：随机生成2个整数，作为电脑下棋的坐标，赋给board数组。
private void compPlay() {
// 构造一个随机数生成器
Random rnd = new Random();
// Random类的nextInt(int n))方法：随机地生成并返回指定范围中的一个 int 值，
// 即：在此随机数生成器序列中 0（包括）和 n（不包括）之间均匀分布的一个int值。
int compXPos = rnd.nextInt(15);
int compYPos = rnd.nextInt(15);
// 保证电脑下的棋的坐标上不能已经有棋子（通过判断对应数组元素只能是"╋"来确定）
while (board[compXPos][compYPos].equals("╋") == false) {
compXPos = rnd.nextInt(15);
compYPos = rnd.nextInt(15);
}
System.out.println(compXPos);
System.out.println(compYPos);
// 把对应的数组元素赋为"○"。
board[compXPos][compYPos] = "○";
}
// 该方法用于判断胜负：进行四次循环扫描，判断横、竖、左斜、右斜是否有5个棋连在一起
private boolean judgeWin() {
// flag表示是否可以断定赢/输
boolean flag = false;
// joinEle：将每一个横/竖/左斜/右斜行中的元素连接起来得到的一个字符串
String joinEle;
// 进行横行扫描
for (int i = 0; i < BOARD_SIZE; i++) {
// 每扫描一行前，将joinEle清空
joinEle = "";
for (int j = 0; j < BOARD_SIZE; j++) {
joinEle += board[i][j];
}
// String类的contains方法：当且仅当该字符串包含指定的字符序列时，返回true。
if (joinEle.contains("●●●●●")) {
System.out.println("您赢啦！");
flag = true;
// 停止往下继续执行，提前返回flag。
// 如果执行了这个return，就直接返回该方法的调用处；
// 不会再执行后面的任何语句，包括最后那个return语句。
// （而break仅仅是完全跳出这个for循环，还会继续执行下面的for循环。）
return flag;
} else if (joinEle.contains("○○○○○")) {
System.out.println("您输啦！");
flag = true;
// 提前返回flag
return flag;
}
}
// 进行竖行扫描
for (int i = 0; i < BOARD_SIZE; i++) {
joinEle = "";
for (int j = 0; j < BOARD_SIZE; j++) {
// 竖行的元素是它们的列值相同
joinEle += board[j][i];
}
if (joinEle.contains("●●●●●")) {
System.out.println("您赢啦！");
flag = true;
return flag;
} else if (joinEle.contains("○○○○○")) {
System.out.println("您输啦！");
flag = true;
return flag;
}
}
// 进行左斜行扫描
for (int i = -(BOARD_SIZE - 2); i < BOARD_SIZE - 1; i++) {
joinEle = "";
for (int j = 0; j < BOARD_SIZE; j++) {
int line = i + j;
// 只截取坐标值没有越界的点
if (line >= 0 && line < 15) {
joinEle += board[j][line];
}
}
if (joinEle.contains("●●●●●")) {
System.out.println("您赢啦！");
flag = true;
return flag;
} else if (joinEle.contains("○○○○○")) {
System.out.println("您输啦！");
flag = true;
return flag;
}
}
// 进行右斜行扫描
for (int i = 1; i < 2 * (BOARD_SIZE - 1); i++) {
joinEle = "";
for (int j = 0; j < BOARD_SIZE; j++) {
int line = i - j;
if (line >= 0 && line < 15) {
joinEle += board[j][line];
}
}
if (joinEle.contains("●●●●●")) {
System.out.println("您赢啦！");
flag = true;
return flag;
} else if (joinEle.contains("○○○○○")) {
System.out.println("您输啦！");
flag = true;
// 最后这个return可省略
}
}
// 确保该方法有返回值（如果上面条件都不满足时）
return flag;
}
public static void main(String[] args) throws Exception, IOException {
Gobang gb = new Gobang();
gb.initBoard();
gb.printBoard();
// BufferedReader类：带缓存的读取器————从字符输入流中读取文本，并缓存字符。可用于高效读取字符、数组和行。
// 最好用它来包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。
// 下面构造一个读取器对象。
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
// 定义输入字符串
String inputStr = null;
// br.readLine()：每当在键盘上输入一行内容按回车，刚输入的内容将被br（读取器对象）读取到。
// BufferedReader类的readLine方法：读取一个文本行。
// 初始状态由于无任何输入，br.readLine()会抛出异常。因而main方法要捕捉异常。
while ((inputStr = br.readLine()) != null) {
// 将用户输入的字符串以逗号（,）作为分隔符，分隔成2个字符串。
// String类的split方法，将会返回一个拆分后的字符串数组。
String[] posStrArr = inputStr.split(",");
// 将2个字符串转换成用户下棋的坐标
int xPos = Integer.parseInt(posStrArr[0]);
int yPos = Integer.parseInt(posStrArr[1]);
// 校验用户下棋坐标的有效性，只能是数字，不能超出棋盘范围
if (xPos > 15 || xPos < 1 || yPos > 15 || yPos < 1) {
System.out.println("您下棋的坐标值应在1到15之间，请重新输入！");
continue;
}
// 保证用户下的棋的坐标上不能已经有棋子（通过判断对应数组元素只能是"╋"来确定）
// String类的equals方法：比较字符串和指定对象是否相等。结果返回true或false。
if (gb.board[xPos - 1][yPos - 1].equals("╋")) {
// 把对应的数组元素赋为"●"。
gb.board[xPos - 1][yPos - 1] = "●";
} else {
System.out.println("您下棋的点已有棋子，请重新输入！");
continue;
}
// 电脑下棋
gb.compPlay();
gb.printBoard();
// 每次下棋后，看是否可以断定赢/输了
if (gb.judgeWin() == false) {
System.out.println("请输入您下棋的坐标，应以x,y的格式：");
} else {
// 完全跳出这个while循环，结束下棋
break;
}
}
}
}
Ⅳ java五子棋源代码
抄来的
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(userNumber>0 && !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;i<50;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;i<50;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代码，要有图形话界面，可以打包直接运行的。
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
class mypanel extends Panel implements MouseListener
{
int chess[][] = new int[11][11];
boolean Is_Black_True;
mypanel()
{
Is_Black_True = true;
for(int i = 0;i < 11;i++)
{
for(int j = 0;j < 11;j++)
{
chess[i][j] = 0;
}
}
addMouseListener(this);
setBackground(Color.BLUE);
setBounds(0, 0, 360, 360);
setVisible(true);
}
public void mousePressed(MouseEvent e)
{
int x = e.getX();
int y = e.getY();
if(x < 25 || x > 330 + 25 ||y < 25 || y > 330+25)
{
return;
}
if(chess[x/30-1][y/30-1] != 0)
{
return;
}
if(Is_Black_True == true)
{
chess[x/30-1][y/30-1] = 1;
Is_Black_True = false;
repaint();
Justisewiner();
return;
}
if(Is_Black_True == false)
{
chess[x/30-1][y/30-1] = 2;
Is_Black_True = true;
repaint();
Justisewiner();
return;
}
}
void Drawline(Graphics g)
{
for(int i = 30;i <= 330;i += 30)
{
for(int j = 30;j <= 330; j+= 30)
{
g.setColor(Color.WHITE);
g.drawLine(i, j, i, 330);
}
}
for(int j = 30;j <= 330;j += 30)
{
g.setColor(Color.WHITE);
g.drawLine(30, j, 330, j);
}
}
void Drawchess(Graphics g)
{
for(int i = 0;i < 11;i++)
{
for(int j = 0;j < 11;j++)
{
if(chess[i][j] == 1)
{
g.setColor(Color.BLACK);
g.fillOval((i + 1) * 30 - 8, (j + 1) * 30 - 8, 16, 16);
}
if(chess[i][j] == 2)
{
g.setColor(Color.WHITE);
g.fillOval((i + 1) * 30 - 8, (j + 1) * 30 - 8, 16, 16);
}
}
}
}
void Justisewiner()
{
int black_count = 0;
int white_count = 0;
int i = 0;
for(i = 0;i < 11;i++)//横向判断
{
for(int j = 0;j < 11;j++)
{
if(chess[i][j] == 1)
{
black_count++;
if(black_count == 5)
{
JOptionPane.showMessageDialog(this, "黑棋胜利");
Clear_Chess();
return;
}
}
else
{
black_count = 0;
}
if(chess[i][j] == 2)
{
white_count++;
if(white_count == 5)
{
JOptionPane.showMessageDialog(this, "白棋胜利");
Clear_Chess();
return;
}
}
else
{
white_count = 0;
}
}
}
for(i = 0;i < 11;i++)//竖向判断
{
for(int j = 0;j < 11;j++)
{
if(chess[j][i] == 1)
{
black_count++;
if(black_count == 5)
{
JOptionPane.showMessageDialog(this, "黑棋胜利");
Clear_Chess();
return;
}
}
else
{
black_count = 0;
}
if(chess[j][i] == 2)
{
white_count++;
if(white_count == 5)
{
JOptionPane.showMessageDialog(this, "白棋胜利");
Clear_Chess();
return;
}
}
else
{
white_count = 0;
}
}
}
for(i = 0;i < 7;i++)//左向右斜判断
{
for(int j = 0;j < 7;j++)
{
for(int k = 0;k < 5;k++)
{
if(chess[i + k][j + k] == 1)
{
black_count++;
if(black_count == 5)
{
JOptionPane.showMessageDialog(this, "黑棋胜利");
Clear_Chess();
return;
}
}
else
{
black_count = 0;
}
if(chess[i + k][j + k] == 2)
{
white_count++;
if(white_count == 5)
{
JOptionPane.showMessageDialog(this, "白棋胜利");
Clear_Chess();
return;
}
}
else
{
white_count = 0;
}
}
}
}
for(i = 4;i < 11;i++)//右向左斜判断
{
for(int j = 6;j >= 0;j--)
{
for(int k = 0;k < 5;k++)
{
if(chess[i - k][j + k] == 1)
{
black_count++;
if(black_count == 5)
{
JOptionPane.showMessageDialog(this, "黑棋胜利");
Clear_Chess();
return;
}
}
else
{
black_count = 0;
}
if(chess[i - k][j + k] == 2)
{
white_count++;
if(white_count == 5)
{
JOptionPane.showMessageDialog(this, "白棋胜利");
Clear_Chess();
return;
}
}
else
{
white_count = 0;
}
}
}
}
}
void Clear_Chess()
{
for(int i=0;i<11;i++)
{
for(int j=0;j<11;j++)
{
chess[i][j]=0;
}
}
repaint();
}
public void paint(Graphics g)
{
Drawline(g);
Drawchess(g);
}
public void mouseExited(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseClicked(MouseEvent e){}
}
class myframe extends Frame implements WindowListener
{
mypanel panel;
myframe()
{
setLayout(null);
panel = new mypanel();
add(panel);
panel.setBounds(0,23, 360, 360);
setTitle("单人版五子棋");
setBounds(200, 200, 360, 383);
setVisible(true);
addWindowListener(this);
}
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent e){}
public void windowActivated(WindowEvent e){}
public void windowOpened(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
}
public class mywindow
{
public static void main(String argc [])
{
myframe f = new myframe();
}
}
Ⅶ 关于java五子棋的代码
//棋子枚举类
publicenumChessman
{
//枚举类第一行必须列出所有实例，这两个表示创建两个棋子视力，它们的棋子成员变量分别是●和○
BLACK_CHESS("●"),WHITE_CHESS("○");
//成员变量，决定这个棋子的类型
privateStringchessman;
//构造器，枚举类的构造器只能提供给自己的实例使用，外部不能调用
privateChessman(Stringchessman)
{
this.chessman=chessman;
}
//获取棋子类型
publicStringgetChessman()
{
returnthis.chessman;
}
}
进行了一下小改动，
1、排版
2、我没记错的话枚举实例是不能使用中文的
Ⅷ java五子棋源代码判断输赢，希望帮忙指出错误并完善
可以建立一个二维数组的数据结构：
int[][] ISFIVE = {
{2,2,1,1,1,1,1,2,2},
{1,1,1,1,1,2,2,2,2},
{2,1,1,1,1,1,2,2,2},
{2,2,2,1,1,1,1,1,2},
{2,2,2,2,1,1,1,1,1}
};
中间那个就是目前下子的位置，1表示和目前子相同颜色，2表示任意。0表示必须是空子，才合格，比如
int[][] ISFOUR = { {0,1,1,1,1,0,2,2,2},
{2,0,1,1,1,1,0,2,2},
{2,2,0,1,1,1,1,0,2},
{2,2,2,0,1,1,1,1,0}
};以上的二维数组中的数组都是属于活四，必胜棋型了。按照这个方法可以描绘出所有棋型。
关于你说的斜线部分，其实变通一下，就是数组的旋转而已，比如X,Y是当前落子的坐标，它的横向 就是 int[] temp= new int[9];
for(int i=-4;i<=4;i++){
temp[i+4] = qipan[x+i][y];
}
纵向就是
for(int i=-4;i<=4;i++){
temp[i+4] = qipan[x][y+i];
}
其实规律可以加入方向因子来解决,p,q的值为[1,0]表横向，[0.1]表纵向，[1,1]和[-1,-1]表两个斜向。
for(int i = -4;i<=4;i++){
temp[i+4] = qipan[x+p*i][y+p*i]
}
这个temp数组和上面的二维数组比较，合格就是那个棋型，就能得到4个走向的棋型。我的思路大致是这样，具体AI的设计就不一一细说了。