制作一个Java2048游戏，在滑动时，它通过循环的次数比它应该的要多，并且点击测试/改变已经改变的数字

所以我有一个可靠的滑动函数，问题是（这很难解释！）它经历了所有的可能性，包括2d数组中已经添加在一起的空间：假设有这样一个设置：4,4,8,2--向右滑动一次后，结果是这样的：，\u，16,2。然而在实际的游戏中，右击一下后，应该是这样的：uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu

基本上，我如何解决这个问题？你不需要告诉我代码，这是我期末考试的项目，但我想得到一些关于为什么会发生这种情况的解释

我试图从右到左循环数组，但这导致数字甚至没有移动

   processUserChoice(String i) {
    if (i.equals("d")) {
     while ((slideRight())) {
      moveRight();
     }
    }
    printBoard();
   }

   public boolean slideRight() {
    for (int i = 0; i < board.length; i++) {
     for (int j = 0; j < board[i].length - 1; j++) {
      if (board[i][j + 1] == 0 && board[i][j] != 0) {
       return true;
      } else if (board[i][j + 1] == board[i][j] && board[i][j] != 0) {
       return true;
      }
     }
    }
    return false;
   }
   public void moveRight() {
    for (int i = 0; i < board.length; i++) {
     for (int j = 0; j < board[i].length - 1; j++) {
      if (board[i][j + 1] == 0 && board[i][j] != 0) {
       board[i][j + 1] = board[i][j];
       board[i][j] = 0;
      } else if (board[i][j + 1] == board[i][j] && board[i][j] != 0) {
       board[i][j + 1] = board[i][j + 1] + board[i][j];
       board[i][j] = 0;
      }
     }
    }
    //checkLose();
   }

processUserChoice（字符串i）{
如果（i等于（“d”））{
而（（slideRight（）））{
moveRight（）；
}
}
印制板（）；
}
公共布尔slideRight（）{
对于（int i=0；i

---

右击一次后，应该是这样的：“\uuuuuuuuuu8,2”（来自前面的示例）。

我以前做过类似的事情。我想用和你现在差不多的方法来做，但是添加一个布尔数组来检查瓷砖是否发生了碰撞，并且只合并没有发生碰撞的瓷砖

class Tile {
    public int value;
    public Boolean collided;

    public Tile(int value) {
        this.value = value;
        collided = false;
    }

    public Tile attemptMerge(Tile target) {
        if (target.value == value) {
            Tile t = new Tile(value * 2);
            t.collided = true;
            return t;
        } else {
            return null;
        }
    }

    public void reset() {
        value = 0;
        collided = false;
    }
}

在主更新循环中的某个位置：

void slideRight() {
    for (int row = 0; row < 4; row++) {
        for (int column = 3; column >= 0; column--) {
            Tile current = board[row][column];

            if (current.value == 0) continue;

            for (int slot = column + 1; slot < 3; slot++) {
                Tile target = board[row][slot];

                if (target.value == 0) {
                    target.value = current.value;
                    current = target;
                    board[row][slot - 1].reset();
                } else if (target.value == current.value) {
                    Tile product = target.merge(current);

                    if (!target.collided && !current.collided) {
                        current = product;
                        board[row][slot - 1].reset();
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            }
        }
    }
}

void slideRight（）{
用于（int行=0；行<4；行++）{
对于（int列=3；列>=0；列--）{
磁砖电流=电路板[行][列]；
如果（current.value==0）继续；
用于（int slot=列+1；slot<3；slot++）{
瓷砖目标=板[行][槽]；
如果（target.value==0）{
target.value=current.value；
当前=目标；
线路板[行][插槽-1]。重置（）；
}else if（target.value==current.value）{
瓷砖产品=目标。合并（当前）；
如果（！target.collide&&！current.collide）{
电流=产品；
线路板[行][插槽-1]。重置（）；
}否则{
打破
}
}否则{
打破
}
}
}
}
}

---

我相信这方面的东西应该会奏效。如果逻辑有点错误，很抱歉。

我以前做过类似的事情。我想用和你现在差不多的方法来做，但是添加一个布尔数组来检查瓷砖是否发生了碰撞，并且只合并没有发生碰撞的瓷砖

class Tile {
    public int value;
    public Boolean collided;

    public Tile(int value) {
        this.value = value;
        collided = false;
    }

    public Tile attemptMerge(Tile target) {
        if (target.value == value) {
            Tile t = new Tile(value * 2);
            t.collided = true;
            return t;
        } else {
            return null;
        }
    }

    public void reset() {
        value = 0;
        collided = false;
    }
}

在主更新循环中的某个位置：

void slideRight() {
    for (int row = 0; row < 4; row++) {
        for (int column = 3; column >= 0; column--) {
            Tile current = board[row][column];

            if (current.value == 0) continue;

            for (int slot = column + 1; slot < 3; slot++) {
                Tile target = board[row][slot];

                if (target.value == 0) {
                    target.value = current.value;
                    current = target;
                    board[row][slot - 1].reset();
                } else if (target.value == current.value) {
                    Tile product = target.merge(current);

                    if (!target.collided && !current.collided) {
                        current = product;
                        board[row][slot - 1].reset();
                    } else {
                        break;
                    }
                } else {
                    break;
                }
            }
        }
    }
}

void slideRight（）{
用于（int行=0；行<4；行++）{
对于（int列=3；列>=0；列--）{
磁砖电流=电路板[行][列]；
如果（current.value==0）继续；
用于（int slot=列+1；slot<3；slot++）{
瓷砖目标=板[行][槽]；
如果（target.value==0）{
target.value=current.value；
当前=目标；
线路板[行][插槽-1]。重置（）；
}else if（target.value==current.value）{
瓷砖产品=目标。合并（当前）；
如果（！target.collide&&！current.collide）{
电流=产品；
线路板[行][插槽-1]。重置（）；
}否则{
打破
}
}否则{
打破
}
}
}
}
}

---

我相信这方面的东西应该会奏效。如果逻辑有点缺陷，很抱歉。

可能使用调试器或打印语句？可能使用调试器或打印语句？我喜欢冲突测试，但我一直在思考如何在代码中实现它？我也做了一些改变：Java是一种OOP语言。好好利用这一点。我建议您花点时间实际创建这个Tile（或TileData）类，并尝试以这种方式实现它。我无法从你的代码中准确地分辨出你在做什么，因为它需要很多东西，但OOP编码风格在正确使用时更具结构化。我喜欢碰撞测试，但我一直在思考如何在我的代码中实现它？我也做了一些改变：Java是一种OOP语言。好好利用这一点。我建议您花点时间实际创建这个Tile（或TileData）类，并尝试以这种方式实现它。我不能从你的代码中准确地分辨出你在做什么，因为它有很多东西需要接受，但OOP编码风格在正确使用时会更加结构化。