消消乐游戏算法实现（三消乐）

先上前端效果图

3消乐地图初始化的时候不允许有下面两种情况的发生，就是不允许3个（3个以上已经包含3个，所以只要判断3个就可以了）相同颜色的格子连在一起，

下图是两种情况，细分分为6种情况，就是初始点为3个格子中的一个为一种情况，所以细分2*3=6种情况

代码中的方法是

private boolean isLine(int x, int y){....}

代码过多，不写出来了

首先初始化地图，看代码注释应该看差不多了

 

3消规则，只要地图中包含其中以下3种情况就可以判断该地图不是死图，红色部分表示

相同颜色的格子，黄色代表如果这个位置如果也是相同颜色只要一动一个位置就可以

3个相同颜色格子并排在一起

比如第一张图，首先判断它上或者下是否有相同颜色

如果1格子是初始格子是红色

 

第一种

先判断标识2格子是否为红色，如果不是一图的情况不用判断了，如果也是红色

那么只要判断上面第一张图的4个黄色位置的格子只要有一个是红色，那么1格子就不是死格子，那么这个图就不是死图

第二种

第2张图，只要判断任意两个相邻黄色位置的格子(有4种情况：a跟b同时为红，b跟d,d跟c，a跟c)的颜色也是红色那么该格子不是死格子，该图不是死图

第三种

跟第二种很像，不过相邻变成了左右，我就不说了

细分的话应该有 2*4+4+2*4=20种情况，所以这个方法的代码量最大，不细说了

代码方法是private boolean isDie(int x, int y) {...}

 

判断这个格子是否是3个以上颜色相同格子相连

比如以1格子为起点，然后向前后左右4个方向扩张

用递归的方法，就有4个方法，每个方法添加相

代码大概如下

colSet =上下相邻颜色相同的格子=向上颜色的格子+向下颜色的格子       

rowSet =左右相邻颜色相同的格子=向左颜色的格子+向右颜色的格子     

如果他们等于3个或者3个以上，那么他们就要被消，先存起来  removeCellSet    

后面再一次性消玩  i为格子的x坐标,j为y坐标

 

 

 

 

 

客户端要求如果不相连的区域要分离出来发给他们，分离出来的列表都要排序，这个要求比较蛋疼

格子坐标（x,y)

格子还有颜色属性Color

比如上图，removeCellSet包含上面格子的key=x+”_”+y;

 

只能用递归，

向相邻的格子扩张，如果相同颜色并且在removeCellSet里面 

格子消掉并下降

0 1 2 3

例如上图给子格子下降

获取所有要消除的给子的x轴

比如有x=0;x=2;x=3这3列中都有空格

然后给这3列的非空格子排序，并重新按顺序填充格子，y大排下面，排完后剩下就为空，效果如下（我这是最简单的方法，不易出错，这个可以优化，优化就比较复杂了）

 

3消中最重要的的方法在这里，上面的方法都在这下面按顺序执行

 

上面代码的流程图

1跟2交换

		1
		2

交换后

消除后

 

 

下降后

补图

因为能消，所以再消

下降

 

再补图

 

再消，但不能再消乐，得移动其中的格子

代码结构

package com.eyugame.tade.module.glops.constant;

/** 
 * 宝石颜色
 *
 * @author  k60
 */
public enum Color {

	/**
	 * 红
	 */
	RED,
	
	/**
	 * 黄
	 */
	YELLOW,
	
	/**
	 * 蓝
	 */
	BLUE,
	
	/**
	 * 绿
	 */
	GREEN,
	
	/**
	 * 紫
	 */
	PURPLE
	
	
	
}

package com.eyugame.tade.module.glops.play;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;

import com.eyugame.tade.module.glops.constant.Color;
import com.eyugame.tade.module.glops.exception.NearCellException;
import com.eyugame.tade.module.glops.exception.NoSpoilageException;
import com.eyugame.tade.module.glops.model.Cell;
import com.eyugame.tade.module.glops.model.RemoveScaleResult;

