棋盘覆盖V1.0

      什么是棋盘覆盖, 棋盘覆盖是用4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格外的所有方格，且任何2个L型骨牌不得重叠覆盖。对,就这么简单!这是我在大学算法里面学分治算法时学的一个实例应用,正好为了学习这个算法以及练笔一下JAVA SWING（主要原因是为别人写的毕业设计），在大学期间弄的这么一个东西。
      首先贴一下最终结果图吧：

从界面不难看出，有棋盘、棋盘上的方格、骨牌（4种）等。

1、棋盘（ChessPanel）：棋盘用了一个JPanel来表示，而棋盘是由一个个的方格（ChessBox）组成的，这个方格将在下面讲到。ChessPanel中主要干的事情就是：

        A.初始化特殊方格:
/** * 初始化特殊方格 * @param dr 特殊方格横坐标 * @param dc 特殊方格纵坐标 */ public void initSpecificPaneLocation(int dr, int dc) { this.dr = dr; this.dc = dc; //初始化 for (int i = 0; i <boxes.length; i++) { for (int j = 0; j <boxes[i].length; j++) { //初始化时棋盘未覆盖，只有特殊方格被黑色覆盖 boxes[i][j] = new ChessBox((i == getDr() && j == getDc()) ? kBoxColor : chessColor); boxes[i][j].setCovered((i == getDr() && j == getDc()) ? true : false); } } //设置棋盘的边界样式 setBorder(new EtchedBorder(EtchedBorder.RAISED, Color.WHITE, new Color(148, 145, 140))); //存储棋盘覆盖正确走法，方便调用 CoverAlgorithm.saveMoveMethod(false, getDr(), getDc(), lens); repaint(); }

       B.初始化棋盘；同上，这里写的时候有点重复代码，当时没有考虑到，刚看的时候发现，呵呵。

       C.实现paintComponent方法，画棋盘。这里也就是画线，由这些线分割成的方格就是棋盘，其中每个方格有自己的颜色属性等。
@Override public void paintComponent(Graphics g) { super.paintComponent(g); //画棋盘 for (int i = 0; i <boxes.length; i++) { for (int j = 0; j <boxes[i].length; j++) { g.setColor(boxes[i][j].getColor()); g.fill3DRect(i * (size / lens), j * (size / lens), size / lens, size / lens, true); } } //画横竖中线 g.setColor(Color.PINK); g.drawLine(0, size / 2 - 2, size - 2, size / 2 - 2); g.drawLine(size / 2 - 2, 0, size / 2 - 2, size - 2); }

2、棋盘上的方格（ChessBox）：就是上面用到的ChessBox，ChessBox里面没有上面逻辑代码，它只有几个属性：颜色、是否被覆盖、大小（这个多余，因为大小都一样了）。

3、骨牌（4种）（DominoPanel）：这个类比较复杂，可能是设计不好的原因吧，这个类比较庞大，有快700行了。DominoPanel也是有ChessBox组成，一个DominoPanel有4个Chessbox组成，4种就需要4*4=16个ChessBox组成了。4种骨牌定义如下：

下面是构造一种形状的骨牌：通过style & key的与的结果来给骨牌（4个ChessBox）着色，得到最终的骨牌的样式。
//骨牌styles中的一种与之“&”(每位逐个相与)，得到骨牌形状 int key = 0x20; int r = new Random().nextInt(255); int g = new Random().nextInt(255); int b = new Random().nextInt(255); Color color = new Color(r, g, b); for (int i = 0; i <boxes.length; i++) { for (int j = 0; j <boxes[i].length; j++) { boolean isColoring = ((style & key) != 0); boxes[i][j] = new ChessBox(isColoring ? color : null); key >>= 1; } key >>= 2; }

      其次就是鼠标拖动骨牌的效果，这种效果很容易，添加当鼠标按下及鼠标拖动事件，当鼠标按下时记录此时鼠标的坐标x、y，当鼠标拖动此骨牌且并未松开鼠标时（即在拖动鼠标事件方法里），设置此骨牌位置如下（panel为骨牌的一个引用对象，骨牌类继承的是一个JPanel）：
setLocation(panel.getX() + e.getX() - x, panel.getY() + e.getY() - y);
这样即可实现骨牌跟随着鼠标走的简单效果，然后在设置一下拖动时的外观，即可实现游戏中的效果，非常容易理解。

      然后就是实现DominoPanel的paintComponent方法：这里有一个拖动时的外观（有小边框）和其他情况时的外观。

@Override public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2d = (Graphics2D) g; //拖动时骨牌外观 if (isDragDomino()) { for (int i = 0; i <boxes.length; i++) { for (int j = 0; j <boxes[i].length; j++) { Color color = boxes[i][j].getColor(); if (color != null) { g.setColor(boxes[i][j].getColor()); g.fill3DRect(j == 0 ? 2 : cellSize, i == 0 ? 2 : cellSize, cellSize - 4, cellSize - 4, true); } } } Rectangle rBig = new Rectangle(0, 0, 2 * cellSize - 2, 2 * cellSize - 2); Rectangle rSmall = new Rectangle( (getStyle() == DominoPanel.styles[0]) || (getStyle() == DominoPanel.styles[2]) ? 0 : cellSize, (getStyle() == DominoPanel.styles[0]) || (getStyle() == DominoPanel.styles[1]) ? 0 : cellSize, cellSize - 2, cellSize - 2); Area area = new Area(rBig); area.subtract(new Area(rSmall)); g2d.setColor(Color.RED); g2d.draw(area); } else { //其他情况时骨牌外观 for (int i = 0; i <boxes.length; i++) { for (int j = 0; j <boxes[i].length; j++) { Color color = boxes[i][j].getColor(); if (color != null) { g.setColor(boxes[i][j].getColor()); g.fill3DRect(j * cellSize, i * cellSize, cellSize, cellSize, true); } } } } }

        最后就是一些细节的处理，1、拖动骨牌（骨牌是一个JPanel，这个东西是方块），所以需要判断如果鼠标在颜色为null地方是拖不动的；2、只有鼠标在棋盘内部才显示边框；3、鼠标拖动骨牌在棋盘内部释放时，骨牌一定要放到正好用线条标好的4个ChessBox里的棋盘上，不能拖到哪放到哪，那样就是乱放了；4、排行榜的实现；5、错误提示；6、自动演示（自动演示时，直接用的直线方程让骨牌直线走到该走的位置的）等。这些请见代码，这里就不多说了。

        好了，从界面上看出来的东西也总结的差不多了，下面就是蛮重要的算法了，我认为算法可以优化，但是当时限于水平有限就没有再在这上面纠结了，希望大虾们可以帮俺看看，谢谢。算法就四个字：分而治之。懂了就懂了，不懂还是不懂。多说无益，算法如下（游戏中源码，未改动）：主要在这里面做的事情就是记录正确的走法，定义一个HashMap来存储正确的走法（通过遍历棋盘覆盖主算法），其中Key存储手工走动时的左上角顶点，Value存储拖动的骨牌的样式（四种中的一种），这样即可实现当拖动骨牌时，根据存储过的走法（HashMap存储个人觉得非常合适，而且效率也非常不错，需要注意的是HashMap中的put方法的使用场合），判断走法是否正确，并给予相关提示，还有就是自动演示部分，这里用到的是Robot。

        /** * 棋盘覆盖算法 * @param robot 自动演示机器人 * @param tr 棋盘位置横坐标 * @param tc 棋盘位置纵坐标 * @param dr 特殊方格横坐标 * @param dc 特殊方格纵坐标 * @param size 棋盘规格 size*size */ private void chessBoard(Robot robot, int tr, int tc, int dr, int dc, int size) { if (size == 1) { return; } int s = size / 2; //左上角 if (dr <tr + s && dc <tc + s) { Point pLeftUp = new Point(tr + s - 1, tc + s - 1); if (autoShow) { robot.delay(autoSpeed); //骨牌的位置，即源位置 int sx = ChessPanel.size + 10; int sy = 2; //目标位置 int dy = pLeftUp.x * (dominoSize / 2), dx = pLeftUp.y * (dominoSize / 2); //源位置到目标位置的直线斜率 double k = (double) (dy - sy) / (double) (dx - sx); robot.mouseMove(wLocation.x + sx + (dominoSize * 3) / 4 + ChessBoardCoverGUI.insets.left, wLocation.y + sy + (dominoSize * 3) / 4 + ChessBoardCoverGUI.insets.top + ChessBoardCoverGUI.menubarHeight); robot.mousePress(InputEvent.BUTTON1_MASK); for (int i = sx; i > dx - 1; i -= 2) { robot.mouseMove(wLocation.x + i + (dominoSize * 3) / 4 + ChessBoardCoverGUI.insets.left, wLocation.y + (int) (sy - k * (sx - i)) + (dominoSize * 3) / 4 + ChessBoardCoverGUI.insets.top + ChessBoardCoverGUI.menubarHeight + 2); } robot.delay(autoSpeed); robot.mouseRelease(InputEvent.BUTTON1_MASK); } else { moveMethod.put(pLeftUp, DominoPanel.styles[0]); } chessBoard(robot, tr, tc, dr, dc, s); chessBoard(robot, tr, tc + s, tr + s - 1, tc + s, s); chessBoard(robot, tr + s, tc, tr + s, tc + s - 1, s); chessBoard(robot, tr + s, tc + s, tr + s, tc + s, s); } //右上角 if (dr <tr + s && dc >= tc + s) { Point pRightUp = new Point(tr + s - 1, tc + s - 1); if (autoShow) { robot.delay(autoSpeed); //骨牌的位置，即源位置 int sx = ChessPanel.size + 10; int sy = dominoSize + 4; //目标位置 int dy = pRightUp.x * (dominoSize / 2), dx = pRightUp.y * (dominoSize / 2); //源位置到目标位置的直线斜率 double k = (double) (dy - sy) / (double) (dx - sx); robot.mouseMove(wLocation.x + sx + dominoSize / 4 + ChessBoardCoverGUI.insets.left, wLocation.y + sy + (dominoSize * 3) / 4 + ChessBoardCoverGUI.insets.top + ChessBoardCoverGUI.menubarHeight); robot.mousePress(InputEvent.BUTTON1_MASK); for (int i = sx; i > dx - 1; i -= 2) { robot.mouseMove(wLocation.x + i + dominoSize / 4 + ChessBoardCoverGUI.insets.left, wLocation.y + (int) (sy - k * (sx - i)) + (dominoSize * 3) / 4 + ChessBoardCoverGUI.insets.top + ChessBoardCoverGUI.menubarHeight + 2); } robot.delay(autoSpeed); robot.mouseRelease(InputEvent.BUTTON1_MASK); } else { moveMethod.put(pRightUp, DominoPanel.styles[1]); } chessBoard(robot, tr, tc, tr + s - 1, tc + s - 1, s); chessBoard(robot, tr, tc + s, dr, dc, s); chessBoard(robot, tr + s, tc, tr + s, tc + s - 1, s); chessBoard(robot, tr + s, tc + s, tr + s, tc + s, s); } //左下角 if (dr >= tr + s && dc <tc + s) { Point pLeftDown = new Point(tr + s - 1, tc + s - 1); if (autoShow) { robot.delay(autoSpeed); //骨牌的位置，即源位置 int sx = ChessPanel.size + 10 + dominoSize + 2; int sy = dominoSize + 4; //目标位置 int dy = pLeftDown.x * (dominoSize / 2), dx = pLeftDown.y * (dominoSize / 2); //源位置到目标位置的直线斜率 double k = (double) (dy - sy) / (double) (dx - sx); robot.mouseMove(wLocation.x + sx + (dominoSize * 3) / 4 + ChessBoardCoverGUI.insets.left, wLocation.y + sy + dominoSize / 4 + ChessBoardCoverGUI.insets.top + ChessBoardCoverGUI.menubarHeight); robot.mousePress(InputEvent.BUTTON1_MASK); for (int i = sx; i > dx - 1; i -= 2) { robot.mouseMove(wLocation.x + i + (dominoSize * 3) / 4 + ChessBoardCoverGUI.insets.left, wLocation.y + (int) (sy - k * (sx - i)) + dominoSize / 4 + ChessBoardCoverGUI.insets.top + ChessBoardCoverGUI.menubarHeight + 2); } robot.delay(autoSpeed); robot.mouseRelease(InputEvent.BUTTON1_MASK); } else { moveMethod.put(pLeftDown, DominoPanel.styles[2]); } chessBoard(robot, tr, tc, tr + s - 1, tc + s - 1, s); chessBoard(robot, tr, tc + s, tr + s - 1, tc + s, s); chessBoard(robot, tr + s, tc, dr, dc, s); chessBoard(robot, tr + s, tc + s, tr + s, tc + s, s); } //右下角 if (dr >= tr + s && dc >= tc + s) { Point pRightDown = new Point(tr + s - 1, tc + s - 1); if (autoShow) { robot.delay(autoSpeed); //骨牌的位置，即源位置 int sx = ChessPanel.size + 10 + dominoSize + 2; int sy = 2; //目标位置 int dy = pRightDown.x * (dominoSize / 2), dx = pRightDown.y * (dominoSize / 2); //源位置到目标位置的直线斜率 double k = (double) (dy - sy) / (double) (dx - sx); robot.mouseMove(wLocation.x + sx + dominoSize / 4 + ChessBoardCoverGUI.insets.left, wLocation.y + sy + dominoSize / 4 + ChessBoardCoverGUI.insets.top + ChessBoardCoverGUI.menubarHeight); robot.mousePress(InputEvent.BUTTON1_MASK); for (int i = sx; i > dx - 1; i -= 2) { robot.mouseMove(wLocation.x + i + dominoSize / 4 + ChessBoardCoverGUI.insets.left, wLocation.y + (int) (sy - k * (sx - i)) + dominoSize / 4 + ChessBoardCoverGUI.insets.top + ChessBoardCoverGUI.menubarHeight + 2); } robot.delay(autoSpeed); robot.mouseRelease(InputEvent.BUTTON1_MASK); } else { moveMethod.put(pRightDown, DominoPanel.styles[3]); } chessBoard(robot, tr, tc, tr + s - 1, tc + s - 1, s); chessBoard(robot, tr, tc + s, tr + s - 1, tc + s, s); chessBoard(robot, tr + s, tc, tr + s, tc + s - 1, s); chessBoard(robot, tr + s, tc + s, dr, dc, s); } }

      算法部分总结就此打住，如果不明白的可以Google，我自己也是。下面是一个计时的东西，之前写的时候不知道JAVA里面有没有专门计时的，所以就自己用了一个Sleep做了这个计时，很简单，另起一个线程（防止界面卡住），在这个线程里面做的事情就是分、秒、毫秒的++操作，具体代码很容易。

import java.util.concurrent.TimeUnit; /** * * @author zxz */ public class TimerThread extends Thread { //定义计时器的开始与否标志，默认为停止 private static boolean start = false; //定义分、秒、毫秒 private static String minute = "0", secOnd= "0", millisecOnd= "0"; private int m = 0, s = 0, ms = 0; /** * 构造器 起初始化作用 */ private TimerThread() { minute = "0"; secOnd= "0"; millisecOnd= "0"; m = 0; s = 0; ms = 0; ChessBoardCoverGUI.getNumLbl().setText("00:00:00"); } public TimerThread(String minute, String second, String millisecond) { TimerThread.minute = minute; TimerThread.secOnd= second; TimerThread.millisecOnd= millisecond; } @Override public void run() { while (start) { ms = Integer.parseInt(millisecond); s = Integer.parseInt(second); m = Integer.parseInt(minute); ms++; if (ms / 10 <1) { //一位数在前面加0 millisecOnd= "0" + ms; } else if (ms == 100) { //毫秒超过2位数则停止计时，算超时 millisecOnd= "00"; s++; } else { //其他情况 millisecOnd= ms + ""; } if (s / 10 <1) { //一位数在前面加0 secOnd= "0" + s; } else if (s == 60) { //超过60设为00 secOnd= "00"; m++; } else { //其他情况 secOnd= s + ""; } if (m / 10 <1) { //一位数在前面加0 minute = "0" + m; } else if (m == 100) { //分钟超过2位数则停止计时，算超时 start = false; } else { //其他情况 minute = m + ""; } ChessBoardCoverGUI.getNumLbl().setText(minute + ":" + second + ":" + millisecond); try { TimeUnit.MILLISECONDS.sleep(9); } catch (InterruptedException ie) { ie.printStackTrace(); } } } /** * 开始计时 */ public static void startTimer() { start = true; new TimerThread().start(); } /** * 结束计时 */ public static void stopTimer() { start = false; } public static void continueTimer(String minute, String second, String millisecond) { start = true; new TimerThread(minute, second, millisecond).start(); } /** * 获取当前计时时间 * @return 时间字符串 xx分xx秒xx毫秒 */ public static String getCurrentTime() { return minute + "分" + second + "秒" + millisecond + "毫秒"; } }

      好了，基本差不多了，界面UI部分就不说了，全部JAVA SWING，因为现在工作了，用的是.net，SWING这方面也忘了差不多了，所以还需要复习一下才能那啥，哈哈。最后上几张图还是有必要的，有图有真相。实在的，虽然很简单的一个东西，写的时候还是考虑很多的细节部分的。

源码下载地址：http://download.csdn.net/source/2545075