Struct Net 

pub struct Net { /* private fields */ }

The network connection: ctx.net. See the module docs.

Implementations

impl Net

pub fn new(game: impl Into<String>) -> Self

An offline network for the game game. Only clients with the same game name can join. The engine creates this as ctx.net with the game title.

pub fn set_name(&mut self, name: impl Into<String>)

The name others see (default "Player", at most 32 characters). Set it before Net::host or Net::join.

Examples found in repository

examples/online.rs (line 66)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Changed { item, value, .. } if item == "name" => {
                self.name = value.as_str().to_string();
                ctx.storage.set("name", &self.name);
            }
            UiEvent::Changed { item, value, .. } if item == "address" => {
                self.address = value.as_str().to_string();
                ctx.storage.set("address", &self.address);
            }
            UiEvent::Activated { item, .. } => match item.as_str() {
                "host" => {
                    ctx.net.set_name(&self.name);
                    match ctx.net.host(net::DEFAULT_PORT) {
                        Ok(()) => {
                            let address = Net::local_ip().map_or("unknown".to_string(), |ip| ip.to_string());
                            ctx.speak(format!("Hosting. Your address is {address}"));
                            Self::start_game(ctx);
                        }
                        Err(e) => ctx.ui.message("error", e.to_string()),
                    }
                }
                "join" => {
                    ctx.net.set_name(&self.name);
                    ctx.net.join(&self.address);
                    ctx.speak(format!("Connecting to {}", self.address));
                }
                "quit" => ctx.quit(),
                _ => {}
            },
            _ => {}
        }
    }

pub fn set_version(&mut self, version: impl Into<String>)

The version of your game, e.g. "1.2" (default empty). Clients with another version cannot join, so old and new game code never meet. Set it before hosting or joining.

pub fn set_max_players(&mut self, max: usize)

How many clients may join (default 32). The host does not count.

pub fn host(&mut self, port: u16) -> Result<()>

Starts a WebSocket server on port that others can join. Port 0 picks a free port (see Net::port). Ends any connection that is open. Fails when the port is in use. Any URL path is accepted, so a web server can pass on wss://example.com/game.

Players outside your local network need the host’s public address, and the port must be forwarded in the host’s router.

Examples found in repository

examples/online.rs (line 67)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Changed { item, value, .. } if item == "name" => {
                self.name = value.as_str().to_string();
                ctx.storage.set("name", &self.name);
            }
            UiEvent::Changed { item, value, .. } if item == "address" => {
                self.address = value.as_str().to_string();
                ctx.storage.set("address", &self.address);
            }
            UiEvent::Activated { item, .. } => match item.as_str() {
                "host" => {
                    ctx.net.set_name(&self.name);
                    match ctx.net.host(net::DEFAULT_PORT) {
                        Ok(()) => {
                            let address = Net::local_ip().map_or("unknown".to_string(), |ip| ip.to_string());
                            ctx.speak(format!("Hosting. Your address is {address}"));
                            Self::start_game(ctx);
                        }
                        Err(e) => ctx.ui.message("error", e.to_string()),
                    }
                }
                "join" => {
                    ctx.net.set_name(&self.name);
                    ctx.net.join(&self.address);
                    ctx.speak(format!("Connecting to {}", self.address));
                }
                "quit" => ctx.quit(),
                _ => {}
            },
            _ => {}
        }
    }

pub fn join(&mut self, address: &str)

