Struct NetcodeInterface 

pub struct NetcodeInterface<const SIZE: usize> { /* private fields */ }

The interface for netcode.

Runs Tokio and iroh under the hood in a separate thread. So, methods must be called from the context of a Tokio runtime. The procedure for operation is as follows.

A new NetcodeInterface should be created on the two players’ machines. The first, the “server,” must provide a oneshot sender that receives a newly generated ticket. The second, the “client,” must provide a ticket string from that server.

The server moves second and the client moves first.

If it is the user’s turn, they may:

• send_turn once
• it will no longer be the user’s turn

If it is not the user’s turn, they may:

• try_recv_turn repeatedly
• if it returns Ok, it will be the user’s turn.

Turns are represented as byte buffers of a constant size. Both players’ buffer sizes must be the same.

Deviations from this procedure are undefined behavior.

Implementations

impl<const SIZE: usize> NetcodeInterface<SIZE>

pub fn new(config: Config) -> Self

Create a new interface.

See the struct’s docs for invariants.

Examples found in repository

examples/ping_echo.rs (line 60)

async fn main() -> Result<(), String> {
    if is_client()? {
        // create a send side & send a ping
        let mut netcode = NetcodeInterface::new(Config::Ticket(ticket()?));
        netcode.send_turn(b"ping");
        println!("Client sent ping");

        assert_eq!(
            b"pong",
            &wait_for(NetcodeInterface::try_recv_turn, &mut netcode).await
        );
        println!("Client recieved pong");

        let mut counter = 0;

        loop {
            let bytes = [0, 0, 0, counter];
            netcode.send_turn(&bytes);
            println!("Client sent {bytes:?}");

            assert_eq!(
                &bytes,
                &wait_for(NetcodeInterface::try_recv_turn, &mut netcode).await
            );
            println!("Client got {bytes:?} back");

            counter += 1;
        }
    } else {
        // create the receive side
        let (send, recv) = oneshot::channel();
        let mut netcode = NetcodeInterface::new(Config::TicketSender(send));

        println!(
            "hosting ping_echo. another player may join with \n\n\
            cargo run --example ping_echo client --ticket={}",
            recv.await.unwrap()
        );

        assert_eq!(
            b"ping",
            &wait_for(NetcodeInterface::try_recv_turn, &mut netcode).await
        );
        println!("Server received ping");

        netcode.send_turn(b"pong");
        println!("Server sent pong");

        loop {
            let bytes = wait_for(NetcodeInterface::try_recv_turn, &mut netcode).await;
            println!("Server received: {:?}", &bytes);

            netcode.send_turn(&bytes);
            println!("Server echoed");

            sleep(Duration::from_secs(1)).await;
        }
    }
}

pub fn send_turn(&mut self, turn: &[u8; SIZE])

Send a turn to the other player.

See the struct’s docs for invariants.

Examples found in repository

examples/ping_echo.rs (line 61)

async fn main() -> Result<(), String> {
    if is_client()? {
        // create a send side & send a ping
        let mut netcode = NetcodeInterface::new(Config::Ticket(ticket()?));
        netcode.send_turn(b"ping");
        println!("Client sent ping");

        assert_eq!(
            b"pong",
            &wait_for(NetcodeInterface::try_recv_turn, &mut netcode).await
        );
        println!("Client recieved pong");

        let mut counter = 0;

        loop {
            let bytes = [0, 0, 0, counter];
            netcode.send_turn(&bytes);
            println!("Client sent {bytes:?}");

            assert_eq!(
                &bytes,
                &wait_for(NetcodeInterface::try_recv_turn, &mut netcode).await
            );
            println!("Client got {bytes:?} back");

            counter += 1;
        }
    } else {
        // create the receive side
        let (send, recv) = oneshot::channel();
        let mut netcode = NetcodeInterface::new(Config::TicketSender(send));

        println!(
            "hosting ping_echo. another player may join with \n\n\
            cargo run --example ping_echo client --ticket={}",
            recv.await.unwrap()
        );

        assert_eq!(
            b"ping",
            &wait_for(NetcodeInterface::try_recv_turn, &mut netcode).await
        );
        println!("Server received ping");

        netcode.send_turn(b"pong");
        println!("Server sent pong");

        loop {
            let bytes = wait_for(NetcodeInterface::try_recv_turn, &mut netcode).await;
            println!("Server received: {:?}", &bytes);

            netcode.send_turn(&bytes);
            println!("Server echoed");

            sleep(Duration::from_secs(1)).await;
        }
    }
}

pub fn try_recv_turn(&mut self) -> Result<[u8; SIZE], ()>

Check if the other player has sent a turn to the user.

See the struct’s docs for invariants.

pub fn my_turn(&self) -> bool

Return whether it is the user’s turn.