entity是可变借用的，然后你试图借用实体的整个集合。这是不允许的，因为实体现在被借用了两次。
通常--特别是在游戏引擎中--这个问题可以通过使用实体-组件-系统（ECS）模式来解决。它通过处理实体的句柄而不是引用来解决这个问题。ECS通常非常快，感觉非常适合Rust，因为它完全消除了复杂的借用交互。ECS crates here有一个很大的列表。
如果你不想使用ECS，你仍然可以使用句柄或id代替引用，例如，使用向量索引作为临时id，在很短的范围内借用，以提取出你需要的单个字段。

// take a slice instead of Vec so that you can't accidentally change its size, 
// which could invalidate the given obj_index.
fn update_obj(obj_index: usize, objects: &mut [Option<Object>]) {
    let obj = objects[obj_index];
    // etc
}

一种解决方案是将向量分割为切片：

use std::vec::Vec;

struct Object {
    a: u32,
    b: u32,
}

impl Object {
    fn new() -> Self {
        Self {
            a: 0,
            b: 0,
        }
    }
    
    // here you should probably change type of objects
    fn update<'a>(&'a mut self, objects: impl Iterator<Item = &'a Option<Object>>) {
        // mutate self here
        // but also read from the object vector
    }
}

fn main() {
    println!("Hello, world!");
    let mut vector: Vec<Option<Object>> = Vec::new();
    vector.push(Some(Object::new()));
    vector.push(Some(Object::new()));
    vector.push(Some(Object::new()));
    
    // 'i' is index of 'o'
    for i in 0..vector.len() {
        // here you split the vector into two mutable slices
        // (they have to be mutable because you need to get 'o' from them)
        let (objects_left_of_o, o_and_objects_right_of_o) = vector.split_at_mut(i);
        
        if let Some((Some(o), objects_right_of_o)) = o_and_objects_right_of_o.split_first_mut() {
            o.update(objects_left_of_o.iter().chain(objects_right_of_o.iter()));
        }
    }
}

另一个解决方案是通过RefCell利用内部可变性。

use std::cell::RefCell;
use std::ops::{Deref, DerefMut};
use std::vec::Vec;

struct Object {
    a: u32,
    b: u32,
}

impl Object {
    fn new() -> Self {
        Self { a: 0, b: 0 }
    }

    // here you can't just borrow from every refcell, cause one of them should have already given
    // out the &mut self reference
    fn update(&mut self, objects: &Vec<RefCell<Option<Object>>>) {
        // DO NOT DO THIS
        for obj in objects {
            // if self refers to an element in the vector, this will PANIC because you would be trying to get another reference to self
            if let Some(o) = obj.borrow().deref() {}
        }

        // here maybe debug assert that you can't get borrow only one of the items (which is self)
        debug_assert_eq!(
            objects
                .iter()
                .filter(|refcell| refcell.try_borrow().is_err())
                .count(),
            1
        );

        for obj in objects {
            // if self refers to an element in the vector, this will PANIC
            if let Ok(reference) = obj.try_borrow() {
                if let Some(o) = reference.deref() {
                    // use 'o', which is an object different from self
                }
            }

            // alternatively, use let-Some-else instead of if-let-Some
            let Ok(reference) = obj.try_borrow() else { continue };
            let Some(o) = reference.deref() else { continue };

            // use 'o'...
        }
    }
}

fn main() {
    println!("Hello, world!");

    // now the vector gets filled with a structure that wraps your Option<Object> and implements
    // interior mutability which means you push some checks onto runtime instead of compile time
    let mut vector = Vec::new();
    vector.push(RefCell::new(Some(Object::new())));
    vector.push(RefCell::new(Some(Object::new())));
    vector.push(RefCell::new(Some(Object::new())));

    // here you are looping on an immutable reference,
    // so you can reference the same vector later again
    for obj in &vector {
        // here obj is &RefCell<Option<Object>>

        // obj.borrow_mut() checks if it has already given out a mutable reference to Option<Object>
        // inside it. If it has it panics, if it hasn't it will return a RefMut<T> struct that
        // represents the borrow (which ends once the struct gets dropped)

        // RefMut<T>.deref_mut() dereferences RefMut<T> to &mut Option<Object>

        if let Some(o) = obj.borrow_mut().deref_mut() {
            // here 'o' is &mut Object, and because you haven't borrowed the vector mutably anywhere,
            // you can do an immutable borrow here
            o.update(&vector);
        }
    }
}