AlpacaBot
/
AlpacaLibrary
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Release 0.40

master
Kasi 2018-05-10 02:08:38 +01:00
parent 5e103dcbae
commit 633a70351f
30 changed files with 550 additions and 560 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Include/Core/Types/Convex.hpp
View File

@ -18,7 +18,7 @@ class Convex
* Default Constructor, constructs a Convex with null Vertices * Default Constructor, constructs a Convex with null Vertices
*/ */
Convex(); Convex();
Convex(std::vector<Point> Vertices); Convex(const std::vector<Point>& Vertices);
/** /**
* @brief Constructs a Convex, by copying another * @brief Constructs a Convex, by copying another
* @param const Convex& C The Convex to "copy" * @param const Convex& C The Convex to "copy"

2
Include/Core/Types/Logger.hpp
View File

@ -23,7 +23,7 @@ class Logger : public std::ostream, public std::streambuf
* LevelUp << "Mining" << std::endl; * LevelUp << "Mining" << std::endl;
* @endcode * @endcode
*/ */
Logger(std::string Prefix, bool Enabled = true); Logger(const std::string& Prefix, bool Enabled = true);
/** /**
* @brief Constructs a Logger, with a function pointer that returns a String * @brief Constructs a Logger, with a function pointer that returns a String
* @param std::string (*Func)() Prefix The Prefix that's added before a message * @param std::string (*Func)() Prefix The Prefix that's added before a message

9
Include/Game/Core.hpp
View File

@ -9,6 +9,7 @@
#include "Tools/Settings.hpp" #include "Tools/Settings.hpp"
#include "Tools/Widgets.hpp" #include "Tools/Widgets.hpp"
#include "Tools/Worlds.hpp" #include "Tools/Worlds.hpp"
#include "Tools/RandomHandler.hpp"
#include "Interfaces/Bank.hpp" #include "Interfaces/Bank.hpp"
#include "Interfaces/Chat.hpp" #include "Interfaces/Chat.hpp"
@ -43,12 +44,12 @@
#include "Interactable/DecorativeObject.hpp" #include "Interactable/DecorativeObject.hpp"
#include "Interactable/GameObject.hpp" #include "Interactable/GameObject.hpp"
#include "Interactable/GroundItem.hpp"
#include "Interactable/GroundObject.hpp" #include "Interactable/GroundObject.hpp"
#include "Interactable/WallObject.hpp"
#include "Interactable/Player.hpp"
#include "Interactable/NPC.hpp" #include "Interactable/NPC.hpp"
#include "Interactable/Player.hpp"
#include "Tools/RandomHandler.hpp" #include "Interactable/WallObject.hpp"
#include "Interactable/Widget.hpp"
// //
// DoxyGen // DoxyGen

19
Include/Game/Interactable/DecorativeObject.hpp
View File

@ -5,7 +5,9 @@
#include "../../Core/Classes/ObjectInfo.hpp" #include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp" #include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp" #include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Box.hpp"
#include "../../Core/Types/Convex.hpp" #include "../../Core/Types/Convex.hpp"
#include "../../Core/Input.hpp"
#include <cstdint> #include <cstdint>
namespace Interactable namespace Interactable
@ -13,15 +15,24 @@ namespace Interactable
class DecorativeObject : public Internal::DecorativeObject class DecorativeObject : public Internal::DecorativeObject
{ {
public: public:
DecorativeObject(const Internal::DecorativeObject& G); DecorativeObject(const Internal::DecorativeObject& D);
DecorativeObject(const DecorativeObject& G); DecorativeObject(const DecorativeObject& D);
std::int32_t GetID() const; std::int32_t GetID() const;
std::string GetName() const; std::string GetName() const;
Tile GetTile() const;
Internal::ObjectInfo GetInfo() const; Internal::ObjectInfo GetInfo() const;
std::vector<Point> GetModel() const;
Box GetBox() const;
Point GetPoint() const;
Convex GetConvex() const; Convex GetConvex() const;
std::vector<Point> GetModel() const;
double GetVisibility() const;
Tile GetTile() const;
bool Interact(const Button& B = BUTTON_LEFT) const;
bool Interact(const std::string& Option) const;
bool Interact(const std::vector<std::string>& Options) const;
operator Internal::DecorativeObject() const; operator Internal::DecorativeObject() const;
}; };

15
Include/Game/Interactable/GameObject.hpp
View File

@ -5,7 +5,9 @@
#include "../../Core/Classes/ObjectInfo.hpp" #include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp" #include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp" #include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Box.hpp"
#include "../../Core/Types/Convex.hpp" #include "../../Core/Types/Convex.hpp"
#include "../../Core/Input.hpp"
#include <cstdint> #include <cstdint>
namespace Interactable namespace Interactable
@ -18,10 +20,19 @@ namespace Interactable
std::int32_t GetID() const; std::int32_t GetID() const;
std::string GetName() const; std::string GetName() const;
Tile GetTile() const;
Internal::ObjectInfo GetInfo() const; Internal::ObjectInfo GetInfo() const;
std::vector<Point> GetModel() const;
Box GetBox() const;
Point GetPoint() const;
Convex GetConvex() const; Convex GetConvex() const;
std::vector<Point> GetModel() const;
double GetVisibility() const;
Tile GetTile() const;
bool Interact(const Button& B = BUTTON_LEFT) const;
bool Interact(const std::string& Option) const;
bool Interact(const std::vector<std::string>& Options) const;
operator Internal::GameObject() const; operator Internal::GameObject() const;
}; };

25
Include/Game/Interactable/GroundItem.hpp
View File

@ -2,10 +2,12 @@
#define INTERACTABLEGROUNDITEM_HPP_INCLUDED #define INTERACTABLEGROUNDITEM_HPP_INCLUDED
#include "../../Core/Classes/GroundItem.hpp" #include "../../Core/Classes/GroundItem.hpp"
#include "../../Core/Classes/ObjectInfo.hpp" #include "../../Core/Classes/ItemInfo.hpp"
#include "../../Core/Types/Tile.hpp" #include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp" #include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Box.hpp"
#include "../../Core/Types/Convex.hpp" #include "../../Core/Types/Convex.hpp"
#include "../../Core/Input.hpp"
#include <cstdint> #include <cstdint>
namespace Interactable namespace Interactable
@ -13,19 +15,26 @@ namespace Interactable
class GroundItem : public Internal::GroundItem class GroundItem : public Internal::GroundItem
{ {
private: private:
std::int32_t X; Tile LocalTile;
std::int32_t Y;
public: public:
GroundItem(const Internal::GroundItem& G); GroundItem(const Internal::GroundItem& G);
GroundItem(const Internal::GroundItem& G, std::int32_t X, std::int32_t Y); GroundItem(const Internal::GroundItem& G, const Tile& LocalTile);
GroundItem(const GroundItem& G); GroundItem(const GroundItem& G);
std::int32_t GetID() const;
std::string GetName() const; std::string GetName() const;
Tile GetTile() const; Internal::ItemInfo GetInfo() const;
Internal::ObjectInfo GetInfo() const;
std::vector<Point> GetModel() const; Box GetBox() const;
Point GetPoint() const;
Convex GetConvex() const; Convex GetConvex() const;
std::vector<Point> GetModel() const;
double GetVisibility() const;
Tile GetTile() const;
bool Interact(const Button& B = BUTTON_LEFT) const;
bool Interact(const std::string& Option) const;
bool Interact(const std::vector<std::string>& Options) const;
operator Internal::GroundItem() const; operator Internal::GroundItem() const;
}; };

15
Include/Game/Interactable/GroundObject.hpp
View File

@ -5,7 +5,9 @@
#include "../../Core/Classes/ObjectInfo.hpp" #include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp" #include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp" #include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Box.hpp"
#include "../../Core/Types/Convex.hpp" #include "../../Core/Types/Convex.hpp"
#include "../../Core/Input.hpp"
#include <cstdint> #include <cstdint>
namespace Interactable namespace Interactable
@ -18,10 +20,19 @@ namespace Interactable
std::int32_t GetID() const; std::int32_t GetID() const;
std::string GetName() const; std::string GetName() const;
Tile GetTile() const;
Internal::ObjectInfo GetInfo() const; Internal::ObjectInfo GetInfo() const;
std::vector<Point> GetModel() const;
Box GetBox() const;
Point GetPoint() const;
Convex GetConvex() const; Convex GetConvex() const;
std::vector<Point> GetModel() const;
double GetVisibility() const;
Tile GetTile() const;
bool Interact(const Button& B = BUTTON_LEFT) const;
bool Interact(const std::string& Option) const;
bool Interact(const std::vector<std::string>& Options) const;
operator Internal::GroundObject() const; operator Internal::GroundObject() const;
}; };

14
Include/Game/Interactable/NPC.hpp
View File

@ -5,7 +5,9 @@
#include "../../Core/Classes/NPCInfo.hpp" #include "../../Core/Classes/NPCInfo.hpp"
#include "../../Core/Types/Tile.hpp" #include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp" #include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Box.hpp"
#include "../../Core/Types/Convex.hpp" #include "../../Core/Types/Convex.hpp"
#include "../../Core/Input.hpp"
#include <cstdint> #include <cstdint>
namespace Interactable namespace Interactable
@ -18,15 +20,23 @@ namespace Interactable
std::int32_t GetID() const; std::int32_t GetID() const;
std::string GetName() const; std::string GetName() const;
Tile GetTile() const;
Internal::NPCInfo GetInfo() const; Internal::NPCInfo GetInfo() const;
std::vector<Point> GetModel() const;
Box GetBox() const;
Point GetPoint() const;
Convex GetConvex() const; Convex GetConvex() const;
std::vector<Point> GetModel() const;
double GetVisibility() const;
Tile GetTile() const;
Internal::Character GetInteracting() const; Internal::Character GetInteracting() const;
bool Interacting() const; bool Interacting() const;
bool Interacting(const Internal::Character& C) const; bool Interacting(const Internal::Character& C) const;
bool Interact(const Button& B = BUTTON_LEFT) const;
bool Interact(const std::string& Option) const; bool Interact(const std::string& Option) const;
bool Interact(const std::vector<std::string>& Options) const;
operator Internal::NPC() const; operator Internal::NPC() const;
}; };

16
Include/Game/Interactable/Player.hpp
View File

@ -5,7 +5,9 @@
#include "../../Core/Classes/PlayerInfo.hpp" #include "../../Core/Classes/PlayerInfo.hpp"
#include "../../Core/Types/Tile.hpp" #include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp" #include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Box.hpp"
#include "../../Core/Types/Convex.hpp" #include "../../Core/Types/Convex.hpp"
#include "../../Core/Input.hpp"
#include <cstdint> #include <cstdint>
namespace Interactable namespace Interactable
@ -16,14 +18,24 @@ namespace Interactable
Player(const Internal::Player& P); Player(const Internal::Player& P);
Player(const Player& P); Player(const Player& P);
Tile GetTile() const; std::string GetName() const;
Internal::PlayerInfo GetInfo() const; Internal::PlayerInfo GetInfo() const;
std::vector<Point> GetModel() const;
Box GetBox() const;
Point GetPoint() const;
Convex GetConvex() const; Convex GetConvex() const;
std::vector<Point> GetModel() const;
double GetVisibility() const;
Tile GetTile() const;
Internal::Character GetInteracting() const; Internal::Character GetInteracting() const;
bool Interacting() const; bool Interacting() const;
bool Interacting(const Internal::Character& C) const; bool Interacting(const Internal::Character& C) const;
bool Interact(const Button& B = BUTTON_LEFT) const;
bool Interact(const std::string& Option) const; bool Interact(const std::string& Option) const;
bool Interact(const std::vector<std::string>& Options) const;
operator Internal::Player() const; operator Internal::Player() const;
}; };

19
Include/Game/Interactable/WallObject.hpp
View File

@ -5,7 +5,9 @@
#include "../../Core/Classes/ObjectInfo.hpp" #include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp" #include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp" #include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Box.hpp"
#include "../../Core/Types/Convex.hpp" #include "../../Core/Types/Convex.hpp"
#include "../../Core/Input.hpp"
#include <cstdint> #include <cstdint>
namespace Interactable namespace Interactable
@ -13,15 +15,24 @@ namespace Interactable
class WallObject : public Internal::WallObject class WallObject : public Internal::WallObject
{ {
public: public:
WallObject(const Internal::WallObject& G); WallObject(const Internal::WallObject& W);
WallObject(const WallObject& G); WallObject(const WallObject& W);
std::int32_t GetID() const; std::int32_t GetID() const;
std::string GetName() const; std::string GetName() const;
Tile GetTile() const;
Internal::ObjectInfo GetInfo() const; Internal::ObjectInfo GetInfo() const;
std::vector<Point> GetModel() const;
Box GetBox() const;
Point GetPoint() const;
Convex GetConvex() const; Convex GetConvex() const;
std::vector<Point> GetModel() const;
double GetVisibility() const;
Tile GetTile() const;
bool Interact(const Button& B = BUTTON_LEFT) const;
bool Interact(const std::string& Option) const;
bool Interact(const std::vector<std::string>& Options) const;
operator Internal::WallObject() const; operator Internal::WallObject() const;
}; };

35
Include/Game/Interactable/Widget.hpp Normal file
View File

@ -0,0 +1,35 @@
#ifndef INTERACTABLEWIDGET_HPP_INCLUDED
#define INTERACTABLEWIDGET_HPP_INCLUDED
#include "../../Core/Classes/Widget.hpp"
#include "../../Core/Classes/ItemInfo.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Point.hpp"
#include "../../Core/Types/Box.hpp"
#include "../../Core/Types/Convex.hpp"
#include "../../Core/Input.hpp"
#include <cstdint>
namespace Interactable
{
class Widget : public Internal::Widget
{
public:
Widget(const Internal::Widget& W);
Widget(const Widget& W);
bool IsHidden() const;
std::vector<std::int32_t> GetNormalizedItemIDs() const;
Box GetBox() const;
Point GetPoint() const;
bool Interact(const Button& B = BUTTON_LEFT) const;
bool Interact(const std::string& Option) const;
bool Interact(const std::vector<std::string>& Options) const;
operator Internal::Widget() const;
};
}
#endif // INTERACTABLEWIDGET_HPP_INCLUDED

238
Include/Game/Interfaces/Bank.hpp
View File

@ -21,264 +21,53 @@ class Bank
NOTED NOTED
} WITHDRAW_MODE; } WITHDRAW_MODE;
typedef enum REARRANGE_MODE
{
SWAP,
INSERT
} REARRANGE_MODE;
/**
* @brief Returns true if the Bank is currently Open
* @return True if the Bank is currently Open
* @par Example
* @code
* if (Bank::IsOpen)
* return Bank::Close();
* @endcode
*/
static bool IsOpen(); static bool IsOpen();
/**
* @brief Attempts to Close the Bank if it's Currently Open, returns true if the Bank is currently Closed
* @return Returns True if the is successfully Closed, or the Bank is already Closed
* @par Example
* @code
* if (Bank::IsOpen)
* return Bank::Close();
* @endcode
*/
static bool Close(); static bool Close();
static bool EnterPin();
/**
* @brief Returns an array of all Item IDs in the Bank Inventory Container
* @return An array of all Item IDs in the Bank Inventory Container
* @par Example
* @code
* std::int32_t Index = Bank::GetIndexOf(995);
* std::vector<std::int32_t> BankContainerItemIDs = Bank::GetItemIDs();
* if ((Index != -1) && (Index <= BankContainerItemIDs.size()))
* std::cout << "Item with ID " << BankContainerItemIDs[Index] << " is in the " << Index << "th position in Bank" << std::endl;
* @endcode
* @see @ref ICLibFunctions
*/
static std::vector<std::int32_t> GetItemIDs(); static std::vector<std::int32_t> GetItemIDs();
/**
* @brief Returns an array of all Item Names in the Bank Inventory Container
* @return An array of all Item Names in the Bank Inventory Container
* @par Example
* @code
* std::int32_t Index = Bank::GetIndexOf("Coins");
* std::vector<std::int32_t> BankContainerItemNames = Bank::GetItemNames();
* if ((Index != -1) && (Index <= BankContainerItemNames.size()))
* std::cout << "Item with Name " << BankContainerItemNames[Index] << " is in the " << Index << "th position in Bank" << std::endl;
* @endcode
* @see @ref ICLibFunctions
*/
static std::vector<std::string> GetItemNames(); static std::vector<std::string> GetItemNames();
/**
* @brief Returns an array of all Item Names in the Bank Inventory Container
* @return An array of all Item Names in the Bank Inventory Container
* @par Example
* @code
* std::int32_t Index = Bank::GetIndexOf("Coins");
* std::vector<std::int32_t> BankContainerItemNames = Bank::GetItemNames();
* if ((Index != -1) && (Index <= BankContainerItemNames.size()))
* std::cout << "Item with Name " << BankContainerItemNames[Index] << " is in the " << Index << "th position in Bank" << std::endl;
* @endcode
* @see @ref ICLibFunctions
*/
static std::vector<std::int32_t> GetItemAmounts(); static std::vector<std::int32_t> GetItemAmounts();
/**
* @brief Returns the total Item Amount of the specified Item matching the passed ID in the Bank
* @return The total Item Amount of the specified Item matching the passed ID in the Bank
* @par Example
* @code
* if (Bank::GetItemAmount(995) <= 100000)
* return false;
* @endcode
*/
static std::int32_t GetItemAmount(std::int32_t ID); static std::int32_t GetItemAmount(std::int32_t ID);
/**
* @brief Returns the total Item Amount of the specified Item matching the passed Name in the Bank
* @return The total Item Amount of the specified Item matching the passed Name in the Bank
* @par Example
* @code
* if (Bank::GetItemAmount(995) <= 100000)
* return false;
* @endcode
*/
static std::int32_t GetItemAmount(const std::string& Name); static std::int32_t GetItemAmount(const std::string& Name);
/**
* @brief Returns the Index of the first occurrence of the specified Item matching the passed ID in the GetItemIDs() array
* @return The Index of the first occurrence of the specified Item matching the passed ID in the GetItemIDs() array
* @note Returns -1 if no occurrence of the specified Item matching the passed ID is found in the GetItemIDs() array
*/
static std::int32_t GetIndexOf(std::int32_t ID); static std::int32_t GetIndexOf(std::int32_t ID);
/**
* @brief Returns the Index of the first occurrence of the specified Item matching the passed Name in the GetItemIDs() array
* @return The Index of the first occurrence of the specified Item matching the passed Name in the GetItemIDs() array
* @note Returns -1 if no occurrence of the specified Item matching the passed Name is found in the GetItemIDs() array
*/
static std::int32_t GetIndexOf(const std::string& Name); static std::int32_t GetIndexOf(const std::string& Name);
static Convex GetConvexByIndex(std::int32_t Index);
static Convex GetConvexOf(std::int32_t ID); static Convex GetConvexOf(std::int32_t ID);
static Convex GetConvexOf(const std::string& Name); static Convex GetConvexOf(const std::string& Name);
/**
* @brief Returns true if the Bank contains the specified Item matching the passed ID
* @return True if the Bank contains the specified Item matching the passed ID
* @par Example
* @code
* if (Bank::Contains(995))
* return Bank::WithdrawAllOf(995);
* @endcode
*/
static bool Contains(std::int32_t ID); static bool Contains(std::int32_t ID);
/**
* @brief Returns true if the Bank contains the specified Item matching the passed Name
* @return True if the Bank contains the specified Item matching the passed Name
* @par Example
* @code
* if (Bank::Contains("Coins"))
* return Bank::WithdrawAllOf("Coins");
* @endcode
*/
static bool Contains(const std::string& Name); static bool Contains(const std::string& Name);
/**
* @brief Returns true if the Bank contains all passed Item IDs, at least once
* @return True if the Bank contains all passed Item IDs, at least once
*/
static bool Contains(const std::vector<std::int32_t>& IDs); static bool Contains(const std::vector<std::int32_t>& IDs);
/**
* @brief Returns true if the Bank contains all passed Item Names, at least once
* @return True if the Bank contains all passed Item Item Names, at least once
*/
static bool Contains(const std::vector<std::string>& Names); static bool Contains(const std::vector<std::string>& Names);
/**
* @brief Returns true if the Bank contains any of the passed IDs, at least once
* @return True if the Bank contains any of the passed Item IDs, at least once
*/
static bool ContainsAny(const std::vector<std::int32_t>& IDs); static bool ContainsAny(const std::vector<std::int32_t>& IDs);
/**
* @brief Returns true if the Bank contains any of the passed Item Names, at least once
* @return True if the Bank contains any of the passed Item Names, at least once
*/
static bool ContainsAny(const std::vector<std::string>& Names); static bool ContainsAny(const std::vector<std::string>& Names);
/**
* @brief Returns true if the Bank only contains the passed Item ID
* @return True if the Bank only contains the passed Item ID
*/
static bool ContainsOnly(std::int32_t ID); static bool ContainsOnly(std::int32_t ID);
/**
* @brief Returns true if the Bank only contains the passed Item Name
* @return True if the Bank only contains the passed Item Name
*/
static bool ContainsOnly(const std::string& Name); static bool ContainsOnly(const std::string& Name);
/**
* @brief Returns true if the Bank only contains the passed Item IDs
* @return True if the Bank only contains the passed Item IDs
*/
static bool ContainsOnly(const std::vector<std::int32_t>& IDs); static bool ContainsOnly(const std::vector<std::int32_t>& IDs);
/**
* @brief Returns true if the Bank only contains the passed Item Names
* @return True if the Bank only contains the passed Item Names
*/
static bool ContainsOnly(const std::vector<std::string>& Names); static bool ContainsOnly(const std::vector<std::string>& Names);
/**
* @brief Returns the currently active Bank Tab
* @return The currently active Bank Tab
* @note Returns -1 if no currently active Bank Tab is found
* @par Example
* @code
* if (Bank::GetCurrentTab() == 0)
* Debug("The All tab is open");
* @endcode
*/
static std::int32_t GetCurrentTab(); static std::int32_t GetCurrentTab();
/**
* @brief Returns the Tab Index of the specified Item matching the passed ID
* @return The Tab Index of the specified Item matching the passed ID
* @par Example
* @code
* std::int32_t TabWithCoins = Bank::GetTabOf(995);
* if (Bank::GetCurrentTab() != TabWithCoins)
* return Bank::OpenTab(TabWithCoins);
* @endcode
*/
static std::int32_t GetTabOf(std::int32_t ID); static std::int32_t GetTabOf(std::int32_t ID);
/**
* @brief Returns the Tab Index of the specified Item Name
* @return The Tab Index of the specified Item Name
* @par Example
* @code
* std::int32_t TabWithCoins = Bank::GetTabOf("Coins");
* if (Bank::GetCurrentTab() != TabWithCoins)
* return Bank::OpenTab(TabWithCoins);
* @endcode
*/
static std::int32_t GetTabOf(const std::string& Name); static std::int32_t GetTabOf(const std::string& Name);
/**
* @brief Attempts to Open the specified Bank Tab, 0 being all items
* @return True if it successfully opens the specified Bank Tab
* @par Example
* @code
* if ((Bank::IsOpen()) && (Bank::GetCurrentTab() != 0))
* return Bank::OpenTab(0);
* @endcode
*/
static bool OpenTab(std::int32_t Tab); static bool OpenTab(std::int32_t Tab);
/** static bool ScrollTo(std::int32_t ID, bool OpenTab = true);
* @brief Attempts to Scroll to the specified Item matching the passed ID static bool ScrollTo(const std::string& Name, bool OpenTab = true);
* @return True if it successfully scrolls to the specified Item matching the passed ID
* @note Returns true if the Item is already in view
* @par Example
* @code
* if (Bank::Contains(995))
* return Bank::ScrolTo(995);
* @endcode
*/
static bool ScrollTo(std::int32_t ID);
/** static bool InteractItemByIndex(std::int32_t ID, const std::string& Option);
* @brief Attempts to Scroll to the specified Item matching the passed Name static bool InteractItem(std::int32_t ID, const std::string& Option);
* @return True if it successfully scrolls to the specified Item matching the passed Name static bool InteractItem(const std::string& Name, const std::string& Option);
* @note Returns true if the Item is already in view
* @par Example
* @code
* if (Bank::Contains("Coins"))
* return Bank::ScrolTo("Coins");
* @endcode
*/
static bool ScrollTo(const std::string& Name);
/**
* @brief Attempts to Scroll to the specified Item matching the passed Name, and optionally Opens the Tab
* @return True if it successfully scrolls to the specified Item matching the passed Name
* @note Returns true if the Item is already in view
* @par Example
* @code
* if (Bank::Contains("Coins"))
* return Bank::ScrolTo("Coins");
* @endcode
*/
static bool ScrollTo(std::int32_t ID, bool OpenTab);
static bool ScrollTo(const std::string& Name, bool OpenTab);
static bool WithdrawAllOf(std::int32_t ID);
static bool WithdrawAllOf(const std::string& Name);
static bool WithdrawXOf(std::int32_t ID, std::int32_t Amount); static bool WithdrawXOf(std::int32_t ID, std::int32_t Amount);
static bool WithdrawXOf(const std::string& Name, std::int32_t Amount); static bool WithdrawXOf(const std::string& Name, std::int32_t Amount);
static bool WithdrawAllOf(std::int32_t ID);
static bool WithdrawAllOf(const std::string& Name);
static bool WithdrawAllButOneOf(std::int32_t ID); static bool WithdrawAllButOneOf(std::int32_t ID);
static bool WithdrawAllButOneOf(const std::string& Name); static bool WithdrawAllButOneOf(const std::string& Name);
@ -286,15 +75,16 @@ class Bank
static bool DepositAllOf(const std::string& Name); static bool DepositAllOf(const std::string& Name);
static bool DepositXOf(std::int32_t ID, std::int32_t Amount); static bool DepositXOf(std::int32_t ID, std::int32_t Amount);
static bool DepositXOf(const std::string& Name, std::int32_t Amount); static bool DepositXOf(const std::string& Name, std::int32_t Amount);
static bool DepositAllExcept(const std::string Name); static bool DepositAllExcept(const std::string& Name);
static bool DepositAllExcept(const std::vector<std::string> Names); static bool DepositAllExcept(const std::vector<std::string>& Names);
static bool DepositAllExcept(std::int32_t ID); static bool DepositAllExcept(std::int32_t ID);
static bool DepositAllExcept(const std::vector<std::int32_t> IDs); static bool DepositAllExcept(const std::vector<std::int32_t>& IDs);
static bool DepositAll(); static bool DepositAll();
static bool DepositEquipment(); static bool DepositEquipment();
static WITHDRAW_MODE GetWithdrawMode(); static WITHDRAW_MODE GetWithdrawMode();
static bool SetWithdrawMode(WITHDRAW_MODE Mode);
}; };
/** @} */ /** @} */

