Example 01: Basics

This example shows basic BNM's API.

#include <BNM/UserSettings/GlobalSettings.hpp>
 
#include <BNM/Class.hpp>
#include <BNM/Field.hpp>
#include <BNM/Method.hpp>
#include <BNM/Property.hpp>
#include <BNM/Defaults.hpp>
#include <BNM/Operators.hpp>
#include <BNM/BasicMonoStructures.hpp>
 
// Used to not write BNM::Structures for each type
using namespace BNM::Structures; // Mono::String, Mono::Array etc.
using namespace BNM::Operators; // Operators for methods, fields, and properties
 
// Variable for storing class
BNM::Class ObjectClass{};
// Variable for storing property
BNM::Property<Mono::String *> ObjectName{};
// Variable for storing method
BNM::Method<Mono::String *> ObjectToString{};
 
// Variable for storing field
BNM::Field<void *> PlayerConfig{};
 
 
BNM::Field<Mono::String *> ConfigName{};
BNM::Field<int> ConfigHealth{};
BNM::Field<int> ConfigCoins{};
 
// Variable for storing pointer to field
void **PlayerConfigPtr = nullptr;
BNM::UnityEngine::Object *Player = nullptr;
 
void (*old_PlayerStart)(BNM::UnityEngine::Object *);
void PlayerStart(BNM::UnityEngine::Object *instance) {
    old_PlayerStart(instance); // Call original code
 
    // Checking whether the Unity object is alive (UnityEngine.Object and its child classes)
    //! ALWAYS use this check instead of basic nullptr check!
    if (Player->Alive() /*BNM::UnityEngine::IsUnityObjectAlive(Player)*/) {
        BNM_LOG_WARN("Player's Start called twice?");
    }
 
    Player = instance;
 
    //! Mono::String - C# string (string or System.String) in BNM
 
    // In this case, the field has a type and the property will automatically call the Get method to get the name.
    // If you use auto, the field will be a copy of objectName and you will either have to call Get() or add() to objectName, i.e.:
    // (instance >> ObjectName)() // for >> and ->*
    // ObjectName[instance]() // for []
    Mono::String *playerObjectName =
            // Alternatives:
            // * instance >> ObjectName
            // * instance->*ObjectName;
            ObjectName[instance];
 
    // Get pointers to these fields
    PlayerConfigPtr = PlayerConfig[instance].GetPointer();
 
    // In the case of fields, the ->* operator immediately returns a reference to the field data
    auto playerName = *PlayerConfigPtr->*ConfigName;
 
    // Log name of the player's object
    BNM_LOG_INFO("Player's object name: \"%s\"; Player's name: \"%s\"",
                 // str() - convert string to std::string
                 playerObjectName->str().c_str(),
                 // -> - iterator operator for checking data and warning if it is incorrect (in debugging mode)
                 playerName->str().c_str());
 
    //! Call ObjectToString, you can write arguments in (), as when calling any methods
    // Alternative method call with an object
    //     auto objectToStringResult = (instance >> ObjectToString)();
 
    auto objectToStringResult = ObjectToString[instance]();
    BNM_LOG_INFO("objectToStringResult: \"%s\"", objectToStringResult->str().c_str());
 
 
    //! Changing the player's name
 
    *playerName = BNM::CreateMonoString(BNM_OBFUSCATE("BNM_Player"));
}
 
