teascade/quakeball-rust
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move common data from Player to NetPlayer

Browse Source
This commit is contained in:
Sofia 2026-07-22 00:16:23 +03:00
parent 609a803104
commit ef1bb3946d
5 changed files with 67 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
rust/src/game_manager.rs
View File

@ -124,7 +124,7 @@ impl INode for Game {
if let Some(player) = self if let Some(player) = self
.players .players
.iter() .iter()
.find(|p| p.id == self.self_id.unwrap_or(0)) .find(|p| p.id() == self.self_id.unwrap_or(0))
{ {
if let Some(data) = &player.get_self_sync() { if let Some(data) = &player.get_self_sync() {
peer.send_unreliable(socket_addr, SelfSync(data.clone())); peer.send_unreliable(socket_addr, SelfSync(data.clone()));
@ -145,7 +145,7 @@ impl INode for Game {
player.get_transform(), player.get_transform(),
) { ) {
sync_data.insert( sync_data.insert(
player.id, player.id(),
SyncPackage { SyncPackage {
movement_direction: dir, movement_direction: dir,
look_up, look_up,
@ -167,13 +167,14 @@ impl INode for Game {
if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer { if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
if let PeerKind::Server(peer, _) = peer { if let PeerKind::Server(peer, _) = peer {
for player in self.players.clone() { for player in self.players.clone() {
let player_id = player.id();
if let Some(character) = player.character { if let Some(character) = player.character {
if character.dyn_bind().dead_for() > self.respawn_timer { if character.dyn_bind().dead_for() > self.respawn_timer {
let character = self.spawn_player_server(player.id); let character = self.spawn_player_server(player_id);
if let Some(character) = character { if let Some(character) = character {
peer.broadcast_reliable(SpawnPlayer( peer.broadcast_reliable(SpawnPlayer(
player.id, player_id,
character.dyn_bind().get_transform(), character.dyn_bind().get_transform(),
)); ));
} }
@ -251,10 +252,13 @@ impl Game {
id id
}; };
self.players.push(Player { self.players.push(Player {
id,
connection_addr: addr, connection_addr: addr,
data: NetPlayer {
id,
name, name,
ping: 0, ping: 0,
team: 0,
},
ready: false, ready: false,
character: None, character: None,
}); });
@ -265,7 +269,7 @@ impl Game {
pub fn set_players(&mut self, players: Vec<Player>) { pub fn set_players(&mut self, players: Vec<Player>) {
self.players = players; self.players = players;
for player in self.players.clone() { for player in self.players.clone() {
self.run_deferred(move |s| s.signals().on_new_player().emit(player.id)); self.run_deferred(move |s| s.signals().on_new_player().emit(player.id()));
} }
} }
@ -278,34 +282,34 @@ impl Game {
} }
pub fn find_player(&self, player_id: u16) -> Option<&Player> { pub fn find_player(&self, player_id: u16) -> Option<&Player> {
self.players.iter().find(|p| p.id == player_id) self.players.iter().find(|p| p.id() == player_id)
} }
pub fn find_player_mut(&mut self, player_id: u16) -> Option<&mut Player> { pub fn find_player_mut(&mut self, player_id: u16) -> Option<&mut Player> {
self.players.iter_mut().find(|p| p.id == player_id) self.players.iter_mut().find(|p| p.id() == player_id)
} }
pub fn remove_player(&mut self, id: u16) { pub fn remove_player(&mut self, id: u16) {
self.players.retain(|p| p.id != id); self.players.retain(|p| p.id() != id);
self.run_deferred(move |s| s.signals().on_player_disconnected().emit(id)); self.run_deferred(move |s| s.signals().on_player_disconnected().emit(id));
} }
pub fn update_player_nick(&mut self, player_id: u16, nick: String) { pub fn update_player_nick(&mut self, player_id: u16, nick: String) {
if let Some(player) = self.players.iter_mut().find(|p| p.id == player_id) { if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
player.name = nick; player.data.name = nick;
} }
self.run_deferred(|s| s.signals().on_players_updated().emit()); self.run_deferred(|s| s.signals().on_players_updated().emit());
} }
pub fn update_player_ping(&mut self, player_id: u16, ping: u128) { pub fn update_player_ping(&mut self, player_id: u16, ping: u128) {
if let Some(player) = self.players.iter_mut().find(|p| p.id == player_id) { if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
player.ping = ping; player.data.ping = ping;
} }
self.run_deferred(|s| s.signals().on_players_updated().emit()); self.run_deferred(|s| s.signals().on_players_updated().emit());
} }
pub fn update_player_ready(&mut self, player_id: u16, ready: bool) { pub fn update_player_ready(&mut self, player_id: u16, ready: bool) {
if let Some(player) = self.players.iter_mut().find(|p| p.id == player_id) { if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
player.ready = ready; player.ready = ready;
} }
self.run_deferred(|s| s.signals().on_players_updated().emit()); self.run_deferred(|s| s.signals().on_players_updated().emit());
@ -319,7 +323,7 @@ impl Game {
} else { } else {
self.run_deferred(|s| { self.run_deferred(|s| {
for player in s.players.clone() { for player in s.players.clone() {
s.spawn_player_server(player.id); s.spawn_player_server(player.id());
} }
s.spawn_ball(None, None, None); s.spawn_ball(None, None, None);
}); });
@ -396,7 +400,7 @@ impl Game {
&& let Some(character) = &mut player.character && let Some(character) = &mut player.character
{ {
character.dyn_bind_mut().swap_weapon(weapon_type); character.dyn_bind_mut().swap_weapon(weapon_type);
let player_id = player.id; let player_id = player.id();
self.run_deferred(move |_| { self.run_deferred(move |_| {
if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
&& let PeerKind::Server(peer, _) = peer && let PeerKind::Server(peer, _) = peer
@ -464,15 +468,15 @@ impl Game {
// Method called on the client-side whenever a player has spawned // Method called on the client-side whenever a player has spawned
pub fn spawn_player_client(&mut self, id: u16, transform: NetTransform) { pub fn spawn_player_client(&mut self, id: u16, transform: NetTransform) {
if let Some(map) = &mut self.current_map { if let Some(map) = &mut self.current_map {
if let Some(player) = self.players.iter_mut().find(|p| p.id == id) { if let Some(player) = self.players.iter_mut().find(|p| p.id() == id) {
if let Some(character) = &mut player.character { if let Some(character) = &mut player.character {
// This is a respawn, delete old character // This is a respawn, delete old character
character.queue_free(); character.queue_free();
} }
let character = map.bind_mut().spawn_player( let character = map.bind_mut().spawn_player(
player.id, player.id(),
player.id == self.self_id.unwrap_or(0), player.id() == self.self_id.unwrap_or(0),
Some(transform), Some(transform),
); );
player.character = character; player.character = character;
@ -495,8 +499,8 @@ impl Game {
}, },
) in sync_data ) in sync_data
{ {
if let Some(player) = self.players.iter_mut().find(|p| p.id == player_id) { if let Some(player) = self.players.iter_mut().find(|p| p.id() == player_id) {
if player.id != self.self_id.unwrap_or(0) { if player.id() != self.self_id.unwrap_or(0) {
// Sync remote players always // Sync remote players always
player.set_transform(transform); player.set_transform(transform);
player.set_move_dir(movement_direction); player.set_move_dir(movement_direction);
@ -541,7 +545,7 @@ impl Game {
) -> bool { ) -> bool {
let self_id = self.self_id.clone().unwrap_or(0); let self_id = self.self_id.clone().unwrap_or(0);
if let Some(player) = self.find_player_mut(player_id) { if let Some(player) = self.find_player_mut(player_id) {
if player.id != self_id { if player.id() != self_id {
player.try_shoot(to, transform, look_up, deal_damage) player.try_shoot(to, transform, look_up, deal_damage)
} else { } else {
false false
@ -590,10 +594,8 @@ impl Game {
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct Player { pub struct Player {
pub id: u16,
pub connection_addr: SocketAddr, pub connection_addr: SocketAddr,
pub name: String, pub data: NetPlayer,
pub ping: u128,
pub ready: bool, pub ready: bool,
pub character: Option<DynGd<CharacterBody3D, dyn IPlayer + 'static>>, pub character: Option<DynGd<CharacterBody3D, dyn IPlayer + 'static>>,
} }
@ -688,6 +690,10 @@ impl Player {
false false
} }
} }
pub fn id(&self) -> u16 {
self.data.id
}
} }
#[derive(Debug, Serialize, Deserialize, Clone)] #[derive(Debug, Serialize, Deserialize, Clone)]
@ -695,15 +701,14 @@ pub struct NetPlayer {
pub id: u16, pub id: u16,
pub name: String, pub name: String,
pub ping: u128, pub ping: u128,
pub team: u8,
} }
impl From<NetPlayer> for Player { impl From<NetPlayer> for Player {
fn from(value: NetPlayer) -> Self { fn from(value: NetPlayer) -> Self {
Player { Player {
id: value.id,
connection_addr: SocketAddr::from(([0, 0, 0, 0], 0)), connection_addr: SocketAddr::from(([0, 0, 0, 0], 0)),
name: value.name, data: value,
ping: value.ping,
ready: false, ready: false,
character: None, character: None,
} }
@ -712,10 +717,6 @@ impl From<NetPlayer> for Player {
impl From<Player> for NetPlayer { impl From<Player> for NetPlayer {
fn from(value: Player) -> Self { fn from(value: Player) -> Self {
NetPlayer { value.data
id: value.id,
name: value.name,
ping: value.ping,
}
} }
} }

4
rust/src/net/network_manager.rs
View File

@ -90,8 +90,8 @@ impl INode for NetworkManager {
.cloned(); .cloned();
if let Some(player) = player { if let Some(player) = player {
game.bind_mut() game.bind_mut()
.update_player_ping(player.id, connection.ping.as_millis()); .update_player_ping(player.id(), connection.ping.as_millis());
pings.insert(player.id, connection.ping.as_millis()); pings.insert(player.id(), connection.ping.as_millis());
} }
} }
} }

26
rust/src/net/protocol.rs
View File

@ -212,7 +212,7 @@ impl NetworkManager {
let player_id = game let player_id = game
.bind() .bind()
.find_player_by_addr(&connection.address) .find_player_by_addr(&connection.address)
.map(|p| p.id); .map(|p| p.id());
if let Some(player_id) = player_id { if let Some(player_id) = player_id {
peer.broadcast_reliable(Package::PlayerLeft( peer.broadcast_reliable(Package::PlayerLeft(
game.bind().find_player(player_id).unwrap().clone().into(), game.bind().find_player(player_id).unwrap().clone().into(),
@ -234,10 +234,10 @@ impl NetworkManager {
game.bind().find_player_by_addr(&conn.address).cloned(); game.bind().find_player_by_addr(&conn.address).cloned();
if let Some(player) = player { if let Some(player) = player {
peer.broadcast_reliable(Package::SetNick( peer.broadcast_reliable(Package::SetNick(
player.id, player.id(),
nick.clone(), nick.clone(),
)); ));
game.bind_mut().update_player_nick(player.id, nick); game.bind_mut().update_player_nick(player.id(), nick);
} }
} }
} }
@ -246,8 +246,11 @@ impl NetworkManager {
let player = let player =
game.bind().find_player_by_addr(&conn.address).cloned(); game.bind().find_player_by_addr(&conn.address).cloned();
if let Some(player) = player { if let Some(player) = player {
game.bind_mut().update_player_ready(player.id, is_ready); game.bind_mut().update_player_ready(player.id(), is_ready);
peer.broadcast_reliable(Package::SetReady(player.id, is_ready)); peer.broadcast_reliable(Package::SetReady(
player.id(),
is_ready,
));
} }
} }
} }
@ -257,7 +260,7 @@ impl NetworkManager {
if let Some(transform) = player.get_transform() { if let Some(transform) = player.get_transform() {
peer.send_reliable( peer.send_reliable(
&conn.address, &conn.address,
Package::SpawnPlayer(player.id, transform), Package::SpawnPlayer(player.id(), transform),
); );
} }
} }
@ -277,8 +280,8 @@ impl NetworkManager {
let player = let player =
game.bind().find_player_by_addr(&conn.address).cloned(); game.bind().find_player_by_addr(&conn.address).cloned();
if let Some(player) = player { if let Some(player) = player {
game.bind_mut().handle_jump(player.id); game.bind_mut().handle_jump(player.id());
peer.broadcast_reliable(Package::Jump(player.id)); peer.broadcast_reliable(Package::Jump(player.id()));
} }
} }
} }
@ -288,14 +291,17 @@ impl NetworkManager {
game.bind().find_player_by_addr(&conn.address).cloned(); game.bind().find_player_by_addr(&conn.address).cloned();
if let Some(player) = player { if let Some(player) = player {
if game.bind_mut().handle_shoot( if game.bind_mut().handle_shoot(
player.id, player.id(),
to.into(), to.into(),
transform, transform,
look_up, look_up,
true, true,
) { ) {
peer.broadcast_reliable(Package::Shoot( peer.broadcast_reliable(Package::Shoot(
player.id, to, transform, look_up, player.id(),
to,
transform,
look_up,
)); ));
} }
} }

2
rust/src/ui/lobby.rs
View File

@ -143,7 +143,7 @@ impl LobbyPanel {
for player in &game.bind().players { for player in &game.bind().players {
if let Some(node) = prefab.instantiate() { if let Some(node) = prefab.instantiate() {
let mut listing = node.cast::<PlayerListing>(); let mut listing = node.cast::<PlayerListing>();
listing.bind_mut().player_id = Some(player.id); listing.bind_mut().player_id = Some(player.id());
listing.bind_mut().update_teams(game.bind().get_teams()); listing.bind_mut().update_teams(game.bind().get_teams());
listing.bind_mut().update(); listing.bind_mut().update();
list.add_child(&listing); list.add_child(&listing);

15
rust/src/ui/player_listing.rs
View File

@ -29,7 +29,10 @@ impl PlayerListing {
&& let Some(player) = game.bind().find_player(*player_id) && let Some(player) = game.bind().find_player(*player_id)
{ {
if let Some(player_label) = &mut self.name_label { if let Some(player_label) = &mut self.name_label {
player_label.set_text(&format!("{} ({})", player.name, player.connection_addr)); player_label.set_text(&format!(
"{} ({})",
player.data.name, player.connection_addr
));
} }
if let Some(ready_label) = &mut self.ready_label { if let Some(ready_label) = &mut self.ready_label {
@ -41,7 +44,7 @@ impl PlayerListing {
} }
if let Some(ping_label) = &mut self.ping_label { if let Some(ping_label) = &mut self.ping_label {
ping_label.set_text(&format!("({}ms)", player.ping)); ping_label.set_text(&format!("({}ms)", player.data.ping));
} }
} }
} }
@ -53,7 +56,13 @@ impl PlayerListing {
for team in teams.iter_shared() { for team in teams.iter_shared() {
dropdown.add_item(&team.bind().name); dropdown.add_item(&team.bind().name);
} }
dropdown.select(prev_selection); dropdown.select(prev_selection.min((teams.len() - 1) as i32));
}
}
pub fn select_team(&mut self, team: u8) {
if let Some(dropdown) = &mut self.team_dropdown {
dropdown.select(team as i32);
} }
} }
} }