bonkmaykr/ojrc
1
0
Fork 0
mirror of https://git.ngram.ca/OpenJam/rc-servers synced 2026-08-23 23:08:52 +00:00
Code Activity

Implemented respawning for #32

Browse Source
This commit is contained in:
NG (Graham)
2025-09-01 18:50:03 -04:00
parent 1ae6851346
commit 9c03201bac
2 changed files with 76 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
rc_multiplayer/src/matches/generic.rs
View File

@@ -594,7 +594,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 player {} (user {}) in game {}", remote_player, killer_player, user_id, self.game_guid());
if self.custom_logic_handler.on_vehicle_destroyed(&self, killer_player, remote_player).await {
// the kill tracking is initiated separately by the client with kill bonus event
if let Some(killed) = self.users.read().await.get(&remote_player) {
@@ -817,26 +817,6 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
}, literustlib::packet::Property::Unreliable, &conn.connection.connection).await);
}
}
/*if self.game_start.load(std::sync::atomic::Ordering::Relaxed) == -1 {
let mut all_users_loading_complete = true;
for conn in self.users.read().await.values() {
let mode = ConnectionMode::from_u8(conn.state.mode.load(std::sync::atomic::Ordering::Relaxed));
let is_in_sync = matches!(mode, ConnectionMode::Sync);
log::info!("Player {} is in mode {:?}", conn.descriptor.player_id, mode);
all_users_loading_complete &= is_in_sync && conn.state.progress.load(std::sync::atomic::Ordering::Relaxed) == 100;
}
if all_users_loading_complete {
for (id, conn) in self.users.read().await.iter() {
if let Err(e) = conn.connection.rlnl().send_empty(
rlnl::event_code::NetworkEvent::EndOfSync,
literustlib::packet::Property::ReliableOrdered,
&conn.connection.connection
).await {
log::error!("Failed to send EndOfSync event to user {}: {}", id, e);
}
}
}
}*/
} else {
log::warn!("Received machine motion with unknown player id {} from user {}", motion.player_id, user_id);
}
@@ -986,7 +966,6 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
.await?;
continue;
}
}
// fallback
log::warn!("No spawn point found for player {} on team {}, using bad fallback", player.player_id, team);
@@ -1063,7 +1042,12 @@ impl <L: super::CustomGameLogic> GenericGamemodeEngine<L> {
}
pub(super) fn game_done(&self) {
self.is_complete.store(true, std::sync::atomic::Ordering::SeqCst);
let old = self.is_complete.swap(true, std::sync::atomic::Ordering::SeqCst);
if old {
log::warn!("Game {} was marked as done again", self.game_guid());
} else {
log::debug!("Game {} is marked done (handler will exit once all players have disconnected)", self.game_guid());
}
}
pub(super) fn is_game_done(&self) -> bool {

71
rc_multiplayer/src/matches/modes/battle_arena.rs
View File

@@ -597,6 +597,73 @@ impl BattleArenaLogic {
}
}
}
async fn do_respawn_tasks(&self, generic: &crate::matches::GenericGamemodeEngine<Self>, player_id: u8) {
log::info!("Handling respawn player {} in game {}", player_id, generic.game_guid());
let respawn_time = std::time::Duration::from_secs(self.config.respawn_time_seconds as u64);
let now = chrono::Utc::now();
let respawn_timestamp = now + respawn_time;
if let Some(player_respawn) = self.player_tracking.respawning.read().await.get(&player_id) {
player_respawn.store(respawn_timestamp.timestamp(), std::sync::atomic::Ordering::Relaxed);
}
let respawn_payload = rlnl::events::ingame::RespawnTime {
owner: player_id,
waiting_time: self.config.respawn_time_seconds as i16,
};
generic.broadcast(
rlnl::event_code::NetworkEvent::SetRespawnWaitingTime,
literustlib::packet::Property::ReliableOrdered,
&respawn_payload,
true
).await;
if let Some(player_team) = self.player_tracking.team(player_id).await {
let spawn_point = if let Some(team_spawns) = generic.map_config.spawns.get(&player_team) {
if team_spawns.is_empty() {
oj_rc_core::persist::config::Point {
x: 10.0 * (player_id as f32),
y: 100.0,
z: 10.0 * (player_team as f32) + 10.0,
}
} else {
let index = (player_id as usize) % team_spawns.len();
team_spawns[index].clone()
}
} else {
oj_rc_core::persist::config::Point {
x: 10.0 * (player_id as f32),
y: 100.0,
z: 10.0 * (player_team as f32) + 10.0,
}
};
let connections = generic.users.read().await.values().map(|player_info| player_info.connection.clone()).collect();
tokio::task::spawn(Self::respawn_player_after(respawn_timestamp, connections, spawn_point, player_id));
} else {
log::error!("Player {} cannot respawn because they are not in a team!?", player_id);
}
}
async fn respawn_player_after(after: chrono::DateTime<chrono::Utc>, players: Vec<crate::matches::generic::UserSender>, spawn: oj_rc_core::persist::config::Point, player_id: u8) {
let sleep_dur = after.signed_duration_since(chrono::Utc::now()).to_std().expect("Respawn duration too long to sleep");
tokio::time::sleep(sleep_dur).await;
let spawn_payload = 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_id,
};
log::debug!("Respawning player {} after {}ms", player_id, sleep_dur.as_millis());
for player in players {
if !player.connection.is_connected() { continue; }
crate::events::log_lnl_send_failure(player.rlnl().send_data(
&spawn_payload,
rlnl::event_code::NetworkEvent::FreeRespawnPoint,
literustlib::packet::Property::ReliableOrdered,
&player.connection,
).await);
}
}
}
#[async_trait::async_trait]
@@ -619,13 +686,13 @@ impl CustomGameLogic for BattleArenaLogic {
async fn on_vehicle_destroyed(&self, generic: &crate::matches::GenericGamemodeEngine<Self>, _killer: u8, victim: u8) -> bool {
self.do_destruct_tasks(generic, victim).await;
// TODO handle respawn
self.do_respawn_tasks(generic, victim).await;
true
}
async fn on_vehicle_self_destruct(&self, generic: &crate::matches::GenericGamemodeEngine<Self>, user: u8, _is_classic: bool) -> bool {
self.do_destruct_tasks(generic, user).await;
// TODO handle respawn
self.do_respawn_tasks(generic, user).await;
true
}