Java 对对碰游戏


对对碰游戏规则说明：

一． 概述

游戏在 8 × 8 格子的游戏池中进行。每个格子中有一个图标。鼠标连续选中两个相邻的图标，它们的位置会互换，互换后如果横排或竖排有 3 个以上相同的图标，则可以消去该图标，并得分。

二． 基本规则

交换
玩家选中相邻（横、竖）的两个图标，则这两个图标的位置发生互换，如果互换成功则消去图标，否则取消位置交换。

消去
玩家选择两个图标进行位置互换，互换后如果横排或竖排有 3 个以上相同的图标，则消去这几个相同的图标，如果互换后没有可以消去的图标，则选中的两个图标换回原来的位置。消去后的空格由上面的图标掉下来补齐。每次消去图标玩家都能得到一定的分数。

连锁
玩家消去图标后，上面的图标掉下来补充空格。如果这时游戏池中有连续摆放（横、竖）的 3 个或 3 个以上相同的图标，则可以消去这些图标，这就是一次连锁。空格被新的图标填充，又可以进行下一次连锁。每次连锁会有加分。

重排
玩家已经不能消去任何图标时，将清空游戏池，用新的图标填充。

对对碰游戏算法分析：
分析一下，交换一般分为三种情况：
情况1：交换后，消除的头像是竖排的。
情况2：交换后，消除的头像是横排的。
情况3：交换后，消除的头像横竖排都存在
过程就是点击两个图样，先检查是否是同一图样，再检查是否在同一直线，再检查是否是一个折点，再是两个折点，如果都不是则返回无解，如果是，返回TRUE，记录折点，用直线连接折点和连接点并消除两个图样，这个点的值变为0

  

交换、消除、填补算法

  1. public void setExchange() {   
  2.         if (isSelected) {   
  3.             isExchange = true;   
  4.             isSelected = false;   
  5.             doExchange();   
  6.         }   
  7.     }   
  8.   
  9.     private void moveRightDown() {   
  10.         if (currentX == BODY_W - 1 || currentY == BODY_H - 1) {   
  11.             isSelected = false;   
  12.         }   
  13.         currentX = ++currentX % BODY_W;   
  14.         currentY = ++currentY % BODY_H;   
  15.         setExchange();   
  16.     }   
  17.   
  18.     private void moveLeftDown() {   
  19.         if (currentX == 0 || currentY == BODY_H - 1) {   
  20.             isSelected = false;   
  21.         }   
  22.         currentX = (--currentX + BODY_W) % BODY_W;   
  23.         currentY = ++currentY % BODY_H;   
  24.         setExchange();   
  25.     }   
  26.   
  27.     private void moveRightUp() {   
  28.         if (currentY == 0 || currentX == BODY_W - 1) {   
  29.             isSelected = false;   
  30.         }   
  31.         currentX = ++currentX % BODY_W;   
  32.         currentY = (--currentY + BODY_H) % BODY_H;   
  33.         setExchange();   
  34.     }   
  35.   
  36.     private void moveLeftUp() {   
  37.         if (currentX == 0 || currentY == 0) {   
  38.             isSelected = false;   
  39.         }   
  40.         currentX = (--currentX + BODY_W) % BODY_W;   
  41.         currentY = (--currentY + BODY_H) % BODY_H;   
  42.         setExchange();   
  43.     }   
  44.   
  45.     private void moveUp() {   
  46.         if (currentY == 0) {   
  47.             isSelected = false;   
  48.         }   
  49.         currentY = (--currentY + BODY_H) % BODY_H;   
  50.         setExchange();   
  51.     }   
  52.   
  53.     private void moveDown() {   
  54.         if (currentY == BODY_H - 1) {   
  55.             isSelected = false;   
  56.         }   
  57.         currentY = ++currentY % BODY_H;   
  58.         setExchange();   
  59.     }   
  60.   
  61.     private void moveLeft() {   
  62.         if (currentX == 0) {   
  63.             isSelected = false;   
  64.         }   
  65.         currentX = (--currentX + BODY_W) % BODY_W;   
  66.         setExchange();   
  67.     }   
  68.   
  69.     private void moveRight() {   
  70.         if (currentX == BODY_W - 1) {   
  71.             isSelected = false;   
  72.         }   
  73.         currentX = ++currentX % BODY_W;   
  74.         setExchange();   
  75.     }   
  76.   
  77.   
  78. private void doExchange() {   
  79.         if (currentX - selectedX == -1) {   
  80.             if (currentY - selectedY == -1) {   
  81.                 tempMove[currentX][currentY] = 9;   
  82.                 tempMove[selectedX][selectedY] = 1;   
  83.             } else if (currentY - selectedY == 0) {   
  84.                 tempMove[currentX][currentY] = 6;   
  85.                 tempMove[selectedX][selectedY] = 4;   
  86.             } else if (currentY - selectedY == 1) {   
  87.                 tempMove[currentX][currentY] = 3;   
  88.                 tempMove[selectedX][selectedY] = 7;   
  89.             }   
  90.         } else if (currentX - selectedX == 0) {   
  91.             if (currentY - selectedY == -1) {   
  92.                 tempMove[currentX][currentY] = 8;   
  93.                 tempMove[selectedX][selectedY] = 2;   
  94.             } else if (currentY - selectedY == 1) {   
  95.                 tempMove[currentX][currentY] = 2;   
  96.                 tempMove[selectedX][selectedY] = 8;   
  97.             }   
  98.         } else if (currentX - selectedX == 1) {   
  99.             if (currentY - selectedY == -1) {   
  100.                 tempMove[currentX][currentY] = 7;   
  101.                 tempMove[selectedX][selectedY] = 3;   
  102.             } else if (currentY - selectedY == 0) {   
  103.                 tempMove[currentX][currentY] = 4;   
  104.                 tempMove[selectedX][selectedY] = 6;   
  105.             } else if (currentY - selectedY == 1) {   
  106.                 tempMove[currentX][currentY] = 1;   
  107.                 tempMove[selectedX][selectedY] = 9;   
  108.             }   
  109.         }   
  110.         int temp = body[selectedX][selectedY];   
  111.         body[selectedX][selectedY] = body[currentX][currentY];   
  112.         body[currentX][currentY] = temp;   
  113.     }  

相关内容