Two languages

/// The tooltip on a counter in the HUD: it fills in how many the hero has
/// found of what the counter counts, where the tooltip's words say {count}.
component CounterTip {
    /// The kept number it tells: coins or gems.
    kind: String = "coins",

    fn loop() {
        // The words come from the string tables, in the game's language, by
        // the Localized Text beside this script, whose first substitution,
        // named count, fills {count}. A pickup adds to its number on the step
        // the hero walks into it, and the tooltip says so from the next step.
        let found = kept_number(kind, 0.0);
        set_text("LocalizedTextComponent", "substitutions.0.value", text(found));
    }
}

/// The dialog a bag slot's Inspect opens: it names the item kept under
/// inspect and says what it does, in the game's language, and OK, or Escape,
/// shuts it.
component InspectDialog {
    fn loop() {
        // A slot's Inspect keeps its item under inspect: 1 a potion, 2 the
        // elixir, 3 a key, and 0 once the dialog is shut.
        let item = kept_number("inspect", 0.0);
        // A click on OK, Enter, or Escape through the Cancel Action presses
        // inspect_ok on the game's next step.
        if pressed("inspect_ok") {
            keep_number("inspect", 0.0);
            hide();
        } else if item > 0.0 {
            // The item's name over what its tooltip says: the key of each,
            // which the Localized Text beside this script writes into the
            // dialog's title and its question in the game's language.
            if item == 1.0 {
                set_text("LocalizedTextComponent", "key", "item.potion");
                set_text("LocalizedTextComponent", "body", "tip.potion");
            } else if item == 2.0 {
                set_text("LocalizedTextComponent", "key", "item.elixir");
                set_text("LocalizedTextComponent", "body", "tip.elixir");
            } else {
                set_text("LocalizedTextComponent", "key", "item.key");
                set_text("LocalizedTextComponent", "body", "tip.key");
            }
            show();
        }
    }
}

/// A row of the journal's window: it shows one line of the journal in the
/// game's language, and hides while that line is not written yet.
component JournalLine {
    /// The line it shows, from 1 at the top to 20 at the bottom: the journal
    /// keeps it as journal_1 to journal_20.
    index: f32 = 1.0,

    fn loop() {
        // The keeper writes each line as the code of what happened, and 0
        // while the line is empty. Each code's words are a key in the string
        // tables, chosen here and only here, and the Localized Text beside
        // this script writes them into the row.
        let code = kept_number("journal_" + text(index), 0.0);
        let words = "journal.empty";
        if code == 1.0 {
            words = "journal.potion";
        } else if code == 2.0 {
            words = "journal.elixir";
        } else if code == 3.0 {
            words = "journal.key";
        } else if code == 4.0 {
            words = "journal.gem";
        } else if code == 5.0 {
            words = "journal.coin";
        } else if code == 6.0 {
            words = "journal.door";
        } else if code == 7.0 {
            words = "journal.drank";
        } else if code == 8.0 {
            words = "journal.hurt";
        } else if code == 9.0 {
            words = "journal.rest";
        }
        set_text("LocalizedTextComponent", "key", words);
        if words == "journal.empty" {
            // A hidden row takes no room in the journal's Stack, so the
            // journal is as long as the lines written.
            hide();
        } else {
            show();
        }
    }
}

