RTXPOWER

https://docs.rtxpower.com
Admin
RTXPOWER is an SDK providing tools for developing plugins, likely for a game, with features for game...
Tokens:29,596
Snippets:200
Trust Score:4.6
Update:11 months ago
Show doc for...
Tokens:
Raw
### Basic RTX Plugin dllmain.cpp Example

Source: https://docs.rtxpower.com/intro

A simple C++ dllmain.cpp file to get started with an RTX plugin. It includes the necessary headers, defines the plugin name, and implements basic SDK load and unload functions, including a console print statement.

```cpp
#include "../plugin_sdk/plugin_sdk.hpp"

PLUGIN_NAME( "Test plugin" );

PLUGIN_API bool on_sdk_load( plugin_sdk_core* plugin_sdk_good )
{
    DECLARE_GLOBALS( plugin_sdk_good );

    console->print( "Hello from Test Plugin" );

    return true;
}

PLUGIN_API void on_sdk_unload( )
{

}
```

--------------------------------

### Clone RTX SDK Plugin Starter Template

Source: https://docs.rtxpower.com/intro

Clones the RTX SDK plugin starter template repository and initializes submodules. This provides a boilerplate project for developing RTX plugins.

```git
git clone --REPO-- PluginTemplate.git
cd PluginTemplate
git submodule init
git submodule update --remote --merge
```

--------------------------------

### Add RTX SDK as Git Submodule

Source: https://docs.rtxpower.com/intro

Adds the official RTX SDK repository as a git submodule to your project. This is the recommended method for including the SDK, allowing for easier updates.

```git
git submodule add https://github.com/RTXPOWER/SDK.git plugin_sdk
```

--------------------------------

### Example Spell Configurations (C++)

Source: https://docs.rtxpower.com/API/spell

This snippet provides practical examples of configuring different spells, including Ezreal's Q as a skillshot, Xerath's Q as a charged skillshot, and Xerath's R as a circular skillshot. It demonstrates the combined use of `register_spell`, `set_skillshot`, and `set_charged`.

```c++
// Example: Declaring Ezreal's Q
// q = plugin_sdk->register_spell(spellslot::q, 1200);
// q->set_skillshot(0.25f, 60.0f, 2000.0f, { collisionable_objects::minions, collisionable_objects::yasuo_wall, collisionable_objects::heroes }, skillshot_type::skillshot_line);

// Example: Declaring Xerath's Q
// q = plugin_sdk->register_spell(spellslot::r, 1450);
// q->set_charged(735.0f, 1450.0f, 2.0f);
// q->set_skillshot(0.625f, 70.f, FLT_MAX, { }, skillshot_type::skillshot_line);

// Example: Declaring Xerath's R
// r = plugin_sdk->register_spell(spellslot::r, 5000);
// r->set_skillshot(0.7f, 200.f, FLT_MAX, { }, skillshot_type::skillshot_circle);
```

--------------------------------

### OnUpdate Event Implementation - C++

Source: https://docs.rtxpower.com/API/events

Complete example demonstrating how to register and unregister an OnUpdate event callback. The on_update function is called every game update cycle. Event registration occurs in on_sdk_load and cleanup in on_sdk_unload.

```C++
void on_update( )
{

}

PLUGIN_API bool on_sdk_load( plugin_sdk_core* plugin_sdk_good )
{
    DECLARE_GLOBALS( plugin_sdk_good );

    event_handler< events::on_update >::add_callback( on_update );

    return true;
}

PLUGIN_API void on_sdk_unload( )
{
    event_handler< events::on_update >::remove_handler( on_update );
}
```

--------------------------------

### C++ Iterating Through Object Perks

Source: https://docs.rtxpower.com/API/GameObject

Provides a C++ code example for iterating through all perks an object possesses using the `get_perks` function. This is useful for examining or acting upon each perk individually.

```cpp
if ( object->is_ai_base( ) )
{
    for ( auto&& perk : object->get_perks( ) )
    {
        ...
    }
}
```

--------------------------------

### Get Best Target by Priority - C++

Source: https://docs.rtxpower.com/API/menusample

This function iterates through possible targets, calculates their priority using a 'TreeEntry' object, and sorts them to return the highest priority target. It handles cases where no valid targets are found. Dependencies include 'game_object_script' and 'TreeEntry'.

```cpp
TreeEntry* use_r_prority = nullptr;

game_object_script get_best_target_prority( const std::vector<game_object_script>& possible_targets )
{
    std::vector<std::pair<game_object_script, std::int32_t>> valid_targets;

    for ( auto&& target : possible_targets )
    {
        auto target_prority = use_r_prority->get_prority( target->get_network_id( ) );

        if ( target_prority.first == -1 || !target_prority.second )
            continue;

        valid_targets.push_back( { target, target_prority.first } );
    }

    std::sort( valid_targets.begin( ), valid_targets.end( ), [](const std::pair<game_object_script, std::int32_t>& a, const std::pair<game_object_script, std::int32_t>& b )
    {
        // Sort by prority value
        //
        //   First in vector = top
        //
        return a.second < b.second;
    } );

    // Return best target
    //
    //   If list is empty return nullptr
    //
    return valid_targets.empty( ) ? nullptr : valid_targets.front( ).first;
}
```

--------------------------------

### Spell and Action Management (C++)

Source: https://docs.rtxpower.com/API/GameObject

