AlpacaLibrary/Include/Game/Interfaces/Menu.hpp

#ifndef MENU_HPP_INCLUDED
#define MENU_HPP_INCLUDED

#include "../../Core/Types/Box.hpp"
#include <cstdint>
#include <string>
#include <vector>

/** @addtogroup Interfaces
* @{ */
class Menu
{
    public:

        /**
         * @brief Returns true if the right-click menu is open
         *
         * @return true if the right-click menu is open
         */
        static bool IsOpen();

        /**
         * @brief Opens the menu by right-clicking wherever the mouse currently is
         *
         * @return true if the menu is currently open or opened by right clicking
         * @return false if WaitFunc fails - WaitFunc(1000, 100, Menu::IsOpen, true);
         * @note Implements an %Interactable delay if succesful
         */
        static bool Open();

        /**
         * @brief Closes the menu by moving the mouse to either left or right of the menu, uses the current mouse position as a base point
         *
         * @return true if the menu isn't open, or closed by moving the mouse
         * @return false if the generated point is off-screen, or WaitFunc fails - WaitFunc(1000, 100, Menu::IsOpen, false);
         * @note Implements an %Interactable delay if succesful
         */
        static bool Close();


        /**
         * @brief Get the number of menu options
         *
         * @return the number of menu options
         */
        static std::int32_t GetCount();

        /**
         * @brief Get the raw, un-filtered menu actions
         *
         * @description By default the game includes html code in menu actions/targets
         * This function returns those actions without the removal of the html code
         *
         * @return std::vector<std::string>
         */
        static std::vector<std::string> GetActionsRaw();

        /**
         * @brief Get the raw, un-filtered menu targets
         *
         * @description By default the game includes html code in menu actions/targets
         * This function returns those targets without the removal of the html code
         *
         * @return std::vector<std::string>
         */
        static std::vector<std::string> GetTargetsRaw();

        /**
         * @brief Get the menu actions
         *
         * @description Actions are almost always the very first word in a menu option
         * 'Use' - action 'gold bar' - target
         * 'Attack' - action 'Guard  (level-21)' - target
         *
         * @return std::vector<std::string> array of menu actions
         */
        static std::vector<std::string> GetActions();

        /**
         * @brief Get the menu targets
         *
         * @description Targets are almost always everything after the action
         * 'Use' - action 'gold bar' - target
         * 'Attack' - action 'Guard  (level-21)' - target
         *
         * @return std::vector<std::string> array of menu targets
         */
        static std::vector<std::string> GetTargets();

        /**
         * @brief Get the menu options
         *
         * @description
         * 'Use' - action 'gold bar' - target
         * 'Attack' - action 'Guard  (level-21)' - target
         * 'Use gold bar' - option
         * 'Attack Guard  (level-21)' - option
         * @return std::vector<std::string> array of menu options
         */
        static std::vector<std::string> GetOptions();


        /**
         * @brief Get the index of the found option
         *
         * @description This function will find the first menu option containing the string 'Option'
         * This means passing 'Att' or 'Attack' will return the first found menu option containing 'Att' or 'Attack'
         * If you want to find a very specific menu option, the more the 'Option' string contains, the more specific it'll be
         *
         * Say for example, you want to attack a guard whose level is 40, and on this one tile, there's 5 different guards, all with different levels
         * If you pass 'Attack' as the 'Option' to look for, it'll select the very first guard, regardless of level.
         * If you pass 'Attack Guard  (level-40)' as the 'Option' to look for, it'll attack the guard whose level is 40.
         *
         * @note Notice that 'Attack Guard  (level-40)' has a double space after 'Guard', menu options can vary, in this case the menu option i'm looking for
         * has a double space after 'Guard'.
         *
         * @param Option Menu option to look for, can be very specific, or very lenient
         * @return std::int32_t The index of the found option, -1 if an option wasn't found
         */
        static std::int32_t IndexOf(const std::string& Option);

        /**
         * @brief Get the index of the first found option
         *
         * @description This function will return the first found index, of the first found option.
         * This function is just Menu::IndexOf(const std::string& Option), but instead of looking for one single option, this function can look for multiple
         *
         * @param Options
         * @return std::int32_t The index of the first found option, -1 if an option wasn't found
         * @see Menu::IndexOf(const std::string& Option)
         */
        static std::int32_t IndexOf(const std::vector<std::string>& Options);


        /**
         * @brief Looks for a menu option at the passed index, and returns information about the found option
         *
         * @param Index The index of the menu option to look at
         * @return std::tuple<bool, std::string, std::string>
         * std::int32_t [0] = Index of the option that was found (-1 if the option wasn't found)
         * std::string [1] = Action that was found at index
         * std::string [2] = Target that was found at index
         * @see Menu::IndexOf(const std::string& Option)
         */
        static std::tuple<std::int32_t, std::string, std::string> FindOption(std::uint32_t Index);

        /**
         * @brief Looks for a menu option containing the passed Option, and returns information about the found option
         *
         * @param Option Menu option to look for, the more specific, the more accurate the result will be
         * @return std::tuple<bool, std::string, std::string>
         * std::int32_t [0] = Index of the option that was found (-1 if the option wasn't found)
         * std::string [1] = Action that was found
         * std::string [2] = Target that was found
         * @see Menu::IndexOf(const std::string& Option)
         */
        static std::tuple<std::int32_t, std::string, std::string> FindOption(const std::string& Option);