Joins the server at address: a host name or IP address, with or without port ("example.com", "192.168.1.20:7777", "[::1]:7777"), or a WebSocket URL ("ws://example.com:7777/", "wss://example.com/game"). Without a port, DEFAULT_PORT is used (URLs: 80 for ws://, 443 for wss://). Ends any connection that is open.

Returns at once. Later a NetEvent::Connected says the connection is ready, or a NetEvent::Disconnected says why it failed (after at most about 10 seconds).

Examples found in repository

examples/online.rs (line 78)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Changed { item, value, .. } if item == "name" => {
                self.name = value.as_str().to_string();
                ctx.storage.set("name", &self.name);
            }
            UiEvent::Changed { item, value, .. } if item == "address" => {
                self.address = value.as_str().to_string();
                ctx.storage.set("address", &self.address);
            }
            UiEvent::Activated { item, .. } => match item.as_str() {
                "host" => {
                    ctx.net.set_name(&self.name);
                    match ctx.net.host(net::DEFAULT_PORT) {
                        Ok(()) => {
                            let address = Net::local_ip().map_or("unknown".to_string(), |ip| ip.to_string());
                            ctx.speak(format!("Hosting. Your address is {address}"));
                            Self::start_game(ctx);
                        }
                        Err(e) => ctx.ui.message("error", e.to_string()),
                    }
                }
                "join" => {
                    ctx.net.set_name(&self.name);
                    ctx.net.join(&self.address);
                    ctx.speak(format!("Connecting to {}", self.address));
                }
                "quit" => ctx.quit(),
                _ => {}
            },
            _ => {}
        }
    }

pub fn close(&mut self)

Leaves the game, or stops the server and sends every player away with Reason::Closed. Called automatically when the game quits. Does nothing when offline. Produces no events.

Examples found in repository

examples/online.rs (line 273)

    fn update(&mut self, ctx: &mut Context) {
        let step = vec3(
            ctx.input.repeating(Key::Right, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Left, 0.25, 0.25) as i32 as f32,
            ctx.input.repeating(Key::Up, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Down, 0.25, 0.25) as i32 as f32,
            0.0,
        );
        if step != Vec3::ZERO {
            self.position = (self.position + step).clamp(Vec3::splat(-20.0), Vec3::splat(20.0));
            ctx.play("step");
            if ctx.net.is_host() {
                ctx.net.send_all(Packet::new("pos").with(PeerId::SERVER).with(self.position));
            } else {
                ctx.net.send_all(Packet::new("move").with(self.position));
            }
        }
        ctx.audio.set_listener(self.position, 0.0);

        if ctx.pressed(Key::Enter) {
            ctx.ui.input("chat", "Message");
        }
        if ctx.pressed(Key::Space) {
            let text = if self.others.is_empty() {
                "Nobody else is here".to_string()
            } else {
                let places: Vec<String> = self
                    .others
                    .values()
                    .map(|o| format!("{}: {}", o.name, ctx.lang.describe_position(self.position, 0.0, o.position)))
                    .collect();
                places.join(". ")
            };
            ctx.speak(text);
        }
        if ctx.pressed(Key::P) {
            if ctx.net.is_host() {
                ctx.speak(format!("You are the host, {} players connected", ctx.net.player_count()));
            } else {
                let ms = (ctx.net.ping(PeerId::SERVER) * 1000.0).round();
                ctx.speak(format!("Ping {ms} milliseconds"));
            }
        }
        if ctx.pressed(Key::Escape) {
            ctx.net.close();
            ctx.audio.stop_all();
            ctx.speak("You left");
            let scene = Lobby::new(ctx);
            ctx.switch_scene(scene);
        }
    }

pub fn kick(&mut self, peer: PeerId, reason: &str)

Host: sends a player away. They get Reason::Kicked with reason (may be empty). The host gets a NetEvent::Disconnected for them next frame.

pub fn send(&mut self, peer: PeerId, packet: impl Into<Packet>)

Sends a packet to one peer. On a client, the only peer is PeerId::SERVER. Does nothing if the peer is not connected.

Examples found in repository

