Struct NetResource 

pub struct NetResource { /* private fields */ }

Bevy resource that owns the networking transport and packet queues.

Implementations

impl NetResource

pub fn new() -> Self

Creates an empty networking resource.

pub fn is_server(&self) -> bool

Returns true when the resource is currently running as server.

pub fn join_server(&mut self, server_address: String)

Connects to a server and binds packet handlers to the new socket.

Examples found in repository

examples/messages_demo.rs (line 110)

fn setup(mut net: ResMut<NetResource>, mode: Res<DemoMode>) {
    match mode.0 {
        Mode::Server => {
            net.start_server(5002);
            println!("server listening on {ADDRESS}");
        }
        Mode::Client => {
            net.join_server(ADDRESS.to_string());
            println!("client connected to {ADDRESS}");
        }
    }
}

examples/replication_demo.rs (line 67)

fn setup(mut commands: Commands, mut net: ResMut<NetResource>, mode: Res<DemoMode>) {
    match mode.0 {
        Mode::Server => {
            net.start_server(5001);
            println!("server listening on {ADDRESS}");
            commands.spawn((
                Replicated,
                Position(Vec2::ZERO),
                Health(100),
            ));
        }
        Mode::Client => {
            net.join_server(ADDRESS.to_string());
            println!("client connected to {ADDRESS}");
        }
    }
}

examples/cubes_demo.rs (line 89)

fn setup(mut commands: Commands, mut net: ResMut<NetResource>, mode: Res<DemoMode>) {
    match mode.0 {
        Mode::Server => {
            net.start_server(5003);
            println!("server listening on {ADDRESS}");

            for index in 0..5 {
                commands.spawn((
                    Replicated,
                    Position(Vec2::new(index as f32 * 80.0 - 160.0, 0.0)),
                    Velocity(Vec2::new(
                        70.0 + index as f32 * 15.0,
                        40.0 + index as f32 * 10.0,
                    )),
                ));
            }
        }
        Mode::Client => {
            net.join_server(ADDRESS.to_string());
            println!("client connected to {ADDRESS}");
        }
    }
}

pub fn start_server(&mut self, port: u16)

Starts the server and installs the connection callback.

Examples found in repository

examples/messages_demo.rs (line 106)

fn setup(mut net: ResMut<NetResource>, mode: Res<DemoMode>) {
    match mode.0 {
        Mode::Server => {
            net.start_server(5002);
            println!("server listening on {ADDRESS}");
        }
        Mode::Client => {
            net.join_server(ADDRESS.to_string());
            println!("client connected to {ADDRESS}");
        }
    }
}

examples/replication_demo.rs (line 58)

fn setup(mut commands: Commands, mut net: ResMut<NetResource>, mode: Res<DemoMode>) {
    match mode.0 {
        Mode::Server => {
            net.start_server(5001);
            println!("server listening on {ADDRESS}");
            commands.spawn((
                Replicated,
                Position(Vec2::ZERO),
                Health(100),
            ));
        }
        Mode::Client => {
            net.join_server(ADDRESS.to_string());
            println!("client connected to {ADDRESS}");
        }
    }
}

examples/cubes_demo.rs (line 74)

fn setup(mut commands: Commands, mut net: ResMut<NetResource>, mode: Res<DemoMode>) {
    match mode.0 {
        Mode::Server => {
            net.start_server(5003);
            println!("server listening on {ADDRESS}");

            for index in 0..5 {
                commands.spawn((
                    Replicated,
                    Position(Vec2::new(index as f32 * 80.0 - 160.0, 0.0)),
                    Velocity(Vec2::new(
                        70.0 + index as f32 * 15.0,
                        40.0 + index as f32 * 10.0,
                    )),
                ));
            }
        }
        Mode::Client => {
            net.join_server(ADDRESS.to_string());
            println!("client connected to {ADDRESS}");
        }
    }
}

pub fn queue_packet(&mut self, packet: ReplicationPacket)

Adds a replication packet to the outgoing queue.

pub fn send_packet_to(&self, socket: &Socket, packet: ReplicationPacket)

Sends a replication packet immediately to one socket.

pub fn inject_packet(&mut self, packet: ReplicationPacket)

Injects a packet directly into the incoming queue.

