Rust战斗模拟引擎如何解决tick方法的借用检查器报错问题

你遇到的是Rust典型的借用规则冲突：代码同时持有了combatants数组的可变借用（指向第一个元素的target可变引用）和不可变借用（遍历数组时拿到的所有战斗单位的不可变引用），Rust的借用规则禁止同一时间对同一个集合存在活跃的可变和不可变借用，从根源上避免数据竞争、悬垂引用等内存安全问题。

以下是三种适配不同场景的实现方案：

方案1：索引拆分借用（适合简单逻辑） #

通过索引定位单位，使用split_at_mut拆分数组拿到两个不重叠的元素引用，避免同时借用整个数组：

impl Battlefield {
    fn tick(&mut self) {
        let target_idx = 0;
        // 遍历索引而非直接持有元素引用
        for attacker_idx in 0..self.combatants.len() {
            // 跳过自己攻击自己的逻辑
            if attacker_idx == target_idx {
                continue;
            }
            // 拆分数组获得两个不重叠的可变片段
            let (left, right) = self.combatants.split_at_mut(attacker_idx.max(target_idx));
            // 分别从对应片段取出攻击者和目标
            let (attacker, target) = match attacker_idx.cmp(&target_idx) {
                std::cmp::Ordering::Less => (&left[attacker_idx], &mut right[0]),
                std::cmp::Ordering::Greater => (&right[0], &mut left[target_idx]),
                std::cmp::Ordering::Equal => unreachable!(),
            };
            attacker.attack(target);
        }
    }
}

适用场景：逻辑简单，单位交互规则不复杂的小型模拟项目。

方案2：先收集指令再批量执行（推荐，适合复杂战斗逻辑） #

把帧逻辑拆分为两个阶段：第一阶段只读遍历所有单位，收集所有要执行的操作指令；第二阶段统一执行指令修改单位状态，完全避免借用冲突，还能保证同一帧的所有决策都基于上一帧的状态，符合绝大多数游戏引擎的帧更新设计：

// 定义战斗操作枚举，后续可扩展移动、治疗、释放技能等逻辑
enum CombatAction {
    Attack {
        attacker_idx: usize,
        target_idx: usize,
        damage: i16,
    }
}

impl Battlefield {
    fn tick(&mut self) {
        let mut actions = Vec::new();
        // 第一阶段：只读遍历，收集所有操作
        for (attacker_idx, combatant) in self.combatants.iter().enumerate() {
            // 这里写你的决策逻辑：选目标、判断攻击/移动逻辑等
            let target_idx = 0;
            if attacker_idx != target_idx {
                actions.push(CombatAction::Attack {
                    attacker_idx,
                    target_idx,
                    damage: 3,
                });
            }
        }
        // 第二阶段：执行所有操作修改状态
        for action in actions {
            match action {
                CombatAction::Attack { target_idx, damage, .. } => {
                    self.combatants[target_idx].current_health -= damage;
                }
            }
        }
    }
}

适用场景：战斗逻辑复杂，后续要扩展大量单位交互、技能逻辑的项目，也是行业内的通用实现方案。

方案3：内部可变性（适合少量字段修改场景） #

用Cell包裹需要修改的属性，让不可变引用也能修改内部字段，不需要可变引用即可完成攻击逻辑：

use std::cell::Cell;

struct Combatant{
    current_health: Cell<i16>,
    max_health: i16
}

impl Combatant {
    // 不再需要other的可变引用
    fn attack(&self, other: &Combatant) {
        other.current_health.set(other.current_health.get() - 3);
    }
}

impl Battlefield {
    fn tick(&mut self) {
        let target = &self.combatants[0];
        for combatant in &self.combatants {
            // 跳过自己攻击自己
            if std::ptr::eq(combatant, target) {
                continue;
            }
            combatant.attack(target);
        }
    }
}

适用场景：仅少量字段需要修改，不想调整整体逻辑的单线程模拟场景，多线程场景需要替换为Arc<Mutex>等同步原语，会有额外性能开销。

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