Functions related to spell casting and combat actions, including checking mana costs, retrieving spell states (Ready, Cooldown, etc.), getting auto-attack damage, and verifying if an object can attack, move, or cast. These are vital for combat AI and ability usage.

```cpp
//Returns mana needed to use a spell 
//  - spellslot of the spell
float get_mana_for_spell( spellslot slot );

//Returns auto attack damage of the object on the target.
//  - target
//  - include passive damage in calculations (eg. on-hit damages)
float get_auto_attack_damage( game_object_script to, bool respect_passives = true );

//Checks if the target is in auto attack range of the object.
//  - target
//  - additional range 
bool is_in_auto_attack_range( game_object_script to, float additional = 0.f );

//Checks if the object can issue an attack command.
//Example: if the object is stunned function will return false
bool can_attack( );

//Checks if the object can issue a move command.
//Example: if the object is stunned function will return false
bool can_move( );

//Checks if the object can cast a spell.
//Example: if the object is stunned function will return false
bool can_cast( );

//Checks if Local Player can issue an attack command on the object
//  - Skip invulnerability buff check
bool is_attack_allowed_on_target( bool ignore_invulnerability = false );

//Returns spell_state flags of the spell.
//  - spellslot of the spell to check
//
//  Available states:
//      spell_state::Ready,
//      spell_state::NotLearned ,
//      spell_state::NotAvaliable,
//      spell_state::Surpressed,
//      spell_state::Cooldown,
//      spell_state::NotEnoughMana,
//      spell_state::UnknownState
spell_state get_spell_state( spellslot spell ) = 0;
//
//How to check if spell is ready?
//
//  if ( object->get_spell_state( spellslot::q ) & spell_state::Ready )
//  {
//      ...
//  }
//
//Checks if object is targetable to team.
//  - team to check
bool is_targetable_to_team( game_object_team team );

//Returns ChampionId. Object must be of type AIHeroClient.
//Check is_ai_hero() before calling this function
champion_id get_champion( );
```

--------------------------------

### Position and Navigation (C++)

Source: https://docs.rtxpower.com/API/GameObject

Functions for retrieving and calculating distances related to game object positions and paths. Includes getting the object's position, its real path, perpendicular direction, and distance to other objects or positions.

```cpp
//Returns path starting from object position to it's destination.  
std::vector<vector> get_real_path( );

//Returns 2 dimensional distance from object to object.
//  - object to check distance
float get_distance( game_object_script to );

//Returns 2 dimensional distance from object to position.
//  - position in the game
float get_distance( vector to );

//Returns the object position in the game.
vector get_position( );

//Returns the perpendicular direction of the object.
vector get_direction_perpendicular( );

//Returns the direction of the object.
vector get_direction( );
```

--------------------------------

### C++ Buff Management Functions

Source: https://docs.rtxpower.com/API/GameObject

Provides C++ functions for retrieving, checking, and managing buffs associated with an object. Includes functions to get a list of buffs, check for specific buffs by hash or type, and retrieve buff details like count and time left. Assumes the existence of buff_instance and buff_type structures.

```cpp
std::vector<std::shared_ptr<buff_instance>> get_bufflist( );
bool has_buff( uint32_t hash );
bool has_buff( std::vector<uint32_t> hashes );
bool has_buff_type( buff_type type );
bool has_buff_type( std::vector<buff_type> type );
buff_instance_script get_buff( uint32_t hash );
buff_instance_script get_buff_by_type( buff_type type );
buff_instance_script get_buff_by_type( std::vector<buff_type> type );
int get_buff_count( uint32_t hash );
float get_buff_time_left( uint32_t hash );
```

--------------------------------

### C++ TreeTab Class Definition for RTX Power UI

Source: https://docs.rtxpower.com/API/menusample

Defines the TreeTab class, inheriting from TreeEntry, for organizing UI elements in the RTX Power application. It includes methods to get entries by key and add various control types such as tabs, separators, hotkeys, checkboxes, sliders, display values, comboboxes, color pickers, priority lists, images, and text inputs. It also provides functions to clear the tab, enable revert functionality, and set textures and active states.

