Give element in vector access to other elements

For context, I am creating a simple game engine.

My game objects are all stored in a vector and every frame each object is iterated over and updated.

The problem with this is that occasionally an object needs to have access to the data of other objects in the vector, I can't pass in an immutable/mutable reference to the vector itself because it is being iterated over mutably.

How can i allow each game object to access fields (position, rotation e.t.c.) of other game objects in the same Vector?

here is the loop that is causing issues:

for entity in self.scene.collidable_entitys {
    match &mut entity.value {
        Some(e) => {
            e.update(&frame_descriptor, &self.input, &self.scene.collidable_entitys);
            entity_count += 1;
        }
        None => {}
    }
}

the compiler doesn't like me giving an immutable reference to self.scene.collidable_entitys because it is borrowed mutably to iterate over.

here is a simple example to show my problem.

use std::vec::Vec;

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

impl Object {
    fn new() -> Self {
        Self {
            a: 0,
            b: 0,
        }
    }
    
    fn update(&mut self, objects: &Vec<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()));

    for obj in vector.as_ref() {
        match obj {
            Some(o) => o.update(&vector),
            None => {}
        }
    }
}

any help or alternatives to systems i could use is much appreciated.

The entity is mutably borrowed, and then you are trying to borrow the entire collection of entities. That isn't allowed because the entity is now borrowed twice.

Usually–-especially in game engines––this problem is solved by employing the Entity-Component-System (ECS) pattern. It gets around the problem by working with handles to the entities instead of references. ECS is usually very fast and feels like the perfect fit for Rust because it completely eliminates complex borrowing interactions. There is a big list of ECS crates here.

If you didn't want to use ECS, you can still take the idea of using handles or ids instead of references. For example, using the vector index as a temporary id and borrowing in very short scopes, to pull out individual fields that you need.

// 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
}

One solution is splitting the vector into slices:

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()));
}
}
}

Another solution is making use of interior mutability via 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);
}
}
}