feat: bot performance with improved tick rate, bandwidth tracking, and added test-demo

Author: ronakgh97

README.md

@@ -8,16 +8,38 @@
 [![Reshiram](https://img.pokemondb.net/sprites/black-white/anim/normal/reshiram.gif)](https://pokemondb.net/pokedex/reshiram)
 [![Kyurem](https://img.pokemondb.net/sprites/black-white/anim/normal/kyurem.gif)](https://pokemondb.net/pokedex/kyurem)
 
-Networking in game is super frustrating, even a simple relay server takes lots of time.
-Forgot the actual game, now you are stuck with networking code chaos, forever and eternally, and you will never finish
-your game, and you will never be satisfied, and you will never be proud of your work, and you will never be able to show
-it to anyone or PLAY, and you will never be able to have fun at all......YOU WILL NEVER BE LOVED EVER....AGAIN....
-and you will just be stuck in this endless loop of networking code forever.
+Networking in games is pure suffering.
+
+You start with “just a simple relay server.” *(alone let authoritative servers)*
+Just a few sockets. A couple messages. Clean.
+Few hours later:
+you’re debugging why one packet arrives in the future, one in the past, and one simply refuses to exist.
+You forget the game.
+The game forgets you.
+Now it’s just you, a growing pile of networking code,
+and a silent client that *definitely* connected but somehow didn’t.
+You promise yourself:
+“just one more fix”
+Congratulations.
+You are now in a long-term relationship with a race condition.
+Days pass.
+You no longer render frames.
+You render logs.
+At some point, you question reality:
+“is UDP unordered, or am I?”
+Eventually, you accept it.
+There is no game.
+There never was.
+Only packets.
+Only retries.
+Only pain.
 
 **Dakara watashi ga anata o sukutte agemashou**
 
 This will be a very simple AND opinionated game network libray not a daemon
-(You will still need to embed it in a server wrapper or something)
+`(You will still need to embed it in a server wrapper or something, 
+and also this is not a Authoritative server library, thought it can be made with more hooks and callbacks, 
+but the main point is effortlessly broadcasting with high tick rate and low-memory usage)`
 
 > Note: This is very experimental.
 > I am making this for learning networking and get familiar with tokio ecosystem,
@@ -32,6 +54,15 @@ Usage (I don't like release cycles and versioning, so just use local)
 game-server = { git = "https://github.com/ronakgh97/ghost-sync" }
 ```
 
+![Bot-test](test-demo.gif)
+
+Tick rate: 60 hz
+Bot-client: 128
+
+`N * C msg/second for each broadcast, so (N - 1) * (N * C) msg/second in total broadcast`
+
+*That's 58,521,600 msg/second with 512 mb buffer channel*
+
 TODO
 
 Better lib design, currently its just a mess of functions and structs, need to refactor it into a more usable and
@@ -40,3 +71,4 @@ Add more examples, maybe a mini-game?
 Experimental UDP support, maybe using QUIC?
 Add tuned buffering and improve performance by lessen serialization and deserialization, where possible (Zero-copy,
 etc.)
+Fixed the DAMN BACKPRESSURE, CHANNEL GETS FULL AND THEN EVERYTHING BLOWS UP

examples/bot.rs

@@ -2,26 +2,30 @@ use ::rand::RngExt;
 use dashmap::DashMap;
 use ghost_sync::{Client, ServerEvent};
 use macroquad::prelude::*;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use std::thread;
 use std::time::{Duration, Instant};
 use uuid::Uuid;
 use wincode::{SchemaRead, SchemaWrite};
 
 const ADDR: &str = "127.0.0.1:7777";
-const ROOM: &str = "room-128";
+const ROOM: &str = "test-room";
 const BOT_COUNT: usize = 128;
-const TICK_RATE: u64 = 20;
-const MAX_SPEED: f32 = 100.0;
+const TICK_RATE: u64 = 60;
+const MAX_SPEED: f32 = 400.0;
 const SCREEN: f32 = 800.0;
 
+static BYTES_SENT: AtomicU64 = AtomicU64::new(0);
+static BYTES_RECV: AtomicU64 = AtomicU64::new(0);
+
 fn winconfig() -> Conf {
     Conf {
         window_title: "Bot Stress Test".into(),
         window_width: SCREEN as i32,
         window_height: SCREEN as i32,
         window_resizable: false,
-        sample_count: BOT_COUNT as i32,
+        sample_count: 512,
         ..Default::default()
     }
 }
@@ -56,7 +60,7 @@ impl Bot {
     #[inline(always)]
     pub fn update(&mut self, dt: f32) {
         let target_pos = self.pos + self.vel * dt;
-        self.pos = self.pos.lerp(target_pos, 0.225); // Smooth movement visual
+        self.pos = self.pos.lerp(target_pos, 0.225); // Smooth visual (render only)
         self.pos.x = self.pos.x.rem_euclid(SCREEN);
         self.pos.y = self.pos.y.rem_euclid(SCREEN);
     }
@@ -76,12 +80,12 @@ async fn bot_loop(map: BotMap, bot_index: usize) {
     let mut client = match Client::connect(ADDR).await {
         Ok(c) => c,
         Err(e) => {
-            eprintln!("[{bot_index}] connect error: {e}");
+            eprintln!("Bot: [{bot_index}] connect error: {e}");
             return;
         }
     };
     if let Err(e) = client.join(ROOM).await {
-        eprintln!("[{bot_index}] join error: {e}");
+        eprintln!("Bot: [{bot_index}] join error: {e}");
         return;
     }
 
@@ -92,7 +96,7 @@ async fn bot_loop(map: BotMap, bot_index: usize) {
 
     map.insert(self_id, Bot::new(&mut rng));
 
-    // Tick rate limiter
+    // Tick limit to avoid flooding the server with updates. The bot's movement is smoothed
     let send_interval = Duration::from_millis(1000 / TICK_RATE);
     let mut last_send = Instant::now();
 
@@ -106,33 +110,41 @@ async fn bot_loop(map: BotMap, bot_index: usize) {
                     vx: bot.vel.x,
                     vy: bot.vel.y,
                 };
-                let _ = client
-                    .broadcast(&wincode::serialize(&payload).unwrap())
-                    .await;
+                let data = wincode::serialize(&payload).unwrap();
+                BYTES_SENT.fetch_add(data.len() as u64, Ordering::Relaxed);
+                let _ = client.broadcast(&data).await;
 
                 bot.random_velo(&mut rng);
             }
         }
 
         loop {
-            // Draining incoming messages with a short timeout to avoid stalling the loop
-            match tokio::time::timeout(Duration::from_micros(10), client.recv()).await {
+            // Timeout for recv to avoid stalling the bot loop if the server is unresponsive.
+            // The bot's movement is still updated and rendered during this time
+            match tokio::time::timeout(Duration::from_millis(100), client.recv()).await {
                 Ok(Ok(Some(ServerEvent::Broadcast { sender_id, data })))
-                // Update the bot map, we will render them later
                     if sender_id != self_id =>
                 {
+                    BYTES_RECV.fetch_add(data.len() as u64, Ordering::Relaxed);
                     if let Ok(v) = wincode::deserialize::<Payload>(&data) {
                         map.entry(v.id)
                             .and_modify(|b| b.vel = Vec2::new(v.vx, v.vy))
                             .or_insert(Bot {
                                 pos: Vec2::new(
-                                    rng.random::<f32>() * SCREEN,
-                                    rng.random::<f32>() * SCREEN,
+                                    rng.random_range(0.0..SCREEN),
+                                    rng.random_range(0.0..SCREEN),
                                 ),
                                 vel: Vec2::new(v.vx, v.vy),
                             });
                     }
                 }
+                Ok(Ok(Some(ServerEvent::PlayerLeft { client_id }))) => {
+                    map.remove(&client_id);
+                    eprintln!("Bot: {client_id} disconnected, removed from map");
+                }
+                Ok(Ok(Some(ServerEvent::Joined { client_id, .. }))) => {
+                    eprintln!("Bot: {client_id} joined");
+                }
                 _ => break,
             }
         }
@@ -143,28 +155,61 @@ async fn bot_loop(map: BotMap, bot_index: usize) {
 
 #[macroquad::main(winconfig)]
 async fn main() {
-    let map: BotMap = Arc::new(DashMap::new());
+    let map: BotMap = Arc::new(DashMap::with_capacity(BOT_COUNT));
 
     for i in 0..BOT_COUNT {
         let m = map.clone();
-        thread::spawn(move || {
-            let rt = tokio::runtime::Runtime::new().unwrap();
-            rt.block_on(bot_loop(m, i));
+        thread::spawn(move || match tokio::runtime::Runtime::new() {
+            Ok(rt) => rt.block_on(bot_loop(m, i)),
+            Err(e) => eprintln!("Tokio runtime error: {e}"),
         });
     }
 
-    let delta = get_frame_time();
+    let mut last_bandwidth = Instant::now();
+    let mut sent_acc = 0u64;
+    let mut recv_acc = 0u64;
 
     loop {
+        let delta = get_frame_time();
+
         clear_background(BLACK);
+
+        let connected = map.len();
         draw_text(
-            &format!("Bots:{BOT_COUNT} Fps:{:.0}", 1.0 / delta.max(0.001)),
+            &format!("Bots: {connected}/{BOT_COUNT}"),
             10.0,
             24.0,
             20.0,
             WHITE,
         );
-        draw_text(&format!("Tick rate: {TICK_RATE}"), 10.0, 48.0, 20.0, WHITE);
+        draw_text(
+            &format!("FPS: {:.0}", 1.0 / delta.max(0.001)),
+            10.0,
+            48.0,
+            20.0,
+            WHITE,
+        );
+        draw_text(&format!("Tick rate: {TICK_RATE}"), 10.0, 72.0, 20.0, WHITE);
+
+        if last_bandwidth.elapsed().as_secs_f32() >= 1.0 {
+            sent_acc = BYTES_SENT.swap(0, Ordering::Relaxed);
+            recv_acc = BYTES_RECV.swap(0, Ordering::Relaxed);
+            last_bandwidth = Instant::now();
+        }
+        draw_text(
+            &format!("TX: {} KB/s", sent_acc / 1024),
+            10.0,
+            96.0,
+            20.0,
+            GREEN,
+        );
+        draw_text(
+            &format!("RX: {} KB/s", recv_acc / 1024),
+            10.0,
+            120.0,
+            20.0,
+            BLUE,
+        );
 
         for mut entry in map.iter_mut() {
             let bot = entry.value_mut();

examples/daemon.rs

@@ -266,9 +266,9 @@ async fn main() -> Result<()> {
         .bind("0.0.0.0:7777")
         .max_clients(1024)
         .max_payload(256 * 1024)
-        .idle_timeout(Duration::from_secs(31))
-        .ping_interval(Duration::from_secs(12))
-        .channel_capacity(1024 * 1024 * 64)
+        .idle_timeout(Duration::from_secs(25))
+        .ping_interval(Duration::from_secs(15))
+        .channel_capacity(1024 * 1024 * 512)
         .handler(DaemonHandler::new(daemon.clone()))
         .build();
 
@@ -279,6 +279,8 @@ async fn main() -> Result<()> {
         server_handle.create_room(&format!("room-{}", i))?;
     }
 
+    server_handle.create_room("test-room")?;
+
     let ctrl_listener = TcpListener::bind("0.0.0.0:8888").await?;
     info!("Control server listening on 0.0.0.0:8888");
 

src/client.rs

@@ -138,8 +138,8 @@ impl ClientBuilder {
         let (read_half, write_half) = stream.into_split();
 
         Ok(Client {
-            reader: BufReader::with_capacity(64 * 1024, read_half),
-            writer: BufWriter::with_capacity(64 * 1024, write_half),
+            reader: BufReader::with_capacity(128 * 1024, read_half),
+            writer: BufWriter::with_capacity(128 * 1024, write_half),
             max_payload: self.max_payload,
         })
     }

test-demo.gif

@@ -426,18 +426,14 @@ async fn runtime_room_management() {
     }
 
     assert_eq!(handle.room_client_count("match-1"), Some(1));
-
-    // Delete room at runtime (soft delete)
     assert!(handle.delete_room("match-1"));
     assert!(!handle.room_exists("match-1"));
     assert_eq!(handle.room_count(), 1);
-
-    // Delete non-existent room returns false
     assert!(!handle.delete_room("nonexistent"));
 }
 
-const LOAD_CLIENTS: usize = 512;
-const LOAD_DURATION: Duration = Duration::from_secs(12);
+const LOAD_CLIENTS: usize = 256;
+const LOAD_DURATION: Duration = Duration::from_secs(8);
 
 #[inline(always)]
 fn get_random_bytes(size: u32) -> Vec<u8> {
@@ -542,7 +538,7 @@ async fn server_load_test() {
         .max_payload(1024)
         .idle_timeout(Duration::from_secs(60))
         .ping_interval(Duration::from_secs(30))
-        .channel_capacity(256)
+        .channel_capacity(1024)
         .build();
 
     server.pre_create_room("load_test").unwrap();