```cpp
class TreeTab: public TreeEntry
{
public:

    // Gets menu element by key, only for this tab
    //
    // If not found returns nullptr
    //
    virtual TreeEntry* get_entry( const std::string& key );

    // Creates or gets (if already exists and type is TreeTab) menu element
    //
    // See TreeTab element to get more information
    //
    virtual TreeTab* add_tab( const std::string& key, const std::string& name );

    // Creates or gets (if already exists and type is TreeSeperator) menu element
    //
    // See TreeSeperator element to get more information
    //
    virtual TreeEntry* add_separator( const std::string& key, const std::string& name );

    // Creates or gets (if already exists and type is TreeHotkey) menu element
    //
    // See TreeHotkey element to get more information
    //
    virtual TreeEntry* add_hotkey( const std::string& key, const std::string& name, const std::int32_t& type, const std::int32_t& vkey, const bool& default_value, const bool& should_save = true );

    // Creates or gets (if already exists and type is TreeCheckbox) menu element
    //
    // See TreeCheckbox element to get more information
    //
    virtual TreeEntry* add_checkbox( const std::string& key, const std::string& name, const bool& default_value, const bool& should_save = true );

    // Creates or gets (if already exists and type is TreeSlider) menu element
    //
    // See TreeSlider element to get more information
    //
    virtual TreeEntry* add_slider( const std::string& key, const std::string& name, const int32_t& default_value, const std::int32_t& min, const std::int32_t& max, const bool& should_save = true );

    // Creates or gets (if already exists and type is TreeDisplayInt) menu element
    //
    // See TreeDisplayInt element to get more information
    //
    virtual TreeEntry* add_display_value( const std::string& key, const std::string& name, std::int32_t* value );

    // Creates or gets (if already exists and type is TreeCombobox) menu element
    //
    // See TreeCombobox element to get more information
    //
    virtual TreeEntry* add_combobox( const std::string& key, const std::string& name, const std::vector<std::pair<std::string, void*>>& combo_elements, const std::int32_t& default_value, const bool& should_save = true );

    // Creates or gets (if already exists and type is TreeColorPicker) menu element
    //
    // See TreeColorPicker element to get more information
    //
    virtual TreeEntry* add_colorpick( const std::string& key, const std::string& name, std::array<float, 4> const& default_color, const bool& should_save = true );

    // Creates or gets (if already exists and type is TreeColorPicker) menu element
    //
    // See TreeColorPicker element to get more information
    //
    virtual TreeEntry* add_colorpick( const std::string& key, const std::string& name, float default_color[ 4 ], const bool& should_save = true );

    // Creates or gets (if already exists and type is TreeProrityList) menu element
    //
    // See TreeProrityList element to get more information
    //
    virtual TreeEntry* add_prority_list( const std::string& key, const std::string& name, const std::vector<ProrityCheckItem>& prority_elements, const bool& always_active = true, const bool& should_save = true );

    // Creates or gets (if already exists and type is TreeImage) menu element
    //
    // See TreeImage element to get more information
    //
    virtual TreeEntry* add_image_item( const std::string& key, void* texture, const std::int32_t& height );

    // Creates or gets (if already exists and type is TreeTextInput) menu element
    //
    // See TreeTextInput element to get more information
    //
    virtual TreeEntry* add_text_input( const std::string& key, const std::string& name, const std::string& default_value, const bool& should_save = true );

    // Creates or gets (if already exists and type is TreeButton) menu element
    //
    // See TreeButton element to get more information
    //
    virtual TreeEntry* add_button( const std::string& key, const std::string& name );

    // Remove all sub elements of this tab
    //
    // After clear menu elements created with this tab will be invalid and you can't use them
    //
    virtual void clear( );

    // Sets if user is able to use revert function (right click) on this tab
    //
    // Default: false
    //
    virtual void set_revert_enabled( bool enabled );

    // Sets assigned texture for this tab
    //
    // Function is same as set_texture from TreeEntry
    //
    virtual void set_assigned_texture( void* texture );

    // Sets assigned active for this tab
    //
    // You can use bool pointer or TreeEntry pointer
    //
    //   TreeEntry must be type of TreeCheckbox
    //
    virtual void set_assigned_active( TreeEntry* active );
    virtual void set_assigned_active( bool* active );

    // Reserved for core
    //
    virtual void reserved_3( );
};

```

--------------------------------

### Get Missile Positions

Source: https://docs.rtxpower.com/API/GameObject

Retrieves start and end positions of a missile object. These positions are used to track missile trajectory and determine collision points.

```C++
vector missile_get_start_position( );
vector missile_get_end_position( );
```

--------------------------------

### Load RTXPower Plugin Entry Point (C++)

Source: https://docs.rtxpower.com/champion

The dllmain.cpp file serves as the entry point for the RTXPower plugin. It handles plugin loading and unloading, checking for supported champions and calling the appropriate champion-specific scripts. It depends on the plugin_sdk. The input is the plugin_sdk_core object, and the output is a boolean indicating successful loading.

```cpp
#include "../plugin_sdk/plugin_sdk.hpp"

// Declare plugin name & supported champions
//
PLUGIN_NAME( "CarryGaren" );
SUPPORTED_CHAMPIONS( champion_id::Garen );

// Include champion file
//
#include "garen.h"

// Entry point of plugin
//
PLUGIN_API bool on_sdk_load( plugin_sdk_core* plugin_sdk_good )
{
    // Global declaretion macro
    //
    DECLARE_GLOBALS( plugin_sdk_good );

    //Switch by myhero champion id
    //
    switch ( myhero->get_champion( ) )
    {
        case champion_id::Garen:
            // Load garen script
            //
            garen::load( );
            break;
        default:
            // We don't support this champ, print message and return false (core will not load this plugin and on_sdk_unload will be never called)
            //
            console->print( "Champion %s is not supported!", myhero->get_model_cstr() );
            return false;
    }

    // Return success, our plugin will be loaded now
    //
    return true;
}

// Unload function, only when on_sdk_load returned true
//
PLUGIN_API void on_sdk_unload( )
{
    switch ( myhero->get_champion( ) )
    {
        case champion_id::Garen:
            // Unload garen script
            //
            garen::unload( );
            break;
        default:
            break;
    }
}
```

--------------------------------

### Cast Spell with Start and End Positions - Local Player Action

Source: https://docs.rtxpower.com/API/GameObject

Casts a spell with both start and end positions specified. Supports optional event triggering and charged spell mode. Used for spells with trajectory or cone effects.

```C++
void cast_spell( spellslot slot, vector startPos, vector endPos, bool trigger_event = true, bool is_charging = false );
```

--------------------------------

### Configure Harass Settings UI

Source: https://docs.rtxpower.com/champion

