`

写一个简易版的连连看

    博客分类:
  • Java
阅读更多
写一个简易版的连连看

游戏规则:

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();
	}
}


分享到:
评论

相关推荐

    自己写的简易连连看的实现

    在本项目中,标题"自己写的简易连连看的实现"表明了这是一个个人开发的简易版连连看游戏,采用Java编程语言实现。连连看是一款广受欢迎的休闲益智游戏,其核心玩法是找到并消除两个相同的元素,直到所有元素都被消除...

    简易连连看

    "简易连连看"是一款基于VB(Visual Basic)编程语言开发的简单版连连看游戏。VB是一种面向对象的编程语言,由微软公司推出,常用于快速应用程序开发,尤其适合创建Windows桌面应用。在这个项目中,开发者可能利用VB...

    简单连连看 JAVA

    通过以上技术的组合和应用,开发者成功地实现了这个“简单连连看”项目,为玩家提供了一个集趣味性、互动性于一体的休闲游戏。学习这个项目的源码,对于理解Java GUI编程和游戏开发有很好的参考价值。

    简易dos版连连看(就是黑乎乎界面的那个==凑字数中)

    本文将深入探讨这个简易DOS版连连看,带您领略其设计原理和操作技巧。 连连看,源于中国,以其简单的规则和丰富的策略性深受喜爱。在DOS版本中,游戏界面虽没有华丽的色彩和动态效果,但依然能提供纯粹的游戏体验。...

    PTA简易连连看(C语言版)

    本题要求实现一个简易连连看游戏模拟程序。 给定一个2N×2N的方阵网格游戏盘面,每个格子中放置一些符号。这些符号一定是成对出现的,同一个符号可能不止一对。程序读入玩家给出的一对位置(x ​1 ​​ ,y ​1 ​​ ...

    Delphi简易连连看.7z

    《Delphi简易连连看程序解析》 Delphi是一款历史悠久的集成开发环境(IDE),由Borland公司开发,主要用于创建Windows平台的应用程序。虽然现在有许多更先进的开发工具,但Delphi因其高效的编译器和直观的可视化...

    html5连连看源码

    很不错的使用html学习连连看游戏的源代码,能够顺利的实现功能。

    java swing 简单连连看

    本项目“java swing 简单连连看”是一个基于Swing实现的简易版连连看游戏,适合初学者学习Swing的基本用法和游戏开发的基础知识。 连连看游戏的基本规则是:在二维网格中,有若干对相同图案的方块被随机放置,玩家...

    java开发的连连看游戏

    【标题】"java开发的连连看游戏"是一个基于Java编程语言开发的简易版连连看游戏。这个项目展示了Java在游戏开发中的应用,虽然它被开发者称为半成品,但仍然能够提供一个基础的游戏框架,供有兴趣深入学习Java游戏...

    连连看游戏java程序代码

    【连连看游戏java程序代码】是一个Java编程语言实现的简易版连连看游戏。这个程序集成了游戏界面设计和源代码,让玩家可以在计算机上运行并体验由Java开发的连连看游戏。通过分析这个项目的标签“连连看”、“作品”...

    java做的连连看 简单版 测试可用

    本篇文章将对一个基于Java语言实现的简单连连看游戏进行深入分析。这款游戏适用于学习Java编程基础的开发者,通过实际项目来理解Java图形用户界面(GUI)组件、事件处理机制以及基本的数据结构等核心概念。 #### ...

    连连看代码详解

    本篇将详细解析一个简易版连连看游戏的C语言实现代码,帮助读者理解其背后的逻辑与算法。 #### 二、代码结构及功能介绍 ##### 1. 导入头文件 ```c #include #include #include #include ``` 这里导入了四个标准...

    数字游戏(GUI版本和简易版本).zip

    标题中的“数字游戏(GUI版本和简易版本).zip”表明这是一个包含两种不同版本的数字游戏,一个是图形用户界面(GUI)版本,另一个是简化或命令行版本。这些游戏可能是用Python编程语言编写的,因为标签中提到了...

    python递归法实现简易连连看小游戏

    问题:简单版连连看小游戏 一个分割成w*h个正方格子的矩形板上,每个正方格子可以有游戏卡,也可以没有游戏卡 两个游戏卡之间有一条路径相连需满足以下三个条件: 1.路径只包含水平和垂直的直线段 2.路径不能穿过别...

    llk.rar_画图板

    标题中的"llk.rar_画图板"表明这是一个与画图相关的软件或程序,很可能是一个简易版的图形编辑工具,用户可以通过它进行简单的绘画创作。这个名称中的".rar"是常见的压缩文件格式,意味着里面包含了该画图板的源代码...

    Tiny4412中文用户手册

    Tiny4412是一款基于ARM9架构的开发板,它为嵌入式Linux的学习和开发提供了一个良好的平台。该开发板具有丰富的接口和功能,是针对嵌入式Linux系统、C语言编程以及ARM处理器研究的理想选择。广州友善之臂计算机科技...

    小游戏2048(Vue版) 源码

    1、手指向一个方向滑动,所有格子会向那个方向运动。 2、相同数字的两个格子,相遇时数字会相加。 3、每次滑动时,空白处会随机出现一个数字。 4、当所有单元格都不可移动时,游戏结束;当界面中最大数字是2048时,...

    61个android项目源码

    新浪、腾讯、网易、搜狐微博OAuth认证整合Android版 ,天天动听 半透明Menu效果,植物大战僵尸(简单版),网络通信的六种方式示例代码,三国杀版连连看(使用html5的canvas特性,纯javascript开发),商情商灵商...

Global site tag (gtag.js) - Google Analytics