        /**
         * @brief Looks for a menu option containing the passed Option, and returns information about the found option
         *
         * @param Options Menu options to look for, returns on first option found, if using RequireAllOptions, returns only if all options are found. The more specific, the more accurate the result will be
         * @return std::tuple<bool, std::string, std::string>
         * std::int32_t [0] = Index of the option that was found (-1 if the option wasn't found)
         * std::string [1] = Action that was found
         * std::string [2] = Target that was found
         * @see Menu::IndexOf(const std::string& Option)
         */
        static std::tuple<std::int32_t, std::string, std::string> FindOption(const std::vector<std::string>& Options, bool RequireAllOptions = false);

        /**
         * @brief Looks for a menu option containing the passed Option, and returns information of all options that were found
         *
         * @param Option Menu option to look for, the more specific, the more accurate the result will be
         * @return std::vector<std::tuple<std::int32_t, std::string, std::string>>
         * std::int32_t [0] = Index of the option that was found (-1 if the option wasn't found)
         * std::string [1] = Action that was found
         * std::string [2] = Target that was found
         * @see Menu::IndexOf(const std::string& Option)
         */
        static std::vector<std::tuple<std::int32_t, std::string, std::string>> FindOptions(const std::string& Option);

        /**
         * @brief Looks for a menu option containing the passed Option, and returns information of all options that were found
         *
         * @param Options Menu options to look for, returns on first option found, if using RequireAllOptions, returns only if all options are found. The more specific, the more accurate the result will be
         * @return std::vector<std::tuple<std::int32_t, std::string, std::string>>
         * std::int32_t [0] = Index of the option that was found (-1 if the option wasn't found)
         * std::string [1] = Action that was found
         * std::string [2] = Target that was found
         * @see Menu::IndexOf(const std::string& Option)
         */
        static std::vector<std::tuple<std::int32_t, std::string, std::string>> FindOptions(const std::vector<std::string>& Options, bool RequireAllOptions = true);


        /**
         * @brief Returns true if the menu contains the passed Option
         *
         * @param Option Menu option to look for, the more specific, the more accurate the result will be
         * @return true if the menu contains the passed Option
         * @see Menu::IndexOf(const std::string& Option)
         */
        static bool Contains(const std::string& Option);

        /**
         * @brief Returns true if the menu contains at least one of the passed Options
         *
         * @param Options Menu options to check for, returns on first option found, the more specific, the more accurate the result will be
         * @return true if the menu contains at least one of the passed Options
         * @see Menu::IndexOf(const std::string& Option)
         */
        static bool Contains(const std::vector<std::string>& Options);


        /**
         * @brief Waits until the menu contains the passed option
         *
         * @param Duration How long to wait until returning
         * @param Step How long to wait until it checks the menu options
         * @param Option Option to look for, the more specific, the more accurate the result will be
         * @return true if the option was found
         * @return false if the function doesn't find the passed option after running for Duration
         */
        static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::string& Option);

        /**
         * @brief Waits until the menu contains at leaset one of the passed options
         *
         * @param Duration How long to wait until returning
         * @param Step How long to wait until it checks the menu options
         * @param Options Options to look for, returns on first option found, the more specific, the more accurate the result will be
         * @return true if at least one of the options was found
         * @return false if the function doesn't find at least one of the passed options after running for Duration
         */
        static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::vector<std::string>& Options);


        /**
         * @brief Selects the menu option by the passed index if the menu is open
         *
         * @param Index The index of the option
         * @param CloseMenu Close the menu if the function fails by using Menu::Close(), true by default
         * @return true if the function selected the option by index
         * @return false if the index was invalid, the option was off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false)
         * @note Implements an %Interactable delay if succesful
         */
        static bool Select(std::int32_t Index, bool CloseMenu = true);

        /**
         * @brief Selects the passed menu option if the menu is open
         *
         * @param Option Menu option to look for, the more specific, the more accurate the result will be
         * @param CloseMenu Close the menu if the function fails by using Menu::Close(), true by default
         * @return true if the function selected the option by option
         * @return false if the menu isn't open, the found option was invalid, the option was off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false)
         * @note Implements an %Interactable delay if succesful
         * @see Menu::IndexOf(const std::string& Option)
         */
        static bool Select(const std::string& Option, bool CloseMenu = true);

        /**
         * @brief Selects the first found option in the menu
         *
         * @param Options String array of menu options to look for, returns on first option found, the more specific, the more accurate the result will be
         * @param CloseMenu Close the menu if the function fails using Menu::Close(), true by default
         * @return true if the function selected the option by the first found option
         * @return false if the menu isn't open, the found option was invalid, the option was off-screen, or the WaitFunc failed - WaitFunc(1000, 100, Menu::IsOpen, false)
         * @note Implements an %Interactable delay if succesful
         */
        static bool Select(const std::vector<std::string>& Options, bool CloseMenu = true);


        /**
         * @brief Get the array of menu option boxes, each box is a menu option
         *
         * @return std::vector<Box> array of menu option boxes, menu must be open
         */
        static std::vector<Box> GetOptionBoxes();

        /**
         * @brief Get the full menu box
         *
         * @return Box of the full menu, menu must be open
         */
        static Box GetBox();
};

/** @} */

#endif // MENU_HPP_INCLUDED