pub fn queue_message<T: NetMessage>(&mut self, message: T)

Queues a typed network message for broadcast.

Examples found in repository

examples/messages_demo.rs (lines 126-128)

fn server_handle_messages(
    mut commands: Commands,
    mut net: ResMut<NetResource>,
) {
    for chat in net.drain_messages::<ChatSend>() {
        println!("chat: {}", chat.text);
        net.queue_message(ChatBroadcast {
            text: format!("server heard: {}", chat.text),
        });
    }

    for shot in net.drain_messages::<ShootProjectile>() {
        println!("shoot request from client: {:?} -> {:?}", shot.origin, shot.direction);
        commands.spawn((
            Replicated,
            Projectile,
            Position(shot.origin),
            Velocity(shot.direction.normalize_or_zero() * 150.0),
        ));
    }
}

fn server_move_projectiles(
    time: Res<Time>,
    mut query: Query<(&mut Position, &Velocity), With<Projectile>>,
) {
    for (mut position, velocity) in &mut query {
        position.0 += velocity.0 * time.delta_secs();
    }
}

fn client_send_messages(
    time: Res<Time>,
    mut tick: Local<f32>,
    mut net: ResMut<NetResource>,
) {
    *tick += time.delta_secs();
    if *tick < 1.0 {
        return;
    }
    *tick = 0.0;

    net.queue_message(ChatSend {
        text: "hello from client".to_string(),
    });
    net.queue_message(ShootProjectile {
        origin: Vec2::new(0.0, 0.0),
        direction: Vec2::new(1.0, 0.2),
    });
}

pub fn drain_outbox(&mut self) -> Vec<ReplicationPacket>

Drains all queued outgoing replication packets.

pub fn drain_inbox(&mut self) -> Vec<ReplicationPacket>

Drains all received replication packets.

pub fn drain_new_connections(&mut self) -> Vec<Socket>

Drains sockets that connected since the last snapshot broadcast.

pub fn drain_message_inbox(&mut self) -> Vec<RawNetMessage>

Drains raw messages regardless of wire type.

pub fn drain_messages<T: NetMessage>(&mut self) -> Vec<T>

Extracts only messages of type T, leaving the rest queued.

Examples found in repository

examples/messages_demo.rs (line 124)

fn server_handle_messages(
    mut commands: Commands,
    mut net: ResMut<NetResource>,
) {
    for chat in net.drain_messages::<ChatSend>() {
        println!("chat: {}", chat.text);
        net.queue_message(ChatBroadcast {
            text: format!("server heard: {}", chat.text),
        });
    }

    for shot in net.drain_messages::<ShootProjectile>() {
        println!("shoot request from client: {:?} -> {:?}", shot.origin, shot.direction);
        commands.spawn((
            Replicated,
            Projectile,
            Position(shot.origin),
            Velocity(shot.direction.normalize_or_zero() * 150.0),
        ));
    }
}

fn server_move_projectiles(
    time: Res<Time>,
    mut query: Query<(&mut Position, &Velocity), With<Projectile>>,
) {
    for (mut position, velocity) in &mut query {
        position.0 += velocity.0 * time.delta_secs();
    }
}

fn client_send_messages(
    time: Res<Time>,
    mut tick: Local<f32>,
    mut net: ResMut<NetResource>,
) {
    *tick += time.delta_secs();
    if *tick < 1.0 {
        return;
    }
    *tick = 0.0;

    net.queue_message(ChatSend {
        text: "hello from client".to_string(),
    });
    net.queue_message(ShootProjectile {
        origin: Vec2::new(0.0, 0.0),
        direction: Vec2::new(1.0, 0.2),
    });
}

fn client_print_broadcasts(mut net: ResMut<NetResource>) {
    for chat in net.drain_messages::<ChatBroadcast>() {
        println!("broadcast: {}", chat.text);
    }
}

pub fn flush_outbox(&mut self)

Serializes and flushes all queued packets to connected clients.

pub fn poll_incoming(&mut self)

Placeholder hook for future socket polling implementations.

Trait Implementations

impl Default for NetResource

fn default() -> NetResource

Returns the “default value” for a type.

impl Resource for NetResource

where Self: Send + Sync + 'static,