Sets up the 'Harass Settings' tab with checkboxes for using Q and E abilities. It retrieves spell icons to visually represent the abilities in the UI.

```cpp
auto harass = main_tab->add_tab( myhero->get_model( ) + ".harass", "Harass Settings" );
{
    harass::use_q = harass->add_checkbox( myhero->get_model( ) + ".harassUseQ", "Use Q", true );
    harass::use_q->set_texture( myhero->get_spell( spellslot::q )->get_icon_texture( ) );
    harass::use_e = harass->add_checkbox( myhero->get_model( ) + ".harassUseE", "Use E", true );
    harass::use_e->set_texture( myhero->get_spell( spellslot::e )->get_icon_texture( ) );
}
```

--------------------------------

### Configure Miscellaneous Settings UI

Source: https://docs.rtxpower.com/champion

Sets up the 'Misc Settings' tab, including a checkbox for using the W ability and a sub-tab for W configuration. The sub-tab contains sliders to set damage prediction time and HP percentage thresholds.

```cpp
auto misc = main_tab->add_tab( myhero->get_model( ) + ".misc", "Misc Settings" );
{
    misc::use_w = misc->add_checkbox( myhero->get_model( ) + ".miscUseW", "Use W", true );
    misc::use_w->set_texture( myhero->get_spell( spellslot::w )->get_icon_texture( ) );
    auto w_config = misc->add_tab( myhero->get_model( ) + ".miscWConfig", "W Config" );
    {
        misc::time = w_config->add_slider( myhero->get_model( ) + ".miscWConfigTime", "Set coming damage time (in ms)", 150, 0, 1000 );
        misc::over_my_hp_in_percent = w_config->add_slider( myhero->get_model( ) + ".miscWConfigOverMyHpInPercent", "Coming damage is over my HP (in %)", 20, 0, 100 );
    }
}
```

--------------------------------

### Get Immobility Duration - C++

Source: https://docs.rtxpower.com/API/GameObject

Returns the remaining time in seconds that the object is immobilized or cannot move.

```cpp
float get_immovibility_time( );
```

--------------------------------

### Garen Spell and Menu Initialization (C++)

Source: https://docs.rtxpower.com/champion

Initializes Garen's spells (Q, W, E, R) and Summoner Flash, then creates a menu structure for configuring spell usage and drawing options. It registers spells with their respective ranges and sets up UI elements like checkboxes and sliders for customization.

```cpp
#include "../plugin_sdk/plugin_sdk.hpp"
#include "garen.h"

namespace garen
{
    // Define the colors that will be used in on_draw()
    //
#define Q_DRAW_COLOR (MAKE_COLOR ( 62, 129, 237, 255 ))  //Red Green Blue Alpha
#define W_DRAW_COLOR (MAKE_COLOR ( 227, 203, 20, 255 ))  //Red Green Blue Alpha
#define E_DRAW_COLOR (MAKE_COLOR ( 235, 12, 223, 255 ))  //Red Green Blue Alpha
#define R_DRAW_COLOR (MAKE_COLOR ( 224, 77, 13, 255 ))   //Red Green Blue Alpha

// To declare a spell, it is necessary to create an object and registering it in load function
    script_spell* q = nullptr;
    script_spell* w = nullptr;
    script_spell* e = nullptr;
    script_spell* r = nullptr;

    script_spell* flash = nullptr;

    // Declaration of menu objects
    TreeTab* main_tab = nullptr;

    namespace draw_settings
    {
        TreeEntry* draw_range_q = nullptr;
        TreeEntry* draw_range_w = nullptr;
        TreeEntry* draw_range_e = nullptr;
        TreeEntry* draw_range_r = nullptr;
        TreeEntry* draw_flash_range = nullptr;
    }

    namespace combo
    {
        TreeEntry* use_q = nullptr;

        TreeEntry* use_w = nullptr;
        TreeEntry* w_enemy_range = nullptr;
        TreeEntry* w_myhero_hp_under = nullptr;

        TreeEntry* use_e = nullptr;
        TreeEntry* use_r = nullptr;
    }

    namespace harass
    {
        TreeEntry* use_q = nullptr;
        TreeEntry* use_e = nullptr;
    }

    namespace laneclear
    {
        TreeEntry* use_q = nullptr;
        TreeEntry* use_q_on_turret = nullptr;

        TreeEntry* use_e = nullptr;
        TreeEntry* auto_disable_e = nullptr;
    }

    namespace jungleclear
    {
        TreeEntry* use_q = nullptr;
        TreeEntry* use_e = nullptr;
        TreeEntry* auto_disable_e = nullptr;
    }

    namespace fleemode
    {
        TreeEntry* use_q;
    }

    namespace misc
    {
        TreeEntry* use_w = nullptr;
        TreeEntry* time = nullptr;
        TreeEntry* over_my_hp_in_percent = nullptr;
    }

    // Event handler functions
    void on_update( );
    void on_draw( );
    void on_before_attack( game_object_script target, bool* process );

    // Declaring functions responsible for spell-logic
    //
    void q_logic( );
    void w_logic( );
    void e_logic( );
    void r_logic( );

    // Enum is used to define myhero region 
    enum Position
    {
        Line,
        Jungle
    };

    Position my_hero_region;

    void load( )
    {
        // Registering a spells
        //
        q = plugin_sdk->register_spell( spellslot::q, 175 );
        w = plugin_sdk->register_spell( spellslot::w, 0 );
        e = plugin_sdk->register_spell( spellslot::e, 330 );
        r = plugin_sdk->register_spell( spellslot::r, 400 );

        // Checking which slot the Summoner Flash is on 
        //
        if ( myhero->get_spell( spellslot::summoner1 )->get_spell_data( )->get_name_hash( ) == spell_hash( "SummonerFlash" ) )
            flash = plugin_sdk->register_spell( spellslot::summoner1, 400.f );
        else if ( myhero->get_spell( spellslot::summoner2 )->get_spell_data( )->get_name_hash( ) == spell_hash( "SummonerFlash" ) )
            flash = plugin_sdk->register_spell( spellslot::summoner2, 400.f );

        // Create a menu according to the description in the "Menu Section"
        //
        main_tab = menu->create_tab( "garen", "Garen" );
        main_tab->set_assigned_texture( myhero->get_square_icon_portrait( ) );
        {
            auto combo = main_tab->add_tab( myhero->get_model( ) + ".combo", "Combo Settings" );
            {
                combo::use_q = combo->add_checkbox( myhero->get_model( ) + ".comboUseQ", "Use Q", true );
                combo::use_q->set_texture( myhero->get_spell( spellslot::q )->get_icon_texture( ) );
                combo::use_w = combo->add_checkbox( myhero->get_model( ) + ".comboUseW", "Use W in Team Fight", true );
                combo::use_w->set_texture( myhero->get_spell( spellslot::w )->get_icon_texture( ) );
                auto w_config = combo->add_tab( myhero->get_model( ) + ".comboWConfig", "W Config" );
                {
                    combo::w_enemy_range = w_config->add_slider( myhero->get_model( ) + ".comboUseWWhenEnemyInRange", "Use W when over enemy in range", 2, 0, 5 );
                    combo::w_myhero_hp_under = w_config->add_slider( myhero->get_model( ) + ".comboMyheroHpUnder", "Myhero HP is under (in %)", 70, 0, 100 );
                }
                combo::use_e = combo->add_checkbox( myhero->get_model( ) + ".comboUseE", "Use E", true );
                combo::use_e->set_texture( myhero->get_spell( spellslot::e )->get_icon_texture( ) );
                combo::use_r = combo->add_checkbox( myhero->get_model( ) + ".comboUseR", "Use R", true );
                combo::use_r->set_texture( myhero->get_spell( spellslot::r )->get_icon_texture( ) );
            }

```

