The hotbar

/// A count in the HUD: it shows how many the hero has of what it counts.
component Counter {
    /// The kept number it shows: keys, coins or gems.
    kind: String = "gems",

    fn loop() {
        // A pickup adds to its number on the step the hero walks into it, and
        // the count shows it from the next step on.
        set_text("TextComponent", "text", text(kept_number(kind, 0.0)));
    }
}

/// The health bar in the HUD: it shows the hero's health, which the spikes
/// take and a potion gives back.
component HealthBar {
    fn loop() {
        // The hero keeps its health as it enters the room. Until then the bar
        // shows what it was made with: full.
        let health = kept_number("health", -1.0);
        if health >= 0.0 {
            set_number("SliderComponent", "value", health);
        }
    }
}

/// The hero's satchel: it files what the hero carries into the slots, the
/// hotbar's four and the bag's sixteen. What the hero owns is kept in
/// potions, elixirs and keys. Each slot is kept too, hotbar_1 to hotbar_4 and
/// bag_1 to bag_16, as the item in it: 1 a potion, 2 the elixir, 3 a key, 0
/// nothing. Only the satchel files, one item a step, so two pickups taken on
/// the same step never go in the same slot.
component Satchel {
    fn loop() {
        // What the slots hold as this step began: how many of each item, how
        // many slots are empty, the first empty one of the hotbar and of the
        // bag, and the last one holding each item.
        let potions = 0.0;
        let elixirs = 0.0;
        let keys = 0.0;
        let empty_hotbar = 0.0;
        let empty_bag = 0.0;
        let first_hotbar = "";
        let first_bag = "";
        let last_potion = "";
        let last_elixir = "";
        let last_key = "";
        for i in 1..5 {
            let slot = "hotbar_" + text(i);
            let item = kept_number(slot, 0.0);
            if item == 0.0 {
                empty_hotbar += 1.0;
                if first_hotbar == "" {
                    first_hotbar = slot;
                }
            } else if item == 1.0 {
                potions += 1.0;
                last_potion = slot;
            } else if item == 2.0 {
                elixirs += 1.0;
                last_elixir = slot;
            } else if item == 3.0 {
                keys += 1.0;
                last_key = slot;
            }
        }
        for i in 1..17 {
            let slot = "bag_" + text(i);
            let item = kept_number(slot, 0.0);
            if item == 0.0 {
                empty_bag += 1.0;
                if first_bag == "" {
                    first_bag = slot;
                }
            } else if item == 1.0 {
                potions += 1.0;
                last_potion = slot;
            } else if item == 2.0 {
                elixirs += 1.0;
                last_elixir = slot;
            } else if item == 3.0 {
                keys += 1.0;
                last_key = slot;
            }
        }

        // What the hero owns that no slot holds yet waits to be filed; less
        // than none is an item a slot holds that the hero no longer owns.
        let waiting_potions = kept_number("potions", 0.0) - potions;
        let waiting_elixirs = kept_number("elixirs", 0.0) - elixirs;
        let waiting_keys = kept_number("keys", 0.0) - keys;

        // One item a step, into the first empty slot. A potion or the elixir,
        // the two things the hero drinks, goes in the hotbar while it has
        // room, then in the bag: drink_slot is where it goes. A key goes only
        // in the bag.
        let drink_slot = first_hotbar;
        if drink_slot == "" {
            drink_slot = first_bag;
        }
        if waiting_potions > 0.0 && drink_slot != "" {
            keep_number(drink_slot, 1.0);
        } else if waiting_elixirs > 0.0 && drink_slot != "" {
            keep_number(drink_slot, 2.0);
        } else if waiting_keys > 0.0 && first_bag != "" {
            keep_number(first_bag, 3.0);
        }

        // An item the hero no longer owns, as the key the door took, leaves
        // the last slot holding it.
        if waiting_potions < 0.0 {
            keep_number(last_potion, 0.0);
        }
        if waiting_elixirs < 0.0 {
            keep_number(last_elixir, 0.0);
        }
        if waiting_keys < 0.0 {
            keep_number(last_key, 0.0);
        }

        // The room left once what waits is filed, which a pickup reads before
        // it lets the hero take it. What the hotbar has no room for waits for
        // the bag.
        let room_hotbar = empty_hotbar - max(waiting_potions, 0.0) - max(waiting_elixirs, 0.0);
        let room_bag = empty_bag - max(waiting_keys, 0.0);
        if room_hotbar < 0.0 {
            room_bag += room_hotbar;
            room_hotbar = 0.0;
        }
        keep_number("room_hotbar", room_hotbar);
        keep_number("room_bag", room_bag);
    }
}

/// The picture in a slot of the hotbar or the bag: it shows the item the slot
/// holds, cut from the items picture by its region, and nothing while the slot
/// is empty.
component SlotPicture {
    /// The slot it shows, 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);
        if item == 1.0 {
            set_text("PanelComponent", "region_name", "potion");
            show();
        } else if item == 2.0 {
            set_text("PanelComponent", "region_name", "elixir");
            show();
        } else if item == 3.0 {
            set_text("PanelComponent", "region_name", "key");
            show();
        } else {
            hide();
        }
    }
}