examples/online.rs (line 153)

    fn host_events(&mut self, event: &NetEvent, ctx: &mut Context) {
        match event {
            NetEvent::Connected(id) => {
                let name = ctx.net.name(*id).to_string();
                ctx.speak(format!("{name} joined"));
                // Tell the newcomer about everybody, and everybody about the newcomer.
                ctx.net.send(*id, Packet::new("player").with(PeerId::SERVER).with(ctx.net.name(PeerId::SERVER)).with(self.position));
                for (other, o) in &self.others {
                    ctx.net.send(*id, Packet::new("player").with(*other).with(&o.name).with(o.position));
                }
                ctx.net.send_all_except(*id, Packet::new("player").with(*id).with(&name).with(Vec3::ZERO));
                self.add(ctx, *id, &name, Vec3::ZERO);
            }
            NetEvent::Message(from, packet) => match packet.kind() {
                "move" => {
                    self.moved(*from, packet.vec3(0));
                    ctx.net.send_all_except(*from, Packet::new("pos").with(*from).with(packet.vec3(0)));
                }
                "chat" => {
                    let text = packet.text(0);
                    ctx.play("chat");
                    ctx.speak(format!("{}: {text}", self.name(ctx, *from)));
                    ctx.net.send_all_except(*from, Packet::new("chat").with(*from).with(text));
                }
                _ => {}
            },
            NetEvent::Disconnected(id, _) => {
                self.remove(ctx, *id);
                ctx.net.send_all(Packet::new("gone").with(*id));
            }
        }
    }

pub fn send_all(&mut self, packet: impl Into<Packet>)

Sends a packet to every connected peer. On a client that is the server.

Examples found in repository

examples/online.rs (line 175)

    fn host_events(&mut self, event: &NetEvent, ctx: &mut Context) {
        match event {
            NetEvent::Connected(id) => {
                let name = ctx.net.name(*id).to_string();
                ctx.speak(format!("{name} joined"));
                // Tell the newcomer about everybody, and everybody about the newcomer.
                ctx.net.send(*id, Packet::new("player").with(PeerId::SERVER).with(ctx.net.name(PeerId::SERVER)).with(self.position));
                for (other, o) in &self.others {
                    ctx.net.send(*id, Packet::new("player").with(*other).with(&o.name).with(o.position));
                }
                ctx.net.send_all_except(*id, Packet::new("player").with(*id).with(&name).with(Vec3::ZERO));
                self.add(ctx, *id, &name, Vec3::ZERO);
            }
            NetEvent::Message(from, packet) => match packet.kind() {
                "move" => {
                    self.moved(*from, packet.vec3(0));
                    ctx.net.send_all_except(*from, Packet::new("pos").with(*from).with(packet.vec3(0)));
                }
                "chat" => {
                    let text = packet.text(0);
                    ctx.play("chat");
                    ctx.speak(format!("{}: {text}", self.name(ctx, *from)));
                    ctx.net.send_all_except(*from, Packet::new("chat").with(*from).with(text));
                }
                _ => {}
            },
            NetEvent::Disconnected(id, _) => {
                self.remove(ctx, *id);
                ctx.net.send_all(Packet::new("gone").with(*id));
            }
        }
    }

    /// The client's side of the protocol.
    fn client_events(&mut self, event: &NetEvent, ctx: &mut Context) {
        match event {
            NetEvent::Message(_, packet) => match packet.kind() {
                "player" => self.add(ctx, packet.peer(0), packet.text(1), packet.vec3(2)),
                "pos" => self.moved(packet.peer(0), packet.vec3(1)),
                "gone" => self.remove(ctx, packet.peer(0)),
                "chat" => {
                    ctx.play("chat");
                    ctx.speak(format!("{}: {}", self.name(ctx, packet.peer(0)), packet.text(1)));
                }
                _ => {}
            },
            NetEvent::Disconnected(_, reason) => {
                ctx.speak(ctx.lang.describe_reason(reason));
                ctx.audio.stop_all();
                let scene = Lobby::new(ctx);
                ctx.switch_scene(scene);
            }
            NetEvent::Connected(_) => {}
        }
    }
}

impl Scene for Field {
    fn start(&mut self, ctx: &mut Context) {
        ctx.speech.speak_queued("Arrows walk, Enter chats, Space finds the others, Escape leaves.");
    }