2
Include/Game/Interfaces/GameTabs/Combat.hpp
View File

@ -22,7 +22,7 @@ class Combat
static bool IsPoisoned(); static bool IsPoisoned();
static bool HasPoisonImmunity(); static bool HasPoisonImmunity();
static bool GetAutoRetaliate(); static bool IsAutoRetaliating();
static bool ToggleAutoRetaliate(bool Toggle); static bool ToggleAutoRetaliate(bool Toggle);
static std::string GetStyle(); static std::string GetStyle();

4
Include/Game/Interfaces/GameTabs/Equipment.hpp
View File

@ -56,6 +56,10 @@ class Equipment
static bool ContainsOnly(const std::vector<std::int32_t>& IDs); static bool ContainsOnly(const std::vector<std::int32_t>& IDs);
static bool ContainsOnly(const std::vector<std::string>& Names); static bool ContainsOnly(const std::vector<std::string>& Names);
static bool InteractItemBySlot(SLOTS Slot, const std::string& Option);
static bool InteractItem(std::int32_t ID, const std::string& Option);
static bool InteractItem(const std::string& Name, const std::string& Option);
static bool UnequipItem(SLOTS Slot); static bool UnequipItem(SLOTS Slot);
static bool UnequipItem(std::int32_t ID); static bool UnequipItem(std::int32_t ID);
static bool UnequipItem(const std::string& Name); static bool UnequipItem(const std::string& Name);