/// A slot of the hotbar: its key or a click on it uses the item it holds. A
/// potion gives back health, but never past the most the hero can have, and
/// at full health it stays in the slot. The elixir hastens the hero. A use
/// empties the slot, which then cools down before it can be used again.
component HotbarSlot {
    /// Which slot it is, 1 to 4: what it holds is kept in hotbar_1 to
    /// hotbar_4, and use_1 to use_4 use it.
    index: f32 = 1.0,
    /// The health a potion gives back.
    heal: f32 = 3.0,
    /// The most health the hero can have.
    max_health: f32 = 10.0,
    /// How long the elixir hastens the hero for.
    #[suffix("s")]
    haste: f32 = 5.0,
    /// How long after a use the slot cannot be used again.
    #[suffix("s")]
    cooldown: f32 = 1.5,
    /// Seconds until the slot can be used again.
    #[hidden]
    cooling: f32 = 0.0,

    fn loop(dt: f32) {
        // Counted here rather than waited out: a hook that waits hears
        // nothing, and a use asked for meanwhile must be refused, not kept.
        if cooling > 0.0 {
            cooling -= dt;
        }
        // Its key, 1 to 4 through the input map, presses its use_ action on
        // the step the key goes down, and a click on the slot on the game's
        // next step.
        if pressed("use_" + text(index)) && cooling <= 0.0 {
            let slot = "hotbar_" + text(index);
            let item = kept_number(slot, 0.0);
            let health = kept_number("health", 0.0);
            let used = false;
            if item == 1.0 && health < max_health {
                add_number("health", min(heal, max_health - health));
                add_number("potions", -1.0);
                used = true;
            } else if item == 2.0 {
                keep_number("haste", haste);
                add_number("elixirs", -1.0);
                used = true;
            }
            if used {
                // Emptied on the step the count goes down, so the satchel
                // finds the two agreeing.
                keep_number(slot, 0.0);
                cooling = cooldown;
                // Heard by the ring the slot's Signal component wires it to,
                // on the next step.
                emit("used");
            }
        }
    }
}

/// Something lying in the room that the hero takes by walking into it. It adds
/// `amount` to the number kept under `kind`, and is gone. A potion, the elixir
/// and the key each need a slot to go in, so one stays on the floor while the
/// satchel has no room for it.
component Pickup : Area {
    /// The kept number it counts into: potions, elixirs, keys, gems or coins.
    kind: String = "gems",
    /// How much it adds to that number.
    amount: f32 = 1.0,
    /// The item a slot shows for it: 1 a potion, 2 the elixir, 3 a key, or 0
    /// for what is only counted, as gems and coins are.
    item: f32 = 0.0,

    fn on_enter(other: NodeId) {
        // The hero's node is in the group "hero".
        if in_group(other, "hero") {
            // The room the satchel keeps: a key goes only in the bag, a potion
            // or the elixir in the hotbar or the bag.
            let room = kept_number("room_bag", 0.0);
            if item == 1.0 || item == 2.0 {
                room += kept_number("room_hotbar", 0.0);
            }
            if item == 0.0 || room >= amount {
                add_number(kind, amount);
                destroy_self();
            }
        }
    }
}

/// The hero, whom the keys walk through its Character Body. A new game starts
/// it with `health`, kept so that everything else can read it. While the
/// elixir hastens it, it walks faster.
component Hero {
    /// The health a new game starts with.
    health: f32 = 10.0,
    /// How fast the keys walk it.
    #[suffix("u/s")]
    walk_speed: f32 = 64.0,
    /// How many times as fast it walks while hastened.
    haste_factor: f32 = 1.5,

    fn on_create() {
        // Only when nothing is kept yet: a hero met again keeps what it has.
        if kept_number("health", -1.0) < 0.0 {
            keep_number("health", health);
        }
    }

    fn loop(dt: f32) {
        // The elixir keeps haste: the seconds left that the hero walks faster
        // for, counted down here.
        let haste = kept_number("haste", 0.0);
        if haste > 0.0 {
            keep_number("haste", max(haste - dt, 0.0));
            set_number("CharacterBodyComponent", "speed", walk_speed * haste_factor);
        } else {
            set_number("CharacterBodyComponent", "speed", walk_speed);
        }
    }
}

/// The bag's window: shut as the delve opens, and opened and shut by B.
component Bag {
    /// Whether the bag is open.
    #[hidden]
    open: bool = false,

    fn on_create() {
        hide();
    }

    fn loop() {
        // B, through the input map's bag, presses bag on the step it goes
        // down.
        if pressed("bag") {
            open = !open;
            if open {
                show();
            } else {
                hide();
            }
        }
    }
}

/// The ring over a hotbar slot: each time the slot is used, it fills and then
/// empties over the slot's cooldown, so the player sees how long it is until
/// the slot can be used again.
component CooldownRing {
    /// How long the ring takes to empty: the slot's cooldown.
    #[suffix("s")]
    seconds: f32 = 1.5,

    fn loop() {
        // The slot emits used when it uses its item, and its Signal component
        // wires that to this ring, which hears it on the next step.
        if heard("used") {
            // Full first, so the anneal starts from there.
            set_number("RadialProgressComponent", "value", 1.0);
            anneal_number("RadialProgressComponent", "value", 0.0, seconds, .Linear);
        }
    }
}