    fn on_net(&mut self, event: &NetEvent, ctx: &mut Context) {
        if ctx.net.is_host() {
            self.host_events(event, ctx);
        } else {
            self.client_events(event, ctx);
        }
    }

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        if let UiEvent::TextSubmitted { id, text } = event
            && id == "chat"
        {
            // The host sends to everybody, a client sends to the host, who passes it on.
            if ctx.net.is_host() {
                ctx.net.send_all(Packet::new("chat").with(PeerId::SERVER).with(text));
            } else {
                ctx.net.send_all(Packet::new("chat").with(text));
            }
            ctx.play("chat");
        }
    }

    fn update(&mut self, ctx: &mut Context) {
        let step = vec3(
            ctx.input.repeating(Key::Right, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Left, 0.25, 0.25) as i32 as f32,
            ctx.input.repeating(Key::Up, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Down, 0.25, 0.25) as i32 as f32,
            0.0,
        );
        if step != Vec3::ZERO {
            self.position = (self.position + step).clamp(Vec3::splat(-20.0), Vec3::splat(20.0));
            ctx.play("step");
            if ctx.net.is_host() {
                ctx.net.send_all(Packet::new("pos").with(PeerId::SERVER).with(self.position));
            } else {
                ctx.net.send_all(Packet::new("move").with(self.position));
            }
        }
        ctx.audio.set_listener(self.position, 0.0);

        if ctx.pressed(Key::Enter) {
            ctx.ui.input("chat", "Message");
        }
        if ctx.pressed(Key::Space) {
            let text = if self.others.is_empty() {
                "Nobody else is here".to_string()
            } else {
                let places: Vec<String> = self
                    .others
                    .values()
                    .map(|o| format!("{}: {}", o.name, ctx.lang.describe_position(self.position, 0.0, o.position)))
                    .collect();
                places.join(". ")
            };
            ctx.speak(text);
        }
        if ctx.pressed(Key::P) {
            if ctx.net.is_host() {
                ctx.speak(format!("You are the host, {} players connected", ctx.net.player_count()));
            } else {
                let ms = (ctx.net.ping(PeerId::SERVER) * 1000.0).round();
                ctx.speak(format!("Ping {ms} milliseconds"));
            }
        }
        if ctx.pressed(Key::Escape) {
            ctx.net.close();
            ctx.audio.stop_all();
            ctx.speak("You left");
            let scene = Lobby::new(ctx);
            ctx.switch_scene(scene);
        }
    }

pub fn send_all_except(&mut self, except: PeerId, packet: impl Into<Packet>)

Sends a packet to every connected peer except one. The usual way for a host to pass on what one player did to everybody else.

Examples found in repository

examples/online.rs (line 157)

    fn host_events(&mut self, event: &NetEvent, ctx: &mut Context) {
        match event {
            NetEvent::Connected(id) => {
                let name = ctx.net.name(*id).to_string();
                ctx.speak(format!("{name} joined"));
                // Tell the newcomer about everybody, and everybody about the newcomer.
                ctx.net.send(*id, Packet::new("player").with(PeerId::SERVER).with(ctx.net.name(PeerId::SERVER)).with(self.position));
                for (other, o) in &self.others {
                    ctx.net.send(*id, Packet::new("player").with(*other).with(&o.name).with(o.position));
                }
                ctx.net.send_all_except(*id, Packet::new("player").with(*id).with(&name).with(Vec3::ZERO));
                self.add(ctx, *id, &name, Vec3::ZERO);
            }
            NetEvent::Message(from, packet) => match packet.kind() {
                "move" => {
                    self.moved(*from, packet.vec3(0));
                    ctx.net.send_all_except(*from, Packet::new("pos").with(*from).with(packet.vec3(0)));
                }
                "chat" => {
                    let text = packet.text(0);
                    ctx.play("chat");
                    ctx.speak(format!("{}: {text}", self.name(ctx, *from)));
                    ctx.net.send_all_except(*from, Packet::new("chat").with(*from).with(text));
                }
                _ => {}
            },
            NetEvent::Disconnected(id, _) => {
                self.remove(ctx, *id);
                ctx.net.send_all(Packet::new("gone").with(*id));
            }
        }
    }