--------------------------------

### Get Bounding Box Coordinates - C++

Source: https://docs.rtxpower.com/API/GameObject

Retrieves the minimum and maximum bounding box vectors for the object's collision volume.

```cpp
vector get_bbox_min( );
vector get_bbox_max( );
```

--------------------------------

### Create Root Menu Tab (C++)

Source: https://docs.rtxpower.com/API/menusample

Demonstrates how to create the main root tab for a plugin menu. This is typically done once during the plugin's initialization phase, often within the `load` function. The `create_tab` method of the `menu` object is used, requiring a unique key and a display name.

```cpp
main_tab = menu->create_tab( "simple_plugin", "Simple Plugin" );

```

--------------------------------

### Get Level Up Stacks - C++

Source: https://docs.rtxpower.com/API/GameObject

Returns the amount of spell training points available for the object, representing unspent ability points.

```cpp
int get_lvlup_stacks( );
```

--------------------------------

### C++ Dynamic Menu Creation with TreeCheckbox for Champions

Source: https://docs.rtxpower.com/API/menusample

Demonstrates creating a dynamic menu using `std::map` and `TreeCheckbox` where keys are champion network IDs. This allows for per-champion settings that are not saved across game sessions (should_save=false). It includes functions to check and retrieve checkbox states.

```cpp
std::map<std::uint32_t, TreeEntry*> use_r_on;

bool can_use_r_on( game_object_script target )
{
    auto it = use_r_on.find( target->get_network_id( ) );
    if ( it == use_r_on.end( ) )
        return false;

    return it->second->get_bool( );
}

// In load function:
auto use_r_on_tab = orbwalker_menu->add_tab( "use_r", "Use R On" );
{
    for ( auto&& enemy : entitylist->get_enemy_heroes( ) )
    {
        // In this case you HAVE to set should save to false since key contains network id which is unique per game
        //
        use_r_on[ enemy->get_network_id( ) ] = use_r_on_tab->add_checkbox( std::to_string( enemy->get_network_id( ) ), enemy->get_model( ), true, false );

        // Set texture to enemy square icon
        //
        use_r_on[ enemy->get_network_id( ) ]->set_texture( enemy->get_square_icon_portrait( ) );
    }
}

// In logic code:
if ( can_use_r_on( target ) )
{
  // Do something
  //
}
```

--------------------------------

### Use Priority Target - C++

Source: https://docs.rtxpower.com/API/menusample

This code snippet shows the application of the 'get_best_target_prority' function. It retrieves a list of potential targets, finds the best one using the priority system, and then proceeds with a game action if a valid target is identified. This illustrates the usage pattern for the target selection logic.

```cpp
// ... code logic

auto best_target = get_best_target_prority( targets );
if ( best_target )
{
    // Do something
    //
}
```

--------------------------------

### Get Missile Spell Data

Source: https://docs.rtxpower.com/API/GameObject

Retrieves spell data associated with a missile. Returns a spell_data_script object containing information about the spell that created the missile.

```C++
spell_data_script get_missile_sdata( );
```

--------------------------------