27
Include/Game/Interfaces/GameTabs/Inventory.hpp
View File

@ -48,8 +48,13 @@ class Inventory
static std::vector<std::int32_t> GetIndicesOf(std::int32_t ID); static std::vector<std::int32_t> GetIndicesOf(std::int32_t ID);
static std::vector<std::int32_t> GetIndicesOf(const std::string& Name); static std::vector<std::int32_t> GetIndicesOf(const std::string& Name);
static Convex GetConvexOf(std::int32_t SlotIndex); static Convex GetConvexByIndex(std::int32_t Index);
static Convex GetConvexOf(std::int32_t ID);
static Convex GetConvexOf(const std::string& Name);
static Convex GetConvexOf(const std::vector<std::int32_t>& IDs); // Returns first found ID Convex
static Convex GetConvexOf(const std::vector<std::string>& Names); // Returns first found Name Convex
static Box GetBoxByIndex(std::int32_t Index);
static Box GetBoxOf(std::int32_t ID); static Box GetBoxOf(std::int32_t ID);
static Box GetBoxOf(const std::string& Name); static Box GetBoxOf(const std::string& Name);
static Box GetBoxOf(const std::vector<std::int32_t>& IDs); // Returns first found ID box static Box GetBoxOf(const std::vector<std::int32_t>& IDs); // Returns first found ID box
@ -72,25 +77,21 @@ class Inventory
static bool ContainsOnly(const std::vector<std::int32_t>& IDs); static bool ContainsOnly(const std::vector<std::int32_t>& IDs);
static bool ContainsOnly(const std::vector<std::string>& Names); static bool ContainsOnly(const std::vector<std::string>& Names);
static bool InteractItemByIndex(std::int32_t Index); static bool InteractItemByIndex(std::int32_t Index, const std::string& Option);
static bool InteractItemByIndex(std::int32_t Index, const std::string& Action); static bool InteractItemByIndex(std::int32_t Index, const std::vector<std::string>& Options);
static bool InteractItemByIndex(std::int32_t Index, const std::vector<std::string>& Actions); static bool InteractItem(std::int32_t ID, const std::string& Option);
static bool InteractItem(const std::string& Name, const std::string& Option);
static bool InteractItem(std::int32_t ID, const std::string& Action = ""); static bool InteractItem(const std::vector<std::int32_t>& IDs, const std::vector<std::string>& Options); //Interacts with first found ID
static bool InteractItem(const std::string& Name, const std::string& Action = ""); static bool InteractItem(const std::vector<std::string>& Names, const std::vector<std::string>& Options); //Interacts with first found Name
static bool InteractItem(const std::vector<std::int32_t>& IDs, const std::vector<std::string>& Actions); //Interacts with first found ID and Action
static bool InteractItem(const std::vector<std::string>& Names, const std::vector<std::string>& Actions); //Interacts with first found Name and Action
static bool DropItemByIndex(std::int32_t Index, bool AllowShiftClick = true); static bool DropItemByIndex(std::int32_t Index, bool AllowShiftClick = true);
static bool DropItem(std::int32_t ID, bool AllowShiftClick = true); static bool DropItem(std::int32_t ID, bool AllowShiftClick = true);
static bool DropItem(const std::string& Name, bool AllowShiftClick = true); static bool DropItem(const std::string& Name, bool AllowShiftClick = true);
static bool UseItem(std::int32_t ID); static bool UseItem(std::int32_t ID);
static bool UseItem(const std::string& Name); static bool UseItem(const std::string& Name);
static bool UseItemOn(std::int32_t FirstItemID, std::int32_t SecondItemID);
static bool UseItemOn(std::int32_t PrimaryID, std::int32_t SecondaryID); static bool UseItemOn(const std::string& FirstItemName, const std::string& SecondItemName);
static bool UseItemOn(const std::string& PrimaryName, const std::string& SecondaryName);
}; };
/** @} */ /** @} */

