HUD.hpp

Go to the documentation of this file.

#ifndef CORE_SYSTEMS_HUD_HPP
#define CORE_SYSTEMS_HUD_HPP
 
#include <BLIB/Engine/System.hpp>
#include <BLIB/Graphics.hpp>
#include <BLIB/Interfaces/Menu.hpp>
#include <BLIB/Interfaces/Utilities.hpp>
#include <BLIB/Resources.hpp>
#include <Core/Input/MenuDriver.hpp>
#include <Core/Systems/HUD/QtyEntry.hpp>
#include <Core/Systems/HUD/ScreenKeyboard.hpp>
#include <functional>
#include <queue>
#include <string>
#include <variant>
#include <vector>
 
namespace core
{
namespace system
{
class Systems;
 
class HUD : public bl::engine::System {
public:
    using Callback = std::function<void(const std::string& value)>;
 
    using QtyCallback = std::function<void(int qty)>;
 
    HUD(Systems& owner);
 
    virtual ~HUD() = default;
 
    void displayMessage(
        const std::string& message, const Callback& cb = [](const std::string&) {});
 
    void displayStickyMessage(
        const std::string& message, bool ghostWrite,
        const Callback& cb = [](const std::string&) {});
 
    bool dismissStickyMessage(bool ignoreGhostWrite = true);
 
    void promptUser(const std::string& prompt, const std::vector<std::string>& choices,
                    const Callback& cb);
 
    void getInputString(const std::string& prompt, unsigned int minLen, unsigned int maxLen,
                        const Callback& cb);
 
    void getQty(const std::string& prompt, int minQty, int maxQty, const QtyCallback& cb);
 
    void displayEntryCard(const std::string& name);
 
    void hideEntryCard();
 
private:
    enum State {
        Hidden,
        Printing,
        WaitingContinue,
        WaitingSticky,
        WaitingPrompt,
        WaitingKeyboard,
        WaitingQty
    };
 
    class Item {
    public:
        enum Type { Message, Prompt, Keyboard, Qty };
 
        Item(const std::string& message, bool sticky, bool ghost, const Callback& cb);
        Item(const std::string& prompt, const std::vector<std::string>& choices,
             const Callback& cb);
        Item(const std::string& prompt, unsigned int minLen, unsigned int maxLen,
             const Callback& cb);
        Item(const std::string& prompt, int minQty, int maxQty, const QtyCallback& cb);
 
        Type getType() const;
        const std::string& getMessage() const;
        bool isSticky() const;
        bool ghostWrite() const;
        const std::vector<std::string>& getChoices() const;
        const Callback& getCallback() const;
        const QtyCallback& getQtyCallback() const;
        unsigned int minInputLength() const;
        unsigned int maxInputLength() const;
        int getMinQty() const;
        int getMaxQty() const;
 
    private:
        const Type type;
        const std::variant<Callback, QtyCallback> cb;
        const std::string message;
        const std::variant<std::pair<bool, bool>, std::vector<std::string>,
                           std::pair<unsigned int, unsigned int>, std::pair<int, int>>
            data;
    };
 
    struct HudListener : public bl::input::Listener {
        HudListener(HUD& owner);
        virtual ~HudListener() = default;
        virtual bool observe(const bl::input::Actor&, unsigned int activatedControl,
                             bl::input::DispatchType, bool eventTriggered) override;
 
        HUD& owner;
    };
 
    class EntryCard {
    public:
        EntryCard(bl::engine::Engine& engine);
        void display(const std::string& text);
        void update(float dt);
        void hide();
 
    private:
        bl::engine::Engine& engine;
        bl::rc::Overlay* currentOverlay;
        bl::rc::res::TextureRef txtr;
        bl::gfx::Sprite card;
        bl::gfx::Text text;
 
        void ensureCreated();
 
        enum State { Hidden, Dropping, Holding, Rising } state;
        float stateVar;
    };
 
    Systems& owner;
    State state;
 
    HudListener inputListener;
    std::queue<Item> queuedOutput;
    bl::interface::GhostWriter currentMessage;
    hud::ScreenKeyboard screenKeyboard;
    EntryCard entryCard;
 
    bl::rc::Overlay* currentOverlay;
    bl::rc::res::TextureRef textboxTxtr;
    bl::gfx::Sprite textbox;
    bl::gfx::Text displayText;
    bl::gfx::Triangle promptTriangle;
    hud::QtyEntry qtyEntry;
 
    bl::menu::Menu choiceMenu;
    core::input::MenuDriver choiceDriver;
    float choiceBoxX;
 
    void setState(State newState);
    void ensureActive();
    void startPrinting();
    void printDoneStateTransition();
    void choiceMade(unsigned int i);
    void keyboardSubmit(const std::string& input);
    void qtySelected(int qty);
    void next();
 
    virtual void init(bl::engine::Engine&) override;
    virtual void update(std::mutex&, float dt, float, float, float) override;
};
 
} // namespace system
} // namespace core
 
#endif