improve remote

Cargo.toml

@@ -0,0 +1,5 @@
+[workspace]
+members = [
+    "./server",
+    "./game",
+]

game/Cargo.toml

@@ -7,8 +7,6 @@ edition = "2021"
 
 [dependencies]
 qrcode = { version = "0.12" }
-specs = "0.18"
-specs-derive = "0.4"
 anyhow = "1.0"
 tokio = { version = "1", features = ["full"] }
 webrtc = "0.7"

game/src/controllers.rs

@@ -157,7 +157,7 @@ pub async fn start_peer_connection(offer: String, sender: Sender<String>) {
     sender.send(answer).await.expect("failed to send answer");
 }
 
-pub fn listen(peer_connection: RTCPeerConnection, sender: Sender<String>) {
+pub fn listen(peer_connection: RTCPeerConnection) {
     peer_connection.on_peer_connection_state_change(Box::new(move |s: RTCPeerConnectionState| {
         println!("Peer Connection State has changed: {s}");
 

game/src/game.rs

@@ -1,15 +1,10 @@
 use serde::Deserialize;
 
+use crate::remotes::RemoteInput;
+
 #[derive(Deserialize)]
 #[serde(untagged)]
 pub enum MessageToGame {
-    Input(Input),
+    RemoteInput(RemoteInput),
     RoomId(String),
-    PlayerDirection(f64),
-}
-
-#[derive(Deserialize)]
-pub enum Input {
-    A,
-    B,
 }

game/src/lib.rs

@@ -0,0 +1,8 @@
+pub mod controllers;
+pub mod game;
+pub mod players_connector;
+pub mod remote_communicator;
+pub mod remotes;
+pub mod room_code;
+pub mod server_communicator;
+pub mod signal;

game/src/main.rs

@@ -1,13 +1,7 @@
-mod controllers;
-mod game;
-mod players_connector;
-mod remote_communicator;
-mod room_code;
-mod server_communicator;
-mod signal;
-
 use futures_channel::mpsc::unbounded;
-use game::{Input, MessageToGame};
+use game::game::MessageToGame;
+use game::remotes::{GameInput, RemoteInput};
+use game::{players_connector, room_code, server_communicator};
 use players_connector::PlayersConnector;
 use sdl2::event::Event;
 use sdl2::keyboard::Keycode;
@@ -19,7 +13,7 @@ use anyhow::Result;
 use image::LoadTexture;
 use room_code::RoomCode;
 use sdl2::image::{self, InitFlag};
-use server_communicator::{MessageToServer, SdpMessage, ServerCommunicator};
+use server_communicator::ServerCommunicator;
 use std::time::Duration;
 use tokio::spawn;
 
@@ -49,7 +43,9 @@ fn render(
     let squares = room_code.get_qr_code_squares(10);
     squares.iter().for_each(|(square, color)| {
         canvas.set_draw_color(*color);
-        canvas.fill_rect(*square).unwrap();
+        let mut square = square.clone();
+        square.offset(10, 10);
+        canvas.fill_rect(square).unwrap();
     });
 
     let (width, height) = canvas.output_size()?;
@@ -94,17 +90,10 @@ async fn main() -> Result<(), String> {
     let server_communicator = ServerCommunicator::new(
         sender_to_game,
         sender_to_player_connector,
-        //receiver_server,
         "ws://localhost:5000",
     );
     spawn(async move { server_communicator.start(receiver_server).await });
 
-    let answer = MessageToServer::SdpAnswer(SdpMessage {
-        data: "hello".to_owned(),
-        id: 23,
-    });
-    //sender_to_server.unbounded_send(answer).unwrap();
-
     let sdl_context = sdl2::init().expect("failed to create context");
     let video_subsystem = sdl_context.video()?;
     // Leading "_" tells Rust that this is an unused variable that we don't care about. It has to
@@ -158,14 +147,17 @@ async fn main() -> Result<(), String> {
                 MessageToGame::RoomId(id) => {
                     println!("creating qrcode with room_id {}", id);
                     room_code = RoomCode::new(
-                        format!("http://192.168.0.103:8080/?room-id={}", id).to_owned(),
+                        format!("http://192.168.0.107:8080/?room-id={}", id).to_owned(),
                     );
                 }
-                MessageToGame::Input(_) => {}
-                MessageToGame::PlayerDirection(direction) => {
+                MessageToGame::RemoteInput(RemoteInput::GameInput(GameInput::Move(direction))) => {
                     player.speed = PLAYER_MOVEMENT_SPEED;
                     player.direction = Direction(direction);
                 }
+                MessageToGame::RemoteInput(RemoteInput::GameInput(GameInput::Stop)) => {
+                    player.speed = 0.0;
+                }
+                MessageToGame::RemoteInput(_) => {}
             }
         }
 

game/src/players_connector.rs

@@ -123,7 +123,7 @@ impl PlayersConnector {
         receiver: UnboundedReceiver<SdpMessage>,
     ) -> Self {
         let mut m = MediaEngine::default();
-        let mut fastest_codec = RTCRtpCodecParameters {
+        let fastest_codec = RTCRtpCodecParameters {
             capability: RTCRtpCodecCapability {
                 mime_type: MIME_TYPE_OPUS.to_owned(),
                 clock_rate: 48000,
@@ -181,13 +181,6 @@ impl PlayersConnector {
                     Ok(()) => println!("The message was successfully sent"),
                     Err(err) => println!("failed to send message {}", err.to_string()),
                 }
-
-                let sender_to_game = self.sender_to_game.clone();
-                /*spawn(async move {
-                    let mut remote_communicator =
-                        RemoteCommunicator::new(peer_connection, sender_to_game);
-                    remote_communicator.start().await
-                });*/
             }
         }
     }

game/src/remote_communicator.rs

@@ -1,22 +1,18 @@
 use anyhow::Result;
 use std::{time::Duration, sync::Arc};
 
-use futures_channel::mpsc::UnboundedSender;
 use webrtc::{peer_connection::{RTCPeerConnection, peer_connection_state::RTCPeerConnectionState}, data_channel::{data_channel_message::DataChannelMessage, RTCDataChannel}};
 
-use crate::game::MessageToGame;
 
 pub struct RemoteCommunicator {
     peer_connection: RTCPeerConnection,
-    sender_to_game: UnboundedSender<MessageToGame>,
 }
 
 impl RemoteCommunicator {
-    pub fn new(peer_connection: RTCPeerConnection, sender_to_game: UnboundedSender<MessageToGame>) -> Self {
+    pub fn new(peer_connection: RTCPeerConnection) -> Self {
         print!("new player could connect");
         Self {
             peer_connection,
-            sender_to_game,
         }
     }
 

game/src/remotes/messages.rs

@@ -0,0 +1,20 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+
+pub enum RemoteInput {
+    GameInput(GameInput),
+    ReadyToPlay,
+    SetUsername(String),
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum GameInput {
+    Aim(f64),
+    Shoot(f64),
+    Bomb,
+    Stop,
+    Move(f64),
+}

game/src/remotes/mod.rs

@@ -0,0 +1,3 @@
+mod messages;
+
+pub use messages::*;

game/src/signal.rs

@@ -1,4 +1,5 @@
 use anyhow::Result;
+use base64::{engine::general_purpose, Engine};
 
 /// must_read_stdin blocks until input is received from stdin
 pub fn must_read_stdin() -> Result<String> {
@@ -17,21 +18,13 @@ pub fn must_read_stdin() -> Result<String> {
 /// encode encodes the input in base64
 /// It can optionally zip the input before encoding
 pub fn encode(b: &str) -> String {
-    //if COMPRESS {
-    //    b = zip(b)
-    //}
-
-    base64::encode(b)
+    general_purpose::STANDARD.encode(b.as_bytes())
 }
 
 /// decode decodes the input from base64
 /// It can optionally unzip the input after decoding
 pub fn decode(s: &str) -> Result<String> {
-    let b = base64::decode(s)?;
-
-    //if COMPRESS {
-    //    b = unzip(b)
-    //}
+    let b = general_purpose::STANDARD.decode(s)?;
 
     let s = String::from_utf8(b)?;
     Ok(s)