自作ゲームの状態管理の実装について考える

struct InGameStateContext {
    a: u32,
}

impl InGameStateContext {
    pub fn handle_update_request(&mut self) {
        self.a += 1;
    }
    pub fn handle_redraw_request(&mut self, dummy_external_context: &mut DummyExternalContext) {
        // render stuffs
    }
}

// ゲームの状態
enum GameState {
    Initial,
    Title,
    InGame(InGameStateContext),
}

// winitのイベントを変換したものと仮定
enum Event {
    KeyboardInput(u32),
    WindowResize((u16, u16)), // new size
    RedrawRequest,
    UpdateRequest,
}

// グラフィックデバイスなどの外側のデータを状態のハンドラ内で利用できるようにするため
#[derive(Default)]
struct DummyExternalContext {
    buffer: Vec<u8>,
    string: String,
    flag: bool,
}

fn main() {
    let mut dummy_external_context = DummyExternalContext::default();

    let dummy_events = vec![
        Event::UpdateRequest,
        Event::RedrawRequest,
        Event::KeyboardInput(0x1),
        Event::WindowResize((0, 0)),
        Event::WindowResize((400, 800)),
        Event::RedrawRequest,
    ];

    let mut current_game_state = GameState::Initial;

    // メインループ
    loop {
        // winit のイベントが次々生成されるイメージ
        for dummy_event in &dummy_events {
            // 現在のゲームの状態に応じてイベントを処理する
            match &mut current_game_state {
                GameState::Initial => {
                    println!("Initial handler");
                    current_game_state = GameState::InGame(InGameStateContext { a: 22 });
                    // InGame状態を初期化して`遷移`する
                }
                GameState::Title => {
                    println!("Title handler");
                    match dummy_event {
                        _ => {}
                    }
                }
                GameState::InGame(in_game_state_context) => {
                    println!("InGame handler");
                    match dummy_event {
                        Event::UpdateRequest => {
                            in_game_state_context.handle_update_request();
                        }
                        Event::RedrawRequest => {
                            in_game_state_context
                                .handle_redraw_request(&mut dummy_external_context); // '外側'のデータを扱う
                        }
                        _ => {}
                    }
                }
            }
        }
        panic!("Demo end");
    }
}

use std::cell::OnceCell;

trait GameState {
    // 実際にはResultを返すようにしたほうが良い
    fn init(&mut self);
    fn handle_redraw_request(&mut self, draw_request: &Event);
}

struct InitialGameState {}

impl InitialGameState {
    fn new() -> Self {
        Self {}
    }
}

impl GameState for InitialGameState {
    fn init(&mut self) {}
    fn handle_redraw_request(&mut self, draw_request: &Event) {}
}

struct TitleState {
    logo_string: String,
}

impl GameState for TitleState {
    fn init(&mut self) {}

    fn handle_redraw_request(&mut self, draw_request: &Event) {}
}

#[derive(Debug)]
struct InGameStateImpl {
    data: Vec<u8>,
}
struct InGameState {
    data: OnceCell<InGameStateImpl>,
    opt: Option<u8>,
}

impl InGameState {
    fn new() -> Self {
        // この時点ではデータ、リソースを生成しない
        Self {
            data: OnceCell::new(),
            opt: None,
        }
    }
}

impl GameState for InGameState {
    fn init(&mut self) {
        // ここで初めてデータを生成する
        self.opt = Some(22);

        self.data
            .set(InGameStateImpl {
                data: vec![1, 2, 3, 4, 5],
            })
            .unwrap(); // 実際にはResultを返したほうが良い
    }

    fn handle_redraw_request(&mut self, draw_request: &Event) {
        // caller側でEventの値を抜き取ればこのmatchは回避できる
        match draw_request {
            Event::RedrawRequest => {} // Eventに値があれば、ここで取得できる
            _ => {
                return;
            }
        }

        // 描画
    }
}

enum Event {
    KeyboardInput(u32),
    WindowResize((u16, u16)), // new size
    RedrawRequest,
    UpdateRequest,
}

#[derive(Default)]
struct DummyExternalContext {
    buffer: Vec<u8>,
    string: String,
    flag: bool,
}

struct Game {
    current_game_state: Box<dyn GameState>,
}

impl Game {}

fn main() {
    // winitのイベントを変換したものと仮定
    let dummy_events = vec![
        Event::UpdateRequest,
        Event::RedrawRequest,
        Event::KeyboardInput(0x1),
        Event::WindowResize((0, 0)),
        Event::WindowResize((400, 800)),
        Event::RedrawRequest,
    ];

    let current_game_state: Box<dyn GameState> = Box::new(InitialGameState::new());

    let mut game = Game { current_game_state };
    // メインループ
    loop {
        // winit のイベントが次々生成されるイメージ
        for dummy_event in &dummy_events {
            // 現在のゲームの状態に応じてイベントを処理する

            match dummy_event {
                Event::RedrawRequest => {
                    // ここでenumのvariantに値があれば取得して関数に渡せる(callee側でeventをmatchしなくて良い)
                    // デモなのでそのまま渡す
                    game.current_game_state.handle_redraw_request(&dummy_event);
                }
                _ => {}
            }
        }
        panic!("Demo end");
    }
}