2048游戏核心机制：实现高效且正确的方块移动与合并逻辑

Player move
    v
13  14  15  16  <-- 扫描顺序 (从下往上)
9   10  11  12
5   6   7   8
1   2   3   4

Player move
    <----
4   3   2   1
8   7   6   5
12  11  10  9
16  15  14  13

// slideAndMergeLine 负责处理单个行或列的滑动和合并
// line: 当前行或列的切片
// isReverse: 如果为true，表示从切片末尾开始处理（对应向下或向右移动）
// 返回处理后的切片和是否有变化
func slideAndMergeLine(line []int, isReverse bool) ([]int, bool) {
    originalLine := make([]int, len(line))
    copy(originalLine, line) // 备份原始数据用于比较

    // 1. 移除零元素并压缩
    nonZero := []int{}
    for _, val := range line {
        if val != 0 {
            nonZero = append(nonZero, val)
        }
    }

    // 如果没有非零元素，直接返回
    if len(nonZero) == 0 {
        return originalLine, false
    }

    // 2. 根据方向执行合并操作
    // 使用一个布尔数组标记哪些方块已经被合并过
    // 这里我们直接在 nonZero 数组上操作，并用一个独立的 merged 标记
    // 为了简化，我们先将 nonZero 视为一个待处理的“临时行”
    processed := make([]int, len(nonZero))
    copy(processed, nonZero)
    hasMerged := make([]bool, len(processed)) // 标记每个方块是否已合并

    if isReverse { // 从末尾向前处理 (向下或向右)
        for i := len(processed) - 1; i > 0; i-- {
            if processed[i] == processed[i-1] && !hasMerged[i] && !hasMerged[i-1] {
                processed[i] *= 2
                processed[i-1] = 0 // 被合并的方块清零
                hasMerged[i] = true // 标记目标方块已合并
            }
        }
    } else { // 从开头向后处理 (向上或向左)
        for i := 0; i < len(processed)-1; i++ {
            if processed[i] == processed[i+1] && !hasMerged[i] && !hasMerged[i+1] {
                processed[i] *= 2
                processed[i+1] = 0 // 被合并的方块清零
                hasMerged[i] = true // 标记目标方块已合并
            }
        }
    }

    // 3. 重新压缩并填充零
    finalLine := []int{}
    for _, val := range processed {
        if val != 0 {
            finalLine = append(finalLine, val)
        }
    }

    // 填充剩余的零
    resultLine := make([]int, len(line))
    if isReverse { // 零在前面 (向下或向右)
        copy(resultLine[len(line)-len(finalLine):], finalLine)
    } else { // 零在后面 (向上或向左)
        copy(resultLine, finalLine)
    }

    // 4. 检查是否有变化
    changed := false
    for i := 0; i < len(line); i++ {
        if originalLine[i] != resultLine[i] {
            changed = true
            break
        }
    }

    return resultLine, changed
}

// BoardDimensions 定义棋盘的宽度和高度
const (
    Width  = 4
    Height = 4
)

// processCommand 处理玩家输入，更新棋盘状态
// 注意：board 应该是一个深拷贝，避免直接修改原始棋盘导致副作用
func processCommand(board [][]int, input string) ([][]int, bool) {
    // 创建一个新棋盘进行操作，避免直接修改传入的原始棋盘
    newBoard := make([][]int, Height)
    for i := range newBoard {
        newBoard[i] = make([]int, Width)
        copy(newBoard[i], board[i]) // 深拷贝
    }

    hasChanged := false

    switch input {
    case "d": // 向下移动
        for j := 0; j < Width; j++ { // 遍历每一列
            col := make([]int, Height)
            for i := 0; i < Height; i++ {
                col[i] = board[i][j] // 提取当前列
            }
            // 向下移动，从下往上扫描，所以 isReverse 为 true
            processedCol, changed := slideAndMergeLine(col, true)
            if changed {
                hasChanged = true
            }
            for i := 0; i < Height; i++ {
                newBoard[i][j] = processedCol[i] // 将处理后的列写回新棋盘
            }
        }
    case "u": // 向上移动
        for j := 0; j < Width; j++ { // 遍历每一列
            col := make([]int, Height)
            for i := 0; i < Height; i++ {
                col[i] = board[i][j] // 提取当前列
            }
            // 向上移动，从上往下扫描，所以 isReverse 为 false
            processedCol, changed := slideAndMergeLine(col, false)
            if changed {
                hasChanged = true
            }
            for i := 0; i < Height; i++ {
                newBoard[i][j] = processedCol[i] // 将处理后的列写回新棋盘
            }
        }
    case "l": // 向左移动
        for i := 0; i < Height; i++ { // 遍历每一行
            row := make([]int, Width)
            copy(row, board[i]) // 提取当前行
            // 向左移动，从左往右扫描，所以 isReverse 为 false
            processedRow, changed := slideAndMergeLine(row, false)
            if changed {
                hasChanged = true
            }
            copy(newBoard[i], processedRow) // 将处理后的行写回新棋盘
        }
    case "r": // 向右移动
        for i := 0; i < Height; i++ { // 遍历每一行
            row := make([]int, Width)
            copy(row, board[i]) // 提取当前行
            // 向右移动，从右往左扫描，所以 isReverse 为 true
            processedRow, changed := slideAndMergeLine(row, true)
            if changed {
                hasChanged = true
            }
            copy(newBoard[i], processedRow) // 将处理后的行写回新棋盘
        }
    // case "gameover": // 游戏结束逻辑通常在外部处理
    //     gameOver = true
    default:
        // 处理无效输入，或者直接忽略
        return board, false // 没有有效命令，棋盘不变
    }

    return newBoard, hasChanged
}