Java五子棋（局域网）

于 2021-08-15 16:59:05 发布
阅读量2.3k 收藏 41
点赞数 2
分类专栏： 项目 文章标签： java 游戏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44685068/article/details/119702146
版权
本文介绍了一款使用Java实现的五子棋游戏，包括棋盘界面、棋子类的构建、棋盘存储和落子逻辑。游戏支持局域网对战，通过Socket进行通信，实现玩家间的信息交互。文章详细讲解了读取存档、游戏流程控制以及功能键的实现，同时提供了部分关键代码示例。
摘要由CSDN通过智能技术生成

 

先画出棋盘界面：

class Gb  extends JFrame implements MouseListener ,Runnable {
	BufferedWriter bw = null;
	BufferedReader br = null;//文档的流
    Chess[] chesses = new Chess[17 * 17];//棋子数组，每个网格一个数组
	TreeMap<Integer,Integer> tm = new TreeMap<>();//key为序号 value为坐标对应的数组index
	TreeMap<Integer,Integer> tmTemp;//读取进度时用，点击加载覆盖tm
	static int width = Toolkit.getDefaultToolkit().getScreenSize().width;
	static int height = Toolkit.getDefaultToolkit().getScreenSize().height;//获取屏幕的分辨率
    boolean isReading = false;
	boolean upCanPress = true;
	boolean downCanPress = false;//用于读取数据的三个变量