pub fn events(&self) -> &[NetEvent]

Everything that happened on the network this frame, in order.

pub fn joined(&self) -> Vec<PeerId>

Players who connected this frame. On a client: PeerId::SERVER when the connection became ready.

pub fn left(&self) -> Vec<(PeerId, Reason)>

Players who left this frame and why. On a client: PeerId::SERVER when the connection ended or could not be made.

pub fn messages(&self) -> Vec<(PeerId, Packet)>

All packets that arrived this frame, with their sender.

pub fn received(&self, kind: &str) -> Vec<(PeerId, Packet)>

The packets of one kind that arrived this frame, with their sender.

pub fn players(&self) -> Vec<PeerId>

The connected peers in the order they joined. Host: all clients. Client: the server, once connected.

pub fn player_count(&self) -> usize

Number of connected peers (the host does not count itself).

Examples found in repository

examples/online.rs (line 266)

    fn update(&mut self, ctx: &mut Context) {
        let step = vec3(
            ctx.input.repeating(Key::Right, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Left, 0.25, 0.25) as i32 as f32,
            ctx.input.repeating(Key::Up, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Down, 0.25, 0.25) as i32 as f32,
            0.0,
        );
        if step != Vec3::ZERO {
            self.position = (self.position + step).clamp(Vec3::splat(-20.0), Vec3::splat(20.0));
            ctx.play("step");
            if ctx.net.is_host() {
                ctx.net.send_all(Packet::new("pos").with(PeerId::SERVER).with(self.position));
            } else {
                ctx.net.send_all(Packet::new("move").with(self.position));
            }
        }
        ctx.audio.set_listener(self.position, 0.0);

        if ctx.pressed(Key::Enter) {
            ctx.ui.input("chat", "Message");
        }
        if ctx.pressed(Key::Space) {
            let text = if self.others.is_empty() {
                "Nobody else is here".to_string()
            } else {
                let places: Vec<String> = self
                    .others
                    .values()
                    .map(|o| format!("{}: {}", o.name, ctx.lang.describe_position(self.position, 0.0, o.position)))
                    .collect();
                places.join(". ")
            };
            ctx.speak(text);
        }
        if ctx.pressed(Key::P) {
            if ctx.net.is_host() {
                ctx.speak(format!("You are the host, {} players connected", ctx.net.player_count()));
            } else {
                let ms = (ctx.net.ping(PeerId::SERVER) * 1000.0).round();
                ctx.speak(format!("Ping {ms} milliseconds"));
            }
        }
        if ctx.pressed(Key::Escape) {
            ctx.net.close();
            ctx.audio.stop_all();
            ctx.speak("You left");
            let scene = Lobby::new(ctx);
            ctx.switch_scene(scene);
        }
    }

pub fn is_connected_to(&self, peer: PeerId) -> bool

Whether peer is connected right now.

pub fn name(&self, peer: PeerId) -> &str

The name a peer chose with Net::set_name, or "" if not connected. Your own Net::id gives your own name.

Examples found in repository

