Struct Packet 

pub struct Packet { /* private fields */ }

One message between players: a kind (what it is about) and a list of values.

use audio_code::prelude::*;

let packet = Packet::new("move").with(vec3(3.0, 4.0, 0.0)).with(90.0).with("running");
assert_eq!(packet.kind(), "move");
assert_eq!(packet.vec3(0), vec3(3.0, 4.0, 0.0));
assert_eq!(packet.float(1), 90.0);
assert_eq!(packet.text(2), "running");
// Missing or other values give a neutral result instead of a crash:
assert_eq!(packet.int(7), 0);

Text converts into a packet without values, so ctx.net.send_all("ready") works.

Implementations

impl Packet

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

A packet of the given kind without values.

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));
            }
        }
    }

    /// 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 with(self, value: impl Into<Arg>) -> Self

Adds a value (builder style).

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));
            }
        }
    }

    /// 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 push(&mut self, value: impl Into<Arg>)

Adds a value.

pub fn kind(&self) -> &str

What the packet is about, e.g. "move" or "chat".

Examples found in repository

examples/online.rs (line 160)

    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(_) => {}
        }
    }

pub fn is(&self, kind: &str) -> bool

Whether the packet is of this kind.

pub fn args(&self) -> &[Arg]

All values.

pub fn len(&self) -> usize

Number of values.

pub fn is_empty(&self) -> bool

Whether the packet has no values.

pub fn get(&self, index: usize) -> Option<&Arg>

The value at index, if there is one.

pub fn int(&self, index: usize) -> i64

The value at index as a whole number. Decimals are cut off, bool gives 0 or 1, text is parsed. Anything else gives 0.

pub fn float(&self, index: usize) -> f32

The value at index as a decimal number. Whole numbers and bool convert, text is parsed. Anything else gives 0.0.

pub fn bool(&self, index: usize) -> bool

The value at index as bool. Numbers are true when not zero, text when it is "true". Anything else gives false.

pub fn text(&self, index: usize) -> &str

The value at index as text, or "" if it is not text.

Examples found in repository

examples/online.rs (line 166)

    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(_) => {}
        }
    }

pub fn vec2(&self, index: usize) -> Vec2

The value at index as a 2D vector. A 3D vector loses its z. Anything else gives Vec2::ZERO.

pub fn vec3(&self, index: usize) -> Vec3

The value at index as a 3D vector. A 2D vector gets z = 0. Anything else gives Vec3::ZERO.

Examples found in repository

examples/online.rs (line 162)

    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(_) => {}
        }
    }

pub fn peer(&self, index: usize) -> PeerId

The value at index as a player id (stored with .with(peer)). Anything that is not a valid number gives PeerId::SERVER.

Examples found in repository

examples/online.rs (line 184)

    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(_) => {}
        }
    }

pub fn bytes(&self, index: usize) -> &[u8]

The value at index as bytes, or an empty slice if it is not bytes.

Trait Implementations

impl Clone for Packet

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Packet

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

Formats the value using the given formatter.

impl Default for Packet

fn default() -> Self

Returns the “default value” for a type.

impl From<&Packet> for Packet

fn from(packet: &Packet) -> Self

Converts to this type from the input type.

impl From<&str> for Packet

fn from(kind: &str) -> Self

Converts to this type from the input type.

impl From<String> for Packet

fn from(kind: String) -> Self

Converts to this type from the input type.

impl PartialEq for Packet

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Packet