写一个简易版的连连看

写一个简易版的连连看

游戏规则：

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