teascade/skullball
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: teascade:3a0eaa58be234cf9044c56bebcd0d68f5acad56e
Branches Tags
teascade:main
..
compare: teascade:b6278cbc5a765df3f3a719b53a53970c471616ea
Branches Tags
teascade:main

No commits in common. "3a0eaa58be234cf9044c56bebcd0d68f5acad56e" and "b6278cbc5a765df3f3a719b53a53970c471616ea" have entirely different histories.
3a0eaa58be ... b6278cbc5a

13 changed files with 87 additions and 310 deletions
Show Stats Expand all files Collapse all files

4
rust/src/chat.rs
View File

@ -29,9 +29,7 @@ impl Chat {
pub fn new_message(&mut self, message: ChatMessage) { pub fn new_message(&mut self, message: ChatMessage) {
self.messages.len() as i64; self.messages.len() as i64;
self.messages.push(message.clone()); self.messages.push(message.clone());
let label = message.as_label(); self.run_deferred(move |s| s.signals().on_new_message().emit(&message.as_label()));
godot_print_rich!("{}", label.get_text());
self.run_deferred(move |s| s.signals().on_new_message().emit(&label));
} }
} }

2
rust/src/cli_parser.rs
View File

@ -88,7 +88,7 @@ impl INode3D for CliParser {
.connect_other(self, |s| s.on_join_lobby()); .connect_other(self, |s| s.on_join_lobby());
if let Some(port) = options.host { if let Some(port) = options.host {
NetworkManager::singleton().bind_mut().host(port, false); NetworkManager::singleton().bind_mut().host(port);
} else if let Some(addr) = options.join { } else if let Some(addr) = options.join {
NetworkManager::singleton().bind_mut().join_directly(addr); NetworkManager::singleton().bind_mut().join_directly(addr);
} }

201
rust/src/game/mod.rs
View File

@ -37,7 +37,7 @@ use crate::{
}, },
replay::{ReplayEvent, ReplayPlayback, ReplayRecorder}, replay::{ReplayEvent, ReplayPlayback, ReplayRecorder},
team_resource::TeamResource, team_resource::TeamResource,
ui::cli::{CliColor, CommandLinePanel}, ui::cli::CommandLinePanel,
}; };
pub mod commands; pub mod commands;
@ -175,7 +175,6 @@ pub struct Game {
pub private_opts: PrivateGameOptions, pub private_opts: PrivateGameOptions,
is_host: bool, is_host: bool,
host_privileges: bool,
player_counter: u16, player_counter: u16,
pub self_id: Option<u16>, pub self_id: Option<u16>,
pub players: Vec<Player>, pub players: Vec<Player>,
@ -352,46 +351,8 @@ impl Game {
} }
} }
pub fn set_host_privileges(&mut self, privileges: bool) {
if privileges {
self.set_ready(true);
}
self.host_privileges = privileges;
}
pub fn has_host_privileges(&self) -> bool {
self.is_host || self.host_privileges
}
pub fn is_host(&self) -> bool {
self.is_host
}
pub fn set_ready(&mut self, ready: bool) {
if let Some(self_id) = self.self_id {
self.run_deferred(move |s| {
if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
match peer {
PeerKind::Client(peer, socket_addr) => {
godot_print!("Sent ready {}", ready);
peer.send_reliable(&socket_addr, Package::SetReady(self_id, ready))
}
PeerKind::Server(peer, _) => {
if let Some(player) = s.find_player_mut(self_id) {
player.data.ready = ready;
}
peer.broadcast_reliable(Package::SetReady(self_id, ready));
}
}
}
});
}
}
pub fn start_playback(&mut self, time_delta: f64, spectated_id: u16) { pub fn start_playback(&mut self, time_delta: f64, spectated_id: u16) {
if let Some(recorder) = &self.replay_recorder if let Some(recorder) = &self.replay_recorder {
&& self.self_id.is_some()
{
let mut playback = ReplayPlayback::new_alloc(); let mut playback = ReplayPlayback::new_alloc();
let frame = recorder let frame = recorder
@ -448,11 +409,6 @@ impl Game {
pub fn start_game(&mut self) { pub fn start_game(&mut self) {
self.game_started = true; self.game_started = true;
CommandLinePanel::singleton()
.bind_mut()
.publish_message("Game started".to_owned(), CliColor::Info);
if let Some(map) = &self.selected_map { if let Some(map) = &self.selected_map {
if let Some(scene) = &map.bind().scene { if let Some(scene) = &map.bind().scene {
self.base().get_tree().change_scene_to_packed(scene); self.base().get_tree().change_scene_to_packed(scene);
@ -474,11 +430,9 @@ impl Game {
} }
}); });
if self.self_id.is_some() { let recorder = ReplayRecorder::new_alloc();
let recorder = ReplayRecorder::new_alloc(); self.replay_recorder = Some(recorder.clone());
self.replay_recorder = Some(recorder.clone()); self.base_mut().add_child(&recorder);
self.base_mut().add_child(&recorder);
}
} }
pub fn reset_game(&mut self) { pub fn reset_game(&mut self) {
@ -486,10 +440,13 @@ impl Game {
recorder.queue_free(); recorder.queue_free();
} }
if self.has_host_privileges() { if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer
self.set_ready(true); && let PeerKind::Server(peer, _) = peer
&& let Some(player) = self.find_player_mut(self.self_id.unwrap_or(0))
{
player.data.ready = true;
peer.broadcast_reliable(Package::SetReady(player.id(), true));
} }
for player in &mut self.players { for player in &mut self.players {
player.stats = Default::default(); player.stats = Default::default();
} }
@ -539,55 +496,27 @@ impl Game {
unregister_commands(&mut cli); unregister_commands(&mut cli);
} }
pub fn change_option(&mut self, opt: GameOption, value: GameOptionValue, send: bool) { pub fn change_option(&mut self, opt: GameOption, value: GameOptionValue) {
godot_print!("Option changed");
self.opts.values.insert(opt, value); self.opts.values.insert(opt, value);
self.run_deferred(move |s| { self.run_deferred(move |s| {
s.signals().options_changed().emit(); s.signals().options_changed().emit();
if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
&& send if let PeerKind::Server(peer, _) = peer {
{ peer.broadcast_reliable(Package::GameOptionChanged(opt, value));
match peer {
PeerKind::Client(peer, socket_addr) => {
if s.has_host_privileges() {
peer.send_reliable(socket_addr, Package::GameOptionChanged(opt, value));
}
}
PeerKind::Server(peer, _) => {
peer.broadcast_reliable(Package::GameOptionChanged(opt, value));
}
} }
} }
}); });
} }
pub fn change_team_option( pub fn change_team_option(&mut self, team: u8, opt: GameOption, value: GameOptionValue) {
&mut self,
team: u8,
opt: GameOption,
value: GameOptionValue,
send: bool,
) {
if let Some(team) = self.opts.teams.get_mut(team as usize) { if let Some(team) = self.opts.teams.get_mut(team as usize) {
team.values.insert(opt, value); team.values.insert(opt, value);
} }
self.run_deferred(move |s| { self.run_deferred(move |s| {
s.signals().team_options_changed().emit(team); s.signals().team_options_changed().emit(team);
if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
&& send if let PeerKind::Server(peer, _) = peer {
{ peer.broadcast_reliable(Package::TeamGameOptionChanged(team, opt, value));
match peer {
PeerKind::Client(peer, socket_addr) => {
if s.has_host_privileges() {
peer.send_reliable(
socket_addr,
Package::TeamGameOptionChanged(team, opt, value),
);
}
}
PeerKind::Server(peer, _) => {
peer.broadcast_reliable(Package::TeamGameOptionChanged(team, opt, value));
}
} }
} }
}); });
@ -679,13 +608,7 @@ impl Game {
self.self_id = Some(id); self.self_id = Some(id);
} }
pub fn new_player( pub fn new_player(&mut self, addr: SocketAddr, name: Option<String>, id: Option<u16>) -> u16 {
&mut self,
addr: SocketAddr,
name: Option<String>,
id: Option<u16>,
host_privileges: bool,
) -> u16 {
let id = if let Some(id) = id { let id = if let Some(id) = id {
id id
} else { } else {
@ -708,7 +631,6 @@ impl Game {
character: None, character: None,
last_held_weapon: WeaponType::Raygun, last_held_weapon: WeaponType::Raygun,
last_position: Vector3::ZERO, last_position: Vector3::ZERO,
has_host_privileges: host_privileges,
}); });
self.run_deferred(move |s| s.signals().on_new_player().emit(id)); self.run_deferred(move |s| s.signals().on_new_player().emit(id));
@ -733,11 +655,6 @@ impl Game {
.unwrap_or(0); .unwrap_or(0);
self.try_set_player_team(id, team_with_least as u8); self.try_set_player_team(id, team_with_least as u8);
CommandLinePanel::singleton()
.bind_mut()
.publish_message(format!("Player joined: {}", addr), CliColor::Info);
id id
} }
@ -765,17 +682,6 @@ impl Game {
} }
pub fn remove_player(&mut self, id: u16) { pub fn remove_player(&mut self, id: u16) {
if let Some(player) = self.find_player(id) {
CommandLinePanel::singleton().bind_mut().publish_message(
format!(
"Player {} disconnected ({})",
player.id(),
player.connection_addr
),
CliColor::Info,
);
}
if let Some(player) = self.find_player_mut(id) if let Some(player) = self.find_player_mut(id)
&& let Some(mut character) = player.character.take() && let Some(mut character) = player.character.take()
{ {
@ -790,14 +696,6 @@ impl Game {
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) {
CommandLinePanel::singleton().bind_mut().publish_message(
format!(
"Player nick changed {} -> {} ({})",
player.data.name, nick, player.connection_addr
),
CliColor::Info,
);
player.data.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());
@ -1003,23 +901,10 @@ impl Game {
} }
pub fn spawn_player_server(&mut self, id: u16) -> Option<DynGd<CharacterBody3D, dyn IPlayer>> { pub fn spawn_player_server(&mut self, id: u16) -> Option<DynGd<CharacterBody3D, dyn IPlayer>> {
if let Some(self_id) = self.self_id if id == self.self_id.unwrap_or(0) {
&& id == self_id
{
self.stop_playback(); self.stop_playback();
} }
if let Some(player) = self.find_player(id) {
CommandLinePanel::singleton().bind_mut().publish_message(
format!(
"Player spawned {} ({})",
player.id(),
player.connection_addr
),
CliColor::Info,
);
}
if let Some(player) = self.find_player(id) if let Some(player) = self.find_player(id)
&& let Some(mut character) = player.character.clone() && let Some(mut character) = player.character.clone()
{ {
@ -1036,13 +921,9 @@ impl Game {
if let Some(mut map) = self.current_map.clone() { if let Some(mut map) = self.current_map.clone() {
let team = self.find_player(id).map(|p| p.data.team).unwrap_or(0); let team = self.find_player(id).map(|p| p.data.team).unwrap_or(0);
let mut character = map.bind_mut().spawn_player( let mut character =
id, map.bind_mut()
team, .spawn_player(id, team, id == self.self_id.unwrap_or(0), None, true);
self.self_id.map(|self_id| self_id == id).unwrap_or(false),
None,
true,
);
if let Some(character) = &character if let Some(character) = &character
&& let Some(player) = self.find_player_mut(id) && let Some(player) = self.find_player_mut(id)
@ -1114,9 +995,7 @@ 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(self_id) = self.self_id if id == self.self_id.unwrap_or(0) {
&& id == self_id
{
self.stop_playback(); self.stop_playback();
} }
@ -1135,13 +1014,10 @@ impl Game {
character.queue_free(); character.queue_free();
} }
let player_id = player.id();
let mut character = map.bind_mut().spawn_player( let mut character = map.bind_mut().spawn_player(
player.id(), player.id(),
player.data.team, player.data.team,
self.self_id player.id() == self.self_id.unwrap_or(0),
.map(|self_id| self_id == player_id)
.unwrap_or(false),
Some(transform), Some(transform),
true, true,
); );
@ -1195,8 +1071,7 @@ impl Game {
telegrenade.set_linear_velocity(telegrenade_sync.velocity.into()); telegrenade.set_linear_velocity(telegrenade_sync.velocity.into());
} }
let player_id = player.id(); if player.id() != self.self_id.unwrap_or(0) {
if self.self_id.map(|id| id != player_id).unwrap_or(true) {
// 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);
@ -1228,11 +1103,7 @@ impl Game {
// Handle a jump, either from the server or from a client // Handle a jump, either from the server or from a client
pub fn handle_jump(&mut self, player_id: u16) { pub fn handle_jump(&mut self, player_id: u16) {
if self if player_id != self.self_id.unwrap_or(0) {
.self_id
.map(|self_id| self_id != player_id)
.unwrap_or(true)
{
if let Some(recorder) = &mut self.replay_recorder { if let Some(recorder) = &mut self.replay_recorder {
recorder recorder
.bind_mut() .bind_mut()
@ -1272,11 +1143,8 @@ impl Game {
look_up: f32, look_up: f32,
deal_damage: bool, deal_damage: bool,
) -> bool { ) -> bool {
if self let self_id = self.self_id.clone().unwrap_or(0);
.self_id if player_id != self_id {
.map(|self_id| self_id != player_id)
.unwrap_or(true)
{
if let Some(recorder) = &mut self.replay_recorder { if let Some(recorder) = &mut self.replay_recorder {
recorder recorder
.bind_mut() .bind_mut()
@ -1302,11 +1170,8 @@ impl Game {
look_up: f32, look_up: f32,
deal_damage: bool, deal_damage: bool,
) -> bool { ) -> bool {
if self let self_id = self.self_id.clone().unwrap_or(0);
.self_id if player_id != self_id {
.map(|self_id| self_id != player_id)
.unwrap_or(true)
{
if let Some(recorder) = &mut self.replay_recorder { if let Some(recorder) = &mut self.replay_recorder {
recorder recorder
.bind_mut() .bind_mut()
@ -1696,7 +1561,6 @@ pub struct Player {
pub killing_spree_cd: f64, pub killing_spree_cd: f64,
pub last_held_weapon: WeaponType, pub last_held_weapon: WeaponType,
pub last_position: Vector3, pub last_position: Vector3,
pub has_host_privileges: bool,
} }
impl Player { impl Player {
@ -1883,7 +1747,6 @@ impl From<NetPlayer> for Player {
killing_spree_cd: 0., killing_spree_cd: 0.,
last_held_weapon: WeaponType::Raygun, last_held_weapon: WeaponType::Raygun,
last_position: Vector3::ZERO, last_position: Vector3::ZERO,
has_host_privileges: false,
} }
} }
} }

3
rust/src/map/goal.rs
View File

@ -85,8 +85,7 @@ impl Goal {
if let Some(game) = Game::singleton() if let Some(game) = Game::singleton()
&& let Some(ball_holder) = game.bind().ball_holder && let Some(ball_holder) = game.bind().ball_holder
&& let Some(player) = game.bind().find_player(ball_holder) && let Some(player) = game.bind().find_player(ball_holder)
&& let Some(self_id) = game.bind().self_id && ball_holder == game.bind().self_id.unwrap_or(0)
&& ball_holder == self_id
&& player.data.team != self.team && player.data.team != self.team
{ {
icon.set_visible(true); icon.set_visible(true);

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

@ -62,7 +62,7 @@ impl INode for NetworkManager {
cli.bind_mut() cli.bind_mut()
.signals() .signals()
.on_host() .on_host()
.connect_other(self, |s, port, headless| s.host(port, headless)); .connect_other(self, |s, port| s.host(port));
cli.bind_mut() cli.bind_mut()
.signals() .signals()
.on_join() .on_join()
@ -188,7 +188,7 @@ impl NetworkManager {
} }
} }
pub fn host(&mut self, port: u16, headless: bool) { pub fn host(&mut self, port: u16) {
if self.peer.is_none() { if self.peer.is_none() {
let mut cli = CommandLinePanel::singleton(); let mut cli = CommandLinePanel::singleton();
cli.bind_mut() cli.bind_mut()
@ -216,14 +216,11 @@ impl NetworkManager {
.default_name .default_name
.clone(); .clone();
if let Some(game) = &mut Game::singleton() if let Some(game) = &mut Game::singleton() {
&& !headless
{
let id = game.bind_mut().new_player( let id = game.bind_mut().new_player(
SocketAddr::from(([0, 0, 0, 0], 0)), SocketAddr::from(([0, 0, 0, 0], 0)),
Some(default_name), Some(default_name),
None, None,
true,
); );
game.bind_mut().update_player_ready(id, true); game.bind_mut().update_player_ready(id, true);
game.bind_mut().set_self(id); game.bind_mut().set_self(id);
@ -316,13 +313,11 @@ impl NetworkManager {
} }
PeerKind::Server(peer, ..) => { PeerKind::Server(peer, ..) => {
let player_id = if let Some(game) = Game::singleton() { let player_id = if let Some(game) = Game::singleton() {
game.bind().self_id game.bind().self_id.unwrap_or(0)
} else { } else {
None 0
}; };
if let Some(player_id) = player_id { peer.broadcast_reliable(Package::SetNick(player_id, nick));
peer.broadcast_reliable(Package::SetNick(player_id, nick));
}
} }
} }
} }
@ -351,7 +346,7 @@ pub enum Package {
Hello, Hello,
// Meta values // Meta values
Players(Vec<NetPlayer>, u16, bool), Players(Vec<NetPlayer>, u16),
UpdatePings(HashMap<u16, u128>), UpdatePings(HashMap<u16, u128>),
SetNick(u16, String), SetNick(u16, String),
SetSelfNick(String), SetSelfNick(String),

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

@ -95,7 +95,7 @@ impl NetworkManager {
cli.bind_mut() cli.bind_mut()
.publish_message(format!("Got \"Hello\"!"), CliColor::Info); .publish_message(format!("Got \"Hello\"!"), CliColor::Info);
} }
Package::Players(players, self_id, host_privileges) => { Package::Players(players, self_id) => {
cli.bind_mut() cli.bind_mut()
.publish_message(format!("Got players"), CliColor::Info); .publish_message(format!("Got players"), CliColor::Info);
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
@ -103,9 +103,6 @@ impl NetworkManager {
players.into_iter().map(|p| p.clone().into()).collect(), players.into_iter().map(|p| p.clone().into()).collect(),
); );
game.bind_mut().set_self(self_id); game.bind_mut().set_self(self_id);
if host_privileges {
game.bind_mut().set_host_privileges(true);
}
} }
} }
Package::SetNick(id, nick) => { Package::SetNick(id, nick) => {
@ -122,29 +119,18 @@ impl NetworkManager {
} }
Package::NewPlayer(player) => { Package::NewPlayer(player) => {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
if game if player.id != game.bind().self_id.unwrap_or(u16::MAX) {
.bind()
.self_id
.map(|id| player.id != id)
.unwrap_or(true)
{
game.bind_mut().new_player( game.bind_mut().new_player(
SocketAddr::from(([0, 0, 0, 0], 0)), SocketAddr::from(([0, 0, 0, 0], 0)),
Some(player.name), Some(player.name),
Some(player.id), Some(player.id),
false,
); );
} }
} }
} }
Package::PlayerLeft(player) => { Package::PlayerLeft(player) => {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
if game if player.id != game.bind().self_id.unwrap_or(u16::MAX) {
.bind()
.self_id
.map(|id| player.id != id)
.unwrap_or(true)
{
game.bind_mut().remove_player(player.id); game.bind_mut().remove_player(player.id);
} }
} }
@ -243,12 +229,12 @@ impl NetworkManager {
} }
Package::GameOptionChanged(opt, value) => { Package::GameOptionChanged(opt, value) => {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
game.bind_mut().change_option(opt, value, false); game.bind_mut().change_option(opt, value);
} }
} }
Package::TeamGameOptionChanged(team, opt, value) => { Package::TeamGameOptionChanged(team, opt, value) => {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
game.bind_mut().change_team_option(team, opt, value, false); game.bind_mut().change_team_option(team, opt, value);
} }
} }
Package::Goal(scorer, teams) => { Package::Goal(scorer, teams) => {
@ -278,12 +264,7 @@ impl NetworkManager {
} }
Package::ThrowTelegrenade(player_id, to) => { Package::ThrowTelegrenade(player_id, to) => {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
if game if player_id != game.bind().self_id.unwrap_or(0) {
.bind()
.self_id
.map(|id| player_id != id)
.unwrap_or(true)
{
game.bind_mut().on_throw_telegrenade(player_id, to); game.bind_mut().on_throw_telegrenade(player_id, to);
} }
} }
@ -325,13 +306,8 @@ impl NetworkManager {
); );
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
let is_first = game.bind().players.is_empty(); let self_id =
let self_id = game.bind_mut().new_player( game.bind_mut().new_player(connection.address, None, None);
connection.address,
None,
None,
is_first,
);
peer.send_reliable( peer.send_reliable(
&connection.address, &connection.address,
Package::Players( Package::Players(
@ -342,7 +318,6 @@ impl NetworkManager {
.map(|p| p.into()) .map(|p| p.into())
.collect(), .collect(),
self_id, self_id,
is_first,
), ),
); );
peer.send_reliable( peer.send_reliable(
@ -496,12 +471,13 @@ impl NetworkManager {
} }
Package::SetTeam(player_id, team) => { Package::SetTeam(player_id, team) => {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
let player = let self_id = game
game.bind().find_player_by_addr(&conn.address).cloned(); .bind()
if let Some(player) = player { .find_player_by_addr(&conn.address)
.map(|p| p.id());
if let Some(self_id) = self_id {
if game.bind().opts.is_true(GameOption::AllowAnyTeam) if game.bind().opts.is_true(GameOption::AllowAnyTeam)
|| player.id() == player_id || self_id == player_id
|| player.has_host_privileges
{ {
game.bind_mut().try_set_player_team(player_id, team); game.bind_mut().try_set_player_team(player_id, team);
} }
@ -510,14 +486,8 @@ impl NetworkManager {
} }
Package::SelectMap(map_idx) => { Package::SelectMap(map_idx) => {
if let Some(mut game) = Game::singleton() { if let Some(mut game) = Game::singleton() {
let player =
game.bind().find_player_by_addr(&conn.address).cloned();
if game.bind().opts.is_true(GameOption::AllowAnyMap) { if game.bind().opts.is_true(GameOption::AllowAnyMap) {
game.bind_mut().change_map_selection(map_idx, false); game.bind_mut().change_map_selection(map_idx, false);
} else if let Some(player) = player
&& player.has_host_privileges
{
game.bind_mut().change_map_selection(map_idx, false);
} }
} }
} }
@ -562,39 +532,6 @@ impl NetworkManager {
} }
} }
} }
Package::GameStarted => {
if let Some(game) = &mut Game::singleton() {
let player =
game.bind().find_player_by_addr(&conn.address).cloned();
if let Some(player) = player
&& player.has_host_privileges
{
game.bind_mut().start_game();
}
}
}
Package::GameOptionChanged(key, value) => {
if let Some(game) = &mut Game::singleton() {
let player =
game.bind().find_player_by_addr(&conn.address).cloned();
if let Some(player) = player
&& player.has_host_privileges
{
game.bind_mut().change_option(key, value, false);
}
}
}
Package::TeamGameOptionChanged(team, key, value) => {
if let Some(game) = &mut Game::singleton() {
let player =
game.bind().find_player_by_addr(&conn.address).cloned();
if let Some(player) = player
&& player.has_host_privileges
{
game.bind_mut().change_team_option(team, key, value, false);
}
}
}
_ => {} _ => {}
}, },
}, },

3
rust/src/player/remote_player.rs
View File

@ -426,8 +426,7 @@ impl ICharacterBody3D for RemotePlayer {
self.run_deferred(|s| { self.run_deferred(|s| {
if let Some(game) = Game::singleton() if let Some(game) = Game::singleton()
&& let Some(self_id) = game.bind().self_id && let Some(self_player) = game.bind().find_player(game.bind().self_id.unwrap_or(0))
&& let Some(self_player) = game.bind().find_player(self_id)
&& let Some(remote_player) = game.bind().find_player(s.player_id.unwrap_or(0)) && let Some(remote_player) = game.bind().find_player(s.player_id.unwrap_or(0))
&& self_player.data.team == remote_player.data.team && self_player.data.team == remote_player.data.team
&& let Some(sprite) = &mut s.shield_sprite && let Some(sprite) = &mut s.shield_sprite

8
rust/src/ui/chatbox.rs
View File

@ -145,11 +145,9 @@ impl ChatBox {
PeerKind::Server(..) => { PeerKind::Server(..) => {
self.run_deferred(move |_| { self.run_deferred(move |_| {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
let self_id = game.bind().self_id.clone(); let self_id = game.bind().self_id;
if let Some(self_id) = self_id { game.bind_mut()
game.bind_mut() .on_chat_message(self_id.unwrap_or(0), message.to_string());
.on_chat_message(self_id, message.to_string());
}
} }
}); });
} }

11
rust/src/ui/cli.rs
View File

@ -128,7 +128,7 @@ impl IPanel for CommandLinePanel {
#[godot_api] #[godot_api]
impl CommandLinePanel { impl CommandLinePanel {
#[signal] #[signal]
pub fn on_host(port: u16, headless: bool); pub fn on_host(port: u16);
#[signal] #[signal]
pub fn on_join(port: String); pub fn on_join(port: String);
#[signal] #[signal]
@ -223,14 +223,7 @@ impl Command for HostCommand {
fn execute(&self, cli: &mut CommandLinePanel, params: &[&str]) { fn execute(&self, cli: &mut CommandLinePanel, params: &[&str]) {
if let Some(port_str) = params.first() { if let Some(port_str) = params.first() {
if let Ok(port) = u16::from_str_radix(*port_str, 10) { if let Ok(port) = u16::from_str_radix(*port_str, 10) {
let headless = if let Some(param) = params.get(1) cli.signals().on_host().emit(port);
&& *param == "--headless"
{
true
} else {
false
};
cli.signals().on_host().emit(port, headless);
} else { } else {
cli.publish_message(format!("Invalid port: {}", port_str), CliColor::Error); cli.publish_message(format!("Invalid port: {}", port_str), CliColor::Error);
} }

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

@ -108,7 +108,10 @@ impl IPanel for LobbyPanel {
game.signals().options_changed().connect_other(self, |s| { game.signals().options_changed().connect_other(self, |s| {
s.run_deferred(|s| { s.run_deferred(|s| {
if let Some(game) = Game::singleton() { if let Some(game) = Game::singleton() {
s.on_game_opts_update(&game.bind().opts, game.bind().has_host_privileges()); s.on_game_opts_update(
&game.bind().opts,
NetworkManager::singleton().bind().is_host(),
);
} }
}); });
}); });
@ -130,8 +133,8 @@ impl IPanel for LobbyPanel {
}); });
}); });
let is_host = if let Some(game) = &Game::singleton() { let is_host = if let Some(peer) = &NetworkManager::singleton().bind().peer {
game.bind().has_host_privileges() peer.is_host()
} else { } else {
false false
}; };
@ -270,13 +273,13 @@ impl LobbyPanel {
fn option_changed(&mut self, key: GameOption, value: GameOptionValue) { fn option_changed(&mut self, key: GameOption, value: GameOptionValue) {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
game.bind_mut().change_option(key, value, true); game.bind_mut().change_option(key, value);
} }
} }
fn team_option_changed(&mut self, team: u8, key: GameOption, value: GameOptionValue) { fn team_option_changed(&mut self, team: u8, key: GameOption, value: GameOptionValue) {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
game.bind_mut().change_team_option(team, key, value, true); game.bind_mut().change_team_option(team, key, value);
} }
} }
@ -311,8 +314,10 @@ impl LobbyPanel {
} }
fn update_ready_button(&mut self) { fn update_ready_button(&mut self) {
if let Some(game) = Game::singleton() { if let Some(game) = Game::singleton()
if game.bind().has_host_privileges() && let Some(peer) = &NetworkManager::singleton().bind().peer
{
if let PeerKind::Server(_, _) = peer
&& let Some(button) = &mut self.ready_button && let Some(button) = &mut self.ready_button
{ {
let all_ready = game.bind().players.iter().all(|p| p.data.ready); let all_ready = game.bind().players.iter().all(|p| p.data.ready);
@ -341,8 +346,7 @@ impl LobbyPanel {
pub fn update_players(&mut self, replace: bool) { pub fn update_players(&mut self, replace: bool) {
if let Some(game) = &Game::singleton() if let Some(game) = &Game::singleton()
&& let Some(self_id) = game.bind().self_id && let Some(player) = game.bind().find_player(game.bind().self_id.unwrap_or(0))
&& let Some(player) = game.bind().find_player(self_id)
&& let Some(name_label) = &mut self.name_field && let Some(name_label) = &mut self.name_field
{ {
if player.data.name != name_label.get_text().to_string() { if player.data.name != name_label.get_text().to_string() {
@ -383,8 +387,8 @@ impl LobbyPanel {
} }
pub fn on_ready(&mut self) { pub fn on_ready(&mut self) {
let is_host = if let Some(game) = &Game::singleton() { let is_host = if let Some(peer) = &NetworkManager::singleton().bind().peer {
game.bind().has_host_privileges() peer.is_host()
} else { } else {
false false
}; };
@ -392,18 +396,14 @@ impl LobbyPanel {
self.is_ready = !self.is_ready; self.is_ready = !self.is_ready;
self.update_ready_button(); self.update_ready_button();
if let Some(game) = &mut Game::singleton() { if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer {
game.bind_mut().set_ready(self.is_ready); if let PeerKind::Client(peer, socket_addr) = peer {
peer.send_reliable(&socket_addr, Package::SetReady(0, self.is_ready));
}
} }
} else { } else {
if let Some(game) = &mut Game::singleton() { if let Some(game) = &mut Game::singleton() {
if let Some(peer) = &mut NetworkManager::singleton().bind_mut().peer game.bind_mut().start_game();
&& let PeerKind::Client(peer, addr) = peer
{
peer.send_reliable(addr, Package::GameStarted);
} else {
game.bind_mut().start_game();
}
} }
} }
} }
@ -490,9 +490,7 @@ impl LobbyPanel {
GameOptionValue::Boolean(value) => { GameOptionValue::Boolean(value) => {
let mut checkbox = CheckBox::new_alloc(); let mut checkbox = CheckBox::new_alloc();
checkbox.set_pressed(*value); checkbox.set_pressed(*value);
if let Some(game) = &Game::singleton() { checkbox.set_disabled(!NetworkManager::singleton().bind().is_host());
checkbox.set_disabled(!game.bind().has_host_privileges());
}
let checkbox_clone = checkbox.clone(); let checkbox_clone = checkbox.clone();
let option = option.clone(); let option = option.clone();
@ -516,9 +514,7 @@ impl LobbyPanel {
GameOptionValue::Number(value) => { GameOptionValue::Number(value) => {
let mut spinbox = SpinBox::new_alloc(); let mut spinbox = SpinBox::new_alloc();
spinbox.set_value(*value); spinbox.set_value(*value);
if let Some(game) = &Game::singleton() { spinbox.set_editable(NetworkManager::singleton().bind().is_host());
spinbox.set_editable(game.bind().has_host_privileges());
}
let option = option.clone(); let option = option.clone();
spinbox spinbox

3
rust/src/ui/lobby_player_listing.rs
View File

@ -75,10 +75,9 @@ impl IGridContainer for LobbyPlayerListing {
PeerKind::Server(..) => { PeerKind::Server(..) => {
if let Some(player_id) = self.player_id if let Some(player_id) = self.player_id
&& let Some(game) = Game::singleton() && let Some(game) = Game::singleton()
&& let Some(self_id) = game.bind().self_id
{ {
// Hide kick button for self even if host // Hide kick button for self even if host
if player_id == self_id { if player_id == game.bind().self_id.unwrap_or(0) {
kick_btn.hide(); kick_btn.hide();
} }
} }

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

@ -211,7 +211,7 @@ impl MainMenu {
if let Some(host_port) = &self.host_port { if let Some(host_port) = &self.host_port {
NetworkManager::singleton() NetworkManager::singleton()
.bind_mut() .bind_mut()
.host(host_port.get_value() as u16, false); .host(host_port.get_value() as u16);
} }
} }

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

@ -89,7 +89,7 @@ impl PlayerListing {
pub fn update(&mut self) { pub fn update(&mut self) {
if let Some(player_id) = self.player_id { if let Some(player_id) = self.player_id {
if let Some(game) = Game::singleton() { if let Some(game) = Game::singleton() {
let is_self = game.bind().self_id.map(|s| s == player_id).unwrap_or(false); let is_self = player_id == game.bind().self_id.unwrap_or(0);
if let Some(player) = game.bind().find_player(player_id) { if let Some(player) = game.bind().find_player(player_id) {
if let Some(name_label) = &mut self.name_label { if let Some(name_label) = &mut self.name_label {
name_label.set_text(&player.data.name); name_label.set_text(&player.data.name);