You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
155 lines
4.3 KiB
155 lines
4.3 KiB
//! Game server state handler
|
|
//!
|
|
//! A server can host many lobbies at the same time. It listens for
|
|
//! connections according to a address given to the initialiser.
|
|
|
|
use crate::{
|
|
_if::GameIf,
|
|
_match::Match,
|
|
data::Player,
|
|
lobby::LobbyList,
|
|
map::Map,
|
|
users::UserStore,
|
|
wire::{
|
|
Action, AuthErr, Lobby, LobbyErr, LobbyId, LobbyUpdate, MatchErr, MatchId, RegErr,
|
|
Response, UpdateState, User, UserId,
|
|
},
|
|
};
|
|
use async_std::sync::{Arc, Mutex, RwLock};
|
|
use async_trait::async_trait;
|
|
use chrono::{DateTime, Utc};
|
|
use std::{collections::BTreeMap, path::Path};
|
|
|
|
/// A convenience result wrapper for server actions
|
|
pub type ServerResult<T> = Result<T, ServerErr>;
|
|
pub enum ServerErr {
|
|
/// The requested directory is corrupted
|
|
NoSuchDir,
|
|
/// Corrupted game state
|
|
Corrupted,
|
|
/// No such match found
|
|
NoSuchMatch,
|
|
}
|
|
|
|
/// The game's server backend
|
|
pub struct Server {
|
|
matches: BTreeMap<MatchId, Mutex<Match>>,
|
|
users: UserStore,
|
|
lobbies: LobbyList,
|
|
}
|
|
|
|
impl Server {
|
|
/// Create a new game server
|
|
fn new() -> Self {
|
|
Self {
|
|
matches: Default::default(),
|
|
users: UserStore::new(),
|
|
lobbies: LobbyList::new(),
|
|
}
|
|
}
|
|
|
|
/// Open the state dir of a game server
|
|
pub async fn open(self: Arc<Self>, path: &Path) -> ServerResult<()> {
|
|
Ok(())
|
|
}
|
|
|
|
/// Stop accepting new game connections and shutdown gracefully
|
|
///
|
|
/// Returns the number of matches still going on.
|
|
pub async fn shutdown(self: Arc<Self>) -> ServerResult<u64> {
|
|
Ok(0)
|
|
}
|
|
|
|
/// Save and close the statedir and kicking all players
|
|
///
|
|
/// Returns the number of players that were kicked off the server
|
|
/// prematurely.
|
|
pub async fn kill(self: Arc<Self>) -> ServerResult<u64> {
|
|
Ok(0)
|
|
}
|
|
|
|
pub async fn update_map<F>(self: Arc<Self>, id: MatchId, cb: F) -> ServerResult<Response>
|
|
where
|
|
F: Fn(&mut Map) -> ServerResult<Response>,
|
|
{
|
|
match self.matches.get(&id) {
|
|
Some(ref m) => m.lock().await.map.update(cb),
|
|
None => Err(ServerErr::NoSuchMatch),
|
|
}
|
|
}
|
|
|
|
pub async fn update_players<F>(self: Arc<Self>, id: MatchId, cb: F) -> ServerResult<Response>
|
|
where
|
|
F: Fn(&mut Vec<Player>) -> ServerResult<Response>,
|
|
{
|
|
match self.matches.get(&id) {
|
|
Some(ref mut m) => cb(&mut m.lock().await.players),
|
|
None => Err(ServerErr::NoSuchMatch),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl GameIf for Server {
|
|
async fn register(self: Arc<Self>, name: String, pw: String) -> Result<UserId, RegErr> {
|
|
unimplemented!()
|
|
}
|
|
|
|
async fn login(self: Arc<Self>, name: String, pw: String) -> Result<User, AuthErr> {
|
|
unimplemented!()
|
|
}
|
|
|
|
async fn logout(self: Arc<Self>, user: User) -> Result<(), AuthErr> {
|
|
unimplemented!()
|
|
}
|
|
|
|
async fn anonymous(self: Arc<Self>, name: String) -> Result<User, AuthErr> {
|
|
let (_, auth) = self.users.add(name, None, true).await;
|
|
Ok(auth)
|
|
}
|
|
|
|
async fn join(self: Arc<Self>, user: User, lobby: LobbyId) -> Result<Lobby, LobbyErr> {
|
|
let mu = self.users.get(&user).await?;
|
|
self.lobbies.get_mut(lobby, |mut l| l.join(&mu)).await
|
|
}
|
|
|
|
async fn leave(self: Arc<Self>, user: User, lobby: LobbyId) -> Result<(), LobbyErr> {
|
|
let mu = self.users.get(&user).await?;
|
|
self.lobbies.get_mut(lobby, |mut l| l.leave(&mu)).await
|
|
}
|
|
|
|
async fn ready(
|
|
self: Arc<Self>,
|
|
user: User,
|
|
lobby: LobbyId,
|
|
ready: bool,
|
|
) -> Result<LobbyUpdate, LobbyErr> {
|
|
self.lobbies
|
|
.get_mut(lobby, |mut l| l.ready(user, ready))
|
|
.await
|
|
}
|
|
|
|
/// A start request was received
|
|
async fn start_req(
|
|
self: Arc<Self>,
|
|
user: UserId,
|
|
lobby: LobbyId,
|
|
) -> Result<DateTime<Utc>, LobbyErr> {
|
|
self.lobbies.get_mut(lobby, |mut l| l.start(user)).await?;
|
|
let lob = self.lobbies.consume(lobby).await?;
|
|
Ok(Utc::now())
|
|
}
|
|
|
|
async fn perform_action(
|
|
self: Arc<Self>,
|
|
user: User,
|
|
mtch: MatchId,
|
|
act: Action,
|
|
) -> UpdateState {
|
|
unimplemented!()
|
|
}
|
|
|
|
async fn leave_match(self: Arc<Self>, user: User, mtch: MatchId) -> Result<(), MatchErr> {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
|