/// A save slot's Start or Continue button, which opens the delve on the slot's
/// run. A slot in use carries on the run the shrine last saved in it. A free
/// slot starts a new game under the name typed in its field, by this button or
/// by Enter in the field, and starts nothing while the field is empty. The
/// game keeps each slot's saves under its own prefix: slot1. for the first,
/// slot2. and slot3. for the others.
component LoadSlot {
    /// The slot it opens: 1, 2 or 3.
    slot: f32 = 1.0,
    /// The health a new game starts with.
    start_health: f32 = 10.0,

    fn loop() {
        let saves = "slot" + text(slot) + ".";
        // Its slot's name field reports under slot_1_name, slot_2_name or
        // slot_3_name, and this button under slot_1_play and so on.
        let field = "slot_" + text(slot) + "_name";
        let name = saved_text(saves + "name", "");
        // Its word is the string tables' slots.start while the slot is free
        // and slots.continue once it is in use: this chooses the key, and the
        // Localized Text beside it writes the word in the game's language.
        if name == "" {
            set_text("LocalizedTextComponent", "key", "slots.start");
        } else {
            set_text("LocalizedTextComponent", "key", "slots.continue");
        }

        // A click on this button, or Enter while it holds the focus,
        // presses its action, and Enter in the name field presses the
        // field's, each on the game's next step. A free slot starts only once
        // a name is typed in its field.
        let typed = entered(field);
        let asked = pressed("slot_" + text(slot) + "_play") || pressed(field);
        if asked && (name != "" || typed != "") {
            if name == "" {
                // A new game: the slot is the name's from now on.
                save_text(saves + "name", typed);
            }
            // The slot's run, kept where the delve reads it. What the shrine
            // never saved reads as a new game's, and a free slot holds no
            // saves at all, since Delete forgets them: so a new game, or a
            // run that never rested at the shrine, starts at full health with
            // nothing carried, nothing in the journal, every pickup back in
            // the room and the door shut.
            keep_number("health", saved_number(saves + "health", start_health));
            keep_number("potions", saved_number(saves + "potions", 0.0));
            keep_number("elixirs", saved_number(saves + "elixirs", 0.0));
            keep_number("keys", saved_number(saves + "keys", 0.0));
            keep_number("gems", saved_number(saves + "gems", 0.0));
            keep_number("coins", saved_number(saves + "coins", 0.0));
            keep_number("haste", saved_number(saves + "haste", 0.0));
            for i in 1..5 {
                let kept = "hotbar_" + text(i);
                keep_number(kept, saved_number(saves + kept, 0.0));
            }
            for i in 1..17 {
                let kept = "bag_" + text(i);
                keep_number(kept, saved_number(saves + kept, 0.0));
            }
            for i in 1..21 {
                let kept = "journal_" + text(i);
                keep_number(kept, saved_number(saves + kept, 0.0));
            }
            keep_number("journal_count", saved_number(saves + "journal_count", 0.0));
            // And the room as the run left it: each pickup taken, which stays
            // gone, and the door, which opens itself if it was opened.
            for i in 1..13 {
                let kept = "taken_" + text(i);
                keep_number(kept, saved_number(saves + kept, 0.0));
            }
            keep_number("door_open", saved_number(saves + "door_open", 0.0));
            // No rest taken at the shrine yet, and nothing being inspected.
            keep_number("rests", 0.0);
            keep_number("inspect", 0.0);
            // The slot the run is played in, where the shrine saves it and
            // the way out marks it done.
            keep_number("slot", slot);
            // Loaded here, before the delve opens, so everything in it starts
            // on the slot's run: the hero on its health, and the journal's
            // keeper taking what the journal holds as already written.
            play_sound("click");
            change_scene("delve");
        }
    }
}

/// The tooltip on a slot of the hotbar or the bag: it names the item the slot
/// holds, and says nothing while the slot is empty. It chooses the words' key
/// in the string tables, and the Localized Text beside it writes the words,
/// in the game's language, into the slot's own Tooltip component, which shows
/// them once the pointer has rested on the slot for its delay.
component SlotTooltip {
    /// The slot it speaks for, which is kept by that name: hotbar_1 to
    /// hotbar_4, or bag_1 to bag_16.
    slot: String = "hotbar_1",

    fn loop() {
        // The satchel and the slots keep what each slot holds: 1 a potion, 2
        // the elixir, 3 a key, 0 nothing.
        let item = kept_number(slot, 0.0);
        // An empty slot's key has no words in either language, and a Tooltip
        // with no words is never shown, however long the pointer rests.
        let words = "tip.empty";
        if item == 1.0 {
            words = "tip.potion";
        } else if item == 2.0 {
            words = "tip.elixir";
        } else if item == 3.0 {
            words = "tip.key";
        }
        set_text("LocalizedTextComponent", "tooltip", words);
    }
}

/// The Language list on the settings screen: it opens on the language the
/// game's text is in, and each time the player picks one it shows the whole
/// game in that language and saves the choice, which the title gives back as
/// the game opens. Its rows name each language in its own words, English and
/// then Français, the order of the codes it saves: en and fr.
component LanguageList {
    fn on_create() {
        // language() answers the code of the language the game's text is in.
        // Writing the list's choice changes what it shows and presses
        // nothing.
        if language() == "fr" {
            set_number("DropdownComponent", "selected", 1.0);
        } else {
            set_number("DropdownComponent", "selected", 0.0);
        }
    }

    fn loop() {
        // A click on a row, or Enter on the row the arrows lit, chooses it and
        // presses language on that step; amount() answers the row, from 0.
        if pressed("language") {
            let code = "en";
            if amount("language") == 1.0 {
                code = "fr";
            }
            // Every word in the game changes at the end of this step, and
            // the title asks for the saved language as the game next opens.
            set_language(code);
            save_text("language", code);
        }
    }
}

/// The title, as it opens: the language and the volumes the player chose in
/// Settings, set before the game's first word and its first sound, and the
/// menu faded in. The Canvas Group on this node starts at alpha 0, where the
/// menu is not drawn and takes no key; this brings it to 1 over half a second.
component Title {
    fn on_create() {
        // The language the player chose, which lands at the end of this
        // step, before the title is first drawn. With nothing saved it asks
        // for the language the game opened in, which changes nothing.
        set_language(saved_text("language", language()));
        // 0.8 until the player has chosen a volume.
        set_music_volume(saved_number("music_volume", 0.8));
        set_sfx_volume(saved_number("effects_volume", 0.8));
        anneal_number("CanvasGroupComponent", "alpha", 1.0, 0.5, .OutQuad);
    }
}