/**
 * 
 * 
 * @author pengwei
 */
public class BasePlay {

	private final static String LINK = "_";
	/**
	 * 地图
	 */
	private Cell[][] maps;

	/**
	 * 横轴单元格数量
	 */
	private int xSize;

	/**
	 * 竖轴单元格数量
	 */
	private int ySize;
	/**
	 * 随机数
	 */
	private Random random;
	/**
	 * 可以供随机的颜色
	 */
	private List<String> liveColorList = new ArrayList<String>();

	/**
	 * 一次移动的一组（可能多次消除和生成）
	 */
	private List<RemoveScaleResult> removeScaleResultList;

	/**
	 * 要移除的位置
	 */
	private Set<String> removeCellSet = new HashSet<String>();

	/**
	 * 构造方法
	 * 
	 * @param xSize
	 * @param ySize
	 */
	public BasePlay(int xSize, int ySize) {
		super();
		this.xSize = xSize;
		this.ySize = ySize;
		this.maps = new Cell[xSize][ySize];
		random = new Random();
		this.initMaps();
		while (this.isDieMap()) {
			this.initMaps();
		}
	}

	/**
	 * 初始化地图,给地图上色
	 */
	private void initMaps() {
		this.initLiveColor();
		for (int i = 0; i < this.xSize; i++) {
			for (int j = 0; j < this.ySize; j++) {
				// 可供选择的颜色
				int liveSize = liveColorList.size();
				// 判断该位置是否有可供选择的颜色
				if (liveSize > 0) {
					// 随机颜色
					int tem = random.nextInt(liveSize);
					Cell cell = new Cell();
					String liveColor = liveColorList.get(tem);
					// 给格子上坐标跟颜色
					cell.setX(i);
					cell.setY(j);
					cell.setColor(Color.valueOf(liveColor));
					// 放进地图
					maps[i][j] = cell;
					// 判断该格子是否有3个连在一起
					if (this.isLine(i, j)) {
						// 如果是有颜色重叠,从供选择的颜色中去掉该颜色，并重新随机颜色
						j = j - 1;
						liveColorList.remove(liveColor);
					} else {
						// 如果颜色没有3个重复，则初始化可供选择颜色
						this.initLiveColor();
					}
				} else {
					// 如果没有可以选择的颜色，初始化地图
					this.maps = new Cell[xSize][ySize];
					this.initMaps();
					return;
				}
			}
		}
	}

	/**
	 * 初始化随机颜色
	 */
	private void initLiveColor() {
		liveColorList = new ArrayList<String>();
		Color[] colors = Color.values();
		for (Color color : colors) {
			liveColorList.add(new String(color.toString()));
		}
	}