6
Include/Game/Interfaces/GameTabs/Logout.hpp
View File

@ -17,17 +17,17 @@ class Logout
static bool LogoutPlayer(); static bool LogoutPlayer();
static bool IsWorldSwitcherOpen(); static bool IsWorldSwitcherOpen();
static bool OpenWorldSwitcher(bool OpenInventory = false); static bool OpenWorldSwitcher();
static bool WorldSwitcherScrollTo(Internal::World World); static bool WorldSwitcherScrollTo(Internal::World World);
static bool WorldSwitcherScrollTo(std::int32_t WorldID); static bool WorldSwitcherScrollTo(std::int32_t WorldID);
static bool SwitchWorld(Internal::World World); static bool SwitchWorld(const Internal::World& World);
static bool SwitchWorld(std::int32_t WorldID); static bool SwitchWorld(std::int32_t WorldID);
static std::vector<std::uint32_t> GetFavoriteWorlds(); static std::vector<std::uint32_t> GetFavoriteWorlds();
static Internal::Widget GetWorldWidget(Internal::World World); static Internal::Widget GetWorldWidget(const Internal::World& World);
static Internal::Widget GetWorldWidget(std::int32_t WorldID); static Internal::Widget GetWorldWidget(std::int32_t WorldID);
static Internal::Widget GetFavoriteWorldWidget(std::int32_t WorldID); static Internal::Widget GetFavoriteWorldWidget(std::int32_t WorldID);
}; };