    public Gb() {
		this.setTitle("五子棋游戏完成版");
		this.setSize(900, 800);
		this.setLocation((width - 800) / 2, (height - 800) / 2 );
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setResizable(false);
		this.setVisible(true);
		this.repaint();
		this.addMouseListener(this);
		
	}

public void paint(Graphics g) {
		BufferedImage buf = new BufferedImage(900, 800, BufferedImage.TYPE_INT_RGB);//确定界面的大小，以及涂色方式为RGB
		Graphics g1 = buf.createGraphics();

            //选项
			
			//背景和棋盘底色
			//http://zhongguose.com/#zhizihuang
			g1.setColor(new Color(248,232,193));//背景颜色
			g1.fill3DRect(0, 0, 900, 800, true);//绘色：(起始坐标X，起始坐标Y，结束坐标X，结束坐标Y)
			g1.setColor(new Color(235,177,13));//棋盘色
			g1.fill3DRect(60, 60, 680, 680, true);
			
			//棋盘线
			for (int i = 80; i <= 720; i += 40) {
				g1.setColor(Color.BLACK);
				g1.drawLine(80, i, 720, i);
				g1.drawLine(i, 80, i, 720);
			}
			
			//右上角黑白棋
            //用于提醒下一棋子是什么颜色
			if(isBlack) {
				g1.setColor(Color.BLACK);
				g1.fillOval(770, 50, 30, 30);
			}else {
				g1.setColor(Color.WHITE);
				g1.fillOval(770, 50, 30, 30);
			}
			
			//音乐键
            //图片在资源文件夹中，打开放在项目文件下
			try {
				imageMusic= playMusic ? ImageIO.read(new File("performance.png")) : ImageIO.read(new File("volume-mute.png"));
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			g1.drawImage(imageMusic,820,47,null);
			
			//功能按键
			g1.setFont(new Font("微软雅黑",Font.BOLD,15));
			g1.setColor(new Color(158,204,171));
			g1.fill3DRect(770, 100, 100, 40,true);
			g1.fill3DRect(770, 170, 100, 40,true);
			g1.fill3DRect(770, 240, 100, 40,true);
			g1.fill3DRect(770, 310, 100, 40,true);
			g1.fill3DRect(770, 380, 100, 40,true);
            //读取功能，点击之后可以读档，相关按键在功能开启后出现
			if(isReading) {
				g1.fill3DRect(770, 450, 100, 40,upCanPress);
				g1.fill3DRect(770, 520, 100, 40,true);
				g1.fill3DRect(770, 590, 100, 40,downCanPress);
			}
			g1.fill3DRect(770, 660, 100, 40,true);
			
			g1.setColor(Color.BLACK);
			g1.drawString("重新开始", 780, 125);
			g1.drawString("悔棋", 780, 195);
			g1.drawString("认输", 780, 265);
			g1.drawString("保存进度", 780, 335);
			g1.drawString("读取进度", 780, 405);
			if(isReading) {
				g1.drawString("上一步", 780, 475);
				g1.drawString("加载游戏", 780, 545);
				g1.drawString("下一步", 780, 615);
			}
			g1.drawString("返回大厅", 780, 685);
			
			//棋子填充颜色
			for(int i = 0 ; i < 17 ; i++ ) {
				for(int j = 0 ; j < 17 ; j++) {
					if(chesses[ i + j * 17] != null) {
						int realX = 70 + i * 40;
						int realY = 70 + j * 40;
						//判断棋子颜色 true为黑色  false为白色
						if (chesses[i + j * 17].isBlack() == true) {
							g1.setColor(Color.BLACK);
							g1.fillOval(realX, realY, 20, 20);
						}else if (chesses[i + j * 17].isBlack() == false) {
							g1.setColor(Color.WHITE);
							g1.fillOval(realX, realY, 20, 20);
						}
					}
				}
			}

}

棋子类的构建：

public class Chess {
	private int x;
	private int y;
	private int orderNum;
	private boolean black;
	
	public Chess() {
		
	}
	public Chess(int x, int y, int orderNum, boolean color) {
		super();
		this.x = x;
		this.y = y;
		this.orderNum = orderNum;
		this.black = color;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
	public int getOrderNum() {
		return orderNum;
	}
	public void setOrderNum(int orderNum) {
		this.orderNum = orderNum;
	}
	public boolean isBlack() {
		return black;
	}
	public void setBlack(boolean color) {
		this.black = color;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Chess other = (Chess) obj;
		return black == other.black;
	}
	

	
	
}

棋子和棋盘的存储思路：

棋盘是17*17（非标准，当时一拍脑袋决定的），一般来说，用二维数组 chesses[17][17]存储棋盘信息是很符合大脑习惯的，不过二维数组有不方便的地方，直接用chesses[17 * 17]来存储了，其实也很好理解，数组索引对应每个棋子 X + Y * 17（可能需要理解一下），或者由索引反推坐标就是：X = i (数组索引) % 17;     Y = i / 17;。

chesses[17 * 17]是棋盘的存储数据，下一个棋子就会在对应索引新建一个棋子对象，并在对应的坐标绘制棋子图像。

落子的存储是用TreeMap，key为落子顺序(1,2,3,4…)，value为棋子的一维数组索引。

这样存储的好处是方便读取数据，读取存档的时候很方便。

当然还可以另一个思路：

因为Chess类中申明了落子顺序OrderNum，直接用ArrayList存储落子信息以及棋盘信息，用ArrayList的方法也很方便。

下棋子：

           //如果游戏结束，canPlay = false
            if(canPlay) {
                //下棋子
				int x = (e.getX() - 60) / 40;
				int y = (e.getY() - 60) / 40;
				if (e.getX() >= 80 && e.getY() >= 80 && e.getX() <= 720 && e.getY() <= 720) {
					//填充
					if(chesses[x + y * 17] == null) {
						chesses[x + y * 17] = new Chess(x,y,countNum++,isBlack);
						isBlack = !isBlack;
						isSaved = false;
						//测试：棋子序号 + 横坐标 + 纵坐标
						System.out.println(chesses[x + y * 17].getOrderNum() + "..." +chesses[x + y * 17].getX() + "..." + chesses[x + y * 17].getY());
						//test
						System.out.println(maxLine(chesses[x + y * 17]));
					}
					tm.put(chesses[x + y * 17].getOrderNum(), x + y * 17);
					this.repaint();
				}else {
					return;
				}
				//判断胜负
				isWin(maxLine(chesses[x + y * 17]));
			}

 maxLine方法：

米字形判断，每次落子都判断上下左右斜方向的最长连子数。

基本思路：以横向为例，落子后判断索引±4的最长连子，需要注意一个问题，就是棋子在棋盘的边界，需要加一个判断，如果纵坐标变动了（变成另一排），则重新计算maxLine。如果是竖向判断，则需要监控X坐标有无变动；斜向的话，需要监控Y坐标，如果变化为2，重新计算。

//判断最长连子数
	public int maxLine(Chess chess) {
		int xLine = 1;
		int yLine = 1;
		int rightLine = 1;
		int leftLine = 1;
		int max = 1;
		
		int index = chess.getX() + chess.getY() * 17;
		
			//横向判断 
			for (int i = index - 4 ; i < index + 4 ; i ++) {
				if (i > 0 && i < 17*17 - 1 && (i + 1) / 17 - i / 17 == 0 ) {
					if(chesses[i] != null && chesses[i].equals(chess) && chesses[i + 1] != null && chesses[i + 1].equals(chess)) {
						xLine++;
					}else {
						xLine = 1;
						continue;
					}
					max = xLine > max ? xLine : max;
				}else {
					xLine = 1;
				}
			}
		//纵向判断
		if (max == 5) {
			return 5;
		}else {
			for (int i = index - 4 * 17 ; i < index + 4 * 17 ; i += 17) {
				if (i > 0 && i < 17*17 - 17 && (i + 17) % 17 - i % 17 == 0 ) {
					if(chesses[i] != null && chesses[i].equals(chess) && chesses[i + 17] != null && chesses[i + 17].equals(chess)) {
						yLine++;
					}else {
						yLine = 1;
						continue;
					}
					max = yLine > max ? yLine : max;
				}else {
					yLine = 1;
				}
			}
		}
		
		//斜向\
		if(max == 5) {
			return 5;
		}else {
			for (int i = index - 4 * 18; i < index + 4 * 18 ; i += 18) {
				if (i > 0 && i < 17*17 -  18 && (i+ 18) / 17 - i / 17 == 1 ) {
					if(chesses[i] != null && chesses[i].equals(chess) && chesses[i + 18] != null && chesses[i + 18].equals(chess)) {
						leftLine++;
					}else {
						leftLine = 1;
						continue;
					}
					max = leftLine > max ? leftLine : max;
				}else {
					leftLine = 1;
				}
			}
		}
		
		// 斜向/
		if(max == 5) {
			return 5;
		}else {
			for (int i = index - 4 * 16; i < index + 4 * 16 ; i += 16) {
				if (i > 0 && i < 17*17 -  16 && (i+ 16) / 17 - i / 17 == 1 ) {
					if(chesses[i] != null && chesses[i].equals(chess) && chesses[i + 16] != null && chesses[i + 16].equals(chess)) {
						rightLine++;
					}else {
						rightLine = 1;
						continue;
					}
					max = rightLine > max ? rightLine : max;
				}else {
					rightLine = 1;
				}
			}
		}
		return max;	
	}

isWin方法：

//判断是否胜利，输入最长连子数
	public void isWin(int i) {
		if (i >= 5) {
			canPlay = false;
			if(isBlack == true) {
				JOptionPane.showMessageDialog(this, "白方胜利");
			}else {
				JOptionPane.showMessageDialog(this, "黑方胜利");
			}
		}
	}

canPlay用来控制能否下棋，游戏判出胜负后就不能继续落子了，需要点悔棋或者重新开始才能继续。

这样就实现了下棋的基本功能了，至于重新开始，悔棋之类的功能，在单机版很容易实现，之后会po出代码，先将一下稍微有点复杂的读取功能：

先看效果图：

选好文档后，（没有保存文档就乱点然后保存一个）就会弹出“上一步”“加载游戏”“下一步”三个功能按键，“上一步” 和 “下一步”是用来读档的，方便知道落子的顺序，同时也可以选中到想要的进度开始游戏。点击加载就可以从当前画面下的棋盘开始一局游戏了。然后，这三个功能键就会消失，等到再次读取进度的时候再出现。

功能键的画图实现代码在绘图中，功能实现代码如下：

if(e.getX() >= 770 && e.getX() <= 870 && e.getY() >= 380 && e.getY() <= 420) {//这里是坐标
				int isYes = JOptionPane.showConfirmDialog(this, "是否读取进度","readload",JOptionPane.YES_NO_OPTION);
				if(isYes== 0) {
					isReading = true;
					readLoad();//定义的一个方法，具体在一下代码块里，作用是弹出一个选择文件的框
					tmTemp = new TreeMap<>();
					for(Map.Entry<Integer, Integer> entry : tm.entrySet()) {
						tmTemp.put(entry.getKey(), entry.getValue());
					}
					
				}
			}
			/*
			 * 读取中的扩展功能
			 */
			if(isReading) {
				canPlay = false;
				canPress = false;
				int SIZE = tm.size();
				int count = tmTemp.size();
				//上一步
				if(e.getX() >= 770 && e.getX() <= 870 && e.getY() >= 450 && e.getY() <= 490 && upCanPress) {
					if(count > 0 ) {
						chesses[tmTemp.get(count)] = null;
						tmTemp.remove(count-- );
						isBlack = !isBlack;
					}
					//test
					System.out.println(tm+" " + SIZE + "\n" +tmTemp + count );
				}
				//加载
				if(e.getX() >= 770 && e.getX() <= 870 && e.getY() >= 520 && e.getY() <= 560) {
					isReading = false;
					restart();
					for(Map.Entry<Integer, Integer> entry : tmTemp.entrySet()) {
						tm.put(entry.getKey(), entry.getValue());
						chesses[entry.getValue()] = new Chess(entry.getValue() % 17 , entry.getValue() / 17 ,countNum ++ ,isBlack);
						isBlack = !isBlack;
						isWin(maxLine(chesses[entry.getValue()]));
						canPress = true;
					}
					
					this.repaint();
				}
				//下一步
				if(e.getX()
最低0.47元/天 解锁文章
_Wen___
关注
  • 2
    点赞
  • 踩
  • 41
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java五子棋局域网源代码_[Java]局域网五子棋
weixin_42668301的博客
02-26 202
package五子棋;importjava.awt.Graphics;importjava.awt.Image;importjava.awt.event.MouseAdapter;importjava.awt.event.MouseEvent;importjava.io.BufferedReader;importjava.io.BufferedWriter;importjava.io.File;i...
JAVA局域网五子棋
12-03
帮别人写的毕业设计，一个简单的局域网五子棋程序。属于半成品，因为还有一些细节功能没有做，可以作参考，注释都写得比较详细了。使用Socket做的，服务端和客户端没多少代码，所以放在同一个项目里了，设置不同的主类就可以启动服务端和客户端。 服务端主类：server.ChessServer 需要先启动，可以设置PORT 客户端主类：client.GameHall 在GameHall中可以设置服务端的IP，当前默认127.0.0.1 当服务端启动后，局域网内的客户端就可以连接至服务端，当有两个及以上的客户端连接后，GameHall中就可以互相看到对方。接着就可以邀请对方进行游戏了。 本来传输数据是直接使用自定义的字符串格式传输，后来传输在线用户信息的时候发现不好处理，临时加了个json包，运行时注意把根目录的json包也加到环境里。 仅作学习交流用途。
Java五子棋局域网联机版
07-04
Java编写的可以实现局域网联机的五子棋游戏，联机部分由Socket编程完成。代码简洁清晰，界面美观。 先由一台创建主机，另一台电脑可以输入主机ip进行连接。也可以在自己电脑上测试，输入环回IP 127.0.0.1可以在自己电脑上实现连接。 适合初学Socket编程的同僚，来理解网络编程基础。
五子棋java程序（可局域网内联机对战，随意之作）
12-10
基于java GUI的简单五子棋程序，可以局域网内联机对战，人机对战等一些地方未完善
局域网五子棋
03-09
编译环境：VS2008 界面：MFC 网络部分：WinSocket 功能：1、创建游戏房间等待玩家进入，加入游戏对话框可罗列出本局域网内所开的游戏房间，加入即可对战； 2、有单人游戏模式； 3、有英雄榜功能，记录每个ID获胜和失败次数。
java五子棋_java实现五子棋
weixin_35529833的博客
02-15 2334
一、需求分析1、画一个15x15的棋盘版面2、功能按钮：开始游戏，悔棋，认输3、单选按钮：人人对战、人机对战4、要求：在棋盘上下棋子，棋子必须要在交叉点上；同一个位置上不能有再下棋子；棋子不能消失；判断输赢。二、设计思路1、图形界面(棋盘版面)通过JFrame与JPanel 窗体实现，将JFrame分为2个部分，一部分用于绘制棋盘，另一部分用于放置功能按钮等。 并且添加监听。(1)创建窗体pub...
Java五子棋
A_D_I_D_A_S的博客
08-15 1073
今天来分享一个Java五子棋。 所涉及到的知识 1. 画图板的重绘 2. 权值算法 接口 首先定义一个BorderSize的接口，用来设置棋盘和棋子的相关属性。凡是需要用到接口中相关属性的类都必须实现BorderSize接口。 public interface BorderSize { int SIZE = 50; int ROW = 19; int C...
java五子棋局域网版
06-14
【Java五子棋局域网版】是一款基于Java编程语言开发的本地局域网游戏，主要利用了Java的Swing库构建用户界面，通过多线程技术和Socket通信实现在局域网内的玩家对战功能。游戏的核心算法是五子棋的胜负判断，这涉及...
JAVA 局域网对战五子棋游戏（基于RMI）
05-15
java 使用RMI （远程方法调）的网络对战五子棋游戏
局域网五子棋Java版.rar
08-03
局域网五子棋Java版.rar局域网五子棋Java版.rar
java局域网对战版五子棋
05-18
用java实现的五子棋源代码，能够在局域网内对战
java局域网五子棋.rar---java局域网五子棋.rar
05-13
java局域网五子棋.rar java局域网五子棋.rar java局域网五子棋.rar java局域网五子棋.rar
五子棋 单机 局域网联网对战 游戏 java源码
10-09
五子棋小程序是最近用java编写的。它具有人机对战和局域网联机对战功能。 局域网对战时程序可以自动搜索局域网中存在的游戏并且与之连接，即在局域网中打开一个五子棋程序，然后在菜单中选择联网游戏，则程序右上角会出现“正在等待连接”字样，然后如果局域网中再开启一个五子棋程序，选择了联网游戏之后经过少许时间，两个程序的右上角都会显示“已连接”字样，同时显示“游戏尚未开始”，这时只有有一方点击“开始游戏”按钮，则会开始一局游戏。程序右下角是两人聊天的窗口，可以在输入框中输入想说的内容，回车即可发送给对方。在显示框中右键单机，可以弹出“清空聊天内容”的菜单，点击可以清除聊天内容。 程序设计的比较粗糙，请谅解。
wuziqi.zip_五子棋java_局域网 五子棋
最新发布
09-20
本项目“五子棋java_局域网 五子棋”旨在为初学者提供一个实践Java编程和网络通信技术的机会，通过实现局域网对战功能，使玩家能够与附近的伙伴进行实时对弈。 【Java编程基础】 在Java中，五子棋游戏的实现通常会...
Java局域网五子棋V2
07-12
Java局域网五子棋版本2，多线程、swing界面、Socket通信、输入输出流和简单的判断输赢算法。
Android游戏: 五子棋-局域网版
weixin_44116706的博客
09-07 1084
实现环境: android studio 3.2.1, 分辨率为: 1920 * 1080 局域网采用 Socket 连接 分主活动类，主机类，客户端类 效果图： 代码如下 清单文件要添加的权限： <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" /> <uses-permissi...
五子棋局域网联机版
03-08
网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。 建立网络通信连接至少要一对端口号(socket)。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口；HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值