### C++ Dynamic Menu Creation with TreeCombobox for Champions

Source: https://docs.rtxpower.com/API/menusample

Illustrates using `std::map` and `TreeCombobox` for per-champion settings, similar to `TreeCheckbox`. The combobox allows selecting from predefined options, and the code includes a function to retrieve the selected integer value. Settings are not saved across sessions (should_save=false).

```cpp
// In this case you HAVE to set should save to false since key contains network id which is unique per game
//
use_r_on[ enemy->get_network_id( ) ] = use_r_on_tab->add_combobox( std::to_string( enemy->get_network_id( ) ), enemy->get_model( ), { {"Always", nullptr }, {"Killsteal" , nullptr}, {"Never", nullptr} }, 0, false );

std::int32_t use_r_on_mode( game_object_script target )
{
    auto it = use_r_on.find( target->get_network_id( ) );
    if ( it == use_r_on.end( ) )
        return false;

    return it->second->get_int( );
}

// In logic code:
auto mode = use_r_on_mode( target );

if ( mode == 0) //Always
{
    // Do something
    //
} else if ( mode == 1) //Killsteal
{
    // Do something
    //
} else if ( mode == 2) //Never
{
    // Do something
    //
}
```

--------------------------------

### Get Particle Rotation Vectors - C++

Source: https://docs.rtxpower.com/API/GameObject

Retrieves the three basis vectors for particle rotation: right, up, and forward vectors used for 3D rotation calculations.

```cpp
vector get_particle_rotation_right( );
vector get_particle_rotation_up( );
vector get_particle_rotation_forward( );
```

--------------------------------

### Get Object Type Information - C++

Source: https://docs.rtxpower.com/API/GameObject

Retrieves an object_type_script instance containing detailed information about the GameObject's type. This is a foundational function for all type-specific checkers.

```cpp
object_type_script get_type( );
```

--------------------------------

### Pre-Attack Logic for Q Ability Usage

Source: https://docs.rtxpower.com/champion

Defines the logic executed before an auto-attack. It checks if the Q ability is ready and casts it on enemies if in combo or harass mode and if the 'use_q' option is enabled. It also handles casting Q on turrets during lane clear if the 'use_q_on_turret' option is enabled.

```C++
void on_before_attack( game_object_script target, bool* process )
    {
        if ( q->is_ready( ) )
        {
            // Using q before autoattack on enemies
            if ( target->is_ai_hero( ) && ( ( orbwalker->combo_mode( ) && combo::use_q->get_bool( ) ) || ( orbwalker->harass( ) && harass::use_q->get_bool( ) ) ) )
            {
                if ( q->cast( ) )
                {
                    return;
                }
            }

            // Using q before autoattack on turrets
            if ( orbwalker->lane_clear_mode( ) && myhero->is_under_enemy_turret( ) && laneclear::use_q_on_turret->get_bool( ) && target->is_ai_turret( ) )
            {
                if ( q->cast( ) )
                {
                    return;
                }
            }
        }
    }
```

--------------------------------

### Get Real Health with Shields - C++

Source: https://docs.rtxpower.com/API/GameObject

Calculates the effective health including shields. Optional boolean parameters allow inclusion of physical and magical shields in the calculation.

```cpp
float get_real_health( bool physical_shield = false, bool magical_shield = false );
```

--------------------------------

### Get Pathing Direction - C++

Source: https://docs.rtxpower.com/API/GameObject

Retrieves the direction vector of the object's current waypoint. This function returns a vector indicating the direction the object is moving along its path.

```cpp
vector get_pathing_direction( );
```

--------------------------------

### Configure Lane Clear Settings UI

Source: https://docs.rtxpower.com/champion

Sets up the 'Lane Clear Settings' tab with checkboxes for using Q and E abilities, including an option to use Q on turrets and auto-disable E when no minions are present. Spell icons are used for visual representation.

```cpp
auto laneclear = main_tab->add_tab( myhero->get_model( ) + ".laneclear", "Lane Clear Settings" );
{
    laneclear::use_q = laneclear->add_checkbox( myhero->get_model( ) + ".laneclearUseQ", "Use Q", true );
    laneclear::use_q->set_texture( myhero->get_spell( spellslot::q )->get_icon_texture( ) );
    laneclear::use_q_on_turret = laneclear->add_checkbox( myhero->get_model( ) + ".laneclearUseQOnTurret", "Use Q On Turret", true );
    laneclear::use_q_on_turret->set_texture( myhero->get_spell( spellslot::q )->get_icon_texture( ) );
    laneclear::use_e = laneclear->add_checkbox( myhero->get_model( ) + ".laneclearUseE", "Use E", true );
    laneclear::use_e->set_texture( myhero->get_spell( spellslot::e )->get_icon_texture( ) );
    laneclear::use_e = laneclear->add_checkbox( myhero->get_model( ) + ".laneclearUseQ", "Use Q", true );
    laneclear::auto_disable_e = laneclear->add_checkbox( myhero->get_model( ) + ".laneclearAutoDisableE", "Auto disable E if no more minion", true );
}
```

--------------------------------

### Get Maximum Objects Capability from Entity List C++

Source: https://docs.rtxpower.com/API/entitylist

Method to retrieve the current maximum capability of the object list, indicating the maximum number of objects that can be stored.

```cpp
virtual uint32_t get_max_objects( ) = 0;
```

--------------------------------

### Configure Flee Mode Settings UI