1
Include/Game/Interfaces/GameTabs/Quests.hpp
View File

@ -6,6 +6,7 @@
class Quests class Quests
{ {
public: public:
static bool IsOpen(); static bool IsOpen();
static bool Open(); static bool Open();
}; };

24
Include/Game/Interfaces/Mainscreen.hpp
View File

@ -22,7 +22,15 @@ class Mainscreen
PLAYING PLAYING
} SCREEN_STATE; } SCREEN_STATE;
typedef enum CROSSHAIR_STATE
{
NONE,
YELLOW,
RED
} CROSSHAIR_STATE;
static Mainscreen::SCREEN_STATE GetState(); static Mainscreen::SCREEN_STATE GetState();
static Mainscreen::CROSSHAIR_STATE GetCrosshairState();
static bool IsLoggedIn(); static bool IsLoggedIn();
static bool IsPlaying(); static bool IsPlaying();
@ -35,17 +43,11 @@ class Mainscreen
static bool WaitIsUpText(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText); static bool WaitIsUpText(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText);
static bool WaitUpTextContains(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText); static bool WaitUpTextContains(std::uint32_t Duration, std::uint32_t Step, const std::string& UpText);
static Internal::Character GetInteractingByIndex(std::uint32_t Index); static std::int32_t GetCameraX();
static Internal::Character GetInteracting(); //Returns the Character interacting with the Local Player static std::int32_t GetCameraY();
static Internal::Character GetInteractingWith(const Internal::Character& C); //Returns the Character interactinng with the Character static std::int32_t GetCameraZ();
static std::int32_t GetCameraPitch();
static bool IsInteracting(const Internal::Character& A, const Internal::Character& B); // True if A is interacting with B static std::int32_t GetCameraYaw();
static std::int32_t CameraX();
static std::int32_t CameraY();
static std::int32_t CameraZ();
static std::int32_t CameraPitch();
static std::int32_t CameraYaw();
static bool SetCameraPitch(std::int32_t Pitch); static bool SetCameraPitch(std::int32_t Pitch);
}; };

252
Include/Game/Interfaces/Menu.hpp
View File

