added client networking structs to the foundation crate

foundation/src/client/mod.rs

@@ -0,0 +1,18 @@
+use tokio::task::JoinHandle;
+
+use crate::network::{
+	network_connection::NetworkConnection,
+	server_writer_connection::ServerWriterConnection,
+};
+
+pub mod network_connection;
+pub mod server_reader_connection;
+pub mod server_writer_connection;
+
+pub enum NetworkState {
+	Disconnected,
+	Connection {
+		reader_handle: JoinHandle<()>,
+		writer: ServerWriterConnection,
+	},
+}

foundation/src/client/network_connection.rs

@@ -0,0 +1,130 @@
+use std::{io, net::SocketAddr};
+
+use foundation::{
+	networking::{read_message, write_message},
+	prelude::{
+		network_server_message,
+		Connect,
+		GetInfo,
+		Info,
+		NetworkClientMessage,
+		NetworkServerMessage,
+		Request,
+	},
+};
+use tokio::{io::split, net::TcpStream};
+use uuid::Uuid;
+
+use crate::network::{
+	server_reader_connection::ServerReaderConnection,
+	server_writer_connection::ServerWriterConnection,
+};
+
+/// # NetworkConnection
+/// encapsulates the state of the network connection
+/// will connect to a server and ensure it is usinghte protobuf protocol
+///
+/// you can then either get info or connect to the server
+pub struct NetworkConnection {
+	pub(super) stream: TcpStream,
+}
+
+impl NetworkConnection {
+	pub async fn connect(address: SocketAddr) -> io::Result<Self> {
+		let mut stream = TcpStream::connect(address).await.unwrap();
+
+		let msg =
+			read_message::<NetworkServerMessage, TcpStream>(&mut stream).await?;
+
+		let NetworkServerMessage {
+			message: Some(network_server_message::Message::Request(Request {})),
+		} = msg
+		else {
+			return Err(io::Error::new(
+				io::ErrorKind::InvalidData,
+				"Received invalid start message from server",
+			));
+		};
+
+		Ok(Self { stream })
+	}
+
+	/// Will consume the connection, and fetch the servers info.
+	pub async fn send_get_info(mut self) -> io::Result<Info> {
+		_ = write_message(
+			&mut self.stream,
+			NetworkClientMessage {
+				message: Some(
+					foundation::prelude::network_client_message::Message::GetInfo(
+						GetInfo {},
+					),
+				),
+			},
+		)
+		.await;
+
+		let message =
+			read_message::<NetworkServerMessage, TcpStream>(&mut self.stream).await?;
+
+		let NetworkServerMessage {
+			message: Some(network_server_message::Message::GotInfo(msg)),
+		} = message
+		else {
+			return Err(io::Error::new(
+				io::ErrorKind::InvalidData,
+				"sent for info got different message back",
+			));
+		};
+
+		Ok(msg)
+	}
+
+	/// consumes this struct and returns a tuple of the sernding and receiving ahlfs of teh connected conneciton
+	pub async fn send_connect(
+		mut self,
+		uuid: Uuid,
+		username: String,
+	) -> io::Result<(ServerWriterConnection, ServerReaderConnection)> {
+		_ = write_message(
+			&mut self.stream,
+			NetworkClientMessage {
+				message: Some(
+					foundation::prelude::network_client_message::Message::Connect(
+						Connect {
+							username,
+							uuid: uuid.to_string(),
+						},
+					),
+				),
+			},
+		)
+		.await;
+
+		let message =
+			read_message::<NetworkServerMessage, TcpStream>(&mut self.stream).await?;
+
+		let NetworkServerMessage {
+			message: Some(network_server_message::Message::Connected(_)),
+		} = message
+		else {
+			return Err(io::Error::new(
+				io::ErrorKind::InvalidData,
+				"sent connect got different message back or failed to connect",
+			));
+		};
+
+		Ok(self.into())
+	}
+}
+
+impl From<NetworkConnection>
+	for (ServerWriterConnection, ServerReaderConnection)
+{
+	fn from(value: NetworkConnection) -> Self {
+		let (read_half, write_half) = split(value.stream);
+		(
+			ServerWriterConnection::new(write_half),
+			ServerReaderConnection::new(read_half),
+		)
+	}
+}

foundation/src/client/server_reader_connection.rs

@@ -0,0 +1,24 @@
+use std::io;
+
+use foundation::{networking::read_message, prelude::ConnectedServerMessage};
+use tokio::{io::ReadHalf, net::TcpStream};
+
+pub struct ServerReaderConnection {
+	reader: ReadHalf<TcpStream>,
+}
+
+impl ServerReaderConnection {
+	pub(crate) fn new(read_half: ReadHalf<TcpStream>) -> Self {
+		Self { reader: read_half }
+	}
+
+	// move to other one
+	pub async fn get_message(&mut self) -> io::Result<ConnectedServerMessage> {
+		let message = read_message::<ConnectedServerMessage, ReadHalf<TcpStream>>(
+			&mut self.reader,
+		)
+		.await
+		.unwrap();
+		Ok(message)
+	}
+}

foundation/src/client/server_writer_connection.rs

@@ -0,0 +1,13 @@
+use tokio::{io::WriteHalf, net::TcpStream};
+
+pub struct ServerWriterConnection {
+	writer: WriteHalf<TcpStream>,
+}
+
+impl ServerWriterConnection {
+	pub(crate) fn new(writer: WriteHalf<TcpStream>) -> Self {
+		Self { writer }
+	}
+
+	pub async fn request_clients(&mut self) {}
+}