2048游戏核心机制：实现高效准确的瓷砖移动与合并

行索引：
0
1
2
3 (底部)

package main

import (
    "fmt"
)

const (
    height = 4
    width  = 4
)

// deepCopyBoard 进行棋盘的深拷贝，避免直接修改原始棋盘
func deepCopyBoard(board [][]int) [][]int {
    newBoard := make([][]int, height)
    for i := range newBoard {
        newBoard[i] = make([]int, width)
        copy(newBoard[i], board[i])
    }
    return newBoard
}

// slideAndMergeRowOrCol 负责对一行或一列进行滑动和合并
// isRow: true表示处理行，false表示处理列
// index: 行或列的索引
// direction: "u", "d", "l", "r"
// 返回值：棋盘是否发生变化
func slideAndMergeRowOrCol(board [][]int, index int, direction string, merged [][]bool) bool {
    changed := false
    var values []int // 存储当前行/列的非零值

    // 提取当前行/列的非零值
    if direction == "u" || direction == "d" { // 处理列
        for r := 0; r < height; r++ {
            if board[r][index] != 0 {
                values = append(values, board[r][index])
            }
        }
    } else { // 处理行
        for c := 0; c < width; c++ {
            if board[index][c] != 0 {
                values = append(values, board[index][c])
            }
        }
    }

    // 合并逻辑
    processedValues := make([]int, 0, len(values))
    if direction == "u" || direction == "l" { // 从前往后合并
        for i := 0; i < len(values); i++ {
            if i+1 < len(values) && values[i] == values[i+1] {
                processedValues = append(processedValues, values[i]*2)
                i++ // 跳过下一个已合并的瓷砖
            } else {
                processedValues = append(processedValues, values[i])
            }
        }
    } else { // 从后往前合并 (d, r)
        for i := len(values) - 1; i >= 0; i-- {
            if i-1 >= 0 && values[i] == values[i-1] {
                processedValues = append([]int{values[i]*2}, processedValues...)
                i-- // 跳过前一个已合并的瓷砖
            } else {
                processedValues = append([]int{values[i]}, processedValues...)
            }
        }
    }

    // 填充回棋盘
    // 先清空当前行/列
    if direction == "u" || direction == "d" { // 清空列
        for r := 0; r < height; r++ {
            if board[r][index] != 0 {
                board[r][index] = 0
                changed = true // 至少有瓷砖被清空，说明有变化
            }
        }
    } else { // 清空行
        for c := 0; c < width; c++ {
            if board[index][c] != 0 {
                board[index][c] = 0
                changed = true // 至少有瓷砖被清空，说明有变化
            }
        }
    }

    // 重新填充
    if direction == "u" || direction == "l" { // 向上或向左，从起始位置填充
        for i, val := range processedValues {
            if direction == "u" {
                if board[i][index] != val { // 检查是否真的改变
                    board[i][index] = val
                    changed = true
                }
            } else { // "l"
                if board[index][i] != val { // 检查是否真的改变
                    board[index][i] = val
                    changed = true
                }
            }
        }
    } else { // 向下或向右，从结束位置填充
        for i, val := range processedValues {
            if direction == "d" {
                targetRow := height - len(processedValues) + i
                if board[targetRow][index] != val { // 检查是否真的改变
                    board[targetRow][index] = val
                    changed = true
                }
            } else { // "r"
                targetCol := width - len(processedValues) + i
                if board[index][targetCol] != val { // 检查是否真的改变
                    board[index][targetCol] = val
                    changed = true
                }
            }
        }
    }

    return changed
}

// moveBoard 执行棋盘的整体移动和合并操作
func moveBoard(board [][]int, direction string) bool {
    originalBoard := deepCopyBoard(board) // 记录原始棋盘状态
    changed := false

    // 初始化合并标记数组（在这个简化模型中，我们通过一次性提取-处理-填充来模拟合并标记）
    // 更严格的合并标记需要更细粒度的循环，但对于2048，这种提取处理方式是等效的

    switch direction {
    case "u": // 向上移动：从左到右遍历列
        for col := 0; col < width; col++ {
            if slideAndMergeRowOrCol(board, col, "u", nil) {
                changed = true
            }
        }
    case "d": // 向下移动：从左到右遍历列
        for col := 0; col < width; col++ {
            if slideAndMergeRowOrCol(board, col, "d", nil) {
                changed = true
            }
        }
    case "l": // 向左移动：从上到下遍历行
        for row := 0; row < height; row++ {
            if slideAndMergeRowOr