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

先上前端效果图

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交换

交换后

消除后

下降后

补图

因为能消，所以再消

下降

再补图

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

代码结构

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

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;

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

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;

if (this.isLine(i, j)) {

j = j - 1;

liveColorList.remove(liveColor);

} else {

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

}

}

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;

}

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;

}

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

}

}

}

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

}

}

}

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

}

}

}

}

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;

}

private boolean near(Cell source, Cell target) {

if (this.isInMap(source) && this.isInMap(target) && source.nearCell(target)) {

return true;

}

return false;

}

private boolean isInMap(Cell cell) {

if (cell.X > -1 && cell.X < this.xSize && cell.Y > -1 && cell.Y < this.ySize) {

return true;

}

return false;

}

private Set<Cell> addCell(RemoveScaleResult result) {

Set<Cell> addCellSet = this.getNonePoint();

if (!addCellSet.isEmpty()) {

this.addCell(addCellSet, result);

}

return 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);

}

}

}

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;

}

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

}

}

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) {

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

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--;

}

}

}

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;

}

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;

}

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;

public class Cell {

public int X;

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;

public class RemoveScaleResult {

private List<List<Cell>> removeCellList;

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;

public class NoSpoilageException extends RuntimeException {

private static final long serialVersionUID = 3129338536664414593L;

public NoSpoilageException(String message) {

super(message);

}

}

相关知识

《开心消消乐》关于乐元素所做的三消游戏！
鲜花消消乐游戏下载
百合花消消乐游戏
插花消消乐游戏下载
熊熊三消乐游戏下载
消消乐
花朵消消乐游戏
三消消乐玩法攻略，游戏技巧详解
消消消游戏都有哪些 热门的三消游戏合集2024
为什么消消乐能让8亿人上瘾？

网址: 消消乐游戏算法实现（三消乐） https://www.huajiangbk.com/newsview1753325.html