Browse Source

ClientLocation refactor

pbs
jake 5 years ago
parent
commit
c846bca599
  1. 420
      src/ship/location.rs

420
src/ship/location.rs

@ -1,3 +1,4 @@
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::time::SystemTime;
@ -75,7 +76,10 @@ impl<const N: usize> InnerClientArea<{N}> {
}
}
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct LobbyId(pub usize);
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct RoomId(pub usize);
pub type Lobby = InnerClientArea<12>;
@ -174,20 +178,21 @@ impl Area {
}
}
#[derive(Debug)]
#[derive(Debug, PartialEq)]
pub enum CreateRoomError {
NoOpenSlots,
ClientInAreaAlready,
JoinError,
}
#[derive(Debug)]
#[derive(Debug, PartialEq)]
pub enum JoinRoomError {
RoomDoesNotExist,
RoomFull,
ClientInAreaAlready,
}
#[derive(Debug)]
#[derive(Debug, PartialEq)]
pub enum JoinLobbyError {
LobbyDoesNotExist,
LobbyFull,
@ -303,3 +308,412 @@ impl ClientLocation {
.count() as u8
}
}
#[derive(Debug, Copy, Clone, PartialEq)]
pub struct LocalClientId(usize);
#[derive(Debug, Copy, Clone, PartialEq)]
struct RoomClient {
client: ClientId,
local_client: LocalClientId,
time_join: SystemTime,
}
#[derive(Debug, Copy, Clone, PartialEq)]
struct AreaClient2 {
client: ClientId,
local_client: LocalClientId,
time_join: SystemTime,
}
#[derive(Debug, Copy, Clone, PartialEq)]
struct Lobby2([Option<AreaClient2>; 12]);
#[derive(Debug, Copy, Clone, PartialEq)]
struct Room2([Option<AreaClient2>; 4]);
#[derive(Debug, Copy, Clone, PartialEq)]
enum RoomLobby {
Room(RoomId),
Lobby(LobbyId),
}
#[derive(Debug, PartialEq)]
pub enum ClientRemovalError {
ClientNotInArea,
InvalidArea,
}
#[derive(Debug, PartialEq)]
pub enum GetClientsError {
InvalidArea,
}
#[derive(Debug, PartialEq)]
pub enum GetNeighborError {
InvalidClient,
InvalidArea,
}
#[derive(Debug, PartialEq)]
pub enum GetLeaderError {
InvalidClient,
InvalidArea,
NoClientInArea,
}
pub struct ClientLocation2 {
lobbies: [Lobby2; 15],
rooms: [Option<Room2>; MAX_ROOMS],
client_location: HashMap<ClientId, RoomLobby>,
}
impl ClientLocation2 {
pub fn new() -> ClientLocation2 {
ClientLocation2 {
lobbies: [Lobby2([None; 12]); 15],
rooms: [None; MAX_ROOMS],
client_location: HashMap::new(),
}
}
pub fn add_client_to_lobby(&mut self, id: ClientId, lobby: LobbyId) -> Result<(), JoinLobbyError> {
let l = self.lobbies.get_mut(lobby.0).ok_or(JoinLobbyError::LobbyDoesNotExist)?;
let (index, empty_slot) = l.0.iter_mut()
.enumerate()
.filter(|(_, k)| k.is_none())
.nth(0)
.ok_or(JoinLobbyError::LobbyFull)?;
*empty_slot = Some(AreaClient2 {
client: id,
local_client: LocalClientId(index),
time_join: SystemTime::now(),
});
self.remove_client_from_area(id);
self.client_location.insert(id, RoomLobby::Lobby(lobby));
Ok(())
}
pub fn add_client_to_next_available_lobby(&mut self, id: ClientId, lobby: LobbyId) -> Result<LobbyId, JoinLobbyError> {
let l = (0..15)
.map(|lobby_index| {
let new_lobby = LobbyId((lobby.0 + lobby_index) % 15);
(new_lobby, self.add_client_to_lobby(id, new_lobby))
})
.filter(|(_, lobby_option)| {
lobby_option.is_ok()
})
.nth(0)
.ok_or(JoinLobbyError::LobbyFull)?;
Ok(l.0)
}
fn create_new_room(&mut self, id: ClientId) -> Result<RoomId, CreateRoomError> {
let (index, empty_slot) = self.rooms.iter_mut()
.enumerate()
.filter(|(_, r)| r.is_none())
.nth(0)
.ok_or(CreateRoomError::NoOpenSlots)?;
*empty_slot = Some(Room2([None; 4]));
self.add_client_to_room(id, RoomId(index)).map_err(|err| CreateRoomError::JoinError)?;
Ok(RoomId(index))
}
fn add_client_to_room(&mut self, id: ClientId, room: RoomId) -> Result<(), JoinRoomError> {
let r = self.rooms.get_mut(room.0)
.ok_or(JoinRoomError::RoomDoesNotExist)?
.as_mut()
.ok_or(JoinRoomError::RoomDoesNotExist)?;
let (index, empty_slot) = r.0.iter_mut()
.enumerate()
.filter(|(_, k)| k.is_none())
.nth(0)
.ok_or(JoinRoomError::RoomFull)?;
*empty_slot = Some(AreaClient2 {
client: id,
local_client: LocalClientId(index),
time_join: SystemTime::now(),
});
self.remove_client_from_area(id);
self.client_location.insert(id, RoomLobby::Room(room));
Ok(())
}
fn get_client_neighbors(&self, id: ClientId) -> Result<Vec<(ClientId, LocalClientId)>, GetNeighborError> {
let area = self.client_location.get(&id).ok_or(GetNeighborError::InvalidClient)?;
match area {
RoomLobby::Room(room) => {
Ok(self.get_clients_in_room(*room).map_err(|_| GetNeighborError::InvalidArea)?
.into_iter()
.filter(|c| c.0 != id)
.collect())
},
RoomLobby::Lobby(lobby) => {
Ok(self.get_clients_in_lobby(*lobby).map_err(|_| GetNeighborError::InvalidArea)?
.into_iter()
.filter(|c| c.0 != id)
.collect())
}
}
}
fn get_room_leader_by_client(&self, id: ClientId) -> Result<(ClientId, LocalClientId), GetLeaderError> {
let area = self.client_location.get(&id).ok_or(GetLeaderError::InvalidClient)?;
match area {
RoomLobby::Room(room) => {
let mut r = self.rooms[room.0]
.as_ref()
.ok_or(GetLeaderError::InvalidArea)?
.0.iter().flat_map(|k| k)
.collect::<Vec<_>>();
//r.sort_by(|a, b| a.time_join.cmp(&b.time_join));
r.sort_by_key(|k| k.time_join);
let c = r.get(0).ok_or(GetLeaderError::NoClientInArea)?;
Ok((c.client, c.local_client))
},
RoomLobby::Lobby(lobby) => {
let mut l = self.lobbies[lobby.0]
.0.iter().flat_map(|k| k)
.collect::<Vec<_>>();
l.sort_by_key(|k| k.time_join);
let c = l.get(0).ok_or(GetLeaderError::NoClientInArea)?;
Ok((c.client, c.local_client))
}
}
}
pub fn get_clients_in_lobby(&self, lobby: LobbyId) -> Result<Vec<(ClientId, LocalClientId)>, GetClientsError> {
Ok(self.lobbies.get(lobby.0).ok_or(GetClientsError::InvalidArea)?.0
.iter()
.filter_map(|client| {
client.map(|c| {
(c.client, c.local_client)
})
}).collect())
}
pub fn get_clients_in_room(&self, room: RoomId) -> Result<Vec<(ClientId, LocalClientId)>, GetClientsError> {
Ok(self.rooms.get(room.0)
.ok_or(GetClientsError::InvalidArea)?
.ok_or(GetClientsError::InvalidArea)?.0
.iter()
.filter_map(|client| {
client.map(|c| {
(c.client, c.local_client)
})
}).collect())
}
pub fn remove_client_from_area(&mut self, id: ClientId) -> Result<(), ClientRemovalError> {
let area = self.client_location.get_mut(&id).ok_or(ClientRemovalError::ClientNotInArea)?;
let client_list = match area {
RoomLobby::Room(room) => {
self.rooms[room.0].as_mut().map_or(None, |r| {
Some(r.0.iter_mut())
})
},
RoomLobby::Lobby(lobby) => {
Some(self.lobbies[lobby.0].0.iter_mut())
}
};
client_list
.ok_or(ClientRemovalError::InvalidArea)?
.filter(|client| {
client.map_or(false, |c| {
c.client == id
})
})
.for_each(|client| {
*client = None
});
Ok(())
}
}
#[cfg(test)]
mod test {
use super::*;
#[test]
fn test_add_client_to_lobby() {
let mut cl = ClientLocation2::new();
cl.add_client_to_lobby(ClientId(12), LobbyId(0));
cl.add_client_to_lobby(ClientId(13), LobbyId(1));
cl.add_client_to_lobby(ClientId(14), LobbyId(0));
assert!(cl.get_clients_in_lobby(LobbyId(0)) == Ok(vec![
(ClientId(12), LocalClientId(0)),
(ClientId(14), LocalClientId(1)),
]));
}
#[test]
fn test_add_client_to_full_lobby() {
let mut cl = ClientLocation2::new();
(0..12).for_each(|i| {
cl.add_client_to_lobby(ClientId(i), LobbyId(0));
});
assert!(cl.add_client_to_lobby(ClientId(99), LobbyId(0)) == Err(JoinLobbyError::LobbyFull));
}
#[test]
fn test_add_client_to_next_available_lobby() {
let mut cl = ClientLocation2::new();
(1..4).for_each(|lobby| {
(0..12).for_each(|i| {
cl.add_client_to_lobby(ClientId(lobby*12+i), LobbyId(lobby));
});
});
assert!(cl.add_client_to_next_available_lobby(ClientId(99), LobbyId(1)) == Ok(LobbyId(4)));
}
#[test]
fn test_add_to_lobby_when_all_are_full() {
let mut cl = ClientLocation2::new();
(0..15).for_each(|lobby| {
(0..12).for_each(|i| {
cl.add_client_to_lobby(ClientId(lobby*12+i), LobbyId(lobby));
});
});
assert!(cl.add_client_to_next_available_lobby(ClientId(99), LobbyId(1)) == Err(JoinLobbyError::LobbyFull));
}
#[test]
fn test_new_room() {
let mut cl = ClientLocation2::new();
assert!(cl.create_new_room(ClientId(12)) == Ok(RoomId(0)));
}
#[test]
fn test_add_client_to_room() {
let mut cl = ClientLocation2::new();
let room = cl.create_new_room(ClientId(12)).unwrap();
assert!(cl.add_client_to_room(ClientId(234), room) == Ok(()));
assert!(cl.get_clients_in_room(room) == Ok(vec![
(ClientId(12), LocalClientId(0)),
(ClientId(234), LocalClientId(1)),
]));
}
#[test]
fn test_no_new_room_slots() {
let mut cl = ClientLocation2::new();
for i in 0..128 {
cl.create_new_room(ClientId(i));
}
assert!(cl.create_new_room(ClientId(234)) == Err(CreateRoomError::NoOpenSlots));
}
#[test]
fn test_joining_full_room() {
let mut cl = ClientLocation2::new();
let room = cl.create_new_room(ClientId(0)).unwrap();
assert!(cl.add_client_to_room(ClientId(1), room) == Ok(()));
assert!(cl.add_client_to_room(ClientId(2), room) == Ok(()));
assert!(cl.add_client_to_room(ClientId(3), room) == Ok(()));
assert!(cl.add_client_to_room(ClientId(234), room) == Err(JoinRoomError::RoomFull));
}
#[test]
fn test_adding_client_to_room_removes_from_lobby() {
let mut cl = ClientLocation2::new();
cl.add_client_to_lobby(ClientId(93), LobbyId(0));
cl.add_client_to_lobby(ClientId(23), LobbyId(0));
cl.add_client_to_lobby(ClientId(51), LobbyId(0));
cl.add_client_to_lobby(ClientId(12), LobbyId(0));
let room = cl.create_new_room(ClientId(51)).unwrap();
assert!(cl.add_client_to_room(ClientId(93), room) == Ok(()));
assert!(cl.get_clients_in_lobby(LobbyId(0)) == Ok(vec![
(ClientId(23), LocalClientId(1)),
(ClientId(12), LocalClientId(3)),
]));
assert!(cl.get_clients_in_room(room) == Ok(vec![
(ClientId(51), LocalClientId(0)),
(ClientId(93), LocalClientId(1)),
]));
}
#[test]
fn test_getting_neighbors() {
let mut cl = ClientLocation2::new();
cl.add_client_to_lobby(ClientId(93), LobbyId(0));
cl.add_client_to_lobby(ClientId(23), LobbyId(0));
cl.add_client_to_lobby(ClientId(51), LobbyId(0));
cl.add_client_to_lobby(ClientId(12), LobbyId(0));
assert!(cl.get_client_neighbors(ClientId(23)) == Ok(vec![
(ClientId(93), LocalClientId(0)),
(ClientId(51), LocalClientId(2)),
(ClientId(12), LocalClientId(3)),
]));
}
#[test]
fn test_failing_to_join_lobby_does_not_remove_from_current_area() {
let mut cl = ClientLocation2::new();
(0..12).for_each(|i| {
cl.add_client_to_lobby(ClientId(i), LobbyId(0));
});
cl.add_client_to_lobby(ClientId(99), LobbyId(1));
cl.add_client_to_lobby(ClientId(99), LobbyId(0));
assert!(cl.get_clients_in_lobby(LobbyId(0)).unwrap().len() == 12);
assert!(cl.get_clients_in_lobby(LobbyId(1)) == Ok(vec![
(ClientId(99), LocalClientId(0)),
]));
}
#[test]
fn test_room_leader() {
let mut cl = ClientLocation2::new();
cl.add_client_to_lobby(ClientId(93), LobbyId(0));
cl.add_client_to_lobby(ClientId(23), LobbyId(0));
cl.add_client_to_lobby(ClientId(51), LobbyId(0));
cl.add_client_to_lobby(ClientId(12), LobbyId(0));
assert!(cl.get_room_leader_by_client(ClientId(51)) == Ok((ClientId(93), LocalClientId(0))));
}
#[test]
fn test_remove_client_from_room() {
let mut cl = ClientLocation2::new();
let room = cl.create_new_room(ClientId(51)).unwrap();
cl.add_client_to_room(ClientId(93), room);
cl.add_client_to_room(ClientId(23), room);
cl.remove_client_from_area(ClientId(51));
cl.add_client_to_room(ClientId(12), room);
assert!(cl.get_clients_in_room(room) == Ok(vec![
(ClientId(12), LocalClientId(0)),
(ClientId(93), LocalClientId(1)),
(ClientId(23), LocalClientId(2)),
]));
}
#[test]
fn test_room_leader_changes_on_leader_leaving() {
let mut cl = ClientLocation2::new();
let room = cl.create_new_room(ClientId(51)).unwrap();
cl.add_client_to_room(ClientId(93), room);
cl.add_client_to_room(ClientId(23), room);
cl.remove_client_from_area(ClientId(51));
cl.add_client_to_room(ClientId(12), room);
cl.remove_client_from_area(ClientId(23));
cl.add_client_to_room(ClientId(99), room);
assert!(cl.get_room_leader_by_client(ClientId(12)) == Ok((ClientId(93), LocalClientId(1))));
}
}
Loading…
Cancel
Save