如何实现海洋生态模拟中多对象的同步移动与碰撞处理？

项目背景 #

我正在开发一个包含海龟、垃圾/塑料和船只的海洋生态系统2D网格模拟项目，对象已预填充在网格中，移动规则为随机移动：

• 船只移动频率高
• 海龟较常静止
• 垃圾基本静止

碰撞规则 #

对象间的碰撞逻辑通过如下映射定义：

std::map<std::pair<Ocean::Occupy, Ocean::Occupy>, Ocean::CollisionResult> collision_logics = {
            // Turtle encounters an empty space -> It can move.
            { {Ocean::Occupy::Turtle, Ocean::Occupy::Empty},   Ocean::CollisionResult::Move },
            // Turtle encounters trash -> It dies.
            { {Ocean::Occupy::Turtle, Ocean::Occupy::Trash},   Ocean::CollisionResult::Die },
            // Turtle encounters a ship -> Movement is blocked.
            { {Ocean::Occupy::Turtle, Ocean::Occupy::Ship},    Ocean::CollisionResult::Block },
            // Turtle encounters another turtle -> Movement is blocked.
            { {Ocean::Occupy::Turtle, Ocean::Occupy::Turtle},  Ocean::CollisionResult::Block },

            // Trash encounters an empty space -> It can move.
            { {Ocean::Occupy::Trash,  Ocean::Occupy::Empty},   Ocean::CollisionResult::Move },
            // Trash encounters a turtle -> Movement is allowed.
            { {Ocean::Occupy::Trash,  Ocean::Occupy::Turtle},  Ocean::CollisionResult::Move },
            // Trash encounters another trash -> Movement is blocked.
            { {Ocean::Occupy::Trash,  Ocean::Occupy::Trash},   Ocean::CollisionResult::Block },
            // Trash encounters a ship -> It gets cleared (dies).
            { {Ocean::Occupy::Trash,  Ocean::Occupy::Ship},    Ocean::CollisionResult::Die },

            // Ship encounters an empty space -> It can move.
            { {Ocean::Occupy::Ship,   Ocean::Occupy::Empty},   Ocean::CollisionResult::Move },
            // Ship encounters trash -> It survives and clears the trash.
            { {Ocean::Occupy::Ship,   Ocean::Occupy::Trash},   Ocean::CollisionResult::Move },
            // Ship encounters another ship -> Movement is blocked.
            { {Ocean::Occupy::Ship,   Ocean::Occupy::Ship},    Ocean::CollisionResult::Block },
            // Ship encounters a turtle -> Movement is blocked.
            { {Ocean::Occupy::Ship,   Ocean::Occupy::Turtle},  Ocean::CollisionResult::Block}
        };

核心逻辑：海龟误食垃圾死亡，船只清除垃圾，同类或不同类对象的移动阻挡规则如上。

当前问题 #

需要实现所有对象的同步更新，但目前通过临时网格逐对象更新的方式无法满足：

• 例如(0,1)的海龟与(0,2)的垃圾同时移动到(1,1)时，需要判定海龟死亡，垃圾留在(1,1)
• 又如(2,0)的海龟尝试移动到(2,1)，但船只静止时，海龟移动被阻挡，停留在原位置

现有代码片段：

