Struct Lang 

pub struct Lang { /* private fields */ }

The translation tables and the current language. Reach it through ctx.lang.

Implementations

impl Lang

pub fn new() -> Self

Empty tables, English as current and fallback language.

pub fn load_dir(&mut self, dir: impl AsRef<Path>) -> usize

Loads every <code>.txt in dir. Returns how many languages were loaded. A missing folder is fine and loads nothing.

pub fn add_text(&mut self, code: &str, text: &str)

Adds the lines of a translation file (key = text) to a language. Later keys replace earlier ones. Handy with include_str! to ship texts inside the executable.

pub fn insert( &mut self, code: &str, key: impl Into<String>, text: impl Into<String>, )

Adds or replaces one text.

pub fn set(&mut self, code: &str) -> bool

Switches the language. "de-AT" falls back to "de". Returns false (and keeps the current language) if no texts exist for it. English and German always exist, because the engine’s own texts are built in. To remember the choice, use Context::set_language(crate::Context::set_language) instead.

pub fn current(&self) -> &str

The current language code, e.g. "de".

pub fn fallback(&self) -> &str

The language used for keys missing in the current one (default "en").

pub fn set_fallback(&mut self, code: &str)

Changes the fallback language.

pub fn languages(&self) -> Vec<String>

The languages with loaded texts, sorted by code. Built in engine texts do not count, so this lists exactly the languages your game was translated to.

pub fn name(&self, code: &str) -> String

The name of a language as written in its file (key language), else the code.

pub fn has(&self, key: &str) -> bool

Whether key has a text in the current or the fallback language.

pub fn get(&self, key: &str) -> String

The text for key in the current language. See the module docs for what happens when it is missing.

pub fn format(&self, key: &str, args: &[(&str, &dyn Display)]) -> String

The text for key with {name} placeholders filled in.

// score = {player} has {points} points
let text = ctx.lang.format("score", &[("player", &"Anna"), ("points", &12)]);

pub fn plural(&self, key: &str, n: i64) -> String

Picks key.one when n is 1 (or -1) and key.other otherwise, and fills in {n}. Without those keys, key itself is used.

pub fn plural_with( &self, key: &str, n: i64, args: &[(&str, &dyn Display)], ) -> String

Like Lang::plural with more placeholders.

pub fn system() -> Option<String>

The player’s system language (e.g. "de"), if the system tells.

pub fn direction_name(&self, degrees: f32) -> String

Like math::direction_name in the current language.

pub fn describe_position(&self, from: Vec3, yaw: f32, target: Vec3) -> String

Like math::describe_position in the current language, e.g. "3 Uhr, 12 Meter".

Examples found in repository

examples/online.rs (line 258)

    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 describe_speed(&self, vehicle: &Vehicle) -> String

Like Vehicle::describe_speed in the current language.

pub fn describe_reason(&self, reason: &Reason) -> String

Why a network connection ended, as a sentence in the current language, e.g. "The server is full".

for (_, reason) in ctx.net.left() {
    ctx.speak(ctx.lang.describe_reason(&reason));
}

Examples found in repository

examples/online.rs (line 91)

    fn on_net(&mut self, event: &NetEvent, ctx: &mut Context) {
        match event {
            NetEvent::Connected(_) => Self::start_game(ctx),
            NetEvent::Disconnected(_, reason) => ctx.ui.message("error", ctx.lang.describe_reason(reason)),
            NetEvent::Message(..) => {}
        }
    }

    fn update(&mut self, _ctx: &mut Context) {}
}

/// Another player: where they are and the sound that marks them.
struct Other {
    name: String,
    position: Vec3,
    sound: Sound,
}

struct Field {
    position: Vec3,
    others: BTreeMap<PeerId, Other>,
}

impl Field {
    fn new(ctx: &mut Context) -> Self {
        ctx.audio.register("other", Synth::triangle(660.0).length(0.06).decay(40.0).then(Synth::silence(0.5)));
        ctx.audio.register("step", Synth::noise().length(0.05).decay(80.0).volume(0.5));
        ctx.audio.register("chat", Synth::sine(1200.0).length(0.05).volume(0.3));
        Self { position: Vec3::ZERO, others: BTreeMap::new() }
    }

    fn add(&mut self, ctx: &mut Context, id: PeerId, name: &str, position: Vec3) {
        let sound = ctx.audio.play_looped_at("other", position);
        sound.set_pitch(1.0 + id.number() as f32 * 0.15);
        self.others.insert(id, Other { name: name.to_string(), position, sound });
    }

    fn remove(&mut self, ctx: &mut Context, id: PeerId) {
        if let Some(other) = self.others.remove(&id) {
            other.sound.stop();
            ctx.speak(format!("{} left", other.name));
        }
    }

    fn moved(&mut self, id: PeerId, position: Vec3) {
        if let Some(other) = self.others.get_mut(&id) {
            other.position = position;
            other.sound.set_position(position);
        }
    }

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

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

Trait Implementations

impl Clone for Lang

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 Lang

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

Formats the value using the given formatter.

impl Default for Lang

fn default() -> Self

Returns the “default value” for a type.