server.rs 2.0 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374
  1. use std::collections::HashMap;
  2. use std::net::TcpListener;
  3. mod messages;
  4. #[derive(Debug)]
  5. struct Player {
  6. name: String,
  7. xy: (f32, f32),
  8. }
  9. #[derive(Debug)]
  10. struct State {
  11. players: HashMap<u16, Player>,
  12. }
  13. impl State {
  14. fn new() -> State {
  15. let players = HashMap::new();
  16. State { players }
  17. }
  18. fn handle_message(&mut self, msg: messages::Msg) {
  19. let nonce = msg.nonce;
  20. match msg.command {
  21. messages::Command::Hello(name) => {
  22. let player = Player { name, xy: (0.0, 0.0) };
  23. self.players.insert(nonce, player);
  24. }
  25. messages::Command::Goodbye => {
  26. self.players.remove(&nonce);
  27. }
  28. messages::Command::Update(x, y) => {
  29. if let Some(p) = self.players.get_mut(&nonce) {
  30. p.xy = (x, y);
  31. }
  32. }
  33. }
  34. }
  35. }
  36. fn main() {
  37. let (send, recv) = std::sync::mpsc::channel();
  38. let udp_send = send.clone();
  39. std::thread::spawn(move || {
  40. let listener = TcpListener::bind("0.0.0.0:9991").unwrap();
  41. loop {
  42. match listener.accept() {
  43. Ok((sock, _addr)) => {
  44. let msg = match messages::Msg::parse(sock) {
  45. Some(m) => m,
  46. None => continue,
  47. };
  48. send.send(msg).unwrap();
  49. },
  50. Err(e) => eprintln!("Problem! {:?}", e),
  51. }
  52. }
  53. });
  54. std::thread::spawn(move || {
  55. let socket = std::net::UdpSocket::bind("0.0.0.0:9992").unwrap();
  56. let mut buf = [0;1024];
  57. loop {
  58. let (amt, _) = socket.recv_from(&mut buf).unwrap();
  59. let msg = messages::Msg::from_slice(&buf[..amt]);
  60. udp_send.send(msg).unwrap();
  61. }
  62. });
  63. let mut state = State::new();
  64. while let Ok(msg) = recv.recv() {
  65. state.handle_message(msg);
  66. println!("State: {:?}", state);
  67. }
  68. }