写一个简易版的连连看

最新推荐文章于 2022-07-22 10:54:43 发布
最新推荐文章于 2022-07-22 10:54:43 发布
阅读量404 收藏 1
点赞数
分类专栏： Java 文章标签： Java 连连看 控制台
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_19643/article/details/82600526
版权
[url=http://yeepay-dev.iteye.com/blog/2059620]写一个简易版的连连看[/url]

游戏规则：

1.游戏棋盘大小为6X6的矩阵，共有6种颜色的图片

2.每次初始化随机填充棋盘，同一种颜色的格子数量必须为偶数个

3.同色两个格子无障碍连线不超过2个折点则允许消除

4.不需要做出图形界面，程序启动后生成的棋盘直接在控制以数字格式输出（格式见下方）

5.程序监听控制台输入（输入格式如：2,3;4,2），程序根据输入的坐标判断两个格子能否连接消除，如果满足条件则消除，否则给出相应提示

6.每次消除后控制台输出当前棋盘，并监听下次输入，直到全部消除

输出格式：数字表示不同颜色，0表示已消除的空格

0 0 0 4 0 0

1 0 4 2 1 0

0 0 3 0 2 0

0 5 3 0 0 0

0 0 5 0 0 0

0 0 0 0 0 0 


package come.chenjo.linkgame;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
/**
 * 游戏区域类
 * @author Jonathan Chen
 *
 */
public class Chessboard {
	//定义一个二维数组来表示游戏区域
	private int[][] board;
	//定义区域的大小
	public static final int BOARD_SIZE = 6;
	/**
	 * 初始化游戏区域
	 */
	public void initBoard(){
		List<Integer> numbers = new ArrayList<Integer>();
		//生成最初的6组数字,因为我发现完全靠随机有时会漏掉1-6中的某个数字
		for(int i=0; i<6; i++){
			numbers.add(i+1);
			numbers.add(i+1);
		}
		//随机生成12组数字
		Random random = new Random();
		int temp = 0;
		for(int i=0; i<12; i++){
			temp = random.nextInt(6)+1;
			numbers.add(temp);
			numbers.add(temp);
		}	
		//打乱次序
		Collections.shuffle(numbers);	
		//初始化二维数组
		board = new int[6][6];



		temp=0;
		for(int i=0; i<BOARD_SIZE; i++){
			for(int j=0; j<BOARD_SIZE; j++){
				board[j][i] = numbers.get(temp++).intValue();
			}
		}
	}
	/**
	 * 游戏区域坐标系的定义: 以左上角为原点, 从原点向右为X轴, 向下为Y轴
	 * 普通二维数组的控制台输出恰恰相反,以左上角为原点,从原点向右为Y轴(第二维度), 向下为X轴(第一维度)
	 * 为了统一二者的坐标系, 注意下面输出二维数组时有意对调了第一维度和第二维度
	 */
	public void printBoard(){
		for(int i=0; i<BOARD_SIZE; i++){
			for(int j=0; j<BOARD_SIZE; j++){
				System.out.print(" " + board[j][i]);
			}
			System.out.println();
		}
	}

	public static void main(String[] args){
		Chessboard c = new Chessboard();
		c.initBoard();
		c.printBoard();
	}

	public void setBoard(int posX, int posY, int chessman){
		this.board[posX][posY] = chessman;
	}

	public int[][] getBoard(){
		return this.board;
	}
}



package come.chenjo.linkgame;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * 简易版的连连看游戏
 * @author Jonathan Chen
 *
 */
public class LinkGame {
	//图片一的x坐标
	private int posX1 = 0;
	//图片一的y坐标
	private int posY1 = 0;
	//图片二的x坐标
	private int posX2 = 0;
	//图片二的y坐标
	private int posY2 = 0;
	//定义游戏区域
	private Chessboard chessboard;
	/**
	 * 构造器, 初始化游戏区域
	 * @param chessboard
	 */
	public LinkGame(Chessboard chessboard){
		this.chessboard = chessboard;
	}
	/**
	 * 检查用户输入是否合法
	 * @param inputStr 用户从控制台输入的字符串
	 * @return
	 */
	public boolean isValid(String inputStr){
		String regex = "^\\d,\\d;\\d,\\d$";
		Pattern p = Pattern.compile(regex);
		Matcher m = p.matcher(inputStr);
		if(!m.find()){
			chessboard.printBoard();
			System.out.println("请输入图片的坐标，应以x1,y1;x2,y2的格式输入：");
			return false;
		}

		String[] inputStrArr = inputStr.split(";");
		String[] posStrArrA = inputStrArr[0].split(",");
		String[] posStrArrB = inputStrArr[1].split(",");
		try{
			posX1 = Integer.parseInt(posStrArrA[0]) - 1;
			posY1 = Integer.parseInt(posStrArrA[1]) - 1;
			posX2 = Integer.parseInt(posStrArrB[0]) - 1;
			posY2 = Integer.parseInt(posStrArrB[1]) - 1;

		}catch(NumberFormatException e){
			chessboard.printBoard();
			System.out.println("请输入图片的坐标，应以x1,y1;x2,y2的格式输入：");
			return false;
		}
		//检查输入数值是否在范围之内
		if(posX1 < 0 || posX1 >= Chessboard.BOARD_SIZE
				|| posY1 <0 || posY1 >= Chessboard.BOARD_SIZE
				|| posX2 <0 || posX2 >= Chessboard.BOARD_SIZE
				|| posY2 <0 || posY2 >= Chessboard.BOARD_SIZE){
			System.out.println("X与Y坐标只能大于等于1,且小于等于" + Chessboard.BOARD_SIZE
					+ ",请重新输入：");
			return false;
		}
		//检查输入的位置是否已经没有图片
		int[][] board = chessboard.getBoard();
		if(board[posX1][posY1] == 0 || board[posX2][posY2] == 0){
			System.out.println("此位置已不存在图片（非零数字），请重新输入：");
			return false;
		}
		//检查输入的位置是否重复
		if(posX1 == posX2 && posY1 == posY2){
			System.out.println("两幅图片坐标相同，请重新输入：");
			return false;
		}
		//检查输入的图片是否相同
		if(board[posX1][posY1] != board[posX2][posY2]){
			System.out.println("这两幅图片不相同，请重新输入：");
			return false;
		}

		return true;
	}
	/**
	 * 开始游戏
	 * @throws Exception
	 */
	public void start() throws Exception{
		// true表示游戏结束
		boolean isOver = false;
		chessboard.initBoard();
		chessboard.printBoard();
		System.out.println("请输入图片的坐标，应以x1,y1;x2,y2的格式输入：");
		// 获取键盘输入
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String inputStr = null;
		// br.readLine: 每当用户从键盘输入一行按回车键, 则输入被br读取
		while( (inputStr=br.readLine()) != null){
			if(!isValid(inputStr)){
				// 如果不合法, 则要求重新输入
				continue;
			}
			//检测是否满足两图片间的连线的条件
			if(isLink(posX1, posY1, posX2, posY2, chessboard.getBoard())){
				//删除满足连线条件的两图片
				removeLinkedImages(posX1, posY1, posX2, posY2);
				chessboard.printBoard();
				System.out.println("请输入图片的坐标，应以x1,y1;x2,y2的格式输入：");
				//判断是否全部图片都以消除
				if(isWon(chessboard.getBoard())){
					//如果是则该场游戏结束
					isOver = true;
				}
			}
			else{
				chessboard.printBoard();
				System.out.println("不符合连线规则（最多两折三连线），请输入两幅图片的坐标：");
			}
			// 询问用户是否继续游戏
			if (isOver) {
				// 如果继续，重新初始化游戏区域，继续游戏
				if (isReplay()) {
					isOver = false;
					chessboard.initBoard();
					chessboard.printBoard();
					continue;
				}
				// 如果不继续，则退出程序
				break;
			}			
		}
	}
	/**
	 * 判断游戏输赢
	 * @param board
	 * @return 如果全部图片都已消除(以0表示), 则返回真
	 */
	private boolean isWon(int[][] board) {
		for(int i=0; i<board.length; i++){
			for(int j=0; j<board[i].length; j++){
				if(board[i][j] != 0){
					return false;
				}
			}
		}
		return true;
	}
	/**
	 * 删除已连接的两图片
	 * @param posX1
	 * @param posY1
	 * @param posX2
	 * @param posY2
	 */
	public void removeLinkedImages(int posX1, int posY1, int posX2, int posY2){
		this.chessboard.setBoard(posX1, posY1, 0);
		this.chessboard.setBoard(posX2, posY2, 0);
	}
	/**
	 * 是否再次开始游戏
	 * @return
	 * @throws Exception
	 */
	public boolean isReplay() throws Exception {
		String message = "恭喜您，您通过了！";
		System.out.println(message + "再下一局？(y/n)");
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		if(br.readLine().equals("y")){
			return true;
		}
		return false;
	}
	/**
	 * 判断两图片能否相连
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	public boolean isLink(int posX1, int posY1, int posX2, int posY2, int[][] board){

		//是否可以一直线相连
		if(isLinkByOneLine(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		//是否可以两直线相连
		if(isLinkByTwoLines(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		//是否可以三直线相连
		if(isLinkByThreeLines(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		return false;
	}
	/**
	 * 判断在一列之内两图片之间是否全部是空白或直接相邻
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	private boolean containsAllOrNoneZeroInColumn(int posX1, int posY1, int posX2, int posY2, int[][] board){
		//直接相连,因而不包含空白
		if(Math.abs(posY1 - posY2) == 0){
			return true;
		}
		int a = posY1 < posY2 ? posY1 : posY2;
		int b = posY1 < posY2 ? posY2 : posY1;
		for(int j=a+1; j < b; j++){
			if(board[posX1][j] != 0){
				return false;
			}
		}
		return true;
	}
	/**
	 * 判断在一行之内两图片之间是否全部是空白或直接相邻
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	private boolean containsAllOrNoneZeroInRow(int posX1, int posY1, int posX2, int posY2, int[][] board){
		//直接相连,因而不包含空白
		if(Math.abs(posX1 - posX2) == 0){
			return true;
		}
		int a = posX1 < posX2 ? posX1 : posX2;
		int b = posX1 < posX2 ? posX2 : posX1;
		for(int i=a+1; i < b; i++){
			if(board[i][posY1] != 0){
				return false;
			}
		}
		return true;
	}
	/**
	 * 是否可以一直线相连
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	private boolean isLinkByOneLine(int posX1, int posY1, int posX2, int posY2, int[][] board){

		if(posX1 != posX2 && posY1 != posY2){
			return false;
		}
		if(posX1 == posX2){
			if(containsAllOrNoneZeroInColumn(posX1, posY1, posX2, posY2, board)){
				return true;
			}
		}
		if(posY1 == posY2){
			if(containsAllOrNoneZeroInRow(posX1, posY1, posX2, posY2, board)){
				return true;
			}
		}
		return false;
	}
	/**
	 * 是否可以两直线相连
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	private boolean isLinkByTwoLines(int posX1, int posY1, int posX2, int posY2, int[][] board){
		if(posX1 != posX2 && posY1 != posY2){
			//x1,y1	to	x2,y1	to	x2,y2		row+col
			if(containsAllOrNoneZeroInRow(posX1, posY1, posX2, posY1, board) 
					&& board[posX2][posY1] == 0 
					&& containsAllOrNoneZeroInColumn(posX2, posY1, posX2, posY2, board)){
				return true;
			}
			//x1,y1	to	x1,y2	to	x2,y2		col+row
			if(containsAllOrNoneZeroInColumn(posX1, posY1, posX1, posY2, board)
					&& board[posX1][posY2] == 0
					&& containsAllOrNoneZeroInRow(posX1, posY2, posX2, posY2, board)){
				return true;
			}

		}
		return false;
	}
	/**
	 * 是否可以三直线相连
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */	
	private boolean isLinkByThreeLines(int posX1, int posY1, int posX2, int posY2, int[][] board){
		if(isOnSameEdge(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		if(isOnThreeLinesLikeArc(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		if(isOnThreeLinesLikeZigzag(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		return false;
	}
	/**
	 * 是否可以三直线相连,似U形
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */	
	private boolean isOnThreeLinesLikeArc(int posX1, int posY1, int posX2, int posY2, int[][] board) {
		if(isOnUpArc(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		if(isOnDownArc(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		if(isOnLeftArc(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		if(isOnRightArc(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		return false;
	}

	/**
	 * 是否可以三直线相连,似向上弓形
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */	
	/*
	 ----
	 |  |
	 |  |

	 */
	private boolean isOnUpArc(int posX1, int posY1, int posX2, int posY2, int[][] board) {
		// Y --> 0
		int lessY = posY1 < posY2 ? posY1 : posY2;
		for(int j = lessY - 1; j >= 0; j--){
			if(containsAllOrNoneZeroInRow(posX1, j, posX2, j, board)
					&& containsAllOrNoneZeroInColumn(posX1, posY1, posX1, j, board)
					&& containsAllOrNoneZeroInColumn(posX2, posY2, posX2, j, board)
					&& board[posX1][j] == 0
					&& board[posX2][j] == 0){
				return true;
			}
		}

		if(		isOnSameEdge(posX1, 0, posX2, 0, board)
				&& containsAllOrNoneZeroInColumn(posX1, posY1, posX1, 0, board)
				&& containsAllOrNoneZeroInColumn(posX2, posY2, posX2, 0, board)
				&& (board[posX1][0] == 0 && board[posX2][0] == 0
				|| board[posX1][0] == 0 && board[posX2][0] == board[posX2][posY2] 
				|| board[posX1][0] == board[posX1][posY1] && board[posX2][0] == 0)){
			return true;
		}

		return false;
	}
	/**
	 * 是否可以三直线相连,似向下弓形
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */		
	/*

	 |  |
	 |  |
	 ----
	 */
	private boolean isOnDownArc(int posX1, int posY1, int posX2, int posY2, int[][] board){
		int moreY = posY1 < posY2 ?  posY2 : posY1;
		for(int j = moreY + 1; j <= Chessboard.BOARD_SIZE - 1; j++){
			if(containsAllOrNoneZeroInRow(posX1, j, posX2, j, board)
					&& containsAllOrNoneZeroInColumn(posX1, posY1, posX1, j, board)
					&& containsAllOrNoneZeroInColumn(posX2, posY2, posX2, j, board)
					&& board[posX1][j] == 0
					&& board[posX2][j] == 0){
				return true;
			}
		}
		if(		isOnSameEdge(posX1, Chessboard.BOARD_SIZE - 1, posX2, Chessboard.BOARD_SIZE - 1, board)
				&& containsAllOrNoneZeroInColumn(posX1, posY1, posX1, Chessboard.BOARD_SIZE - 1, board)
				&& containsAllOrNoneZeroInColumn(posX2, posY2, posX2, Chessboard.BOARD_SIZE - 1, board)
				&& (board[posX1][Chessboard.BOARD_SIZE - 1] == 0 && board[posX2][Chessboard.BOARD_SIZE - 1] == 0
				|| board[posX1][Chessboard.BOARD_SIZE - 1] == board[posX1][posY1] && board[posX2][Chessboard.BOARD_SIZE - 1] == 0
				|| board[posX1][Chessboard.BOARD_SIZE - 1] == 0 && board[posX2][Chessboard.BOARD_SIZE - 1] == board[posX2][posY2])){
			return true;
		}
		return false;
	}
	/**
	 * 是否可以三直线相连,似向左弓形
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	/*
	 ---
	 |
	 |
	 ---
	 */
	private boolean isOnLeftArc(int posX1, int posY1, int posX2, int posY2, int[][] board) {
		int lessX = posX1 < posX2 ? posX1 : posX2;
		for(int i = lessX - 1; i >= 0; i--){
			if(containsAllOrNoneZeroInColumn(i, posY1, i, posY2, board)
					&& containsAllOrNoneZeroInRow(i, posY1, posX1, posY1, board)
					&& containsAllOrNoneZeroInRow(i, posY2, posX2, posY2, board)
					&& board[i][posY1] == 0
					&& board[i][posY2] == 0){
				return true;
			}
		}

		if(		isOnSameEdge(0, posY1, 0, posY2, board)
				&& containsAllOrNoneZeroInRow(0, posY1, posX1, posY1, board)
				&& containsAllOrNoneZeroInRow(0, posY2, posX2, posY2, board)
				&& (board[0][posY1] == 0 && board[0][posY2] == 0
				|| board[0][posY1] == board[posX1][posY1] && board[0][posY2] == 0
				|| board[0][posY1] == 0 && board[0][posY2] == board[posX2][posY2])){
			return true;
		}

		return false;
	}
	/**
	 * 是否可以三直线相连,似向右弓形
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */	
	/*
	 ---
	 	|
	 	|
	 ---
	 */
	private boolean isOnRightArc(int posX1, int posY1, int posX2, int posY2, int[][] board) {
		int moreX = posX1 < posX2 ? posX2 : posX1;
		for(int i = moreX + 1; i <= Chessboard.BOARD_SIZE - 1; i++){
			if(containsAllOrNoneZeroInColumn(i, posY1, i, posY2, board)
					&& containsAllOrNoneZeroInRow(i, posY1, posX1, posY1, board)
					&& containsAllOrNoneZeroInRow(i, posY2, posX2, posY2, board)
					&& board[i][posY1] == 0
					&& board[i][posY2] == 0){
				return true;
			}
		}

		if(
				isOnSameEdge(Chessboard.BOARD_SIZE - 1, posY1, Chessboard.BOARD_SIZE - 1, posY2, board)
				&& containsAllOrNoneZeroInRow(posX1, posY1, Chessboard.BOARD_SIZE - 1, posY1, board)
				&& containsAllOrNoneZeroInRow(posX2, posY2, Chessboard.BOARD_SIZE - 1, posY2, board)
				&& (board[Chessboard.BOARD_SIZE - 1][posY1] == 0 && board[Chessboard.BOARD_SIZE - 1][posY2] == 0
				|| board[Chessboard.BOARD_SIZE - 1][posY1] == board[posX1][posY1] && board[Chessboard.BOARD_SIZE - 1][posY2] == 0
				|| board[Chessboard.BOARD_SIZE - 1][posY1] == 0 && board[Chessboard.BOARD_SIZE - 1][posY2] == board[posX2][posY2])){
			return true;
		}

		return false;
	}
	/**
	 * 是否可以三直线相连,似之字形
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	private boolean isOnThreeLinesLikeZigzag(int posX1, int posY1, int posX2, int posY2, int[][] board) {
		if(isOnZigzagWith1Row2Cols(posX1, posY1, posX2, posY2, board)){
			return true;
		}
		if(isOnZigzagWith2Rows1Col(posX1, posY1, posX2, posY2, board)){
			return true;
		}

		return false;
	}
	/**
	 * 是否可以三直线相连,似之字形, 两行一列
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	private boolean isOnZigzagWith2Rows1Col(int posX1, int posY1, int posX2, int posY2, int[][] board) {
		int moreX = posX1 < posX2 ? posX2 : posX1;
		int lessX = posX1 < posX2 ? posX1 : posX2;
		for(int i = lessX + 1; i < moreX; i++){
			if(containsAllOrNoneZeroInColumn(i, posY1, i, posY2, board)
					&& containsAllOrNoneZeroInRow(i, posY1, posX1, posY1, board)
					&& containsAllOrNoneZeroInRow(i, posY2, posX2, posY2, board)
					&& board[i][posY1] == 0
					&& board[i][posY2] == 0){
				return true;
			}
		}
		return false;
	}
	/**
	 * 是否可以三直线相连,似之字形, 一行两列
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	private boolean isOnZigzagWith1Row2Cols(int posX12, int posY12, int posX22,
			int posY22, int[][] board) {
		int moreY = posY1 < posY2 ? posY2 : posY1;
		int lessY = posY1 < posY2 ? posY1 : posY2;
		for(int j = lessY + 1; j < moreY; j++){
			if(containsAllOrNoneZeroInRow(posX1, j, posX2, j, board)
					&& containsAllOrNoneZeroInColumn(posX1, posY1, posX1, j, board)
					&& containsAllOrNoneZeroInColumn(posX2, posY2, posX2, j, board)
					&& board[posX1][j] == 0
					&& board[posX2][j] == 0){
				return true;
			}
		}
		return false;
	}
	/**
	 * 是否处于游戏区域的4条边的同一边上
	 * @param posX1	图片一的x坐标
	 * @param posY1	图片一的y坐标
	 * @param posX2	图片二的x坐标
	 * @param posY2	图片二的y坐标
	 * @param board	游戏区域
	 * @return
	 */
	private boolean isOnSameEdge(int posX1, int posY1, int posX2, int posY2, int[][] board){
		if((posY1 == posY2 && posY2 == 0)
				|| (posY1 == posY2 && posY2 == Chessboard.BOARD_SIZE - 1)
				|| (posX1 == posX2 && posX2 == 0)
				|| (posX1 == posX2 && posX2 == Chessboard.BOARD_SIZE - 1)){
			return true;
		}

		return false;
	}

	public static void main(String[] args) throws Exception{
		LinkGame lg = new LinkGame(new Chessboard());
		lg.start();
	}
}
iteye_19643
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java简易版连连看_Java版连连看小游戏
weixin_33842051的博客
02-26 249
2.[代码][Java]代码package com;import java.awt.Color;import java.awt.EventQueue;import java.awt.Graphics;import java.awt.Rectangle;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;imp...
python实现简易版连连看
qq_42420425的博客
10-29 2962
小时候熟悉的连连看游戏的简易版，需要自己创建imgs文件夹，里面放置1-12张图片，命名为n.png，还有bg.png和win.png 打开游戏开始计时，玩家点击相同的图案即可消除。可以通过游戏时间的长短来进行pk。 # coding:utf-8 import pygame, sys, random, time from pygame.locals import * # 初始化pygame环境 pygame.init() # 创建窗口 canvas = pygame.display.set_mode..
android简易连连看游戏代码,android连连看游戏源代码（加入8种关卡设计）
weixin_39844284的博客
05-28 1148
【实例简介】说明：这是本人根据 awen_PC 上传的代码《个人根据Android移动开发案例详解手写的一个连连看游戏2》(http://download.csdn.net/detail/awen_PC/3174778)而改写的连连看游戏。在原来代码的基础上增加了7种不同的关卡(体现在消完方块后剩下的方块会移动)。另外增加了帮助菜单和退出菜单，每关时间进度条等，并修改了连连看的图片。大大增加了游戏...
python连连看小游戏_python递归法实现简易连连看小游戏
weixin_39974932的博客
12-10 230
问题：简单版连连看小游戏一个分割成w*h个正方格子的矩形板上，每个正方格子可以有游戏卡，也可以没有游戏卡两个游戏卡之间有一条路径相连需满足以下三个条件：1.路径只包含水平和垂直的直线段2.路径不能穿过别的游戏卡片3.允许路径临时离开矩形板输入要求：第一行包括两个整数：w 和 h ; w:矩形板的宽度，h:矩形板的长度下面h行，每行包括w个字符，表示矩形板上卡片的分布情况：'X'代表这个地方有卡片；...
简易连连看
SIH__的博客
05-08 966
新建文本文档，复制下面的代码，保存，文件名：index.html，打开&lt;!DOCTYPE html&gt;&lt;html lang="en"&gt;&lt;head&gt;    &lt;meta charset="UTF-8"&gt;    &lt;meta name="viewport" content="width=device-width, initi
android连连看源代码,#经典连连看#源码分享
weixin_31477659的博客
05-26 1371
Dim qdx,qdy,jk,jg,colorsex,colors,colorss,colorssex,临时列表Dim 格子(9,13),检测(9,13)//格子数组是保存每个格子数据，检测数组是保存格子是否为空Dim 横向一步列表,纵向一步列表横向一步列表 = "s" : 纵向一步列表 = "s" //初始化值Dim 延迟延迟 = 5 //适当加个延迟SetControlBarPos 0.9...
java小程序——《连连看（简易版）》
刘莹慧的专栏
11-01 5839
package com.nh; import java.util.Scanner; import java.util.Random; import com.nh.Point; public class chess{ public static void main(String[] agrs ){ Scanner sc=new Scanner(System.in); System.out.
无聊时做的一个简易的WEB版连连看
infosec006的专栏
04-13 907
这几天写毕业论文写的实在烦闷，想起来有次面试问我连连看中判断是否相消的算法，那时根本不知道怎么回事，直接被鄙视，后来才知道原来是编程之美里面的题，后悔的一塌糊涂，突然萌生了写个连连看的想法。这次写的连连看主要应该包括随机生成格子和判断是否相消两部分，其实还应该有一个是判断是死局，也就是判断是否存在可以相消的格子，这两天太懒了，下次在写。首先是随机数的生成，每次生成两
浙大版《C语言程序设计实验与习题指导（第4版）》题目集 实验7-2-10 简易连连看
Tomlin1164919639的博客
07-22 265
浙大版《C语言程序设计实验与习题指导（第4版）》题目集 实验7-2-10 简易连连看
自己写的简易连连看的实现
07-30
在本项目中，标题"自己写的简易连连看的实现"表明了这是一个个人开发的简易版连连看游戏，采用Java编程语言实现。连连看是一款广受欢迎的休闲益智游戏，其核心玩法是找到并消除两个相同的元素，直到所有元素都被消除...
PTA简易连连看（C语言版）
06-18
本题要求实现一个简易连连看游戏模拟程序。 给定一个2N×2N的方阵网格游戏盘面，每个格子中放置一些符号。这些符号一定是成对出现的，同一个符号可能不止一对。程序读入玩家给出的一对位置(x ​1 ​​ ,y ​1 ​​ ...
Delphi简易连连看.7z
04-26
《Delphi简易连连看程序解析》 Delphi是一款历史悠久的集成开发环境（IDE），由Borland公司开发，主要用于创建Windows平台的应用程序。虽然现在有许多更先进的开发工具，但Delphi因其高效的编译器和直观的可视化...
python递归法实现简易连连看小游戏
09-19
根据提供的信息，我们可以详细解析如何使用Python通过递归方法实现一个简易版本的连连看小游戏。 ### 游戏规则概述 1. **游戏区域**：游戏在一个由`w`（宽度）× `h`（高度）个正方形格子组成的矩形板上进行。 2. ...
JSOUP获取网页数据返回403错误（403 error loading URL,connection类）
技术与人际，两手都要硬
07-22 1000
转载自: http://blog.csdn.net/arvon2012/article/details/7979139   最近做的项目需要利用JSOUP进行网页获取和解析，但是遇到了拒绝访问的问题，返回的结果是： java.io.IOException: 403 error loading URL http://www.xxx.com/xxx 连接代码是这样的： Document d...
ora-01950:对表空间XXX无权限
技术与人际，两手都要硬
10-16 567
以前执行了grant dba to 用户 查了一下dba角色中有一项 ： DBA     UNLIMITED TABLESPACE   YES 现在执行了revoke dba from 用户 报错：ora-01950:对表空间XXX无权限  For example: ORA-01950: no privileges on tablespace 'DATA' 办法： alter us...
注解之类型 Annotations Types
技术与人际，两手都要硬
10-09 389
1.13.1 Annotations and Annotation Types 注解和注解类型 Annotations are notes in Java programs to instruct the Java compiler to do something. Java provides three standard annotations and four standard meta...
Maven usage
技术与人际，两手都要硬
10-23 291
P:\&gt;mvn --help   usage: mvn [options] [&lt;goal(s)&gt;] [&lt;phase(s)&gt;]   Options:  -am,--also-make                        If project list is specified, also                              ...
用html编写一个简易版连连看
最新发布
06-11
好的，以下是一个简单的 HTML 连连看游戏示例代码，您可以在浏览器中打开它来玩。 ```html <!DOCTYPE html> 连连看 .container { margin: 0 auto; width: 500px; height: 500px; background-...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值