examples/online.rs (line 141)

    fn name(&self, ctx: &Context, id: PeerId) -> String {
        if id == ctx.net.id() {
            return ctx.net.name(id).to_string();
        }
        self.others.get(&id).map_or("Someone".to_string(), |o| o.name.clone())
    }

    /// The host's side of the protocol.
    fn host_events(&mut self, event: &NetEvent, ctx: &mut Context) {
        match event {
            NetEvent::Connected(id) => {
                let name = ctx.net.name(*id).to_string();
                ctx.speak(format!("{name} joined"));
                // Tell the newcomer about everybody, and everybody about the newcomer.
                ctx.net.send(*id, Packet::new("player").with(PeerId::SERVER).with(ctx.net.name(PeerId::SERVER)).with(self.position));
                for (other, o) in &self.others {
                    ctx.net.send(*id, Packet::new("player").with(*other).with(&o.name).with(o.position));
                }
                ctx.net.send_all_except(*id, Packet::new("player").with(*id).with(&name).with(Vec3::ZERO));
                self.add(ctx, *id, &name, Vec3::ZERO);
            }
            NetEvent::Message(from, packet) => match packet.kind() {
                "move" => {
                    self.moved(*from, packet.vec3(0));
                    ctx.net.send_all_except(*from, Packet::new("pos").with(*from).with(packet.vec3(0)));
                }
                "chat" => {
                    let text = packet.text(0);
                    ctx.play("chat");
                    ctx.speak(format!("{}: {text}", self.name(ctx, *from)));
                    ctx.net.send_all_except(*from, Packet::new("chat").with(*from).with(text));
                }
                _ => {}
            },
            NetEvent::Disconnected(id, _) => {
                self.remove(ctx, *id);
                ctx.net.send_all(Packet::new("gone").with(*id));
            }
        }
    }

pub fn ping(&self, peer: PeerId) -> f32

The round trip time to a peer in seconds: how long a message takes there and back. Updated every second; 0.0 until measured or when not connected.

Examples found in repository

examples/online.rs (line 268)

    fn update(&mut self, ctx: &mut Context) {
        let step = vec3(
            ctx.input.repeating(Key::Right, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Left, 0.25, 0.25) as i32 as f32,
            ctx.input.repeating(Key::Up, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Down, 0.25, 0.25) as i32 as f32,
            0.0,
        );
        if step != Vec3::ZERO {
            self.position = (self.position + step).clamp(Vec3::splat(-20.0), Vec3::splat(20.0));
            ctx.play("step");
            if ctx.net.is_host() {
                ctx.net.send_all(Packet::new("pos").with(PeerId::SERVER).with(self.position));
            } else {
                ctx.net.send_all(Packet::new("move").with(self.position));
            }
        }
        ctx.audio.set_listener(self.position, 0.0);

        if ctx.pressed(Key::Enter) {
            ctx.ui.input("chat", "Message");
        }
        if ctx.pressed(Key::Space) {
            let text = if self.others.is_empty() {
                "Nobody else is here".to_string()
            } else {
                let places: Vec<String> = self
                    .others
                    .values()
                    .map(|o| format!("{}: {}", o.name, ctx.lang.describe_position(self.position, 0.0, o.position)))
                    .collect();
                places.join(". ")
            };
            ctx.speak(text);
        }
        if ctx.pressed(Key::P) {
            if ctx.net.is_host() {
                ctx.speak(format!("You are the host, {} players connected", ctx.net.player_count()));
            } else {
                let ms = (ctx.net.ping(PeerId::SERVER) * 1000.0).round();
                ctx.speak(format!("Ping {ms} milliseconds"));
            }
        }
        if ctx.pressed(Key::Escape) {
            ctx.net.close();
            ctx.audio.stop_all();
            ctx.speak("You left");
            let scene = Lobby::new(ctx);
            ctx.switch_scene(scene);
        }
    }

pub fn id(&self) -> PeerId

Your own id: PeerId::SERVER for the host, the number the server gave you on a client.

Examples found in repository

examples/online.rs (line 140)

    fn name(&self, ctx: &Context, id: PeerId) -> String {
        if id == ctx.net.id() {
            return ctx.net.name(id).to_string();
        }
        self.others.get(&id).map_or("Someone".to_string(), |o| o.name.clone())
    }

pub fn is_host(&self) -> bool

Whether this game is hosting.

Examples found in repository

