werewolves/werewolves-server/src/runner.rs

// Copyright (C) 2025 Emilis Bliūdžius
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.
use core::{num::NonZeroU8, time::Duration};
use std::sync::Arc;

use werewolves_proto::{
    message::{ClientMessage, Identification, host::HostMessage},
    player::PlayerId,
};

use crate::{
    LogError,
    communication::lobby::LobbyComms,
    connection::JoinedPlayers,
    game::{GameEnd, GameRunner},
    lobby::{Lobby, LobbyPlayers},
    saver::Saver,
};

#[derive(Debug, Clone, PartialEq)]
pub struct IdentifiedClientMessage {
    pub identity: Identification,
    pub message: ClientMessage,
}

pub async fn run_game(joined_players: JoinedPlayers, comms: LobbyComms, mut saver: impl Saver) {
    let mut lobby = Lobby::new(joined_players, comms);
    if let Some(dummies) = option_env!("DUMMY_PLAYERS").and_then(|p| p.parse::<NonZeroU8>().ok()) {
        log::info!("creating {dummies} dummy players");
        lobby.set_players_in_lobby(LobbyPlayers::with_dummies(dummies));
        lobby.send_lobby_info_to_host().await.log_debug();
    }
    let mut state = RunningState::Lobby(lobby);
    loop {
        match &mut state {
            RunningState::Lobby(lobby) => {
                if let Some(game) = lobby.next().await {
                    state = RunningState::Game(game)
                }
            }
            RunningState::Game(game) => {
                if let Some(result) = game.next().await {
                    match saver.save(game.proto_game()) {
                        Ok(path) => {
                            log::info!("saved game to {path}");
                        }
                        Err(err) => {
                            log::error!("saving game: {err}");
                            let game_clone = game.proto_game().clone();
                            let mut saver_clone = saver.clone();
                            tokio::spawn(async move {
                                let started = chrono::Utc::now();
                                loop {
                                    tokio::time::sleep(Duration::from_secs(30)).await;
                                    match saver_clone.save(&game_clone) {
                                        Ok(path) => {
                                            log::info!("saved game from {started} to {path}");
                                            return;
                                        }
                                        Err(err) => {
                                            log::error!("saving game from {started}: {err}")
                                        }
                                    }
                                }
                            });
                        }
                    }
                    state = match state {
                        RunningState::Game(game) => {
                            RunningState::GameOver(GameEnd::new(game, result))
                        }
                        _ => unsafe { core::hint::unreachable_unchecked() },
                    };
                }
            }
            RunningState::GameOver(end) => {
                if let Some(mut new_lobby) = end.next().await {
                    new_lobby.send_lobby_info_to_clients().await;
                    new_lobby.send_lobby_info_to_host().await.log_debug();
                    state = RunningState::Lobby(new_lobby)
                }
            }
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum Message {
    Host(HostMessage),
    Client(IdentifiedClientMessage),
    ConnectedList(Arc<[PlayerId]>),
}

pub enum RunningState {
    Lobby(Lobby),
    Game(GameRunner),
    GameOver(GameEnd),
}