Source: https://docs.rtxpower.com/champion

Sets up the 'Flee Mode' tab with a checkbox to enable using the Q ability for fleeing. The spell icon for Q is also displayed.

```cpp
auto fleemode = main_tab->add_tab( myhero->get_model( ) + ".fleemode", "Flee Mode" );
{
    fleemode::use_q = fleemode->add_checkbox( myhero->get_model( ) + ".fleemodeUseQ", "Use Q to ran away", true );
    fleemode::use_q->set_texture( myhero->get_spell( spellslot::q )->get_icon_texture( ) );
}
```

--------------------------------

### Main Update Loop with Spell Logic and Combat Modes - C++

Source: https://docs.rtxpower.com/champion

Core game loop function that executes spell casting decisions based on character state, buff status, and selected combat mode. Implements defensive W casting based on incoming damage prediction, and offensive spell logic for combo, harass, flee, and lane clear modes. Uses orbwalker for movement timing and target selection with null-pointer validation.

```cpp
// Main update script function
void on_update( )
{
    if ( myhero->is_dead( ) )
    {
        return;
    }

    if ( !myhero->has_buff( buff_hash( "GarenW" ) ) && misc::use_w->get_bool( ) && w->is_ready( ) )
    {
        if ( ( health_prediction->get_incoming_damage( myhero, misc::time->get_int( ) / 1000.f, true ) * 100.f ) /
             myhero->get_max_health( ) > myhero->get_health_percent( ) * ( misc::over_my_hp_in_percent->get_int( ) / 100.f ) )
        {
            w->cast( );
        }
    }

    // Very important if can_move ( extra_windup ) 
    // Extra windup is the additional time you have to wait after the aa
    // Too small time can interrupt the attack
    if ( orbwalker->can_move( 0.05f ) )
    {
        //Checking if the user has combo_mode() (Default SPACE)
        if ( orbwalker->combo_mode( ) )
        {
            if ( r->is_ready( ) && combo::use_r->get_bool( ) )
            {
                r_logic( );
            }

            if ( q->is_ready( ) && combo::use_q->get_bool( ) )
            {
                q_logic( );
            }

            if ( w->is_ready( ) && combo::use_w->get_bool( ) )
            {
                w_logic( );
            }

            if ( e->is_ready( ) && combo::use_e->get_bool( ) )
            {
                e_logic( );
            }
        }

        //Checking if the user has selected harass() (Default C)
        if ( orbwalker->harass( ) )
        {
            if ( q->is_ready( ) && harass::use_q->get_bool( ) )
            {
                // Get a target from a given range
                auto target = target_selector->get_target( q->range( ), damage_type::physical );

                // Always check an object is not a nullptr!
                if ( target != nullptr )
                {
                    if ( !myhero->has_buff( buff_hash( "GarenE" ) ) )
                    {
                        if ( !myhero->is_under_enemy_turret( ) )
                        {
                            if ( q->cast( ) )
                            {
                                return;
                            }
                        }
                    }

                    // Disabling e if q inflicts more damage than the enemy's health
                    else if ( myhero->has_buff( buff_hash( "GarenE" ) ) && q->get_damage( target ) > target->get_health( ) )
                    {
                        if ( e->cast( ) )
                        {
                            if ( q->cast( ) )
                            {
                                return;
                            }
                        }
                    }

                }
            }
            if ( !q->is_ready( ) && e->is_ready( ) && harass::use_e->get_bool( ) )
            {
                // Get a target from a given range
                auto target = target_selector->get_target( e->range( ), damage_type::physical );

                // Always check an object is not a nullptr!
                if ( target != nullptr )
                {
                    if ( !myhero->has_buff( buff_hash( "GarenE" ) ) )
                    {
                        if ( e->cast( ) )
                        {
                            return;
                        }
                    }
                }
            }

        }

        // Checking if the user has selected flee_mode() (Default Z)
        if ( orbwalker->flee_mode( ) )
        {
            if ( q->is_ready( ) && fleemode::use_q->get_bool( ) )
            {
                if ( q->cast( ) )
                {
                    return;
                }
            }
        }

        // Checking if the user has selected lane_clear_mode() (Default V)
        if ( orbwalker->lane_clear_mode( ) )
        {

            // Gets enemy minions from the entitylist
        }
    }
}
```

--------------------------------

### Retrieve Missile Target Object

Source: https://docs.rtxpower.com/API/GameObject

Gets the target object of a missile by retrieving the target ID and querying the entity list. Includes null check to ensure the object exists before using it.

```C++
auto target = entitylist->get_object( missile->missile_get_target_id( ) );

if ( target != nullptr ) 
{
    ...
}
```

--------------------------------

### Retrieve Missile Sender Object

Source: https://docs.rtxpower.com/API/GameObject

Gets the sender object of a missile by retrieving the sender ID and querying the entity list. Includes null check to ensure the object exists before using it.

```C++
auto sender = entitylist->get_object( missile->missile_get_sender_id( ) );

if ( sender != nullptr ) 
{
    ...
}
```

--------------------------------

### Q Ability Logic for Targeting and Damage

Source: https://docs.rtxpower.com/champion

Implements the logic for the Q ability, including selecting a target within a specified range, checking if the target is within Q's range, and determining if the Q ability's damage is sufficient to kill the target. It also includes conditions for casting E before Q under specific circumstances.