@ -12,38 +12,252 @@ class Menu
{ {
public: public:
/**
* @brief Returns true if the right-click menu is open
*
* @return true if the right-click menu is open
*/
static bool IsOpen(); 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(); 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(); 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(); static std::vector<std::string> GetActionsRaw();
static std::vector<std::string> GetActions();
/**
* @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(); 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(); 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(); static std::vector<std::string> GetOptions();
static std::int32_t IndexOf(const std::string& Action);
static std::int32_t IndexOf(const std::string& Action, const std::string& Target);
static std::int32_t IndexOf(const std::vector<std::string>& PossibleActions);
static std::int32_t IndexOf(const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets);
static bool Contains(const std::string& Action); /**
static bool Contains(const std::string& Action, const std::string& Target); * @brief Get the index of the found option
static bool Contains(const std::vector<std::string>& PossibleActions); *
static bool Contains(const std::vector<std::string>& PossibleActions, const std::vector<std::string>& Targets); * @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);
static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::string& Action); /**
static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::string& Action, const std::string& Target); * @brief Get the index of the first found option
static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::vector<std::string>& PossibleActions); // Waits until the Menu contains at least one of these actions *
static bool WaitContains(std::uint32_t Duration, std::uint32_t Step, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets); // Waits until the Menu contains at least one of these actions and Targets * @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);
static bool Select(std::uint32_t Index);
static bool Select(const std::string& Action);
static bool Select(const std::string& Action, const std::string& Target);
static bool Select(const std::vector<std::string>& PossibleActions);
static bool Select(const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets);
static std::vector<Box> GetBoxes(); /**
* @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>
* bool [0] = Found option at index was found in menu options (should be always true if something was found at index)
* 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<bool, 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>
* bool [0] = Option was found in the Menu options
* std::string [1] = Action that was found
* std::string [2] = Target that was found
* @see Menu::IndexOf(const std::string& Option)
*/
static std::tuple<bool, 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, the more specific, the more accurate the result will be
* @return std::tuple<bool, std::string, std::string>
* bool [0] = Option was found in the Menu options
* std::string [1] = Action that was found
* std::string [2] = Target that was found
* @see Menu::IndexOf(const std::string& Option)
*/
static std::tuple<bool, std::string, std::string> FindOption(const std::vector<std::string>& Options);
/**
* @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(); static Box GetBox();
}; };

36
Include/Game/Models/DecorativeObjects.hpp
View File

@ -1,10 +1,7 @@
#ifndef DECORATIVEOBJECTS_HPP_INCLUDED #ifndef DECORATIVEOBJECTS_HPP_INCLUDED
#define DECORATIVEOBJECTS_HPP_INCLUDED #define DECORATIVEOBJECTS_HPP_INCLUDED
#include "../../Core/Classes/DecorativeObject.hpp" #include "../../Game/Interactable/DecorativeObject.hpp"
#include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Convex.hpp"
#include <functional> #include <functional>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@ -16,25 +13,20 @@ class DecorativeObjects
{ {
public: public:
static Internal::ObjectInfo GetInfoOf(const Internal::DecorativeObject& D); static std::vector<Interactable::DecorativeObject> GetAll();
static Tile GetTileOf(const Internal::DecorativeObject& D); static std::vector<Interactable::DecorativeObject> GetAll(std::int32_t ID);
static std::vector<Point> GetModelOf(const Internal::DecorativeObject& D); static std::vector<Interactable::DecorativeObject> GetAll(const std::string& Name);
static Convex GetConvexOf(const Internal::DecorativeObject& D); static std::vector<Interactable::DecorativeObject> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Interactable::DecorativeObject> GetAll(const std::vector<std::string>& Names);
static std::vector<Interactable::DecorativeObject> GetAll(const std::function<bool (const Interactable::DecorativeObject&)>& Filter);
//consider changing to Interactable::GameObject static Interactable::DecorativeObject Get();
static std::vector<Internal::DecorativeObject> GetAll(); static Interactable::DecorativeObject Get(const Tile& T);
static std::vector<Internal::DecorativeObject> GetAll(std::int32_t ID); static Interactable::DecorativeObject Get(std::int32_t ID);
static std::vector<Internal::DecorativeObject> GetAll(const std::string& Name); static Interactable::DecorativeObject Get(const std::string& Name);
static std::vector<Internal::DecorativeObject> GetAll(const std::vector<std::int32_t>& PossibleIDs); static Interactable::DecorativeObject Get(const std::vector<std::int32_t>& IDs);
static std::vector<Internal::DecorativeObject> GetAll(const std::vector<std::string>& PossibleNames); static Interactable::DecorativeObject Get(const std::vector<std::string>& Names);
static std::vector<Internal::DecorativeObject> GetAll(const std::function<bool (const Internal::DecorativeObject&)>& Filter); static Interactable::DecorativeObject Get(const std::function<bool (const Interactable::DecorativeObject&)>& Filter);
static Internal::DecorativeObject Get(const Tile& T);
static Internal::DecorativeObject Get(std::int32_t ID);
static Internal::DecorativeObject Get(const std::string& Name);
static Internal::DecorativeObject Get(const std::vector<std::int32_t>& PossibleIDs);
static Internal::DecorativeObject Get(const std::vector<std::string>& PossibleNames);
static Internal::DecorativeObject Get(const std::function<bool (const Internal::DecorativeObject&)>& Filter);
}; };
/** @} */ /** @} */

38
Include/Game/Models/GameObjects.hpp
View File

@ -1,10 +1,7 @@
#ifndef GAMEOBJECTS_HPP_INCLUDED #ifndef GAMEOBJECTS_HPP_INCLUDED
#define GAMEOBJECTS_HPP_INCLUDED #define GAMEOBJECTS_HPP_INCLUDED
#include "../../Core/Classes/GameObject.hpp" #include "../../Game/Interactable/GameObject.hpp"
#include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Convex.hpp"
#include <functional> #include <functional>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@ -16,26 +13,21 @@ class GameObjects
{ {
public: public:
static Internal::ObjectInfo GetInfoOf(const Internal::GameObject& G); static std::vector<Interactable::GameObject> GetAll();
static Tile GetTileOf(const Internal::GameObject& G); static std::vector<Interactable::GameObject> GetAll(const Tile& T);
static std::vector<Point> GetModelOf(const Internal::GameObject& G); static std::vector<Interactable::GameObject> GetAll(std::int32_t ID);
static Convex GetConvexOf(const Internal::GameObject& G); static std::vector<Interactable::GameObject> GetAll(const std::string& Name);
static std::vector<Interactable::GameObject> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Interactable::GameObject> GetAll(const std::vector<std::string>& Names);
static std::vector<Interactable::GameObject> GetAll(const std::function<bool (const Interactable::GameObject&)>& Filter);
//consider changing to Interactable::GameObject static Interactable::GameObject Get();
static std::vector<Internal::GameObject> GetAll(); static Interactable::GameObject Get(const Tile& T);
static std::vector<Internal::GameObject> GetAll(const Tile& T); static Interactable::GameObject Get(std::int32_t ID);
static std::vector<Internal::GameObject> GetAll(std::int32_t ID); static Interactable::GameObject Get(const std::string& Name);
static std::vector<Internal::GameObject> GetAll(const std::string& Name); static Interactable::GameObject Get(const std::vector<std::int32_t>& IDs);
static std::vector<Internal::GameObject> GetAll(const std::vector<std::int32_t>& PossibleIDs); static Interactable::GameObject Get(const std::vector<std::string>& Names);
static std::vector<Internal::GameObject> GetAll(const std::vector<std::string>& PossibleNames); static Interactable::GameObject Get(const std::function<bool (const Interactable::GameObject&)>& Filter);
static std::vector<Internal::GameObject> GetAll(const std::function<bool (const Internal::GameObject&)>& Filter);
static Internal::GameObject Get(const Tile& T);
static Internal::GameObject Get(std::int32_t ID);
static Internal::GameObject Get(const std::string& Name);
static Internal::GameObject Get(const std::vector<std::int32_t>& PossibleIDs);
static Internal::GameObject Get(const std::vector<std::string>& PossibleNames);
static Internal::GameObject Get(const std::function<bool (const Internal::GameObject&)>& Filter);
}; };
/** @} */ /** @} */

33
Include/Game/Models/GroundItems.hpp
View File

@ -1,9 +1,7 @@
#ifndef GROUNDITEMS_HPP_INCLUDED #ifndef GROUNDITEMS_HPP_INCLUDED
#define GROUNDITEMS_HPP_INCLUDED #define GROUNDITEMS_HPP_INCLUDED
#include "../../Core/Classes/GroundItem.hpp" #include "../../Game/Interactable/GroundItem.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Convex.hpp"
#include <functional> #include <functional>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@ -14,23 +12,22 @@
class GroundItems class GroundItems
{ {
public: public:
static std::vector<Internal::GroundItem> GetAll();
static std::vector<Internal::GroundItem> GetAll(Tile T);
static std::vector<Internal::GroundItem> GetAll(std::int32_t ID);
static std::vector<Internal::GroundItem> GetAll(const std::string& Name);
static std::vector<Internal::GroundItem> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Internal::GroundItem> GetAll(const std::vector<std::string>& Names);
static std::vector<Internal::GroundItem> GetAll(const std::function<bool (Internal::GroundItem&)>& Filter);
static Internal::GroundItem Get(Tile T); static std::vector<Interactable::GroundItem> GetAll();
static Internal::GroundItem Get(std::int32_t ID); static std::vector<Interactable::GroundItem> GetAll(const Tile& T);
static Internal::GroundItem Get(const std::string& Name); static std::vector<Interactable::GroundItem> GetAll(std::int32_t ID);
static Internal::GroundItem Get(const std::vector<std::int32_t>& IDs); static std::vector<Interactable::GroundItem> GetAll(const std::string& Name);
static Internal::GroundItem Get(const std::vector<std::string>& Names); static std::vector<Interactable::GroundItem> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Interactable::GroundItem> GetAll(const std::vector<std::string>& Names);
static std::vector<Interactable::GroundItem> GetAll(const std::function<bool (Interactable::GroundItem&)>& Filter);
static Tile GetTileOf(Internal::GroundItem G); static Interactable::GroundItem Get();
static Interactable::GroundItem Get(const Tile& T);
static Convex GetConvexOf(Internal::GroundItem G); static Interactable::GroundItem Get(std::int32_t ID);
static Interactable::GroundItem Get(const std::string& Name);
static Interactable::GroundItem Get(const std::vector<std::int32_t>& IDs);
static Interactable::GroundItem Get(const std::vector<std::string>& Names);
static Interactable::GroundItem Get(const std::function<bool (Interactable::GroundItem&)>& Filter);
}; };
/** @} */ /** @} */

36
Include/Game/Models/GroundObjects.hpp
View File

@ -1,10 +1,7 @@
#ifndef GROUNDOBJECTS_HPP_INCLUDED #ifndef GROUNDOBJECTS_HPP_INCLUDED
#define GROUNDOBJECTS_HPP_INCLUDED #define GROUNDOBJECTS_HPP_INCLUDED
#include "../../Core/Classes/GroundObject.hpp" #include "../../Game/Interactable/GroundObject.hpp"
#include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Convex.hpp"
#include <functional> #include <functional>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@ -16,25 +13,20 @@ class GroundObjects
{ {
public: public:
static Internal::ObjectInfo GetInfoOf(const Internal::GroundObject& G); static std::vector<Interactable::GroundObject> GetAll();
static Tile GetTileOf(const Internal::GroundObject& G); static std::vector<Interactable::GroundObject> GetAll(std::int32_t ID);
static std::vector<Point> GetModelOf(const Internal::GroundObject& G); static std::vector<Interactable::GroundObject> GetAll(const std::string& Name);
static Convex GetConvexOf(const Internal::GroundObject& G); static std::vector<Interactable::GroundObject> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Interactable::GroundObject> GetAll(const std::vector<std::string>& Names);
static std::vector<Interactable::GroundObject> GetAll(const std::function<bool (const Interactable::GroundObject&)>& Filter);
//consider changing to Interactable::GameObject static Interactable::GroundObject Get();
static std::vector<Internal::GroundObject> GetAll(); static Interactable::GroundObject Get(const Tile& T);
static std::vector<Internal::GroundObject> GetAll(std::int32_t ID); static Interactable::GroundObject Get(std::int32_t ID);
static std::vector<Internal::GroundObject> GetAll(const std::string& Name); static Interactable::GroundObject Get(const std::string& Name);
static std::vector<Internal::GroundObject> GetAll(const std::vector<std::int32_t>& PossibleIDs); static Interactable::GroundObject Get(const std::vector<std::int32_t>& IDs);
static std::vector<Internal::GroundObject> GetAll(const std::vector<std::string>& PossibleNames); static Interactable::GroundObject Get(const std::vector<std::string>& Names);
static std::vector<Internal::GroundObject> GetAll(const std::function<bool (const Internal::GroundObject&)>& Filter); static Interactable::GroundObject Get(const std::function<bool (const Interactable::GroundObject&)>& Filter);
static Internal::GroundObject Get(const Tile& T);
static Internal::GroundObject Get(std::int32_t ID);
static Internal::GroundObject Get(const std::string& Name);
static Internal::GroundObject Get(const std::vector<std::int32_t>& PossibleIDs);
static Internal::GroundObject Get(const std::vector<std::string>& PossibleNames);
static Internal::GroundObject Get(const std::function<bool (const Internal::GroundObject&)>& Filter);
}; };
/** @} */ /** @} */

35
Include/Game/Models/NPCs.hpp
View File

@ -1,9 +1,7 @@
#ifndef NPCS_HPP_INCLUDED #ifndef NPCS_HPP_INCLUDED
#define NPCS_HPP_INCLUDED #define NPCS_HPP_INCLUDED
#include "../../Core/Classes/NPC.hpp" #include "../../Game/Interactable/NPC.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Convex.hpp"
#include <functional> #include <functional>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@ -15,25 +13,22 @@
class NPCs class NPCs
{ {
public: public:
static std::vector<Internal::NPC> GetAll();
static std::vector<Internal::NPC> GetAll(const Tile& Tile);
static std::vector<Internal::NPC> GetAll(std::int32_t ID);
static std::vector<Internal::NPC> GetAll(const std::string& Name);
static std::vector<Internal::NPC> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Internal::NPC> GetAll(const std::vector<std::string>& Names);
static std::vector<Internal::NPC> GetAll(const std::function<bool (Internal::NPC&)>& Filter);
static Internal::NPC Get(); static std::vector<Interactable::NPC> GetAll();
static Internal::NPC Get(const Tile& Tile); static std::vector<Interactable::NPC> GetAll(const Tile& Tile);
static Internal::NPC Get(std::int32_t ID); static std::vector<Interactable::NPC> GetAll(std::int32_t ID);
static Internal::NPC Get(const std::string& Name); static std::vector<Interactable::NPC> GetAll(const std::string& Name);
static Internal::NPC Get(const std::vector<std::int32_t>& IDs); static std::vector<Interactable::NPC> GetAll(const std::vector<std::int32_t>& IDs);
static Internal::NPC Get(const std::vector<std::string>& Names); static std::vector<Interactable::NPC> GetAll(const std::vector<std::string>& Names);
static Internal::NPC Get(const std::function<bool (Internal::NPC&)>& Filter); static std::vector<Interactable::NPC> GetAll(const std::function<bool (Interactable::NPC&)>& Filter);
static Tile GetTileOf(const Internal::NPC& NPC); static Interactable::NPC Get();
static Interactable::NPC Get(const Tile& Tile);
static Convex GetConvexOf(const Internal::NPC& NPC); static Interactable::NPC Get(std::int32_t ID);
static Interactable::NPC Get(const std::string& Name);
static Interactable::NPC Get(const std::vector<std::int32_t>& IDs);
static Interactable::NPC Get(const std::vector<std::string>& Names);
static Interactable::NPC Get(const std::function<bool (Interactable::NPC&)>& Filter);
}; };
/** @} */ /** @} */

29
Include/Game/Models/Players.hpp
View File

@ -1,9 +1,7 @@
#ifndef PLAYERS_HPP_INCLUDED #ifndef PLAYERS_HPP_INCLUDED
#define PLAYERS_HPP_INCLUDED #define PLAYERS_HPP_INCLUDED
#include "../../Core/Classes/Player.hpp" #include "../../Game/Interactable/Player.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Convex.hpp"
#include <functional> #include <functional>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@ -14,22 +12,19 @@
class Players class Players
{ {
public: public:
static Internal::Player GetLocal();
static std::vector<Internal::Player> GetAll();
static std::vector<Internal::Player> GetAll(const Tile& Tile);
static std::vector<Internal::Player> GetAll(const std::string& Name);
static std::vector<Internal::Player> GetAll(const std::vector<std::string>& Names);
static std::vector<Internal::Player> GetAll(const std::function<bool (Internal::Player&)>& Filter);
static Internal::Player Get(); static Interactable::Player GetLocal();
static Internal::Player Get(const Tile& Tile); static std::vector<Interactable::Player> GetAll();
static Internal::Player Get(const std::string& Name); static std::vector<Interactable::Player> GetAll(const Tile& Tile);
static Internal::Player Get(const std::vector<std::string>& Names); static std::vector<Interactable::Player> GetAll(const std::string& Name);
static Internal::Player Get(const std::function<bool (Internal::Player&)>& Filter); static std::vector<Interactable::Player> GetAll(const std::vector<std::string>& Names);
static std::vector<Interactable::Player> GetAll(const std::function<bool (Interactable::Player&)>& Filter);
static Tile GetTileOf(const Internal::Player& P); static Interactable::Player Get();
static Interactable::Player Get(const Tile& Tile);
static Convex GetConvexOf(const Internal::Player& P); static Interactable::Player Get(const std::string& Name);
static Interactable::Player Get(const std::vector<std::string>& Names);
static Interactable::Player Get(const std::function<bool (Interactable::Player&)>& Filter);
}; };
/** @} */ /** @} */

36
Include/Game/Models/WallObjects.hpp
View File

@ -1,10 +1,7 @@
#ifndef WALLOBJECTS_HPP_INCLUDED #ifndef WALLOBJECTS_HPP_INCLUDED
#define WALLOBJECTS_HPP_INCLUDED #define WALLOBJECTS_HPP_INCLUDED
#include "../../Core/Classes/WallObject.hpp" #include "../../Game/Interactable/WallObject.hpp"
#include "../../Core/Classes/ObjectInfo.hpp"
#include "../../Core/Types/Tile.hpp"
#include "../../Core/Types/Convex.hpp"
#include <functional> #include <functional>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@ -16,25 +13,20 @@ class WallObjects
{ {
public: public:
static Internal::ObjectInfo GetInfoOf(const Internal::WallObject& W); static std::vector<Interactable::WallObject> GetAll();
static Tile GetTileOf(const Internal::WallObject& W); static std::vector<Interactable::WallObject> GetAll(std::int32_t ID);
static std::vector<Point> GetModelOf(const Internal::WallObject& W); static std::vector<Interactable::WallObject> GetAll(const std::string& Name);
static Convex GetConvexOf(const Internal::WallObject& W); static std::vector<Interactable::WallObject> GetAll(const std::vector<std::int32_t>& IDs);
static std::vector<Interactable::WallObject> GetAll(const std::vector<std::string>& Names);
static std::vector<Interactable::WallObject> GetAll(const std::function<bool (const Interactable::WallObject&)>& Filter);
//consider changing to Interactable::GameObject static Interactable::WallObject Get();
static std::vector<Internal::WallObject> GetAll(); static Interactable::WallObject Get(const Tile& T);
static std::vector<Internal::WallObject> GetAll(std::int32_t ID); static Interactable::WallObject Get(std::int32_t ID);
static std::vector<Internal::WallObject> GetAll(const std::string& Name); static Interactable::WallObject Get(const std::string& Name);
static std::vector<Internal::WallObject> GetAll(const std::vector<std::int32_t>& PossibleIDs); static Interactable::WallObject Get(const std::vector<std::int32_t>& IDs);
static std::vector<Internal::WallObject> GetAll(const std::vector<std::string>& PossibleNames); static Interactable::WallObject Get(const std::vector<std::string>& Names);
static std::vector<Internal::WallObject> GetAll(const std::function<bool (const Internal::WallObject&)>& Filter); static Interactable::WallObject Get(const std::function<bool (const Interactable::WallObject&)>& Filter);
static Internal::WallObject Get(const Tile& T);
static Internal::WallObject Get(std::int32_t ID);
static Internal::WallObject Get(const std::string& Name);
static Internal::WallObject Get(const std::vector<std::int32_t>& PossibleIDs);
static Internal::WallObject Get(const std::vector<std::string>& PossibleNames);
static Internal::WallObject Get(const std::function<bool (const Internal::WallObject&)>& Filter);
}; };
/** @} */ /** @} */

59
Include/Game/Tools/Interact.hpp
View File

@ -12,62 +12,31 @@
class Interact class Interact
{ {
public: public:
static bool MoveMouse(Point P);
static bool MoveMouse(Box B);
static bool Scroll(ScrollDirection Direction); static bool MoveMouse(const Point& P);
static bool Scroll(Point P, ScrollDirection Direction); static bool MoveMouse(const Box& B);
static bool Scroll(Box B, ScrollDirection Direction);
static bool ScrollUntil(ScrollDirection Direction, std::int32_t Duration, const std::function<bool()>& Func);
static bool Click(Button Button = BUTTON_LEFT); static bool Click(const Button& B = BUTTON_LEFT);
static bool Click(Point P, Button Button = BUTTON_LEFT); static bool Click(const Point& P, const Button& B = BUTTON_LEFT);
static bool Click(Point P, const std::string& Action, const std::string& Target = ""); static bool Click(const Point& P, const std::string& Option);
static bool Click(Point P, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""}); static bool Click(const Point& P, const std::vector<std::string>& Options);
static bool Click(Box B, Button Button = BUTTON_LEFT); static bool Click(const Box& B, const Button& Button = BUTTON_LEFT);
static bool Click(Box B, const std::string& Action, const std::string& Target = ""); static bool Click(const Box& B, const std::string& Option);
static bool Click(Box B, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""}); static bool Click(const Box& B, const std::vector<std::string>& Options);
static bool Click(Internal::Widget W, Button Button = BUTTON_LEFT); static bool Click(const Convex& C, const Button& B = BUTTON_LEFT);
static bool Click(Internal::Widget W, const std::string& Action, const std::string& Target = ""); static bool Click(const Convex& C, const std::string& Option);
static bool Click(Internal::Widget W, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""}); static bool Click(const Convex& C, const std::vector<std::string>& Options);
static bool Click(Convex C, Button Button = BUTTON_LEFT); static bool Scroll(const ScrollDirection& Direction);
static bool Click(Convex C, const std::string& Action, const std::string& Target = ""); static bool ScrollUntil(const ScrollDirection& Direction, std::int32_t Duration, const std::function<bool()>& Func);
static bool Click(Convex C, const std::vector<std::string>& PossibleActions, const std::vector<std::string>& PossibleTargets = {""});
static bool Click(Internal::GroundItem G, Button Button = BUTTON_LEFT);
static bool Click(Internal::GroundItem G, const std::string& Action);
static bool Click(Internal::GroundItem G, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::NPC N, Button Button = BUTTON_LEFT);
static bool Click(Internal::NPC N, const std::string& Action);
static bool Click(Internal::NPC N, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::Player P, Button Button = BUTTON_LEFT);
static bool Click(Internal::Player P, const std::string& Action);
static bool Click(Internal::Player P, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::GameObject G, Button Button = BUTTON_LEFT);
static bool Click(Internal::GameObject G, const std::string& Action);
static bool Click(Internal::GameObject G, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::GroundObject G, Button Button = BUTTON_LEFT);
static bool Click(Internal::GroundObject G, const std::string& Action);
static bool Click(Internal::GroundObject G, const std::vector<std::string>& PossibleActions);
static bool Click(Internal::WallObject W, Button Button = BUTTON_LEFT);
static bool Click(Internal::WallObject W, const std::string& Action);
static bool Click(Internal::WallObject W, const std::vector<std::string>& PossibleActions);
static bool UpKey(std::int32_t Key); static bool UpKey(std::int32_t Key);
static bool DownKey(std::int32_t Key); static bool DownKey(std::int32_t Key);
bool ReleaseKey(std::int32_t Key); bool ReleaseKey(std::int32_t Key);
bool HoldKey(std::int32_t Key, std::uint32_t Duration); bool HoldKey(std::int32_t Key, std::uint32_t Duration);
static bool TypeKey(std::int32_t Key); static bool TypeKey(std::int32_t Key);
static bool TypeString(const std::string& String, bool PressEnter = false); static bool TypeString(const std::string& String, bool PressEnter = false);
}; };

