From 0e32e57d7ddb941bf9d0938876e8a6d1616f076b Mon Sep 17 00:00:00 2001
From: Theis Pieter Hollebeek <tphollebeek@gmail.com>
Date: Mon, 30 Mar 2026 10:00:30 +0200
Subject: [PATCH] server

---
 game/src/vermiparous.rs | 97 +++++++++++++++--------------------------
 1 file changed, 36 insertions(+), 61 deletions(-)

diff --git a/game/src/vermiparous.rs b/game/src/vermiparous.rs
index b8eb6da..f3b08a3 100644
--- a/game/src/vermiparous.rs
+++ b/game/src/vermiparous.rs
@@ -1,72 +1,47 @@
 use std::{
-    io::{Read, Write},
+    io::{BufRead, BufReader},
     net::TcpStream,
 };
 
-struct Server;
-struct UnregisteredServer(TcpStream);
-struct RegisteredServer(TcpStream);
-
-impl Server {
-    pub fn bind(addr: &str) -> UnregisteredServer {
-        UnregisteredServer(TcpStream::connect(addr).unwrap())
-    }
-}
-
-impl UnregisteredServer {
-    pub fn register(mut self, id: u64) -> Result<RegisteredServer, UnregisteredServer> {
-        self.0.write(b"register ").unwrap();
-        self.0.write(id.to_string().as_bytes()).unwrap();
-        self.0.write(b"\n").unwrap();
-
-        let mut buf: [u8; 2] = [0, 0];
-        self.0.read(&mut buf).unwrap();
-        match &buf {
-            b"OK" => Ok(RegisteredServer(self.0)),
-            b"NO" => Err(self),
-            _ => panic!("server error"),
-        }
-    }
-}
+struct Server(TcpStream);
 
 struct Data {
-    sway: f64,
+    x: f64,
+    y: f64,
+    z: f64,
+    a: f64,
+    b: f64,
+    c: f64,
 }
 
-struct Pump<'a>(&'a mut TcpStream, [u8; 4], usize);
+impl Server {
+    pub fn bind(addr: &str) -> Server {
+        Server(TcpStream::connect(addr).unwrap())
+    }
+    fn get_fallible(data: &[f64], idx: usize) -> Result<f64, String> {
+        data.get(idx)
+            .map(|idx| *idx)
+            .ok_or_else(|| format!("protocol error: {idx}"))
+    }
+    pub fn read(&mut self) -> Result<Data, String> {
+        let mut reader = BufReader::new(&mut self.0);
+        let mut data = String::new();
+        reader
+            .read_line(&mut data)
+            .map_err(|err| format!("io error: {}", err.to_string()))?;
+        let data = data
+            .split(",")
+            .map(|x| x.parse::<f64>())
+            .collect::<Result<Vec<f64>, _>>();
+        let data = data.map_err(|err| format!("protocol error: {}", err.to_string()))?;
 
-impl<'a> Pump<'a> {
-    pub fn new(stream: &'a mut TcpStream) -> Self {
-        Self(stream, [0, 0, 0, 0], 0)
-    }
-}
-
-impl<'a> Iterator for Pump<'a> {
-    type Item = std::io::Result<Data>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            let mut bytes = self.0.bytes();
-            let Some(byte) = bytes.next() else {
-                break None;
-            };
-            let byte = match byte {
-                Ok(byte) => byte,
-                Err(err) => break Some(Err(err)),
-            };
-            self.1[self.2] = byte;
-            self.2 += 1;
-            if self.2 == 4 {
-                let sway = u32::from_le_bytes(self.1) as f64;
-                let sway = (sway - 64_000_000.0) / 2.0;
-                break Some(Ok(Data { sway }));
-            }
-        }
-    }
-}
-
-impl RegisteredServer {
-    fn pump(&mut self) -> Pump<'_> {
-        Pump::new(&mut self.0)
+        Ok(Data {
+            x: Self::get_fallible(&data, 0)?,
+            y: Self::get_fallible(&data, 1)?,
+            z: Self::get_fallible(&data, 2)?,
+            a: Self::get_fallible(&data, 3)?,
+            b: Self::get_fallible(&data, 4)?,
+            c: Self::get_fallible(&data, 5)?,
+        })
     }
 }