void (*old_PlayerUpdate)(BNM::UnityEngine::Object *);
void PlayerUpdate(BNM::UnityEngine::Object *instance) {
    old_PlayerUpdate(instance); // Call original code
 
    // Checking whether the pointer to the m_Config field data is correct
    if (PlayerConfigPtr == nullptr) return;
 
    // Set 99999 lives using the operator ->*
    //! *((*PlayerConfigPtr)->*ConfigHealth) = 99999;
    // Or using []
    ConfigHealth[*PlayerConfigPtr] = 99999;
 
    // Set 99999 coins
    ConfigCoins[*PlayerConfigPtr] = 99999;
}
 
 
// Here you can get all the necessary information
void OnLoaded_Example_01() {
    using namespace BNM; // To avoid writing BNM:: in this method
 
    // Get the UnityEngine class.Object
    ObjectClass = Class(BNM_OBFUSCATE("UnityEngine"), BNM_OBFUSCATE("Object"));
 
    // Get UnityEngine.Object::ToString method with 0 parameters
    ObjectToString = ObjectClass.GetMethod(BNM_OBFUSCATE("ToString"), 0);
 
    // Get UnityEngine.Object::name property
    ObjectName = ObjectClass.GetProperty(BNM_OBFUSCATE("name"));
 
 
    /* Let's imagine that there is a class in the game:
        public class Player : MonoBehaviour {
            private void Start();
            private void Update();
            private Config m_Config;
 
            public class Config {
                string Name;
                int Health;
                int Coins;
            }
        }
    */
    // Get the Player class
    auto PlayerClass = Class(BNM_OBFUSCATE(""), BNM_OBFUSCATE("Player"));
 
    // Get the Player::Config class
    auto PlayerConfigClass = PlayerClass.GetInnerClass(BNM_OBFUSCATE("Config"));
 
    // Get the Update and Start methods of the Player class
    auto Update = PlayerClass.GetMethod(BNM_OBFUSCATE("Update"));
    auto Start = PlayerClass.GetMethod(BNM_OBFUSCATE("Start"));
 
    // Get the Player.m_Config field
    PlayerConfig = PlayerClass.GetField(BNM_OBFUSCATE("m_Config"));
 
    // Get Player::Config's fields
    ConfigName = PlayerConfigClass.GetField(BNM_OBFUSCATE("Name"));
    ConfigHealth = PlayerConfigClass.GetField(BNM_OBFUSCATE("Health"));
    ConfigCoins = PlayerConfigClass.GetField(BNM_OBFUSCATE("Coins"));
 
    // Hook Update and Start methods
 
    // There are 3 methods for hooking methods:
    // * HOOK - hook via hooking software
    // * InvokeHook - hook that works for those methods that are called directly by the engine (constructors (.ctor), events (Start, Update, etc.))
    // * VirtualHook - hook for virtual methods
 
    // To replace Start and Update for this class, the best option is InvokeHook
    InvokeHook(Update, PlayerUpdate, old_PlayerUpdate);
    InvokeHook(Start, PlayerStart, old_PlayerStart);
 
    // BNM::Defaults:
 
    // BNM::Defaults::Get<type>() - fast API that allow get all basic C# types and some basic Unity's types
    // Supported types list:
    /*
     C++, C# keyword, .NET type
 
     void, void, System.Void
     bool, bool, System.Boolean
 
     BNM::Types::byte (uint8_t), byte, System.Byte
     BNM::Types::sbyte (int8_t), sbyte, System.SByte
 
     short (int16_t), short, System.Int16
     BNM::Types::ushort (uint16_t), ushort, System.UInt16
 
     int (int32_t), int, System.Int32
     BNM::Types::uint (unsigned int), uint, System.UInt32
 
     BNM::Types::nint (intptr_t), nint, System.IntPtr
     BNM::Types::nuint (uintptr_t), nuint, System.UIntPtr
 
     long, long, System.Int64
     BNM::Types::ulong (unsigned long), ulong, System.UInt64
 
     float, float, System.Single
     double, double, System.Double
     BNM::Types::decimal, decimal, System.Double
 
     BNM::IL2CPP::Il2CppString *, BNM::Structures::Mono::String *, string, System.String
     BNM::Structures::Unity::Vector2, Vector2, UnityEngine.Vector2
     BNM::Structures::Unity::Vector3, Vector3, UnityEngine.Vector3
     BNM::Structures::Unity::Vector4, Vector4, UnityEngine.Vector4
     BNM::Structures::Unity::Color, Color, UnityEngine.Color
     BNM::Structures::Unity::Color32, Color32, UnityEngine.Color32
     BNM::Structures::Unity::Ray, Ray, UnityEngine.Ray
     BNM::Structures::Unity::Quaternion, Quaternion, UnityEngine.Quaternion
     BNM::Structures::Unity::Matrix3x3, Matrix3x3, UnityEngine.Matrix3x3
     BNM::Structures::Unity::Matrix4x4, Matrix4x4, UnityEngine.Matrix4x4
     BNM::Structures::Unity::RaycastHit, RaycastHit, UnityEngine.RaycastHit
     BNM::UnityEngine::Object *, Object, UnityEngine.Object
     BNM::UnityEngine::MonoBehaviour *, MonoBehaviour, UnityEngine.MonoBehaviour
 
     Any other pointer, object, System.Object
    */
 
    // Get int.Parse method
    BNM::Method<int> Parse = BNM::Defaults::Get<int>().ToClass().GetMethod(BNM_OBFUSCATE("Parse"), 1);
}