五子棋控制台显示

最新推荐文章于 2021-10-09 13:54:50 发布

原创最新推荐文章于 2021-10-09 13:54:50 发布 · 1.2k 阅读

0 ·

CC 4.0 BY-SA版权

java 专栏收录该内容

8 篇文章

订阅专栏

本文介绍了一个简单的五子棋游戏程序的设计与实现过程。通过定义棋盘类、棋子类和游戏类，实现了用户交互、游戏逻辑判断等功能。具体包括棋盘初始化、用户输入验证、胜负判断等关键环节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

三个类：

一、Chessboard

棋盘类

棋盘初始化

棋盘输出

棋盘赋值

返回棋盘

二、Chessman

棋手类

黑手

白手

三、gobangGame

五子棋游戏类

机器人下棋位置

是否重来

输入是否合法

判断输赢

流程如下：

1、初始化棋盘，将棋盘显示

2、获取用户输入

3、判断输入是否合法

4、用户将输入放到棋盘

5、判断是否赢，赢了将isOver设置成true

6、如果用户没赢，计算机下棋后，判断是否赢，赢了将isOver设置成true

7、如果赢了，看用户是否继续还是退出

代码如下：

Chessboard：

package com.gobang;

public class Chessboard {
	//定义一个二维数组来充当棋盘
	private String[][] board;
	//定义棋盘大小
	public static final int BOARD_SIZE=22;
	
	/**
	 * 初始化棋盘
	 */
	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++) {
				board[i][j] = "十";
			}
		}
	}
	
	//???
	public void test(){
		Object[][] array = new Object[10][10];
		for (int i = 0; i < array.length; i++) {
			for (int j = 0; j < array[i].length; j++) {
				array[i][j] = new Object();
			}
		}
	}
	
	/**
	 * 控制台输出棋盘
	 */
	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");
		}
	}
	
	/**
	 * 给棋盘赋值
	 * @param posX
	 *           X坐标
	 * @param posY
	 *           y坐标
	 * @param chessman
	 *           棋子
	 */
	public void setBoard(int posX, int posY, String chessman){
		this.board[posX][posY] = chessman;
	}
	
	/**
	 * 返回棋盘
	 * 
	 * @return 返回棋盘
	 */
	public String[][] getBoard(){
		return this.board;
	}
}

Chessman：

package com.gobang;

/**
 * 棋子枚举类
 * @author zj
 *
 */

public enum Chessman {
	BLACK("●"), WHITE("○");
	private String chessman;
	
	private Chessman(String chessman){
		this.chessman = chessman;
	}
	
	public String getChessman(){
		return this.chessman;
	}
}

gobangGame：

package com.gobang;

import java.io.BufferedReader;
import java.io.InputStreamReader;

import org.omg.CORBA.PUBLIC_MEMBER;

public class gobangGame {
	//定义达到赢条件的棋子数目
	private final int WIN_COUNT = 5;
	//定义用户输入的x坐标
	private int posX = 0;
	//定义用户输入的y坐标
	private int posY = 0;
	//定义棋盘
	private Chessboard chessboard;
	
	/**
	 * 空构造函数
	 */
	public gobangGame(){
		
	}
	
	/**
	 * 构造函数
	 */
	public gobangGame(Chessboard chessboard){
		this.chessboard = chessboard;
	}
	
	/**
	 * 检查输入是否合法
	 * 
	 */
	public boolean isValid(String inputStr){
		//将用户输入的字符串以逗号作为分隔
		String[] posStrArr = inputStr.split(",");
		try {
			posX = Integer.parseInt(posStrArr[0]) - 1;
			posY = Integer.parseInt(posStrArr[1]) - 1;
		} catch (NumberFormatException e) {
			chessboard.printBoard();
			System.out.println("请以（数字，数字）的格式输入：");
			return false;
		}
		//检查输入数值是否在范围之内
		if(posX<0 || posX >= Chessboard.BOARD_SIZE 
		   || posY<0 || posY >= Chessboard.BOARD_SIZE){
			chessboard.printBoard();
			System.out.println("X与Y坐标只能大于等于1，小于等于" + Chessboard.BOARD_SIZE + ",请重新输入");
			return false;
		}
		
		//检查输入位置是否已经有棋子
		String[][] board = chessboard.getBoard();
		if(board[posX][posY] != "十"){
			chessboard.printBoard();
			System.out.println("此位置已经有棋子,请重新输入: ");
			return false;
		}
		return true;
	}
	
