Ranzear fucked around with this message at 23:14 on May 28, 2023

gonadic io fucked around with this message at 01:40 on May 29, 2023

GameState {
	Areas: Vec<{
		decks: Vec<Deck>,
		slots: Vec<Slot>
	}>
}

    fn update(&mut self, state: &mut GameState) -> GameResult {

        for p in &state.players {
            let area = get_area_by_id(&mut state.areas, *p)?; // Mut ref to areas vec
            let deck = get_deck(&mut area.decks, 0)?; // Mut ref to single area instance

            for i in 0..area.slots.len() {
                let slot = get_slot(&mut area.slots, i)?;
                if slot.is_empty() {
                    move_card(deck, slot, 0);
                }
            }
        }
    }

Vilgefartz fucked around with this message at 07:27 on Jun 10, 2023

Game {
	state: GameState,
	phases: Vec<Box<dyn GamePhase>>,
}

GameState {
	phase_idx: usize
	areas: Vec<{
		slot: Vec<Slot>,
		decks: Vec<Deck>
	}>
}

impl Game {
	fn update(&mut self)  {
		self.phases[self.state.phase_idx].update(&mut self.state)
	}
}

struct TestPhase {}
impl GamePhase for TestPhase {
	fn update(&mut self, state: &mut GameState) { ...etc }
}

GameState.update(&mut self, phase: Box<dyn GamePhase>) {
	phase.update(self)
}

Vilgefartz fucked around with this message at 11:59 on Jun 19, 2023

struct GameState {
    foo: Foo,
    bar: Bar,
}

/// My impression is that you were essentially trying to do
/// this earlier before rewriting to access state.foo, state.bar
/// directly.
impl GameState {
    fn foo_mut(&mut self) -> &mut Foo;
    fn bar_mut(&mut self) -> &mut Bar;
}

impl GameState {
    /// Don't allow direct access to internal state
    // fn foo_mut(&mut self) -> &mut Foo;

    fn do_something_with_foo(&mut self, params: &Baz);

    /// Similar for bar
}

impl GameState {
    /// Intentionally move these pieces out so that the caller
    /// can mutate the internal state and then stitch back
    /// together.
    fn into_foobar(self) -> (Foo, Bar) {
        (self.foo, self.bar)
    }
    
    fn from_foobar(foo: Foo, bar: Bar);
}

let (mut foo, mut bar) = state.into_foobar();
// ...
let state = GameState::from_foobar(foo, bar);

impl GameState {
    /// Moves out foo and bar so you can mutate them separately.
    /// Doesn't consume self.
    /// Safe because self.foo, self.bar are now None while
    /// while you're arbitrarily mutating the returned Foo, Bar.
    ///
    /// After the arbitrary mutations are done, move the Foo and Bar
    /// back inside GameState.
    fn take_foobar(&mut self) -> (Option<Foo>, Option<Bar>) {
        (self.foo.take(), self.bar.take())
    }
}

let (mut foo, mut bar) = state.into_foobar();
// ...
let state = GameState::from_foobar(foo, bar);

mondomole fucked around with this message at 14:01 on Jun 19, 2023

Love Stole the Day fucked around with this message at 22:55 on Jun 23, 2023