4
Include/Game/Tools/Settings.hpp
View File

@ -14,7 +14,11 @@ class Settings
static std::int32_t GetSetting(std::int32_t SettingIndex); static std::int32_t GetSetting(std::int32_t SettingIndex);
static std::int32_t GetSetting(std::int32_t SettingIndex, std::int32_t BitMask); static std::int32_t GetSetting(std::int32_t SettingIndex, std::int32_t BitMask);
static bool GetSettingBit(std::int32_t SettingIndex, std::int32_t BitIndex); static bool GetSettingBit(std::int32_t SettingIndex, std::int32_t BitIndex);
static std::int32_t GetScreenType(); static std::int32_t GetScreenType();
static bool IsEscToCloseInterfacesOn();
static bool IsShiftClickToDropOn();
}; };
/** @} */ /** @} */

75
Include/Game/Tools/Widgets.hpp
View File

@ -1,8 +1,7 @@
#ifndef WIDGETS_HPP_INCLUDED #ifndef WIDGETS_HPP_INCLUDED
#define WIDGETS_HPP_INCLUDED #define WIDGETS_HPP_INCLUDED
#include "../../Core/Types/Box.hpp" #include "../../Game/Interactable/Widget.hpp"
#include "../../Core/Classes/Widget.hpp"
#include <functional> #include <functional>
#include <cstdint> #include <cstdint>
#include <vector> #include <vector>
@ -12,74 +11,14 @@
class Widgets class Widgets
{ {
public: public:
/**
* @brief Returns true if the Widget, or it's Parent, is Hidden
* @code
* Widget Inventory = Widgets::GetWidget(149, 0);
* bool InventoryHidden = Widgets::IsHidden(Inventory);
* @endcode
*/
static bool IsHidden(const Internal::Widget& W);
/**
* @brief Returns the Box of the passed Widget
* @code
* Widget BankInventory = Widgets::GetWidget(15, 3);
* Box BankInventoryBox = Widgets::GetBox(BankInventory);
* @endcode
*/
static Box GetBox(const Internal::Widget& W);
/**
* @brief Returns the absolute X of the passed Widget
* @code
* Widget BankInventory = Widgets::GetWidget(15, 3);
* std::int32_t BankInventoryX = Widgets::GetX(BankInventory);
* @endcode
*/
static std::int32_t GetX(const Internal::Widget& W);
/**
* @brief Returns the absolute Y of the passed Widget
* @code
* Widget BankInventory = Widgets::GetWidget(15, 3);
* std::int32_t BankInventoryY = Widgets::GetX(BankInventory);
* @endcode
*/
static std::int32_t GetY(const Internal::Widget& W);
/** static std::vector<std::vector<Interactable::Widget>> GetAll();
* @brief (Temp) Returns the ItemIDs of the passed Widget static std::vector<Interactable::Widget> GetAll(std::int32_t Parent);
* @note Temporary function, this should be used over Widget.GetItemIDs() static std::vector<Interactable::Widget> GetAll(const std::function<bool (Interactable::Widget&)>& Filter);
*/
static std::vector<std::int32_t> GetItemIDs(const Internal::Widget& W);
/**
* @brief Returns a vector of All Loaded Widgets
* @code std::vector<std::vector<Internal::Widget>> Widgets = Widgets::GetAll(); @endcode
*/
static std::vector<std::vector<Internal::Widget>> GetAll();
/**
* @brief Returns the specified Widget by Parent ID
* @code std::vector<Internal::Widget> BankParent = Widgets::Get(15); @endcode
*/
static std::vector<Internal::Widget> GetAll(std::int32_t Parent);
/**
* @brief Returns the specified Widget by Parent, and Child ID
* @code Widget BankInventory = Widgets::Get(15, 3); @endcode
*/
static Internal::Widget Get(std::int32_t Parent, std::int32_t Child = -1);
/**
* @brief Returns the specified Widget by Parent, and Child, and Grandchild ID
* @code Widget BankCloseButton = Widgets::Get(12, 3, 11); @endcode
*/
static Internal::Widget Get(std::int32_t Parent, std::int32_t Child, std::int32_t Grandchild);
/**
* @brief Returns a vector of all Widgets that pass the specified Filter @see LibraryFilterLambdas
* @code
* auto const WTextEquals = [](const Widget& W){ return W.GetText() == "Enter Amount"; };
* std::vector<Widget> Widgets = Widgets::Get(WTextEquals); @endcode
* Will return all Widgets whose Text equals Enter Amount
*/
static std::vector<Internal::Widget> GetAll(const std::function<bool (Internal::Widget&)>& Filter);
static Interactable::Widget Get(std::int32_t Parent, std::int32_t Child = -1);
static Interactable::Widget Get(std::int32_t Parent, std::int32_t Child, std::int32_t Grandchild);
static Interactable::Widget Get(const std::function<bool (Interactable::Widget&)>& Filter);
}; };
/** @} */ /** @} */

BIN
Library/libAlpacaLibrary.a
View File

Binary file not shown.