mirror of
https://git.ngram.ca/OpenJam/rc-servers
synced 2026-08-23 23:08:52 +00:00
Use real spawn points when available #30
This commit is contained in:
NG (Graham)
@@ -2,6 +2,7 @@ pub struct GameMatches {
|
||||
matches: std::collections::HashMap<String, tokio::sync::mpsc::Sender<super::GameMessage>>,
|
||||
routing: std::collections::HashMap<i32, String>, // user id to game guid
|
||||
mode_configs: oj_rc_core::data::game_mode::GameModeConfigs,
|
||||
map_configs: std::collections::HashMap<String, oj_rc_core::persist::config::MapConfig>,
|
||||
}
|
||||
|
||||
impl GameMatches {
|
||||
@@ -10,6 +11,10 @@ impl GameMatches {
|
||||
matches: std::collections::HashMap::new(),
|
||||
routing: std::collections::HashMap::new(),
|
||||
mode_configs: <oj_rc_core::persist::config::ConfigImpl as oj_rc_core::ConfigProvider<()>>::gamemodes(conf),
|
||||
map_configs: <oj_rc_core::persist::config::ConfigImpl as oj_rc_core::ConfigProvider<()>>::maps(conf)
|
||||
.into_iter()
|
||||
.map(|(map, conf)| (oj_rc_core::data::game_mode::GameMap::from_persist(map).as_str().to_owned(), conf))
|
||||
.collect(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -19,13 +24,44 @@ impl GameMatches {
|
||||
tx
|
||||
}
|
||||
|
||||
async fn start_new_match_engine(&self, _user: &Box<dyn oj_rc_core::persist::user::MultiplayerUser + Send + Sync + 'static>, guid: &str) -> tokio::sync::mpsc::Sender<super::GameMessage> {
|
||||
// TODO figure out gamemode and act accordingly
|
||||
let engine = super::GenericGamemodeEngine::new(
|
||||
guid.to_owned(),
|
||||
super::modes::EliminationLogic::new(&self.mode_configs.elimination)
|
||||
);
|
||||
engine.spawn()
|
||||
async fn start_new_match_engine(&self, user: &Box<dyn oj_rc_core::persist::user::MultiplayerUser + Send + Sync + 'static>, guid: &str) -> Result<tokio::sync::mpsc::Sender<super::GameMessage>, oj_rc_core::persist::user::MultiplayerError> {
|
||||
let game_info = user.game_info(guid).await?
|
||||
.ok_or_else(|| oj_rc_core::persist::user::MultiplayerError {
|
||||
code: oj_rc_core::persist::user::MultiplayerErrorCode::CustomString,
|
||||
message: format!("Failed to find game {}", guid),
|
||||
})?;
|
||||
let map_config = self.map_configs.get(&game_info.map)
|
||||
.map(|x| x.to_owned())
|
||||
.unwrap_or_else(|| {
|
||||
log::warn!("No configuration found for map {}, game {} may not work correctly", game_info.map, guid);
|
||||
oj_rc_core::persist::config::MapConfig {
|
||||
spawns: std::collections::HashMap::default(),
|
||||
bases: std::collections::HashMap::default(),
|
||||
}
|
||||
});
|
||||
let players = user.game_players(guid).await?;
|
||||
if players.is_empty() {
|
||||
log::warn!("No players found to game {}, loading may not work correctly", guid);
|
||||
}
|
||||
match game_info.mode {
|
||||
oj_rc_core::data::game_mode::GameMode::SuddenDeath => {
|
||||
let engine = super::GenericGamemodeEngine::new(
|
||||
game_info,
|
||||
map_config,
|
||||
players,
|
||||
super::modes::EliminationLogic::new(&self.mode_configs.elimination)
|
||||
);
|
||||
Ok(engine.spawn())
|
||||
}
|
||||
mode => {
|
||||
// TODO support mode gamemodes
|
||||
Err(oj_rc_core::persist::user::MultiplayerError {
|
||||
code: oj_rc_core::persist::user::MultiplayerErrorCode::CustomString,
|
||||
message: format!("Game mode {:?} is not supported (yet)", mode),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// create a new match
|
||||
@@ -37,7 +73,18 @@ impl GameMatches {
|
||||
sender: std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>,
|
||||
) {
|
||||
log::info!("Creating new game {}", game_guid);
|
||||
let tx = self.start_new_match_engine(&user, &game_guid).await;
|
||||
let tx = match self.start_new_match_engine(&user, &game_guid).await {
|
||||
Ok(tx) => tx,
|
||||
Err(e) => {
|
||||
if response.send(Some(crate::matches::messages::ErrorMessage {
|
||||
message: e.message.clone(),
|
||||
inner: Some(Box::new(e)),
|
||||
})).is_err() {
|
||||
log::error!("Failed to send NewConnection failure back to event handler");
|
||||
}
|
||||
return;
|
||||
}
|
||||
};
|
||||
self.matches.insert(game_guid.clone(), tx.clone());
|
||||
self.routing.insert(user.user_id(), game_guid.clone());
|
||||
if tx.send(super::GameMessage::NewConnection { user, game_guid, connection, response, sender }).await.is_err() {
|
||||
|
||||
@@ -112,10 +112,12 @@ pub(super) struct GenericGamemodeEngine<L: super::CustomGameLogic> {
|
||||
pub user_id_map: tokio::sync::RwLock<std::collections::HashMap<i32, u8>>,
|
||||
//pub recv: tokio::sync::Mutex<tokio::sync::mpsc::Receiver<super::GameMessage>>,
|
||||
//pub send: tokio::sync::mpsc::Sender<super::GameMessage>,
|
||||
pub game_guid: String,
|
||||
//pub game_guid: String,
|
||||
is_complete: std::sync::atomic::AtomicBool,
|
||||
pub game_start: std::sync::atomic::AtomicI64,
|
||||
pub player_count: std::sync::atomic::AtomicU8,
|
||||
pub map_config: std::sync::Arc<oj_rc_core::persist::config::MapConfig>,
|
||||
pub game_descriptor: oj_rc_core::persist::user::GameDescriptor,
|
||||
pub players_info: std::sync::Arc<Vec<oj_rc_core::persist::user::PlayerDescriptor>>,
|
||||
pub custom_logic_handler: L,
|
||||
}
|
||||
|
||||
@@ -123,19 +125,30 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
const END_OF_SYNC_DELAY: std::time::Duration = std::time::Duration::from_millis(100);
|
||||
const COUNTDOWN_DURATION: std::time::Duration = std::time::Duration::from_secs(5);
|
||||
|
||||
pub fn new(guid: String, custom: L) -> Self {
|
||||
pub fn new(
|
||||
game: oj_rc_core::persist::user::GameDescriptor,
|
||||
map: oj_rc_core::persist::config::MapConfig,
|
||||
players: Vec<oj_rc_core::persist::user::PlayerDescriptor>,
|
||||
custom: L
|
||||
) -> Self {
|
||||
|
||||
Self {
|
||||
users: tokio::sync::RwLock::new(std::collections::HashMap::new()),
|
||||
user_id_map: tokio::sync::RwLock::new(std::collections::HashMap::new()),
|
||||
game_guid: guid,
|
||||
is_complete: std::sync::atomic::AtomicBool::new(false),
|
||||
game_start: std::sync::atomic::AtomicI64::new(-1),
|
||||
player_count: std::sync::atomic::AtomicU8::new(0),
|
||||
map_config: std::sync::Arc::new(map),
|
||||
game_descriptor: game,
|
||||
players_info: std::sync::Arc::new(players),
|
||||
custom_logic_handler: custom,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub(super) fn game_guid(&self) -> &'_ str {
|
||||
&self.game_descriptor.guid
|
||||
}
|
||||
|
||||
pub(super) async fn user_key_by_user_id(&self, user_id: i32) -> Option<u8> {
|
||||
self.user_id_map.read().await.get(&user_id).map(|x| *x)
|
||||
}
|
||||
@@ -216,10 +229,10 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
if let Some(msg) = recv.recv().await {
|
||||
match msg {
|
||||
super::GameMessage::NewConnection { user, game_guid, connection, response, sender } => {
|
||||
if self.game_guid != game_guid {
|
||||
log::error!("Game guid does not match (got: {}, expected: {})", game_guid, self.game_guid);
|
||||
if self.game_guid() != game_guid {
|
||||
log::error!("Game guid does not match (got: {}, expected: {})", game_guid, self.game_guid());
|
||||
response.send(Some(super::messages::ErrorMessage {
|
||||
message: format!("Game guid does not match (got: {}, expected: {})", game_guid, self.game_guid),
|
||||
message: format!("Game guid does not match (got: {}, expected: {})", game_guid, self.game_guid()),
|
||||
inner: None,
|
||||
})).unwrap_or_default();
|
||||
return;
|
||||
@@ -227,41 +240,26 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
let mut users = self.users.write().await;
|
||||
//tokio::time::sleep(std::time::Duration::from_secs(1)).await;
|
||||
//let id = users.len() as u8;
|
||||
match user.game_players(&game_guid).await {
|
||||
Ok(players) => {
|
||||
if self.player_count.load(std::sync::atomic::Ordering::Relaxed) == 0 {
|
||||
self.player_count.store(players.len() as _, std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
let user_id = user.user_id();
|
||||
let player_info = players.iter().filter(|p| p.user_id == user_id).next().unwrap();
|
||||
let id = player_info.player_id;
|
||||
let new_user = UserConnection {
|
||||
user,
|
||||
connection: UserSender {
|
||||
connection,
|
||||
sender,
|
||||
},
|
||||
state: std::sync::Arc::new(UserState::new()),
|
||||
machine: MachineState::new(),
|
||||
descriptor: player_info.to_owned(),
|
||||
};
|
||||
if self.custom_logic_handler.on_player_join(&self, &new_user, &players).await {
|
||||
self.spawn_send_loading_events(&new_user, id, players);
|
||||
log::debug!("User {} is validated to play game {}", new_user.user.user_id(), game_guid);
|
||||
self.user_id_map.write().await.insert(new_user.user.user_id(), id);
|
||||
users.insert(id, new_user);
|
||||
}
|
||||
response.send(None).unwrap_or_default();
|
||||
let user_id = user.user_id();
|
||||
let player_info = self.players_info.iter().filter(|p| p.user_id == user_id).next().unwrap();
|
||||
let id = player_info.player_id;
|
||||
let new_user = UserConnection {
|
||||
user,
|
||||
connection: UserSender {
|
||||
connection,
|
||||
sender,
|
||||
},
|
||||
Err(e) => {
|
||||
log::error!("Failed to retrieve players for game {}: {}", game_guid, e);
|
||||
response.send(Some(super::messages::ErrorMessage {
|
||||
message: "Failed to retrieve players for game".to_owned(),
|
||||
inner: Some(Box::new(e)),
|
||||
})).unwrap_or_default();
|
||||
}
|
||||
state: std::sync::Arc::new(UserState::new()),
|
||||
machine: MachineState::new(),
|
||||
descriptor: player_info.to_owned(),
|
||||
};
|
||||
if self.custom_logic_handler.on_player_join(&self, &new_user, &self.players_info).await {
|
||||
self.spawn_send_loading_events(&new_user, id, self.players_info.clone());
|
||||
log::debug!("User {} is validated to play game {}", new_user.user.user_id(), game_guid);
|
||||
self.user_id_map.write().await.insert(new_user.user.user_id(), id);
|
||||
users.insert(id, new_user);
|
||||
}
|
||||
|
||||
response.send(None).unwrap_or_default();
|
||||
}
|
||||
},
|
||||
super::GameMessage::EndConnection { user_id } => {
|
||||
@@ -287,8 +285,8 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
is_engaged = has_active_connections;
|
||||
if !has_active_connections {
|
||||
if self.custom_logic_handler.on_game_completed(&self).await {
|
||||
if let Err(e) = conn.user.complete_game(&self.game_guid).await {
|
||||
log::error!("Failed to mark game {} as complete: {}", self.game_guid, e);
|
||||
if let Err(e) = conn.user.complete_game(self.game_guid()).await {
|
||||
log::error!("Failed to mark game {} as complete: {}", self.game_guid(), e);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -308,7 +306,7 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
for conn in self.users.read().await.values() {
|
||||
if user_id == conn.user.user_id() {
|
||||
let progress_percent = ((progress * 100.0).ceil() as u8).clamp(0, 100);
|
||||
log::debug!("User {} is loaded {}% into game {}", user_id, progress_percent, self.game_guid);
|
||||
log::debug!("User {} is loaded {}% into game {}", user_id, progress_percent, self.game_guid());
|
||||
conn.state.progress.store(progress_percent, std::sync::atomic::Ordering::Relaxed);
|
||||
if progress_percent != 100 {
|
||||
all_users_loading_complete = false;
|
||||
@@ -378,7 +376,7 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
).await);
|
||||
}
|
||||
} else {
|
||||
log::error!("Failed to find user {} in connected users for match {}", user_id, self.game_guid);
|
||||
log::error!("Failed to find user {} in connected users for match {}", user_id, self.game_guid());
|
||||
}
|
||||
|
||||
},
|
||||
@@ -415,20 +413,19 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
}
|
||||
}
|
||||
}
|
||||
let player_count = self.player_count.load(std::sync::atomic::Ordering::Relaxed) as usize;
|
||||
let player_count = self.players_info.len();
|
||||
if ready_count == player_count {
|
||||
log::info!("All players ({}) awaiting sync for game {}", player_count, self.game_guid);
|
||||
let total_users = self.users.read().await.len() as u8;
|
||||
log::info!("All players ({}) awaiting sync for game {}", player_count, self.game_guid());
|
||||
for (user_key, conn) in self.users.read().await.iter() {
|
||||
let extra_packets = self.custom_logic_handler.extra_sync_events(&self, conn).await;
|
||||
self.spawn_send_sync_events(conn, conn.user.user_id(), *user_key, total_users, extra_packets);
|
||||
self.spawn_send_sync_events(conn, conn.user.user_id(), *user_key, self.players_info.clone(), extra_packets, self.map_config.clone());
|
||||
}
|
||||
}
|
||||
},
|
||||
super::GameMessage::LoadComplete { user_id } => {
|
||||
if let Some(user_key) = self.user_key_by_user_id(user_id).await {
|
||||
if let Some(conn) = self.users.read().await.get(&user_key) {
|
||||
log::info!("Loading complete for game {}, user {} ({})", self.game_guid, user_id, user_key);
|
||||
log::info!("Loading complete for game {}, user {} ({})", self.game_guid(), user_id, user_key);
|
||||
conn.state.progress.store(100, std::sync::atomic::Ordering::Relaxed);
|
||||
conn.state.mode.store(ConnectionMode::WaitingToStart.to_u8(), std::sync::atomic::Ordering::Relaxed);
|
||||
/*let game_start = chrono::DateTime::from_timestamp(self.game_start.load(std::sync::atomic::Ordering::Relaxed), 0).unwrap();
|
||||
@@ -444,11 +441,11 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
}*/
|
||||
self.spawn_initial_ingame_events(conn, user_id);
|
||||
} else {
|
||||
log::warn!("Invalid LoadComplete user key {} for game {}", user_key, self.game_guid);
|
||||
log::warn!("Invalid LoadComplete user key {} for game {}", user_key, self.game_guid());
|
||||
continue;
|
||||
}
|
||||
} else {
|
||||
log::warn!("Unknown LoadComplete user id {} for game {}", user_id, self.game_guid);
|
||||
log::warn!("Unknown LoadComplete user id {} for game {}", user_id, self.game_guid());
|
||||
continue;
|
||||
}
|
||||
// wait for all users to be ready for starting game start countdown
|
||||
@@ -459,8 +456,8 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
}
|
||||
// trigger game start
|
||||
if all_users_loading_complete {
|
||||
let player_count = self.player_count.load(std::sync::atomic::Ordering::Relaxed) as usize;
|
||||
log::info!("All players ({}) are ready for game {}", player_count, self.game_guid);
|
||||
let player_count = self.players_info.len();
|
||||
log::info!("All players ({}) are ready for game {}", player_count, self.game_guid());
|
||||
tokio::time::sleep(Self::END_OF_SYNC_DELAY).await;
|
||||
let game_start = chrono::Utc::now() + Self::COUNTDOWN_DURATION;
|
||||
if self.custom_logic_handler.on_countdown_start(&self, game_start).await {
|
||||
@@ -491,7 +488,7 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
&rlnl::events::ingame::Kill { killee_player_id: remote_player, killer_player_id: killer_player },
|
||||
true,
|
||||
).await;
|
||||
log::info!("Player {} was destroyed by {} ({}) in game {}", remote_player, killer_player, user_id, self.game_guid);
|
||||
log::info!("Player {} was destroyed by {} ({}) in game {}", remote_player, killer_player, user_id, self.game_guid());
|
||||
self.custom_logic_handler.on_vehicle_destroyed(&self, killer_player, remote_player).await;
|
||||
},
|
||||
super::GameMessage::SelfDestruct { user_id, is_classic } => {
|
||||
@@ -503,7 +500,7 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
&rlnl::events::ingame::Kill { killee_player_id: player_id, killer_player_id: player_id },
|
||||
true,
|
||||
).await;
|
||||
log::info!("Player {} ({}) self-destructed in game {} (elimination? {})", player_id, user_id, self.game_guid, is_classic);
|
||||
log::info!("Player {} ({}) self-destructed in game {} (elimination? {})", player_id, user_id, self.game_guid(), is_classic);
|
||||
if self.custom_logic_handler.on_vehicle_self_destruct(&self, player_id, is_classic).await {
|
||||
if is_classic {
|
||||
self.rebroadcast(
|
||||
@@ -589,22 +586,22 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
}
|
||||
}
|
||||
}
|
||||
log::info!("Game {} has exited", self.game_guid);
|
||||
log::info!("Game {} has exited", self.game_guid());
|
||||
}
|
||||
|
||||
fn spawn_send_loading_events(&self, user: &UserConnection, player_id: u8, players: Vec<oj_rc_core::persist::user::PlayerDescriptor>) {
|
||||
fn spawn_send_loading_events(&self, user: &UserConnection, player_id: u8, players: std::sync::Arc<Vec<oj_rc_core::persist::user::PlayerDescriptor>>) {
|
||||
let connection = user.connection.clone();
|
||||
let user_id = user.user.user_id();
|
||||
tokio::spawn(Self::send_loading_events_wrapper(connection, player_id, user_id, players));
|
||||
}
|
||||
|
||||
async fn send_loading_events_wrapper(connection: UserSender, player_id: u8, user_id: i32, players: Vec<oj_rc_core::persist::user::PlayerDescriptor>) {
|
||||
async fn send_loading_events_wrapper(connection: UserSender, player_id: u8, user_id: i32, players: std::sync::Arc<Vec<oj_rc_core::persist::user::PlayerDescriptor>>) {
|
||||
if let Err(e) = Self::send_loading_events(&connection, player_id, players).await {
|
||||
log::error!("Failed to send Loading events for user {} ({}): {}", user_id, player_id, e);
|
||||
}
|
||||
}
|
||||
|
||||
async fn send_loading_events(user: &UserSender, player_id: u8, players: Vec<oj_rc_core::persist::user::PlayerDescriptor>) -> std::io::Result<()> {
|
||||
async fn send_loading_events(user: &UserSender, player_id: u8, players: std::sync::Arc<Vec<oj_rc_core::persist::user::PlayerDescriptor>>) -> std::io::Result<()> {
|
||||
let sender = user.rlnl();
|
||||
sender.send_data(
|
||||
&rlnl::events::ingame::PlayerId { player: player_id },
|
||||
@@ -615,10 +612,10 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
sender.send_data(
|
||||
&rlnl::events::loading::PlayerIDsAndNames {
|
||||
num_players: players.len() as _,
|
||||
players: players.into_iter().map(|player| rlnl::events::loading::PlayerIDAndName {
|
||||
players: players.iter().map(|player| rlnl::events::loading::PlayerIDAndName {
|
||||
player_id: player.player_id as _,
|
||||
name: rlnl::types::BinaryWriterString(player.public_id),
|
||||
display_name: rlnl::types::BinaryWriterString(player.display_name),
|
||||
name: rlnl::types::BinaryWriterString(player.public_id.clone()),
|
||||
display_name: rlnl::types::BinaryWriterString(player.display_name.clone()),
|
||||
})
|
||||
.collect(),
|
||||
},
|
||||
@@ -638,19 +635,20 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn spawn_send_sync_events(&self, user: &UserConnection, user_id: i32, player_id: u8, num_players: u8, extra_packets: Vec<super::RlnlPacket>) {
|
||||
fn spawn_send_sync_events(&self, user: &UserConnection, user_id: i32, player_id: u8, players: std::sync::Arc<Vec<oj_rc_core::persist::user::PlayerDescriptor>>, extra_packets: Vec<super::RlnlPacket>, map: std::sync::Arc<oj_rc_core::persist::config::MapConfig>) {
|
||||
let connection = user.connection.clone();
|
||||
tokio::spawn(Self::send_sync_events_wrapper(connection, user_id, player_id, num_players, extra_packets));
|
||||
tokio::spawn(Self::send_sync_events_wrapper(connection, user_id, player_id, players, extra_packets, map));
|
||||
user.state.mode.store(ConnectionMode::Sync.to_u8(), std::sync::atomic::Ordering::Relaxed);
|
||||
}
|
||||
|
||||
async fn send_sync_events_wrapper(connection: UserSender, user_id: i32, player_id: u8, num_players: u8, extra_packets: Vec<super::RlnlPacket>) {
|
||||
if let Err(e) = Self::send_sync_events(connection, player_id, num_players, extra_packets).await {
|
||||
async fn send_sync_events_wrapper(connection: UserSender, user_id: i32, player_id: u8, players: std::sync::Arc<Vec<oj_rc_core::persist::user::PlayerDescriptor>>, extra_packets: Vec<super::RlnlPacket>, map: std::sync::Arc<oj_rc_core::persist::config::MapConfig>) {
|
||||
if let Err(e) = Self::send_sync_events(connection, player_id, players, extra_packets, map).await {
|
||||
log::error!("Failed to send Sync events for user {}: {}", user_id, e);
|
||||
}
|
||||
}
|
||||
|
||||
async fn send_sync_events(connection: UserSender, _player_id: u8, num_players: u8, extra_packets: Vec<super::RlnlPacket>) -> std::io::Result<()> {
|
||||
async fn send_sync_events(connection: UserSender, _player_id: u8, players: std::sync::Arc<Vec<oj_rc_core::persist::user::PlayerDescriptor>>, extra_packets: Vec<super::RlnlPacket>, map: std::sync::Arc<oj_rc_core::persist::config::MapConfig>) -> std::io::Result<()> {
|
||||
let num_players = players.len() as u8;
|
||||
let sender = connection.rlnl();
|
||||
sender.send_empty(
|
||||
rlnl::event_code::NetworkEvent::BeginSync,
|
||||
@@ -681,21 +679,71 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
|
||||
literustlib::packet::Property::ReliableOrdered,
|
||||
&connection.connection)
|
||||
.await?;
|
||||
for i in 0..num_players {
|
||||
sender.send_data(
|
||||
&rlnl::events::sync::SpawnPoint {
|
||||
pos: rlnl::types::PosQuatPair {
|
||||
pos: rlnl::types::CompressedVec3::from((10.0 * (i as f32), 100.0, 10.0 * (i as f32))),
|
||||
rot: rlnl::types::CompressedQuat { x: 0, y: 0, z: 0 },
|
||||
if map.spawns.is_empty() {
|
||||
// fallback
|
||||
for i in 0..num_players {
|
||||
sender.send_data(
|
||||
&rlnl::events::sync::SpawnPoint {
|
||||
pos: rlnl::types::PosQuatPair {
|
||||
pos: rlnl::types::CompressedVec3::from((10.0 * (i as f32), 100.0, 10.0 * (i as f32))),
|
||||
rot: rlnl::types::CompressedQuat { x: 0, y: 0, z: 0 },
|
||||
},
|
||||
owner: i,
|
||||
},
|
||||
owner: i,
|
||||
},
|
||||
rlnl::event_code::NetworkEvent::FreeSpawnPoint,
|
||||
literustlib::packet::Property::ReliableOrdered,
|
||||
&connection.connection)
|
||||
.await?;
|
||||
rlnl::event_code::NetworkEvent::FreeSpawnPoint,
|
||||
literustlib::packet::Property::ReliableOrdered,
|
||||
&connection.connection)
|
||||
.await?;
|
||||
}
|
||||
} else {
|
||||
let mut last_spawn_point = std::collections::HashMap::with_capacity(2); // team -> last index
|
||||
for player in players.iter() {
|
||||
let team = player.team as u8;
|
||||
if let Some(team_points) = map.spawns.get(&team) {
|
||||
if !team_points.is_empty() {
|
||||
let spawn_index = if let Some(last_spawn_i) = last_spawn_point.get_mut(&team) {
|
||||
*last_spawn_i = (*last_spawn_i + 1) % team_points.len();
|
||||
*last_spawn_i
|
||||
} else {
|
||||
last_spawn_point.insert(team, 0usize);
|
||||
0
|
||||
};
|
||||
let spawn = &team_points[spawn_index];
|
||||
sender.send_data(
|
||||
&rlnl::events::sync::SpawnPoint {
|
||||
pos: rlnl::types::PosQuatPair {
|
||||
pos: rlnl::types::CompressedVec3::from((spawn.x, spawn.y, spawn.z)),
|
||||
rot: rlnl::types::CompressedQuat { x: 0, y: 0, z: 0 },
|
||||
},
|
||||
owner: player.player_id,
|
||||
},
|
||||
rlnl::event_code::NetworkEvent::FreeSpawnPoint,
|
||||
literustlib::packet::Property::ReliableOrdered,
|
||||
&connection.connection)
|
||||
.await?;
|
||||
continue;
|
||||
}
|
||||
|
||||
}
|
||||
// fallback
|
||||
log::warn!("No spawn point found for player {} on team {}, using bad fallback", player.player_id, team);
|
||||
sender.send_data(
|
||||
&rlnl::events::sync::SpawnPoint {
|
||||
pos: rlnl::types::PosQuatPair {
|
||||
pos: rlnl::types::CompressedVec3::from((10.0 * (player.player_id as f32), 100.0, 10.0 * (team as f32) + 10.0)),
|
||||
rot: rlnl::types::CompressedQuat { x: 0, y: 0, z: 0 },
|
||||
},
|
||||
owner: player.player_id,
|
||||
},
|
||||
rlnl::event_code::NetworkEvent::FreeSpawnPoint,
|
||||
literustlib::packet::Property::ReliableOrdered,
|
||||
&connection.connection)
|
||||
.await?;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// seems to be for reconnecting
|
||||
/*sender.send_data(
|
||||
&rlnl::events::sync::SyncMachineCubes {
|
||||
|
||||
@@ -110,7 +110,7 @@ impl CustomGameLogic for EliminationLogic {
|
||||
}
|
||||
self.tracked.destroy_vehicle(&player.descriptor).await;
|
||||
if let Some(winning_team) = self.tracked.winner_team().await {
|
||||
log::info!("Team {} has won sudden death game {} because player {} left", winning_team, generic.game_guid, player.descriptor.player_id);
|
||||
log::info!("Team {} has won sudden death game {} because player {} left", winning_team, generic.game_guid(), player.descriptor.player_id);
|
||||
let data = rlnl::events::ingame::GameLoseWin {
|
||||
winning_team,
|
||||
end_reason: rlnl::types::GameEndReason::OneTeamRemaining,
|
||||
@@ -153,7 +153,7 @@ impl CustomGameLogic for EliminationLogic {
|
||||
true,
|
||||
).await;
|
||||
if let Some(winning_team) = self.tracked.winner_team().await {
|
||||
log::info!("Team {} has won sudden death game {}", winning_team, generic.game_guid);
|
||||
log::info!("Team {} has won sudden death game {}", winning_team, generic.game_guid());
|
||||
let data = rlnl::events::ingame::GameLoseWin {
|
||||
winning_team,
|
||||
end_reason: rlnl::types::GameEndReason::OneTeamRemaining,
|
||||
@@ -174,7 +174,7 @@ impl CustomGameLogic for EliminationLogic {
|
||||
}
|
||||
generic.game_done();
|
||||
} else {
|
||||
log::info!("Player {} has been destroyed in sudden death game {}", victim, generic.game_guid);
|
||||
log::info!("Player {} has been destroyed in sudden death game {}", victim, generic.game_guid());
|
||||
let data = rlnl::events::ingame::GameLoseWin {
|
||||
winning_team: if conn.descriptor.team == 0 { 1 } else { 0 }, // always the other team
|
||||
end_reason: rlnl::types::GameEndReason::NoPlayersRemaining,
|
||||
@@ -261,3 +261,7 @@ impl CustomGameLogic for EliminationLogic {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
// spawn points (best guess)
|
||||
// Mars 1: (16, 0, 19) and (355, 7, 372)
|
||||
// Earth vanguard 2: (-248, 10, -251) and (267, 10, 258)
|
||||
|
||||
Reference in New Issue
Block a user