	/**
	 * 填充地图 不允许3格一排或者一列
	 * 
	 * @param x
	 *            填充格子的x轴
	 * @param y
	 *            填充格子的y轴
	 * @return 是否填充成功
	 */
	private boolean isLine(int x, int y) {
		boolean lx1 = x - 1 > -1;
		boolean lx2 = x - 2 > -1;
		boolean bx1 = x + 1 < this.xSize;
		boolean bx2 = x + 2 < this.xSize;
		boolean ly1 = y - 1 > -1;
		boolean ly2 = y - 2 > -1;
		boolean by1 = y + 1 < this.ySize;
		boolean by2 = y + 2 < this.ySize;
		if (ly1 && by1) {
			if (isCellColorEqual(maps[x][y - 1], maps[x][y], maps[x][y + 1])) {
				return true;
			}
		}
		if (lx1 && bx1) {
			if (isCellColorEqual(maps[x - 1][y], maps[x][y], maps[x + 1][y])) {
				return true;
			}
		}
		if (ly2) {
			if (isCellColorEqual(maps[x][y], maps[x][y - 1], maps[x][y - 2])) {
				return true;
			}
		}
		if (by2) {
			if (isCellColorEqual(maps[x][y], maps[x][y + 1], maps[x][y + 2])) {
				return true;
			}
		}

		if (lx2) {
			if (isCellColorEqual(maps[x][y], maps[x - 1][y], maps[x - 2][y])) {
				return true;
			}
		}
		if (bx2) {
			if (isCellColorEqual(maps[x][y], maps[x + 1][y], maps[x + 2][y])) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 相邻3个格子是否同一颜色
	 * 
	 * @param cell1
	 *            格子1
	 * @param cell2
	 *            格子2
	 * @param cell3
	 *            格子3
	 * @return 统一颜色为true，不同为false
	 */
	private boolean isCellColorEqual(Cell cell1, Cell cell2, Cell cell3) {
		if (cell1 != null && cell2 != null && cell3 != null) {
			Color color1 = cell1.color;
			Color color2 = cell2.color;
			Color color3 = cell3.color;
			if (color1 != null && color2 != null && color3 != null) {
				return (color1 == color2 && color1 == color3);
			}
		}
		return false;
	}

	/**
	 * 在补图要添加的格子中相邻3个格子是否同一颜色
	 * 
	 * @param cell1
	 *            格子1
	 * @param cell2
	 *            格子2
	 * @param cell3
	 *            格子3
	 * @return 统一颜色为true，不同为false
	 */
	private boolean isCellColorEqualInAddCell(Cell cell1, Cell cell2, Cell cell3, Set<Cell> set) {
		if (cell1 != null && cell2 != null && cell3 != null) {
			if (set.contains(cell1) && set.contains(cell2) && set.contains(cell3)) {
				Color color1 = cell1.color;
				Color color2 = cell2.color;
				Color color3 = cell3.color;
				if (color1 != null && color2 != null && color3 != null) {
					return (color1 == color2 && color1 == color3);
				}
			}
		}
		return false;
	}

	/**
	 * 右边颜色一样的格子
	 */
	private void isCellColorEqualRight(int x, int y, Color color, Set<String> set) {
		set.add(this.getKey(x, y));
		int newX = x + 1;
		if (newX < this.xSize) {
			if (maps[newX][y] != null && maps[newX][y].color == color) {
				this.isCellColorEqualRight(newX, y, color, set);
			}
		}

	}

	/**
	 * 左边颜色一样的格子
	 */
	private void isCellColorEqualLeft(int x, int y, Color color, Set<String> set) {
		set.add(this.getKey(x, y));
		int newX = x - 1;
		if (newX >= 0) {
			if (maps[newX][y] != null && maps[newX][y].color == color) {
				this.isCellColorEqualLeft(newX, y, color, set);
			}
		}

	}

	/**
	 * 主键生成
	 * 
	 * @param x
	 *            x坐标
	 * @param y
	 *            y坐标
	 * @return
	 */
	private String getKey(int x, int y) {
		return x + BasePlay.LINK + y;
	}

	/**
	 * 上边颜色一样的格子
	 */
	private void isCellColorEqualUp(int x, int y, Color color, Set<String> set) {
		set.add(this.getKey(x, y));
		int newY = y - 1;
		if (newY >= 0) {
			if (maps[x][newY] != null && maps[x][newY].color == color) {
				this.isCellColorEqualUp(x, newY, color, set);
			}
		}
	}

	/**
	 * 下边颜色一样的格子
	 */
	private void isCellColorEqualDown(int x, int y, Color color, Set<String> set) {
		set.add(this.getKey(x, y));
		int newY = y + 1;
		if (newY < this.ySize) {
			if (maps[x][newY] != null && maps[x][newY].color == color) {
				this.isCellColorEqualDown(x, newY, color, set);

			}
		}
	}

	/**
	 * 在删除的节点中，找到相邻的相同颜色的格子
	 * 
	 * @param x
	 * @param y
	 * @param color
	 * @param set
	 * @param cSet
	 */
	private void nearAdd(int x, int y, Color color, Set<String> set, Set<String> cSet) {
		if (!cSet.isEmpty()) {
			String nKey = this.getKey(x, y);
			cSet.remove(nKey);
			set.add(nKey);
			if (x - 1 > -1) {
				String key = this.getKey(x - 1, y);
				if (removeCellSet.contains(key) && !set.contains(key) && maps[x - 1][y].color == color) {
					this.nearAdd(x - 1, y, color, set, cSet);
				}
			}
			if (x + 1 < this.xSize) {
				String key = this.getKey(x + 1, y);
				if (removeCellSet.contains(key) && !set.contains(key) && maps[x + 1][y].color == color) {
					this.nearAdd(x + 1, y, color, set, cSet);
				}
			}
			if (y - 1 > -1) {
				String key = this.getKey(x, y - 1);
				if (removeCellSet.contains(key) && !set.contains(key) && maps[x][y - 1].color == color) {
					this.nearAdd(x, y - 1, color, set, cSet);
				}
			}
			if (y + 1 < this.ySize) {
				String key = this.getKey(x, y + 1);
				if (removeCellSet.contains(key) && !set.contains(key) && maps[x][y + 1].color == color) {
					this.nearAdd(x, y + 1, color, set, cSet);
				}
			}
		}
	}


	/**
	 * 移动 将source 移动至target
	 * 
	 * @param source
	 * @param target
	 * @throws Exception
	 */
	public List<RemoveScaleResult> move(Cell source, Cell target) {
		if (source != null && target != null) {
			if (this.near(source, target)) {
				Color targetColor = maps[target.X][target.Y].color;
				Color sourceColor = maps[source.X][source.Y].color;
				maps[source.X][source.Y].color = targetColor;
				maps[target.X][target.Y].color = sourceColor;
				if (!this.isLine(source.X, source.Y) && !this.isLine(target.X, target.Y)) {
					maps[source.X][source.Y].color = sourceColor;
					maps[target.X][target.Y].color = targetColor;
					throw new NoSpoilageException("这次移动没有可消除的格子");
				} else {
					removeScaleResultList = new ArrayList<RemoveScaleResult>();
					this.fadeCircle();
				}
			} else {
				throw new NearCellException("目标不在起点旁边");
			}
		} else {
			throw new NullPointerException("起点或者目标为空");
		}
		return removeScaleResultList;
	}

	/**
	 * 起点跟目标点是否相邻
	 * 
	 * @param source
	 * @param target
	 * @return
	 */
	private boolean near(Cell source, Cell target) {
		if (this.isInMap(source) && this.isInMap(target) && source.nearCell(target)) {
			return true;
		}
		return false;
	}

	/**
	 * 判断该点是否超界
	 * 
	 * @param cell
	 * @return
	 */
	private boolean isInMap(Cell cell) {
		if (cell.X > -1 && cell.X < this.xSize && cell.Y > -1 && cell.Y < this.ySize) {
			return true;
		}
		return false;
	}

	/**
	 * 补图 随机添加格子
	 * 
	 * @return
	 */
	private Set<Cell> addCell(RemoveScaleResult result) {
		Set<Cell> addCellSet = this.getNonePoint();
		if (!addCellSet.isEmpty()) {
			this.addCell(addCellSet, result);
		}
		return addCellSet;
	}

	/**
	 * 补图
	 * 
	 * @param addCellSet
	 */

	private void addCell(Set<Cell> addCellSet, RemoveScaleResult result) {
		List<Cell> list = new ArrayList<Cell>();
		this.initLiveColor();
		for (Cell cell : addCellSet) {
			while (true) {
				if (!this.liveColorList.isEmpty()) {
					int tem = random.nextInt(liveColorList.size());
					String liveColor = liveColorList.get(tem);
					cell.setColor(Color.valueOf(liveColor));
					if (!this.isLineOnAddCell(cell, addCellSet)) {
						maps[cell.X][cell.Y] = cell;
						list.add(cell);
						break;
					} else {
						liveColorList.remove(liveColor);
					}
				} else {
					this.addCell(addCellSet, result);
					return;
				}
			}
		}
		
		if (this.isDieMap()) {
			this.addCell(addCellSet, result);
		} else {
			if (!list.isEmpty()) {
				result.setNewCellList(list);
			}
		}
	}

	
	/**
	 * 判断在补图要添加的给子中是否有3个连线
	 * 
	 * @param x
	 * @param y
	 * @param set
	 * @return
	 */
	private boolean isLineOnAddCell(Cell cell, Set<Cell> set) {
		int x=cell.X;
		int y=cell.Y;
		boolean lx1 = x - 1 > -1;
		boolean lx2 = x - 2 > -1;
		boolean bx1 = x + 1 < this.xSize;
		boolean bx2 = x + 2 < this.xSize;
		boolean ly1 = y - 1 > -1;
		boolean ly2 = y - 2 > -1;
		boolean by1 = y + 1 < this.ySize;
		boolean by2 = y + 2 < this.ySize;
		if (ly1 && by1) {
			if (isCellColorEqualInAddCell(maps[x][y - 1], cell, maps[x][y + 1], set)) {
				return true;
			}
		}
		if (lx1 && bx1) {
			if (isCellColorEqualInAddCell(maps[x - 1][y], cell, maps[x + 1][y], set)) {
				return true;
			}
		}
		if (ly2) {
			if (isCellColorEqualInAddCell(cell, maps[x][y - 1], maps[x][y - 2], set)) {
				return true;
			}
		}
		if (by2) {
			if (isCellColorEqualInAddCell(cell, maps[x][y + 1], maps[x][y + 2], set)) {
				return true;
			}
		}

		if (lx2) {
			if (isCellColorEqualInAddCell(cell, maps[x - 1][y], maps[x - 2][y], set)) {
				return true;
			}
		}
		if (bx2) {
			if (isCellColorEqualInAddCell(cell, maps[x + 1][y], maps[x + 2][y], set)) {
				return true;
			}
		}
		return false;
	}

	/**
	 * 3消
	 */
	private void fadeCircle() {
		removeCellSet = new HashSet<String>();
		RemoveScaleResult result = new RemoveScaleResult();
		List<List<Cell>> removeCellList = new ArrayList<List<Cell>>();
		// 判断选出要消除的格子
		this.createRemoveCell();
		// 给要消除的给子分块
		this.blockRemoveCell(removeCellList);
		// 消除格子，并且降落
		this.removeCellAndDown();
		if (!removeCellList.isEmpty()) {
			result.setRemoveCellList(removeCellList);
		}
		// 添加格子
		if (!removeCellSet.isEmpty()) {
			this.addCell(result);
			removeScaleResultList.add(result);
			// 添加格子后再消除格子
			this.fadeCircle();
		}
	}

	/**
	 * 生成要消掉的节点 同颜色同列或者同行超过3个的都要消掉
	 */
	private void createRemoveCell() {
		for (int i = 0; i < this.xSize; i++) {
			for (int j = 0; j < this.ySize; j++) {
				Cell source = maps[i][j];
				String cellKey = this.getKey(i, j);
				if (source != null && !removeCellSet.contains(cellKey)) {
					source.setX(i);
					source.setY(j);
					Set<String> rowSet = new HashSet<String>();
					Set<String> colSet = new HashSet<String>();
					this.isCellColorEqualLeft(i, j, source.color, rowSet);
					this.isCellColorEqualRight(i, j, source.color, rowSet);
					this.isCellColorEqualUp(i, j, source.color, colSet);
					this.isCellColorEqualDown(i, j, source.color, colSet);
					if (rowSet.size() > 2) {
						for (String key : rowSet) {
							removeCellSet.add(key);
						}
					}
					if (colSet.size() > 2) {
						for (String key : colSet) {
							removeCellSet.add(key);
						}
					}
				}
			}
		}
	}

	/**
	 * 给要消除的给子分区域
	 */
	private void blockRemoveCell(List<List<Cell>> removeCellList) {
		// 复制一份要消掉的格子的集合
		Set<String> cSet = new HashSet<String>(removeCellSet);
		for (String key : removeCellSet) {
			// 不在cSet里面的格子说明被归某一区域了，不需要在分区域了
			if (!cSet.isEmpty() && cSet.contains(key)) {
				String[] xy = key.split(BasePlay.LINK);
				int x = Integer.parseInt(xy[0]);
				int y = Integer.parseInt(xy[1]);
				Set<String> set = new HashSet<String>();
				// 为该格子相邻的格子迭代扩张，并从cSet中移除掉
				this.nearAdd(x, y, maps[x][y].color, set, cSet);
				if (!set.isEmpty()) {
					List<Cell> list = new ArrayList<Cell>();
					for (String key2 : set) {
						String[] xy2 = key2.split(BasePlay.LINK);
						int x2 = Integer.parseInt(xy2[0]);
						int y2 = Integer.parseInt(xy2[1]);
						maps[x2][y2].X = x2;
						maps[x2][y2].Y = y2;
						list.add(maps[x2][y2]);
					}
					// 对同属于同一区域的要消除的格子排序
					Collections.sort(list, new Comparator<Cell>() {
						@Override
						public int compare(Cell o1, Cell o2) {
							if (o1.Y == o2.Y) {
								return 0;
							} else if (o1.Y > o2.Y) {
								return -1;
							} else {
								return 1;
							}
						}
					});
					removeCellList.add(list);
				}
			}
		}
	}

	/**
	 * 消除要消除的格子跟并且地图格子下降
	 */
	private void removeCellAndDown() {
		Set<Integer> set = new HashSet<Integer>();
		for (String key : removeCellSet) {
			String[] xy = key.split(BasePlay.LINK);
			int x = Integer.parseInt(xy[0]);
			int y = Integer.parseInt(xy[1]);
			maps[x][y] = null;
			if (!set.contains(x)) {
				set.add(x);
			}
		}
		for (Integer x : set) {
			List<Cell> list = new ArrayList<Cell>();
			for (int j = this.ySize - 1; j > -1; j--) {
				Cell cell = maps[x][j];
				if (cell != null) {
					cell.setX(x);
					cell.setY(j);
					list.add(cell.clone());
					maps[x][j] = null;
				}
			}
			int j = this.ySize - 1;
			for (Cell cell : list) {
				cell.setX(x);
				maps[x][j] = cell;
				j--;
			}
		}
	}

	/**
	 * 获取空的节点
	 * 
	 * @return
	 */
	private Set<Cell> getNonePoint() {
		Set<Cell> set = new HashSet<Cell>();
		for (int i = 0; i < this.xSize; i++) {
			for (int j = 0; j < this.ySize; j++) {
				if (maps[i][j] == null) {
					Cell cell = new Cell();
					cell.setX(i);
					cell.setY(j);
					set.add(cell);
				}
			}
		}
		return set;
	}

	/**
	 * 是否为死图
	 * 
	 * @return
	 */
	private boolean isDieMap() {
		for (int i = 0; i < this.xSize; i++) {
			for (int j = 0; j < this.ySize; j++) {
				maps[i][j].X = i;
				maps[i][j].Y = j;
				if (isDie(i, j) == false) {
					return false;
				}
			}
		}
		return true;
	}

	/**
	 * 判断该格子是否为死格子
	 * 
	 * @param x
	 *            格子的x坐标
	 * @param y
	 *            格子的y坐标
	 * @return
	 */
	private boolean isDie(int x, int y) {
		boolean lx1 = x - 1 > -1;
		boolean lx2 = x - 2 > -1;
		boolean lx3 = x - 3 > -1;
		boolean bx1 = x + 1 < this.xSize;
		boolean bx2 = x + 2 < this.xSize;
		boolean bx3 = x + 3 < this.xSize;
		boolean ly1 = y - 1 > -1;
		boolean ly2 = y - 2 > -1;
		boolean ly3 = y - 3 > -1;
		boolean by1 = y + 1 < this.ySize;
		boolean by2 = y + 2 < this.ySize;
		boolean by3 = y + 3 < this.ySize;
		Color color = maps[x][y].color;
		if (bx1) {
			if (maps[x + 1][y].color == color) {
				if (bx3) {
					if (maps[x + 3][y].color == color) {
						return false;
					}
				}
				if (bx2 && by1) {
					if (maps[x + 2][y + 1].color == color) {
						return false;
					}
				}
				if (bx2 && ly1) {
					if (maps[x + 2][y - 1].color == color) {
						return false;
					}
				}
				if (lx2) {
					if (maps[x - 2][y].color == color) {
						return false;
					}
				}
				if (lx1 && ly1) {
					if (maps[x - 1][y - 1].color == color) {
						return false;
					}
				}
				if (lx1 && by1) {
					if (maps[x - 1][y + 1].color == color) {
						return false;
					}
				}
			}
			if (ly1 && by1) {
				if (maps[x + 1][y - 1].color == color && maps[x + 1][y + 1].color == color) {
					return false;
				}
			}
		}
		if (lx1) {
			if (maps[x - 1][y].color == color) {
				if (lx3) {
					if (maps[x - 3][y].color == color) {
						return false;
					}
				}
				if (lx2 && by1) {
					if (maps[x - 2][y + 1].color == color) {
						return false;
					}
				}
				if (lx2 && ly1) {
					if (maps[x - 2][y - 1].color == color) {
						return false;
					}
				}
				if (bx2) {
					if (maps[x + 2][y].color == color) {
						return false;
					}
				}
				if (bx1 && ly1) {
					if (maps[x + 1][y - 1].color == color) {
						return false;
					}
				}
				if (bx1 && by1) {
					if (maps[x + 1][y + 1].color == color) {
						return false;
					}
				}
			}
			if (ly1 && by1) {
				if (maps[x - 1][y - 1].color == color && maps[x - 1][y + 1].color == color) {
					return false;
				}
			}
		}
		if (by1) {
			if (maps[x][y + 1].color == color) {
				if (by3) {
					if (maps[x][y + 3].color == color) {
						return false;
					}
				}
				if (lx1 && by2) {
					if (maps[x - 1][y + 2].color == color) {
						return false;
					}
				}
				if (bx1 && by2) {
					if (maps[x + 1][y + 2].color == color) {
						return false;
					}
				}
				if (ly2) {
					if (maps[x][y - 2].color == color) {
						return false;
					}
				}
				if (bx1 && ly1) {
					if (maps[x + 1][y - 1].color == color) {
						return false;
					}
				}
				if (lx1 && ly1) {
					if (maps[x - 1][y - 1].color == color) {
						return false;
					}
				}
			}
			if (lx1 && bx1) {
				if (maps[x - 1][y + 1].color == color && maps[x + 1][y + 1].color == color) {
					return false;
				}
			}
		}
		if (ly1) {
			if (maps[x][y - 1].color == color) {
				if (ly3) {
					if (maps[x][y - 3].color == color) {
						return false;
					}
				}
				if (lx1 && ly2) {
					if (maps[x - 1][y - 2].color == color) {
						return false;
					}
				}
				if (bx1 && ly2) {
					if (maps[x + 1][y - 2].color == color) {
						return false;
					}
				}
				if (by2) {
					if (maps[x][y + 2].color == color) {
						return false;
					}
				}
				if (bx1 && by1) {
					if (maps[x + 1][y + 1].color == color) {
						return false;
					}
				}
				if (lx1 && by1) {
					if (maps[x - 1][y + 1].color == color) {
						return false;
					}
				}
			}
			if (lx1 && bx1) {
				if (maps[x - 1][y - 1].color == color && maps[x + 1][y - 1].color == color) {
					return false;
				}
			}
		}
		return true;
	}

	public Cell[][] getMaps() {
		return maps;
	}

	public void setMaps(Cell[][] maps) {
		this.maps = maps;
	}

	public int getxSize() {
		return xSize;
	}

	public void setxSize(int xSize) {
		this.xSize = xSize;
	}

	public int getySize() {
		return ySize;
	}

	public void setySize(int ySize) {
		this.ySize = ySize;
	}

}

package com.eyugame.tade.module.glops.model;

import com.eyugame.tade.module.glops.constant.Color;

/**
 * 单元格
 * 
 * @author k60
 */
public class Cell {

	/**
	 * x坐标
	 */
	public int X;

	/**
	 * y坐标
	 */
	public int Y;

	/**
	 * 颜色
	 */
	public Color color;

	public Cell() {
		super();
	}

	public Cell(int x, int y) {
		super();
		X = x;
		Y = y;
	}

	public int getX() {
		return X;
	}

	public void setX(int x) {
		X = x;
	}

	public int getY() {
		return Y;
	}

	public void setY(int y) {
		Y = y;
	}

	public Color getColor() {
		return color;
	}

	public void setColor(Color color) {
		this.color = color;
	}

	public boolean nearCell(Cell cell) {
		if (cell != null) {
			if (this.X == cell.X && this.Y == (cell.Y + 1)) {
				return true;
			} else if (this.X == cell.X && this.Y == (cell.Y - 1)) {
				return true;
			} else if (this.X == (cell.X + 1) && this.Y == cell.Y) {
				return true;
			} else if (this.X == (cell.X - 1) && this.Y == cell.Y) {
				return true;
			}
		}
		return false;
	}
    
	@Override
	public String toString() {
		return this.X+"_"+this.Y+":"+this.color;
				
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + X;
		result = prime * result + Y;
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Cell other = (Cell) obj;
		if (X != other.X)
			return false;
		if (Y != other.Y)
			return false;
		return true;
	}
	
	public Cell clone(){
		Cell cell=new Cell();
		cell.setX(this.X);
		cell.setY(this.Y);
		cell.setColor(this.color);
		return cell;
	}
	
	
}

package com.eyugame.tade.module.glops.model;

import java.util.List;

/** 
 * 消除刻度结果
 *
 * @author  k60
 */
public class RemoveScaleResult {

	/**
	 * 消除的单元格
	 */
	private List<List<Cell>> removeCellList;
	
	/**
	 * 新产生的单元格颜色列表
	 * 
	 * 产生规则：
	 * X轴,由左至右补
	 * Y轴，由下至上补
	 */
	private List<Cell> newCellList;
	

	public List<List<Cell>> getRemoveCellList() {
		return removeCellList;
	}

	public void setRemoveCellList(List<List<Cell>> removeCellList) {
		this.removeCellList = removeCellList;
	}

	public List<Cell> getNewCellList() {
		return newCellList;
	}

	public void setNewCellList(List<Cell> newCellList) {
		this.newCellList = newCellList;
	}


}

package com.eyugame.tade.module.glops.exception;
/**
 * 
 * 当起点向目标移动，目标跟起点不是相邻时异常
 *
 */
public class NearCellException extends RuntimeException {

	private static final long serialVersionUID = -5973332015600566849L;

	public NearCellException(String message){
		super(message);
	}
	
}

package com.eyugame.tade.module.glops.exception;
/**
 * 
 * 当起点向目标移动，但是不能3消异常
 *
 */
public class NoSpoilageException extends RuntimeException {
	
	private static final long serialVersionUID = 3129338536664414593L;
	
	public NoSpoilageException(String message) {
		super(message);
	}
}