void update_grid() {
    // intialize the grid_copy
    std::vector<int> temp_grid(num_cells, static_cast<int>(Occupy::Empty));
    
    // Iterate over this grid:
    // iterate over rows:
    for (int i = 0; i < num_rows; ++i) {
        // iterate over columns:
        for (int j = 0; j < num_cols; ++j) {
            // retrieve cell state from the grid (again, grid that's not getting updated)
            Occupy curr_obj = static_cast<Occupy>(this->get_cell(i, j));  
            // then apply random movement based on what the curr object is

移动方法返回元组{i, j, obj, new_i, new_j, new_obj}，但逐对象更新会导致先处理的对象影响后处理的对象，无法实现真正同步。

最优实现方案 #

要实现同步更新，必须分两个阶段处理：先收集所有对象的移动意图，再统一处理碰撞与生成新网格，具体步骤如下：

1. 预收集所有对象的移动意图 #

遍历原网格的每个单元格，对每个非空对象计算其目标位置（包括静止的情况，即目标位置等于原位置），将所有意图存储在一个列表中，每个意图包含：

• 原位置(old_i, old_j)
• 对象类型Occupy
• 目标位置(new_i, new_j)

此阶段完全基于原始网格状态计算，不修改任何网格数据，确保所有对象的移动决策都基于同一初始状态。

示例代码思路：

struct MovementIntent {
    int old_i, old_j;
    Ocean::Occupy obj_type;
    int new_i, new_j;
};

std::vector<MovementIntent> collect_movement_intents() {
    std::vector<MovementIntent> intents;
    for (int i = 0; i < num_rows; ++i) {
        for (int j = 0; j < num_cols; ++j) {
            Ocean::Occupy curr_obj = static_cast<Ocean::Occupy>(get_cell(i, j));
            if (curr_obj == Ocean::Occupy::Empty) continue;
            
            // 计算随机移动后的目标位置（根据对象类型的移动频率规则）
            auto [new_i, new_j] = calculate_random_move(i, j, curr_obj);
            intents.push_back({i, j, curr_obj, new_i, new_j});
        }
    }
    return intents;
}

2. 处理碰撞与冲突，生成新网格 #

创建一个空的临时网格，同时为每个目标位置维护一个对象列表，记录所有试图移动到该位置的对象。然后按以下逻辑处理每个位置：

2.1 统计每个目标位置的对象

用一个std::map<std::pair<int, int>, std::vector<MovementIntent>> target_objects来统计：

• 键：目标位置(new_i, new_j)
• 值：所有试图移动到该位置的对象类型列表

2.2 按规则处理每个位置的冲突

遍历每个目标位置的对象列表，根据碰撞规则和优先级处理：

• 单一对象：如果目标位置只有一个对象，检查该位置在原网格中的状态，应用碰撞规则判断是否允许移动、死亡或阻挡
• 多个对象：
  • 海龟+垃圾：海龟死亡，垃圾保留在目标位置
  • 多艘船：全部移动被阻挡，回到原位置
  • 船只+垃圾：垃圾被清除，船只占据目标位置

2.3 构建最终网格

处理完所有冲突后，将结果写入临时网格，最后替换原网格。

示例冲突处理代码片段：

void resolve_conflicts_and_update(const std::vector<MovementIntent>& intents) {
    std::vector<int> new_grid(num_cells, static_cast<int>(Ocean::Occupy::Empty));
    // 先标记所有静止的对象（初始状态，后续会被覆盖）
    for (int i = 0; i < num_rows; ++i) {
        for (int j = 0; j < num_cols; ++j) {
            new_grid[i * num_cols + j] = get_cell(i, j);
        }
    }

    // 统计每个目标位置的移动意图
    std::map<std::pair<int, int>, std::vector<MovementIntent>> target_map;
    for (const auto& intent : intents) {
        target_map[{intent.new_i, intent.new_j}].push_back(intent);
    }

    // 处理每个目标位置的冲突
    for (const auto& [pos, intents_at_pos] : target_map) {
        int x = pos.first;
        int y = pos.second;
        Ocean::Occupy original_cell = static_cast<Ocean::Occupy>(get_cell(x, y));

        if (intents_at_pos.size() == 1) {
            const auto& intent = intents_at_pos[0];
            auto collision_key = std::make_pair(intent.obj_type, original_cell);
            auto result = collision_logics[collision_key];

            switch(result) {
                case Ocean::CollisionResult::Move:
                    new_grid[intent.old_i * num_cols + intent.old_j] = static_cast<int>(Ocean::Occupy::Empty);
                    new_grid[x * num_cols + y] = static_cast<int>(intent.obj_type);
                    break;
                case Ocean::CollisionResult::Die:
                    new_grid[intent.old_i * num_cols + intent.old_j] = static_cast<int>(Ocean::Occupy::Empty);
                    break;
                case Ocean::CollisionResult::Block:
                    // 移动被阻挡，保持原位置不变
                    break;
            }
        } else {
            // 处理多对象冲突场景
            bool has_turtle = std::any_of(intents_at_pos.begin(), intents_at_pos.end(), 
                [](const auto& i){ return i.obj_type == Ocean::Occupy::Turtle; });
            bool has_trash = std::any_of(intents_at_pos.begin(), intents_at_pos.end(), 
                [](const auto& i){ return i.obj_type == Ocean::Occupy::Trash; });
            bool has_ship = std::any_of(intents_at_pos.begin(), intents_at_pos.end(), 
                [](const auto& i){ return i.obj_type == Ocean::Occupy::Ship; });

            if (has_turtle && has_trash) {
                // 海龟死亡，垃圾保留
                for (const auto& intent : intents_at_pos) {
                    if (intent.obj_type == Ocean::Occupy::Turtle) {
                        new_grid[intent.old_i * num_cols + intent.old_j] = static_cast<int>(Ocean::Occupy::Empty);
                    } else if (intent.obj_type == Ocean::Occupy::Trash) {
                        new_grid[intent.old_i * num_cols + intent.old_j] = static_cast<int>(Ocean::Occupy::Empty);
                        new_grid[x * num_cols + y] = static_cast<int>(Ocean::Occupy::Trash);
                    }
                }
            } else if (has_ship && has_trash) {
                // 垃圾死亡，船只占据位置
                for (const auto& intent : intents_at_pos) {
                    if (intent.obj_type == Ocean::Occupy::Trash) {
                        new_grid[intent.old_i * num_cols + intent.old_j] = static_cast<int>(Ocean::Occupy::Empty);
                    } else if (intent.obj_type == Ocean::Occupy::Ship) {
                        new_grid[intent.old_i * num_cols + intent.old_j] = static_cast<int>(Ocean::Occupy::Empty);
                        new_grid[x * num_cols + y] = static_cast<int>(Ocean::Occupy::Ship);
                    }
                }
            }
            // 其他冲突场景可按类似逻辑扩展
        }
    }

    // 替换原网格
    this->grid = new_grid;
}

关键优势 #

• 完全基于原始网格状态计算所有移动意图，确保同步性
• 冲突处理集中进行，避免逐对象更新带来的状态不一致
• 逻辑清晰，易于扩展新的对象类型或碰撞规则

内容的提问来源于stack exchange，提问作者roundofferror