Add full destruction (no respawn) #30

rc_multiplayer/src/events/kill_player.rs

@@ -0,0 +1,31 @@
+pub struct KillEnemy {
+    msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
+}
+
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::SimpleRlnl<rlnl::events::ingame::Kill, KillEnemy> {
+    crate::handlers::SimpleRlnl::new(KillEnemy::new(init_ctx))
+}
+
+impl KillEnemy {
+    fn new(init_ctx: &crate::InitConfig) -> Self {
+        Self {
+            msg_router: init_ctx.matches_chann.clone(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::handlers::RlnlEventCodeHandler for KillEnemy {
+    type In = rlnl::events::ingame::Kill;
+    const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::MachineDestroyed;
+
+    async fn handle(&self, data: Self::In, _peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, _sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {
+        if let Some(user_info) = user.user().await {
+            super::log_channel_send_failure(self.msg_router.send(crate::matches::GameMessage::DestroyVehicle {
+                user_id: user_info.user_id(),
+                remote_player: data.killee_player_id,
+                killer_player: data.killer_player_id,
+            }).await);
+        }
+    }
+}

rc_multiplayer/src/events/mod.rs

@@ -5,6 +5,8 @@ mod weapon_select;
 mod activate_sync;
 mod loading_done;
 //mod player_input;
+mod spot_player;
+mod kill_player;
 
 pub async fn handler(init_ctx: &crate::InitConfig) -> crate::handler::LnlEventHandler {
     crate::handler::LnlEventHandler::new(init_ctx.users.clone(), crate::vehicle_motion::handler(init_ctx))
@@ -42,34 +44,51 @@ pub async fn handler(init_ctx: &crate::InitConfig) -> crate::handler::LnlEventHa
             {literustlib::packet::Property::Unreliable as u8},
             rlnl::events::ingame::FireMiss,
         >::handler(init_ctx))
-        .add(crate::handlers::Broadcaster::<
+        /*.add(crate::handlers::Broadcaster::<
             true,
             {rlnl::event_code::NetworkEvent::EnemySpotted as i16},
             {rlnl::event_code::NetworkEvent::EnemySpotted as i16},
             {literustlib::packet::Property::ReliableOrdered as u8},
             rlnl::events::ingame::SpottingIds,
-        >::handler(init_ctx))
+        >::handler(init_ctx))*/
+        .add(spot_player::handler(init_ctx))
         .add(crate::handlers::Broadcaster::<
-            true,
+            false,
             {rlnl::event_code::NetworkEvent::DamageCube as i16},
             {rlnl::event_code::NetworkEvent::DestroyCubesFull as i16},
             {literustlib::packet::Property::ReliableOrdered as u8},
             rlnl::events::ingame::DestroyCubesFull,
         >::handler(init_ctx))
         .add(crate::handlers::Broadcaster::<
-            true,
+            false,
             {rlnl::event_code::NetworkEvent::DamageCubeNoEffect as i16},
             {rlnl::event_code::NetworkEvent::DestroyCubeNoEffect as i16},
             {literustlib::packet::Property::ReliableOrdered as u8},
             rlnl::events::ingame::DestroyCubeNoEffect,
         >::handler(init_ctx))
         .add(crate::handlers::Broadcaster::<
-            true,
+            false,
             {rlnl::event_code::NetworkEvent::DamageCubeEffectOnly as i16},
             {rlnl::event_code::NetworkEvent::DestroyCubeEffectOnly as i16},
             {literustlib::packet::Property::Unreliable as u8},
             rlnl::events::ingame::DestroyCubeEffectOnly,
         >::handler(init_ctx))
+        .add(crate::handlers::Stub::<
+            {rlnl::event_code::NetworkEvent::DestroyCubesBonusRequest as i16},
+            rlnl::events::ingame::DestroyedHealedCubesBonus,
+        >::handler(init_ctx))
+        .add(crate::handlers::Broadcaster::<
+            false,
+            {rlnl::event_code::NetworkEvent::HealSelf as i16},
+            {rlnl::event_code::NetworkEvent::HealSelfResponse as i16},
+            {literustlib::packet::Property::ReliableOrdered as u8},
+            rlnl::events::HealedCubes,
+        >::handler(init_ctx))
+        .add(crate::handlers::Stub::<
+            {rlnl::event_code::NetworkEvent::KillBonusRequest as i16},
+            rlnl::events::ingame::Kill, // FIXME this is not a player ID -- it's actually sending 2 bytes not 1
+        >::handler(init_ctx))
+        .add(kill_player::handler(init_ctx))
 }
 
 #[inline]

rc_multiplayer/src/events/spot_player.rs

@@ -0,0 +1,30 @@
+pub struct SpotEnemy {
+    msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
+}
+
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::SimpleRlnl<rlnl::events::ingame::SpottingIds, SpotEnemy> {
+    crate::handlers::SimpleRlnl::new(SpotEnemy::new(init_ctx))
+}
+
+impl SpotEnemy {
+    fn new(init_ctx: &crate::InitConfig) -> Self {
+        Self {
+            msg_router: init_ctx.matches_chann.clone(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::handlers::RlnlEventCodeHandler for SpotEnemy {
+    type In = rlnl::events::ingame::SpottingIds;
+    const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::EnemySpotted;
+
+    async fn handle(&self, data: Self::In, _peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, _sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {
+        if let Some(user_info) = user.user().await {
+            super::log_channel_send_failure(self.msg_router.send(crate::matches::GameMessage::SpotVehicle {
+                user_id: user_info.user_id(),
+                remote_player: data.player_id,
+            }).await);
+        }
+    }
+}

rc_multiplayer/src/handlers/mod.rs

@@ -9,3 +9,6 @@ pub use ingame_broadcast::Broadcaster;
 
 mod ingame_broadcast_dataless;
 pub use ingame_broadcast_dataless::DatalessBroadcaster;
+
+mod stub;
+pub use stub::Stub;

rc_multiplayer/src/handlers/stub.rs

@@ -0,0 +1,26 @@
+pub struct Stub<const CODE_IN: i16, In: byteserde::des_slice::ByteDeserializeSlice<In> + Send + Sync + 'static> {
+    _in: std::marker::PhantomData<In>,
+}
+
+impl <const CODE_IN: i16, In: byteserde::des_slice::ByteDeserializeSlice<In> + Send + Sync + 'static> Stub<CODE_IN, In> {
+    pub fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::simple_typed::SimpleRlnl<In, Self> {
+        crate::handlers::simple_typed::SimpleRlnl::new(Stub::new(init_ctx))
+    }
+
+    fn new(_init_ctx: &crate::InitConfig) -> Self {
+        Self {
+            _in: std::marker::PhantomData::default(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl <const CODE_IN: i16, In: byteserde::des_slice::ByteDeserializeSlice<In> + Send + Sync + 'static> crate::handlers::simple_typed::RlnlEventCodeHandler for Stub<CODE_IN, In> {
+    type In = In;
+    const CODE: rlnl::event_code::NetworkEvent = crate::handler::i16_to_event_or_panic(CODE_IN);
+
+    async fn handle(&self, _data: Self::In, _peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, _user: &crate::UserData, _sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {
+        log::debug!("Got {:?} event", Self::CODE);
+        //log::debug!("Got {:?} event: {:?}", Self::CODE, data);
+    }
+}

rc_multiplayer/src/matches/generic.rs

@@ -335,7 +335,7 @@ impl GenericGamemodeEngine {
                                 rlnl::event_code::NetworkEvent::BroadcastWeaponSelect,
                                 literustlib::packet::Property::ReliableOrdered,
                                 &data,
-                                false
+                                true
                             ).await;
                         }
                     },
@@ -406,6 +406,25 @@ impl GenericGamemodeEngine {
                             self.game_start.store(game_start.timestamp(), std::sync::atomic::Ordering::Relaxed);
                             super::countdown::match_countdown(senders, game_start);
                         }
+                    },
+                    super::GameMessage::SpotVehicle { user_id, remote_player } => {
+                        self.rebroadcast(
+                            user_id,
+                            rlnl::event_code::NetworkEvent::RemoteEnemySpotted,
+                            literustlib::packet::Property::ReliableOrdered,
+                            &rlnl::events::ingame::PlayerId { player: remote_player },
+                            true
+                        ).await;
+                    },
+                    super::GameMessage::DestroyVehicle { user_id, remote_player, killer_player } => {
+                        self.rebroadcast(
+                            user_id,
+                            rlnl::event_code::NetworkEvent::MachineDestroyedConfirmed,
+                            literustlib::packet::Property::ReliableOrdered,
+                            &rlnl::events::ingame::Kill { killee_player_id: remote_player, killer_player_id: killer_player },
+                            true,
+                        ).await;
+                        log::warn!("Player {} was destroyed by {} ({}) !!!implement this!!!", remote_player, killer_player, user_id);
                     }
                     super::GameMessage::BroadcastRlnl { user_id: _, event, property, data } => {
                         if let Some(data) = data {
@@ -413,7 +432,7 @@ impl GenericGamemodeEngine {
                         } else {
                             self.broadcast_dataless(event, property, true).await;
                         }
-                    }
+                    },
                     super::GameMessage::RebroadcastRlnl { skip_user_id, event, property, data } => {
                         if let Some(data) = data {
                             self.rebroadcast(skip_user_id, event, property, &*data, true).await;
@@ -421,7 +440,7 @@ impl GenericGamemodeEngine {
                             self.rebroadcast_dataless(skip_user_id, event, property, true).await;
                         }
 
-                    }
+                    },
                     super::GameMessage::Motion { user_id, data } => {
                         for conn in self.users.read().await.values() {
                             if conn.user.user_id() == user_id { continue; } // fun fact: the game hard crashes if you omit this
@@ -432,7 +451,7 @@ impl GenericGamemodeEngine {
                                 data: data.clone(),
                             }, literustlib::packet::Property::Unreliable, &conn.connection.connection).await);
                         }
-                    }
+                    },
                     super::GameMessage::NoOp => {},
                 }
             }

rc_multiplayer/src/matches/messages.rs

@@ -26,6 +26,15 @@ pub enum GameMessage {
     LoadComplete {
         user_id: i32,
     },
+    SpotVehicle {
+        user_id: i32,
+        remote_player: u8,
+    },
+    DestroyVehicle {
+        user_id: i32,
+        remote_player: u8,
+        killer_player: u8,
+    },
     BroadcastRlnl {
         user_id: i32,
         event: rlnl::event_code::NetworkEvent,
@@ -56,6 +65,8 @@ impl GameMessage {
             Self::WeaponSelect { user_id, .. } => *user_id,
             Self::RequestLoadingSync { user_id, .. } => *user_id,
             Self::LoadComplete { user_id, .. } => *user_id,
+            Self::SpotVehicle { user_id, .. } => *user_id,
+            Self::DestroyVehicle { user_id, .. } => *user_id,
             Self::BroadcastRlnl { user_id, .. } => *user_id,
             Self::RebroadcastRlnl { skip_user_id, .. } => *skip_user_id,
             Self::Motion { user_id, .. } => *user_id,