	/**
	 * 开始下棋
	 */
	public void start() throws Exception{
		//true为游戏结束
		boolean isOver = false;
		chessboard.initBoard();
		chessboard.printBoard();
		
		//获取键盘的输入
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String inputStr = null;
		
		while((inputStr = br.readLine()) != null){
			isOver = false;
			if(!isValid(inputStr)){
				//不合法继续输入
				continue;
			}
			
			//把对应的数组赋值为“●”
			String chessman = Chessman.BLACK.getChessman();
			chessboard.setBoard(posX, posY, chessman);
			
			//判断用户是否赢了
			if(isWon(posX, posY, chessman)){
				isOver = true;
			}else{
				//计算机随机选择位置坐标
				int[] computerPosArr = computerDo();
				chessman = Chessman.WHITE.getChessman();
				chessboard.setBoard(computerPosArr[0], computerPosArr[1], chessman);
				
				//判断计算机是否赢了
				if(isWon(computerPosArr[0], computerPosArr[1], chessman)){
					isOver = true;
				}
			}
			
			//如果产生胜者，询问是否继续
			if(isOver){
				//如果继续，重新初始化棋盘，继续游戏
				if(isReplay(chessman)){
					chessboard.initBoard();
					chessboard.printBoard();
					continue;
				}
				//如果不继续，退出程序
				break;
			}
			
			chessboard.printBoard();
			System.out.println("请输入您下棋的坐标，应该以x，y格式输入：");
		}
		
	}
	/**
	 * 是否重新开始下棋
	 * 
	 */
	public boolean isReplay(String chessman) throws Exception{
		chessboard.printBoard();
		String message = chessman.equals(Chessman.BLACK.getChessman()) ? "恭喜您，您赢了" :
			"很遗憾，您输了";
		System.out.println(message + "再下一局?(y/n)");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		if(br.readLine().equals("y")){
			return true;
		}
		return false;
	}
	
	/**
	 * 计算机随机下棋
	 */
	public int[] computerDo(){
		int posX = (int)(Math.random()*(Chessboard.BOARD_SIZE - 1));
		int posY = (int)(Math.random()*(Chessboard.BOARD_SIZE - 1));
		String[][] board = chessboard.getBoard();
		while(board[posX][posY] != "十"){
			 posX = (int)(Math.random()*(Chessboard.BOARD_SIZE - 1));
			 posY = (int)(Math.random()*(Chessboard.BOARD_SIZE - 1));
		}
		int[] result = {posX, posY};
		return result;
	}
	
	/**
	 * 判断输赢
	 */
	public boolean isWon(int posX, int posY, String ico){
		//直线起点的x坐标
		int startX = 0;
		//直线起点的y坐标
		int startY = 0;
		//直线结束x坐标
		int endX = Chessboard.BOARD_SIZE-1;
		//直线结束y坐标
		int endY = endX;
		
		//同一直线上相邻棋子累计数
		int sameCount = 0;
		int temp = 0;
		
		//计算起点的最小x坐标与y坐标
		temp = posX - WIN_COUNT + 1;
		startX = temp < 0 ? 0 : temp;
		temp = posY - WIN_COUNT + 1;
		startY = temp < 0 ? 0 : temp;
		
		//计算终点的最大x坐标与y坐标
		temp = posX + WIN_COUNT - 1;
		endX = temp > Chessboard.BOARD_SIZE - 1 ? Chessboard.BOARD_SIZE - 1 : temp;
		temp = posY + WIN_COUNT - 1;
		endY = temp > Chessboard.BOARD_SIZE - 1 ? Chessboard.BOARD_SIZE - 1 : temp;
		
		//从左到右方向计算相同相邻棋子的数目
		String[][] board = chessboard.getBoard();
		for (int i = startY; i < endY; i++) {
			if(board[posX][i] == ico && board[posX][i+1] == ico){
				sameCount++;
			}else if(sameCount != WIN_COUNT-1){
				sameCount = 0;
			}
		}
		if(sameCount == 0){
			//从上到下计算相同相邻棋子的数目
			for (int i = startX; i < endX; i++) {
				if (board[i][posY] == ico && board[i+1][posY] == ico) {
					sameCount++;
				}else if (sameCount != WIN_COUNT-1) {
					sameCount = 0;
				}
			}
		}
		
		if(sameCount == 0){
			//从左上到右下计算相同相邻棋子的数目
			int j = startY;
			for (int i = startX; i < endX; i++) 
			{
				 if(j < endY)
				 {
					if (board[i][j] == ico && board[i+1][j+1] == ico) {
						sameCount++;
					}else if (sameCount != WIN_COUNT-1) {
						sameCount = 0;
					}
					j++;
				}
			}
		}
		
		return sameCount == WIN_COUNT - 1 ? true : false;
		
	}
	
	public static void main(String[] args) throws Exception{
		gobangGame gb = new gobangGame(new Chessboard());
		gb.start();
	}
}