126 lines
3.0 KiB
Rust
126 lines
3.0 KiB
Rust
use std::{
|
|
sync::Arc,
|
|
};
|
|
|
|
use futures::StreamExt;
|
|
use tokio::sync::Mutex;
|
|
|
|
use opengl_rust::{
|
|
network_protocol::*,
|
|
quinn_common::make_server_endpoint,
|
|
};
|
|
|
|
#[tokio::main]
|
|
async fn main () -> anyhow::Result <()> {
|
|
let server_addr = "127.0.0.1:5000".parse().unwrap();
|
|
let (mut incoming, server_cert) = make_server_endpoint(server_addr)?;
|
|
|
|
let state = NetworkedState {
|
|
positions: vec! [
|
|
(32.0, 32.0),
|
|
],
|
|
};
|
|
let state = Arc::new (Mutex::new (state));
|
|
// let connected_players = Arc::new (Mutex::new (vec! []));
|
|
|
|
// accept a single connection
|
|
let server_task = tokio::spawn (async move {
|
|
use opengl_rust::timestep::TimeStep;
|
|
|
|
let incoming_conn = incoming.next().await.unwrap();
|
|
let new_conn = incoming_conn.await.unwrap();
|
|
println!(
|
|
"[server] connection accepted: addr={}",
|
|
new_conn.connection.remote_address()
|
|
);
|
|
|
|
let quinn::NewConnection {
|
|
connection,
|
|
mut datagrams,
|
|
..
|
|
} = new_conn;
|
|
|
|
let mut i = 0_u64;
|
|
|
|
let cmd = Arc::new (Mutex::new (NetworkCommand::default ()));
|
|
let cmd_2 = Arc::clone (&cmd);
|
|
|
|
// Read player commands
|
|
tokio::spawn (async move {
|
|
while let Some (Ok (datagram)) = datagrams.next ().await {
|
|
let cmd: NetworkCommand = rmp_serde::from_slice (&datagram)?;
|
|
let mut guard = cmd_2.lock ().await;
|
|
*guard = cmd;
|
|
}
|
|
|
|
Ok::<_, anyhow::Error> (())
|
|
});
|
|
|
|
let mut time_step = TimeStep::new (120, 1000);
|
|
let mut state = NetworkedState {
|
|
positions: vec! [
|
|
(32.0, 32.0),
|
|
],
|
|
};
|
|
|
|
loop {
|
|
let cmd = {
|
|
let guard = cmd.lock ().await;
|
|
guard.clone ()
|
|
};
|
|
let frames_to_do = time_step.step ();
|
|
for _ in 0..frames_to_do {
|
|
let speed = 0.25;
|
|
if cmd.left {
|
|
state.positions [0].0 -= speed;
|
|
}
|
|
if cmd.right {
|
|
state.positions [0].0 += speed;
|
|
}
|
|
if cmd.up {
|
|
state.positions [0].1 += speed;
|
|
}
|
|
if cmd.down {
|
|
state.positions [0].1 -= speed;
|
|
}
|
|
}
|
|
|
|
let bytes = rmp_serde::to_vec (&state)?;
|
|
connection.send_datagram (bytes.into ())?;
|
|
|
|
i += 1;
|
|
tokio::time::sleep (std::time::Duration::from_millis(16)).await;
|
|
}
|
|
|
|
// Dropping all handles associated with a connection implicitly closes it
|
|
Ok::<_, anyhow::Error> (())
|
|
});
|
|
|
|
tokio::fs::write ("quic_server.crt", &server_cert).await?;
|
|
|
|
/*
|
|
let endpoint = make_client_endpoint("0.0.0.0:0".parse().unwrap(), &[&server_cert])?;
|
|
// connect to server
|
|
let quinn::NewConnection {
|
|
connection,
|
|
mut uni_streams,
|
|
..
|
|
} = endpoint
|
|
.connect(&server_addr, "localhost")
|
|
.unwrap()
|
|
.await
|
|
.unwrap();
|
|
println!("[client] connected: addr={}", connection.remote_address());
|
|
|
|
// Waiting for a stream will complete with an error when the server closes the connection
|
|
let _ = uni_streams.next().await;
|
|
|
|
// Give the server has a chance to clean up
|
|
endpoint.wait_idle().await;
|
|
*/
|
|
|
|
server_task.await??;
|
|
|
|
Ok(())
|
|
}
|