```C++
void q_logic( )
    {
        // Get a target from a given range
        auto target = target_selector->get_target( 500, damage_type::physical );

        // Always check an object is not a nullptr!
        if ( target != nullptr )
        {
            // Check if the distance between myhero and enemy is smaller than q range
            if ( target->get_distance( myhero ) <= q->range( ) )
            {

                // Checking if the target will die from q damage
                if ( q->get_damage( target ) >= target->get_health( ) )
                {
                    if ( myhero->has_buff( buff_hash( "GarenE" ) ) )
                    {
                        // Deactivation e
                        if ( e->cast( ) )
                        {
                            if ( q->cast( ) )
                                return;
                        }
                    }
                    else
                    {
                        if ( q->cast( ) )
                            return;
                    }
                }
            }
        }
    }
```

--------------------------------

### Get Missile Sender and Target IDs

Source: https://docs.rtxpower.com/API/GameObject

Retrieves the sender and target IDs from a missile object. Returns unsigned short values that can be used with entitylist to retrieve the actual game objects.

```C++
unsigned short missile_get_sender_id( );
unsigned short missile_get_target_id( );
```

--------------------------------

### Garen Champion Script Declaration (C++)

Source: https://docs.rtxpower.com/champion

The garen.h file declares the load and unload functions for the Garen champion script. These functions are called by the main plugin entry point to initialize and clean up Garen-specific logic. It uses a namespace to organize the Garen functions.

```cpp
#pragma once
namespace garen
{
    void load( );
    void unload( );
};

```

--------------------------------

### Initialize Priority List Menu Item - C++

Source: https://docs.rtxpower.com/API/menusample

This code snippet demonstrates how to populate and add a priority list to a menu system within a game. It gathers enemy hero data, including network ID, model, and portrait, to create 'ProrityCheckItem' objects. The 'add_prority_list' function is used to integrate this into the 'orbwalker_menu'.

```cpp
// ... in load function

{
    std::vector<ProrityCheckItem> prority_items;

    for ( auto&& enemy : entitylist->get_enemy_heroes( ) )
    {
        prority_items.push_back( { enemy->get_network_id( ), enemy->get_model( ), true, enemy->get_square_icon_portrait( ) } );
    }

    // In this case you HAVE to set should save to false since prority key contains network id which is unique per game
    //
    use_r_prority = orbwalker_menu->add_prority_list( "use_r_on", "Use R On", prority_items, false, false );
}
```

--------------------------------

### Retrieve and Access Missile Spell Data

Source: https://docs.rtxpower.com/API/GameObject

Gets spell data from a missile object and validates it before use. The spell_data contains information about the spell that created the missile, including damage, range, and other properties.

```C++
auto spell_data = missile->get_missile_sdata( );

if ( spell_data != nullptr )
{
    ...
}
```

--------------------------------

### Get Object Icon Textures - C++

Source: https://docs.rtxpower.com/API/GameObject

Retrieves texture pointers for the object's avatar square icon and passive ability icon. Both functions may return nullptr if textures are not available.

```cpp
uint32_t* get_square_icon_portrait( );
uint32_t* get_passive_icon_texture( );
```

--------------------------------

### Add Priority List to TreeTab in C++

Source: https://docs.rtxpower.com/API/menusample

Creates a priority list element with reorderable items containing unique keys, display names, activation states, and optional texture icons. Supports PropertyChangeCallback and determines whether items can be enabled/disabled by users through the always_active parameter.

```cpp
virtual TreeEntry* add_prority_list( const std::string& key, const std::string& name, const std::vector<ProrityCheckItem>& prority_elements, const bool& always_active = true, const bool& should_save = true );

struct ProrityCheckItem
{
    std::uint32_t key;
    std::string display_name;
    bool is_active = false;
    void* assigned_texture = nullptr;
};

//Element must be type of TreeTab
prority_list = element->add_prority_list( "attackPrority", "Prority list", { { 0, "Champions" }, { 1, "Minions" }, { 2, "Jungle mob" } } );
```

--------------------------------

### Get Hero Stats - C++

Source: https://docs.rtxpower.com/API/GameObject

Retrieves hero statistics by stat ID. Two overloaded versions support both float and integer stat types, accepting float_hero_stat or int_hero_stat ID parameters respectively.

```cpp
float get_hero_stat( float_hero_stat id );
int get_hero_stat( int_hero_stat id );
```

--------------------------------

### Configure Jungle Clear Settings UI

Source: https://docs.rtxpower.com/champion

Sets up the 'Jungle Clear Settings' tab with checkboxes for using Q and E abilities, and an option to auto-disable E when no monsters are present. Spell icons are used for visual representation.

```cpp
auto jungleclear = main_tab->add_tab( myhero->get_model( ) + ".jungleclear", "Jungle Clear Settings" );
{
    jungleclear::use_q = jungleclear->add_checkbox( myhero->get_model( ) + ".jungleclearUseQ", "Use Q", true );
    jungleclear::use_q->set_texture( myhero->get_spell( spellslot::q )->get_icon_texture( ) );
    jungleclear::use_e = jungleclear->add_checkbox( myhero->get_model( ) + ".jungleclearrUseE", "Use E", true );
    jungleclear::use_e->set_texture( myhero->get_spell( spellslot::e )->get_icon_texture( ) );
    jungleclear::auto_disable_e = jungleclear->add_checkbox( myhero->get_model( ) + ".jungleAutoDisableE", "Auto disable E if no more monster", true );
}
```
Tokens:
Raw