examples/online.rs (line 210)

    fn on_net(&mut self, event: &NetEvent, ctx: &mut Context) {
        if ctx.net.is_host() {
            self.host_events(event, ctx);
        } else {
            self.client_events(event, ctx);
        }
    }

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        if let UiEvent::TextSubmitted { id, text } = event
            && id == "chat"
        {
            // The host sends to everybody, a client sends to the host, who passes it on.
            if ctx.net.is_host() {
                ctx.net.send_all(Packet::new("chat").with(PeerId::SERVER).with(text));
            } else {
                ctx.net.send_all(Packet::new("chat").with(text));
            }
            ctx.play("chat");
        }
    }

    fn update(&mut self, ctx: &mut Context) {
        let step = vec3(
            ctx.input.repeating(Key::Right, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Left, 0.25, 0.25) as i32 as f32,
            ctx.input.repeating(Key::Up, 0.25, 0.25) as i32 as f32 - ctx.input.repeating(Key::Down, 0.25, 0.25) as i32 as f32,
            0.0,
        );
        if step != Vec3::ZERO {
            self.position = (self.position + step).clamp(Vec3::splat(-20.0), Vec3::splat(20.0));
            ctx.play("step");
            if ctx.net.is_host() {
                ctx.net.send_all(Packet::new("pos").with(PeerId::SERVER).with(self.position));
            } else {
                ctx.net.send_all(Packet::new("move").with(self.position));
            }
        }
        ctx.audio.set_listener(self.position, 0.0);

        if ctx.pressed(Key::Enter) {
            ctx.ui.input("chat", "Message");
        }
        if ctx.pressed(Key::Space) {
            let text = if self.others.is_empty() {
                "Nobody else is here".to_string()
            } else {
                let places: Vec<String> = self
                    .others
                    .values()
                    .map(|o| format!("{}: {}", o.name, ctx.lang.describe_position(self.position, 0.0, o.position)))
                    .collect();
                places.join(". ")
            };
            ctx.speak(text);
        }
        if ctx.pressed(Key::P) {
            if ctx.net.is_host() {
                ctx.speak(format!("You are the host, {} players connected", ctx.net.player_count()));
            } else {
                let ms = (ctx.net.ping(PeerId::SERVER) * 1000.0).round();
                ctx.speak(format!("Ping {ms} milliseconds"));
            }
        }
        if ctx.pressed(Key::Escape) {
            ctx.net.close();
            ctx.audio.stop_all();
            ctx.speak("You left");
            let scene = Lobby::new(ctx);
            ctx.switch_scene(scene);
        }
    }

pub fn is_client(&self) -> bool

Whether this game is a client that is connected to a server.

pub fn is_joining(&self) -> bool

Whether a Net::join is still in progress.

pub fn is_online(&self) -> bool

Whether this game is hosting or connected to a server.

pub fn port(&self) -> Option<u16>

The port the server listens on while hosting.

pub fn local_ip() -> Option<IpAddr>

This computer’s address in the local network, e.g. 192.168.1.20: what players in the same network type to join. None without a network. Sends nothing.

Examples found in repository

examples/online.rs (line 69)

    fn on_ui(&mut self, event: &UiEvent, ctx: &mut Context) {
        match event {
            UiEvent::Changed { item, value, .. } if item == "name" => {
                self.name = value.as_str().to_string();
                ctx.storage.set("name", &self.name);
            }
            UiEvent::Changed { item, value, .. } if item == "address" => {
                self.address = value.as_str().to_string();
                ctx.storage.set("address", &self.address);
            }
            UiEvent::Activated { item, .. } => match item.as_str() {
                "host" => {
                    ctx.net.set_name(&self.name);
                    match ctx.net.host(net::DEFAULT_PORT) {
                        Ok(()) => {
                            let address = Net::local_ip().map_or("unknown".to_string(), |ip| ip.to_string());
                            ctx.speak(format!("Hosting. Your address is {address}"));
                            Self::start_game(ctx);
                        }
                        Err(e) => ctx.ui.message("error", e.to_string()),
                    }
                }
                "join" => {
                    ctx.net.set_name(&self.name);
                    ctx.net.join(&self.address);
                    ctx.speak(format!("Connecting to {}", self.address));
                }
                "quit" => ctx.quit(),
                _ => {}
            },
            _ => {}
        }
    }

Trait Implementations

impl Debug for Net

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for Net

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.