I need to sleep, here be dragons

2024-04-03 03:19:12 -04:00 · 2024-04-03 03:19:12 -04:00 · cf6989bed2
parent b2a7fe3eaf
commit cf6989bed2
31 changed files with 312 additions and 271 deletions
--- a/dependencies/symbol-processor/src
+++ b/dependencies/symbol-processor/src
@ -1 +1 @@
-Subproject commit 842f05a288de6be14fa92f97755d2e18acb00873
+Subproject commit 67c4adaa772445f919f37131d7605bd374c67845
--- a/libreborn/include/libreborn/patch.h
+++ b/libreborn/include/libreborn/patch.h
@ -11,24 +11,53 @@ extern "C" {
 void reborn_init_patch();

 void _overwrite_call(const char *file, int line, void *start, void *target);
-#define overwrite_call(start, target) _overwrite_call(__FILE__, __LINE__, start, target);
+#define overwrite_call(start, target) _overwrite_call(__FILE__, __LINE__, start, target)
+
+#define _setup_fancy_overwrite(start, name, target) \
+    if (!_is_new_method_##name()) { \
+        ERR("Method Is Not \"New\""); \
+    } \
+    static name##_t _original_for_##target = start; \
+    static name##_t _helper_for_##target = _overwrite_helper_for_##name(target, _original_for_##target)
+
+#define _update_references(from, to) \
+    { \
+        void *old_reference = (void *) from; \
+        for (int i = 0; _all_method_symbols[i] != nullptr; i++) { \
+            if (_all_method_symbols[i] == old_reference) { \
+                _all_method_symbols[i] = (void *) to; \
+            } \
+        } \
+    }

 void _overwrite_calls(const char *file, int line, void *start, void *target);
-#define overwrite_calls(start, target) _overwrite_calls(__FILE__, __LINE__, start, target);
+#define overwrite_calls_manual(start, target) _overwrite_calls(__FILE__, __LINE__, start, target)
+#define overwrite_calls(start, target) \
+    { \
+        _setup_fancy_overwrite(start, start, target); \
+        overwrite_calls_manual((void *) start, (void *) _helper_for_##target); \
+        _update_references(start, _helper_for_##target); \
+    }
+
+#define overwrite_virtual_calls(start, target) \
+    { \
+        _setup_fancy_overwrite(*start##_vtable_addr, start, target); \
+        overwrite_calls_manual((void *) *start##_vtable_addr, (void *) _helper_for_##target); \
+    }

 void _overwrite_calls_within(const char *file, int line, void *from, void *to, void *start, void *target);
-#define overwrite_calls_within(from, to, start, target) _overwrite_calls_within(__FILE__, __LINE__, from, to, start, target);
+#define overwrite_calls_within(from, to, start, target) _overwrite_calls_within(__FILE__, __LINE__, from, to, start, target)

 void *extract_from_bl_instruction(unsigned char *from);

 void _overwrite(const char *file, int line, void *start, void *target);
-#define overwrite(start, target) _overwrite(__FILE__, __LINE__, start, target);
+#define overwrite(start, target) _overwrite(__FILE__, __LINE__, (void *) start, (void *) target)

 void _patch(const char *file, int line, void *start, unsigned char patch[4]);
-#define patch(start, patch) _patch(__FILE__, __LINE__, start, patch);
+#define patch(start, patch) _patch(__FILE__, __LINE__, start, patch)

 void _patch_address(const char *file, int line, void *start, void *target);
-#define patch_address(start, target) _patch_address(__FILE__, __LINE__, start, target);
+#define patch_address(start, target) _patch_address(__FILE__, __LINE__, (void *) start, (void *) target)

 #endif

--- a/mods/include/mods/misc/misc.h
+++ b/mods/include/mods/misc/misc.h
@ -22,9 +22,4 @@ void misc_run_on_language_setup(misc_update_function_void_t function); // obj ==
 typedef bool (*misc_update_function_key_press_t)(Minecraft *minecrtaft, int key);
 void misc_run_on_game_key_press(misc_update_function_key_press_t function); // In-Game Key Presses Only

-void Level_saveLevelData_injection(Level *level);
-
-// Use this instead of directly calling Gui::addMessage(), it has proper logging!
-void misc_add_message(Gui *gui, const char *text);
-
 extern bool is_in_chat;
--- a/mods/src/atlas/atlas.cpp
+++ b/mods/src/atlas/atlas.cpp
@ -7,7 +7,7 @@
 #include <mods/init/init.h>

 // Fix Grass And Leaves Inventory Rendering When The gui_blocks Atlas Is Disabled
-static void ItemRenderer_renderGuiItemCorrect_injection(Font *font, Textures *textures, ItemInstance *item_instance, int32_t param_1, int32_t param_2) {
+static void ItemRenderer_renderGuiItemCorrect_injection(ItemRenderer_renderGuiItemCorrect_t original, Font *font, Textures *textures, ItemInstance *item_instance, int32_t param_1, int32_t param_2) {
    int32_t leaves_id = Tile_leaves->id;
    int32_t grass_id = Tile_grass->id;
    // Replace Rendered Item With Carried Variant
@ -28,7 +28,7 @@ static void ItemRenderer_renderGuiItemCorrect_injection(Font *font, Textures *te
    glDisable(GL_DEPTH_TEST);

    // Call Original Method
-    ItemRenderer_renderGuiItemCorrect(font, textures, use_carried ? &carried_item_instance : item_instance, param_1, param_2);
+    original(font, textures, use_carried ? &carried_item_instance : item_instance, param_1, param_2);

    // Revert GL State Changes
    if (depth_test_was_enabled) {
@ -40,7 +40,7 @@ static void ItemRenderer_renderGuiItemCorrect_injection(Font *font, Textures *te
 static int item_color_fix_mode = 0;
 #define POTENTIAL_FURNACE_ITEM_TRANSPARENCY 0x33
 #define INVALID_FURNACE_ITEM_MULTIPLIER 0.25f
-static void Tesselator_color_injection(Tesselator *tesselator, int32_t r, int32_t g, int32_t b, int32_t a) {
+static void Tesselator_color_injection(Tesselator_color_t original, Tesselator *tesselator, int32_t r, int32_t g, int32_t b, int32_t a) {
    // Fix Furnace UI
    if (item_color_fix_mode != 0) {
        // Force Translucent
@ -55,16 +55,16 @@ static void Tesselator_color_injection(Tesselator *tesselator, int32_t r, int32_
    }

    // Call Original Method
-    Tesselator_color(tesselator, r, g, b, a);
+    original(tesselator, r, g, b, a);
 }
-static void Tesselator_begin_injection(Tesselator *tesselator, int32_t mode) {
+static void Tesselator_begin_injection(Tesselator_begin_t original, Tesselator *tesselator, int32_t mode) {
    // Call Original Method
-    Tesselator_begin(tesselator, mode);
+    original(tesselator, mode);

    // Fix Furnace UI
    if (item_color_fix_mode != 0) {
        // Implict Translucent
-        Tesselator_color_injection(tesselator, 0xff, 0xff, 0xff, 0xff);
+        Tesselator_color(tesselator, 0xff, 0xff, 0xff, 0xff);
    }
 }
 static void InventoryPane_renderBatch_Tesselator_color_injection(Tesselator *tesselator, int32_t r, int32_t g, int32_t b) {
@ -74,9 +74,9 @@ static void InventoryPane_renderBatch_Tesselator_color_injection(Tesselator *tes
    // Enable Item Color Fix
    item_color_fix_mode = 2;
 }
-static void ItemRenderer_renderGuiItem_two_injection(Font *font, Textures *textures, ItemInstance *item_instance, float param_1, float param_2, float param_3, float param_4, bool param_5) {
+static void ItemRenderer_renderGuiItem_two_injection(ItemRenderer_renderGuiItem_two_t original, Font *font, Textures *textures, ItemInstance *item_instance, float param_1, float param_2, float param_3, float param_4, bool param_5) {
    // Call Original Method
-    ItemRenderer_renderGuiItem_two(font, textures, item_instance, param_1, param_2, param_3, param_4, param_5);
+    original(font, textures, item_instance, param_1, param_2, param_3, param_4, param_5);

    // Disable Item Color Fix
    item_color_fix_mode = 0;
@ -92,17 +92,17 @@ static void FurnaceScreen_render_ItemRenderer_renderGuiItem_one_injection(Font *
 // Init
 void init_atlas() {
    // Add Better nullptr-Check (And More UI Fixes When The gui_blocks Atlas Is Disabled)
-    overwrite_calls((void *) ItemRenderer_renderGuiItem_two, (void *) ItemRenderer_renderGuiItem_two_injection);
+    overwrite_calls(ItemRenderer_renderGuiItem_two, ItemRenderer_renderGuiItem_two_injection);

    // Disable The gui_blocks Atlas Which Contains Pre-Rendered Textures For Blocks In The Inventory
    if (feature_has("Disable \"gui_blocks\" Atlas", server_disabled)) {
        unsigned char disable_gui_blocks_atlas_patch[4] = {0x00, 0xf0, 0x20, 0xe3}; // "nop"
        patch((void *) 0x63c2c, disable_gui_blocks_atlas_patch);
        // Fix Grass And Leaves Inventory Rendering When The gui_blocks Atlas Is Disabled
-        overwrite_calls((void *) ItemRenderer_renderGuiItemCorrect, (void *) ItemRenderer_renderGuiItemCorrect_injection);
+        overwrite_calls(ItemRenderer_renderGuiItemCorrect, ItemRenderer_renderGuiItemCorrect_injection);
        // Fix Furnace UI
-        overwrite_calls((void *) Tesselator_begin, (void *) Tesselator_begin_injection);
-        overwrite_calls((void *) Tesselator_color, (void *) Tesselator_color_injection);
+        overwrite_calls(Tesselator_begin, Tesselator_begin_injection);
+        overwrite_calls(Tesselator_color, Tesselator_color_injection);
        overwrite_call((void *) 0x32324, (void *) FurnaceScreen_render_ItemRenderer_renderGuiItem_one_injection);
        overwrite_call((void *) 0x1e21c, (void *) InventoryPane_renderBatch_Tesselator_color_injection);
    }
--- a/mods/src/benchmark/benchmark.cpp
+++ b/mods/src/benchmark/benchmark.cpp
@ -64,7 +64,7 @@ static void Minecraft_tick_injection(__attribute__((unused)) Minecraft *minecraf

 // Get Time
 static long long int get_time() {
-    struct timespec ts;
+    timespec ts = {};
    clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
    long long int a = (long long int) ts.tv_nsec;
    long long int b = ((long long int) ts.tv_sec) * NANOSECONDS_IN_SECOND;
--- a/mods/src/bucket/bucket.cpp
+++ b/mods/src/bucket/bucket.cpp
@ -136,7 +136,7 @@ static int BucketItem_getUseDuration(__attribute__((unused)) FoodItem *item, Ite

 static ItemInstance BucketItem_useTimeDepleted(FoodItem *item, ItemInstance *item_instance, Level *level, Player *player) {
    if (item_instance->auxiliary == 1) {
-        *item_instance = FoodItem_useTimeDepleted_non_virtual(item, item_instance, level, player);
+        *item_instance = (*FoodItem_useTimeDepleted_vtable_addr)(item, item_instance, level, player);
        // Set it to a empty bucket
        item_instance->auxiliary = 0;
        item_instance->count = 1;
@ -212,25 +212,25 @@ static void Item_initItems_injection(__attribute__((unused)) void *null) {
 }

 // Change Max Stack Size Based On Auxiliary
-static int32_t ItemInstance_getMaxStackSize_injection(ItemInstance *item_instance) {
+static int32_t ItemInstance_getMaxStackSize_injection(ItemInstance_getMaxStackSize_t original, ItemInstance *item_instance) {
    if (item_instance->id == bucket->id && item_instance->auxiliary == 0) {
        // Custom Value
        return 16;
    } else {
        // Call Original Method
-        return ItemInstance_getMaxStackSize(item_instance);
+        return original(item_instance);
    }
 }

 // Milking
-bool Cow_interact_injection(Cow *self, Player *player) {
+bool Cow_interact_injection(Cow_interact_t original, Cow *self, Player *player) {
    ItemInstance *item = Inventory_getSelected(player->inventory);
    if (item && item->id == bucket->id && item->auxiliary == 0) {
        // Fill with milk
        fill_bucket(item, player, 1);
        return true;
    }
-    return Cow_interact_non_virtual(self, player);
+    return original(self, player);
 }

 // Creative Inventory
@ -277,7 +277,7 @@ static bool is_calm_liquid(int32_t id) {
        return false;
    }
 }
-static void Minecraft_handleMouseDown_injection(Minecraft *minecraft, int param_1, bool can_destroy) {
+static void Minecraft_handleMouseDown_injection(Minecraft_handleMouseDown_t original, Minecraft *minecraft, int param_1, bool can_destroy) {
    // Check
    Level *level = minecraft->level;
    if (level != nullptr) {
@ -291,7 +291,7 @@ static void Minecraft_handleMouseDown_injection(Minecraft *minecraft, int param_
    }

    // Call Original Method
-    Minecraft_handleMouseDown(minecraft, param_1, can_destroy);
+    original(minecraft, param_1, can_destroy);
 }

 // Custom Crafting Recipes
@ -319,12 +319,12 @@ static void Recipes_injection(Recipes *recipes) {
 }

 // Custom Furnace Fuel
-static int32_t FurnaceTileEntity_getBurnDuration_injection(ItemInstance *item_instance) {
+static int32_t FurnaceTileEntity_getBurnDuration_injection(FurnaceTileEntity_getBurnDuration_t original, ItemInstance *item_instance) {
    if (item_instance->count > 0 && item_instance->id == bucket->id && item_instance->auxiliary == Tile_lava->id) {
        return 20000;
    } else {
        // Call Original Method
-        return FurnaceTileEntity_getBurnDuration(item_instance);
+        return original(item_instance);
    }
 }
 static void FurnaceTileEntity_tick_ItemInstance_setNull_injection(ItemInstance *item_instance) {
@ -353,20 +353,20 @@ void init_bucket() {
        // Add Items
        misc_run_on_items_setup(Item_initItems_injection);
        // Change Max Stack Size Based On Auxiliary
-        overwrite_calls((void *) ItemInstance_getMaxStackSize, (void *) ItemInstance_getMaxStackSize_injection);
+        overwrite_calls(ItemInstance_getMaxStackSize, ItemInstance_getMaxStackSize_injection);
        // Enable milking
-        patch_address((void *) Cow_interact_vtable_addr, (void *) Cow_interact_injection);
+        overwrite_virtual_calls(Cow_interact, Cow_interact_injection);
        // Creative Inventory
        misc_run_on_creative_inventory_setup(Inventory_setupDefault_FillingContainer_addItem_call_injection);
        // Make Liquids Selectable
        overwrite_call((void *) 0x7f5b0, (void *) Mob_pick_Level_clip_injection);
        misc_run_on_tick(handle_tick);
        // Prevent Breaking Liquid
-        overwrite_calls((void *) Minecraft_handleMouseDown, (void *) Minecraft_handleMouseDown_injection);
+        overwrite_calls(Minecraft_handleMouseDown, Minecraft_handleMouseDown_injection);
        // Custom Crafting Recipes
        misc_run_on_recipes_setup(Recipes_injection);
        // Custom Furnace Fuel
-        overwrite_calls((void *) FurnaceTileEntity_getBurnDuration, (void *) FurnaceTileEntity_getBurnDuration_injection);
+        overwrite_calls(FurnaceTileEntity_getBurnDuration, FurnaceTileEntity_getBurnDuration_injection);
        overwrite_call((void *) 0xd351c, (void *) FurnaceTileEntity_tick_ItemInstance_setNull_injection);
        // Language for milk
        misc_run_on_language_setup(Language_injection);
--- a/mods/src/camera/camera.cpp
+++ b/mods/src/camera/camera.cpp
@ -7,16 +7,16 @@
 #include <mods/init/init.h>

 // Take Screenshot Using TripodCamera
-static void AppPlatform_linux_saveScreenshot_injection(__attribute__((unused)) AppPlatform *app_platform, __attribute__((unused)) std::string const& path, __attribute__((unused)) int32_t width, __attribute__((unused)) int32_t height) {
+static void AppPlatform_saveScreenshot_injection(__attribute__((unused)) AppPlatform_saveScreenshot_t original, __attribute__((unused)) AppPlatform *app_platform, __attribute__((unused)) std::string *path, __attribute__((unused)) int32_t width, __attribute__((unused)) int32_t height) {
 #ifndef MCPI_HEADLESS_MODE
    screenshot_take(home_get());
 #endif
 }

 // Enable TripodCameraRenderer
-static EntityRenderDispatcher *EntityRenderDispatcher_injection(EntityRenderDispatcher *dispatcher) {
+static EntityRenderDispatcher *EntityRenderDispatcher_injection(EntityRenderDispatcher_constructor_t original, EntityRenderDispatcher *dispatcher) {
    // Call Original Method
-    EntityRenderDispatcher_constructor(dispatcher);
+    original(dispatcher);

    // Register TripodCameraRenderer
    TripodCameraRenderer *renderer = alloc_TripodCameraRenderer();
@ -36,12 +36,12 @@ static void TripodCamera_tick_Level_addParticle_call_injection(Level *level, std
 // Init
 void init_camera() {
    // Implement AppPlatform_linux::saveScreenshot So Cameras Work
-    patch_address(AppPlatform_linux_saveScreenshot_vtable_addr, (void *) AppPlatform_linux_saveScreenshot_injection);
+    overwrite_virtual_calls(AppPlatform_saveScreenshot, AppPlatform_saveScreenshot_injection);

    // Fix Camera Rendering
    if (feature_has("Fix Camera Rendering", server_disabled)) {
        // Enable TripodCameraRenderer
-        overwrite_calls((void *) EntityRenderDispatcher_constructor, (void *) EntityRenderDispatcher_injection);
+        overwrite_calls(EntityRenderDispatcher_constructor, EntityRenderDispatcher_injection);
        // Display Smoke From TripodCamera Higher
        overwrite_call((void *) 0x87dc4, (void *) TripodCamera_tick_Level_addParticle_call_injection);
    }
--- a/mods/src/chat/chat.cpp
+++ b/mods/src/chat/chat.cpp
@ -21,7 +21,7 @@

 // Send API Command
 std::string chat_send_api_command(Minecraft *minecraft, std::string str) {
-    struct ConnectedClient client;
+    ConnectedClient client;
    client.sock = -1;
    client.str = "";
    client.time = 0;
@ -116,7 +116,7 @@ void init_chat() {
        // Manually Send (And Loopback) ChatPacket
        overwrite_call((void *) 0x6b518, (void *) CommandServer_parse_CommandServer_dispatchPacket_injection);
        // Re-Broadcast ChatPacket
-        patch_address(ServerSideNetworkHandler_handle_ChatPacket_vtable_addr, (void *) ServerSideNetworkHandler_handle_ChatPacket_injection);
+        patch_address(ServerSideNetworkHandler_handle_ChatPacket_vtable_addr, ServerSideNetworkHandler_handle_ChatPacket_injection);
 #ifndef MCPI_HEADLESS_MODE
        // Send Messages On Input Tick
        input_run_on_tick(send_queued_messages);
--- a/mods/src/chat/ui.cpp
+++ b/mods/src/chat/ui.cpp
@ -69,8 +69,9 @@ CUSTOM_VTABLE(chat_screen, Screen) {
        original_render(super, x, y, param_1);
    };
    // Positioning
+    static Screen_setupPositions_t original_setupPositions = vtable->setupPositions;
    vtable->setupPositions = [](Screen *super) {
-        Screen_setupPositions_non_virtual(super);
+        original_setupPositions(super);
        ChatScreen *self = (ChatScreen *) super;
        self->send->height = 24;
        self->send->width = 40;
@ -118,6 +119,7 @@ CUSTOM_VTABLE(chat_screen, Screen) {
        original_keyPressed(super, key);
    };
    // Button Click
+    static Screen_buttonClicked_t original_buttonClicked = vtable->buttonClicked;
    vtable->buttonClicked = [](Screen *super, Button *button) {
        ChatScreen *self = (ChatScreen *) super;
        if (button == self->send) {
@ -126,7 +128,7 @@ CUSTOM_VTABLE(chat_screen, Screen) {
            super->vtable->keyPressed(super, 0x0d);
        } else {
            // Call Original Method
-            Screen_buttonClicked_non_virtual(super, button);
+            original_buttonClicked(super, button);
        }
    };
 }
--- a/mods/src/death/death.cpp
+++ b/mods/src/death/death.cpp
@ -65,19 +65,19 @@ std::string get_death_message(Player *player, Entity *cause, bool was_shot = fal
 }

 static bool is_hurt = false;
-static bool Mob_hurt_injection(Mob *mob, Entity *source, int dmg) {
-    // Call Original Method
+static bool Mob_hurt_injection(Mob_hurt_t original, Mob *mob, Entity *source, int dmg) {
    is_hurt = true;
-    bool ret = Mob_hurt_non_virtual(mob, source, dmg);
+    bool ret = original(mob, source, dmg);
    is_hurt = false;
    return ret;
 }

 // Death Message Logic
-#define Player_death_injections(type) \
-    static void type##Player_die_injection(type##Player *player, Entity *cause) { \
+#define Player_die_injections(type) \
+    static type##_die_t original_##type##_die; \
+    static void type##_die_injection(type *player, Entity *cause) { \
        /* Call Original Method */ \
-        type##Player_die_non_virtual(player, cause); \
+        original_##type##_die(player, cause); \
        \
        /* Get Variable */ \
        RakNetInstance *rak_net_instance = player->minecraft->rak_net_instance; \
@ -90,14 +90,14 @@ static bool Mob_hurt_injection(Mob *mob, Entity *source, int dmg) {
            ServerSideNetworkHandler *server_side_network_handler = (ServerSideNetworkHandler *) player->minecraft->network_handler; \
            ServerSideNetworkHandler_displayGameMessage(server_side_network_handler, &message); \
        } \
-    } \
-    \
-    static void type##Player_actuallyHurt_injection(type##Player *player, int32_t damage) { \
+    }
+#define Player_actuallyHurt_injections(type) \
+    static void type##_actuallyHurt_injection(type *player, int32_t damage) { \
        /* Store Old Health */ \
        int32_t old_health = player->health; \
        \
        /* Call Original Method */ \
-        type##Player_actuallyHurt_non_virtual(player, damage); \
+        (*Mob_actuallyHurt_vtable_addr)((Mob *) player, damage); \
        if (is_hurt == true) return; \
        \
        /* Store New Health */ \
@ -119,18 +119,21 @@ static bool Mob_hurt_injection(Mob *mob, Entity *source, int dmg) {
        } \
    }

-Player_death_injections(Local);
-Player_death_injections(Server);
+Player_die_injections(LocalPlayer)
+Player_die_injections(ServerPlayer)
+
+Player_actuallyHurt_injections(LocalPlayer)
+Player_actuallyHurt_injections(ServerPlayer)

 // Init
 void init_death() {
    // Death Messages
    if (feature_has("Implement Death Messages", server_auto)) {
-        patch_address(ServerPlayer_die_vtable_addr, (void *) ServerPlayer_die_injection);
-        patch_address(LocalPlayer_die_vtable_addr, (void *) LocalPlayer_die_injection);
-        patch_address(ServerPlayer_actuallyHurt_vtable_addr, (void *) ServerPlayer_actuallyHurt_injection);
-        patch_address(LocalPlayer_actuallyHurt_vtable_addr, (void *) LocalPlayer_actuallyHurt_injection);
-        overwrite_calls((void *) Mob_hurt_non_virtual, (void *) Mob_hurt_injection);
+        patch_address(ServerPlayer_die_vtable_addr, ServerPlayer_die_injection);
+        patch_address(LocalPlayer_die_vtable_addr, LocalPlayer_die_injection);
+        patch_address(LocalPlayer_actuallyHurt_vtable_addr, LocalPlayer_actuallyHurt_injection);
+        patch_address(ServerPlayer_actuallyHurt_vtable_addr, ServerPlayer_actuallyHurt_injection);
+        overwrite_virtual_calls(Mob_hurt, Mob_hurt_injection);
    }

    // Fix TNT
--- a/mods/src/fps/fps.cpp
+++ b/mods/src/fps/fps.cpp
@ -9,7 +9,7 @@
 // Track FPS
 #define NANOSECONDS_IN_SECOND 1000000000ll
 static long long int get_time() {
-    struct timespec ts;
+    timespec ts = {};
    clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
    long long int a = (long long int) ts.tv_nsec;
    long long int b = ((long long int) ts.tv_sec) * NANOSECONDS_IN_SECOND;
--- a/mods/src/game-mode/game-mode.cpp
+++ b/mods/src/game-mode/game-mode.cpp
@ -28,21 +28,21 @@ static void set_is_survival(bool new_is_survival) {
 }

 // Handle Gamemode Switching
-static void Minecraft_setIsCreativeMode_injection(Minecraft *self, int32_t new_game_mode) {
+static void Minecraft_setIsCreativeMode_injection(Minecraft_setIsCreativeMode_t original, Minecraft *self, int32_t new_game_mode) {
    set_is_survival(!new_game_mode);

    // Call Original Method
-    Minecraft_setIsCreativeMode(self, new_game_mode);
+    original(self, new_game_mode);
 }

 // Disable CreatorMode-Specific API Features (Polling Block Hits) In SurvivalMode, This Is Preferable To Crashing
-static unsigned char *Minecraft_getCreator_injection(Minecraft *minecraft) {
+static unsigned char *Minecraft_getCreator_injection(Minecraft_getCreator_t original, Minecraft *minecraft) {
    if (is_survival) {
        // SurvivalMode, Return nullptr
        return nullptr;
    } else {
        // CreatorMode, Call Original Method
-        return Minecraft_getCreator(minecraft);
+        return original(minecraft);
    }
 }

@ -51,7 +51,7 @@ void init_game_mode() {
    // Dynamic Game Mode Switching
    if (feature_has("Implement Game-Mode Switching", server_enabled)) {
        set_is_survival(true);
-        overwrite_calls((void *) Minecraft_setIsCreativeMode, (void *) Minecraft_setIsCreativeMode_injection);
+        overwrite_calls(Minecraft_setIsCreativeMode, Minecraft_setIsCreativeMode_injection);

        // Replace CreatorLevel With ServerLevel (This Fixes Beds And Mob Spawning)
        overwrite_call((void *) 0x16f84, (void *) ServerLevel_constructor);
@ -61,7 +61,7 @@ void init_game_mode() {
        patch_address((void *) 0x17004, (void *) level_size);

        // Disable CreatorMode-Specific API Features (Polling Block Hits) In SurvivalMode, This Is Preferable To Crashing
-        overwrite_calls((void *) Minecraft_getCreator, (void *) Minecraft_getCreator_injection);
+        overwrite_calls(Minecraft_getCreator, Minecraft_getCreator_injection);
    }

    // Create World Dialog
--- a/mods/src/game-mode/ui.cpp
+++ b/mods/src/game-mode/ui.cpp
@ -92,8 +92,9 @@ CUSTOM_VTABLE(create_world_screen, Screen) {
        Screen_drawString(super, super->font, &description, self->game_mode->x, self->game_mode->y + self->game_mode->height + description_padding, 0xa0a0a0);
    };
    // Positioning
+    static Screen_setupPositions_t original_setupPositions = vtable->setupPositions;
    vtable->setupPositions = [](Screen *super) {
-        Screen_setupPositions_non_virtual(super);
+        original_setupPositions(super);
        CreateWorldScreen *self = (CreateWorldScreen *) super;
        // Height/Width
        int width = 120;
@ -234,7 +235,7 @@ static void create_world(Minecraft *minecraft, std::string name, bool is_creativ

 // Redirect Create World Button
 #define create_SelectWorldScreen_tick_injection(prefix) \
-    static void prefix##SelectWorldScreen_tick_injection(prefix##SelectWorldScreen *screen) { \
+    static void prefix##SelectWorldScreen_tick_injection(prefix##SelectWorldScreen_tick_t original, prefix##SelectWorldScreen *screen) { \
        if (screen->should_create_world) { \
            /* Open Screen */ \
            Minecraft_setScreen(screen->minecraft, create_create_world_screen()); \
@ -242,7 +243,7 @@ static void create_world(Minecraft *minecraft, std::string name, bool is_creativ
            screen->should_create_world = false; \
        } else { \
            /* Call Original Method */ \
-            prefix##SelectWorldScreen_tick_non_virtual(screen); \
+            original(screen); \
        } \
    }
 create_SelectWorldScreen_tick_injection()
@ -251,8 +252,8 @@ create_SelectWorldScreen_tick_injection(Touch_)
 // Init
 void _init_game_mode_ui() {
    // Hijack Create World Button
-    patch_address(SelectWorldScreen_tick_vtable_addr, (void *) SelectWorldScreen_tick_injection);
-    patch_address(Touch_SelectWorldScreen_tick_vtable_addr, (void *) Touch_SelectWorldScreen_tick_injection);
+    overwrite_virtual_calls(SelectWorldScreen_tick, SelectWorldScreen_tick_injection);
+    overwrite_virtual_calls(Touch_SelectWorldScreen_tick, Touch_SelectWorldScreen_tick_injection);
 }

 #else
--- a/mods/src/input/attack.cpp
+++ b/mods/src/input/attack.cpp
@ -14,9 +14,9 @@ void input_set_is_left_click(int val) {
 }

 // Add Attacking To MouseBuildInput
-static int32_t MouseBuildInput_tickBuild_injection(MouseBuildInput *mouse_build_input, Player *local_player, uint32_t *build_action_intention_return) {
+static int32_t MouseBuildInput_tickBuild_injection(MouseBuildInput_tickBuild_t original, MouseBuildInput *mouse_build_input, Player *local_player, uint32_t *build_action_intention_return) {
    // Call Original Method
-    int32_t ret = MouseBuildInput_tickBuild_non_virtual(mouse_build_input, local_player, build_action_intention_return);
+    int32_t ret = original(mouse_build_input, local_player, build_action_intention_return);

    // Use Attack/Place BuildActionIntention If No Other Valid BuildActionIntention Was Selected And This Was Not A Repeated Left Click
    if (ret != 0 && is_left_click == 1 && *build_action_intention_return == 0xa) {
@ -36,7 +36,7 @@ static int32_t MouseBuildInput_tickBuild_injection(MouseBuildInput *mouse_build_
 }

 // Fix Holding Attack
-static bool last_player_attack_successful = 0;
+static bool last_player_attack_successful = false;
 static bool Player_attack_Entity_hurt_injection(Entity *entity, Entity *attacker, int32_t damage) {
    // Call Original Method
    last_player_attack_successful = entity->vtable->hurt(entity, attacker, damage);
@ -56,7 +56,7 @@ static ItemInstance *Player_attack_Inventory_getSelected_injection(Inventory *in
 void _init_attack() {
    // Allow Attacking Mobs
    if (feature_has("Fix Attacking", server_disabled)) {
-        patch_address(MouseBuildInput_tickBuild_vtable_addr, (void *) MouseBuildInput_tickBuild_injection);
+        overwrite_virtual_calls(MouseBuildInput_tickBuild, MouseBuildInput_tickBuild_injection);

        // Fix Holding Attack
        overwrite_call((void *) 0x8fc1c, (void *) Player_attack_Entity_hurt_injection);
--- a/mods/src/input/input.cpp
+++ b/mods/src/input/input.cpp
@ -19,9 +19,9 @@ void input_run_on_tick(input_tick_function_t function) {
 }

 // Handle Input Fixes
-static void Minecraft_tickInput_injection(Minecraft *minecraft) {
+static void Minecraft_tickInput_injection(Minecraft_tickInput_t original, Minecraft *minecraft) {
    // Call Original Method
-    Minecraft_tickInput(minecraft);
+    original(minecraft);

    // Run Input Tick Functions
    for (input_tick_function_t function : get_input_tick_functions()) {
@ -44,7 +44,7 @@ void init_input() {
    _init_bow();

    // Loop
-    overwrite_calls((void *) Minecraft_tickInput, (void *) Minecraft_tickInput_injection);
+    overwrite_calls(Minecraft_tickInput, Minecraft_tickInput_injection);

    // Allow Attacking Mobs
    _init_attack();
--- a/mods/src/input/misc.cpp
+++ b/mods/src/input/misc.cpp
@ -40,11 +40,11 @@ static bool OptionsScreen_handleBackEvent_injection(OptionsScreen *screen, bool
        Minecraft *minecraft = screen->minecraft;
        Minecraft_setScreen(minecraft, nullptr);
    }
-    return 1;
+    return true;
 }

 // Fix "Sleeping Beauty" Bug
-static int32_t InBedScreen_handleBackEvent_injection(InBedScreen *screen, bool do_nothing) {
+static bool InBedScreen_handleBackEvent_injection(InBedScreen *screen, bool do_nothing) {
    if (!do_nothing) {
        // Close Screen
        Minecraft *minecraft = screen->minecraft;
@ -55,7 +55,7 @@ static int32_t InBedScreen_handleBackEvent_injection(InBedScreen *screen, bool d
            player->vtable->stopSleepInBed(player, 1, 1, 1);
        }
    }
-    return 1;
+    return true;
 }

 // Set Mouse Grab State
@ -91,10 +91,10 @@ static bool Gui_tickItemDrop_Minecraft_isCreativeMode_call_injection(Minecraft *
 }

 // Block UI Interaction When Mouse Is Locked
-static void Gui_handleClick_injection(Gui *gui, int32_t param_2, int32_t param_3, int32_t param_4) {
+static void Gui_handleClick_injection(Gui_handleClick_t original, Gui *gui, int32_t param_2, int32_t param_3, int32_t param_4) {
    if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF) {
        // Call Original Method
-        Gui_handleClick(gui, param_2, param_3, param_4);
+        original(gui, param_2, param_3, param_4);
    }
 }

@ -103,11 +103,11 @@ void _init_misc() {
    enable_misc = feature_has("Miscellaneous Input Fixes", server_disabled);
    if (enable_misc) {
        // Fix OptionsScreen Ignoring The Back Button
-        patch_address(OptionsScreen_handleBackEvent_vtable_addr, (void *) OptionsScreen_handleBackEvent_injection);
+        patch_address(OptionsScreen_handleBackEvent_vtable_addr, OptionsScreen_handleBackEvent_injection);
        // Fix "Sleeping Beauty" Bug
-        patch_address(InBedScreen_handleBackEvent_vtable_addr, (void *) InBedScreen_handleBackEvent_injection);
+        patch_address(InBedScreen_handleBackEvent_vtable_addr, InBedScreen_handleBackEvent_injection);
        // Disable Opening Inventory Using The Cursor When Cursor Is Hidden
-        overwrite_calls((void *) Gui_handleClick, (void *) Gui_handleClick_injection);
+        overwrite_calls(Gui_handleClick, Gui_handleClick_injection);
    }
    // Disable Item Dropping Using The Cursor When Cursor Is Hidden
    overwrite_call((void *) 0x27800, (void *) Gui_tickItemDrop_Minecraft_isCreativeMode_call_injection);
--- a/mods/src/input/toggle.cpp
+++ b/mods/src/input/toggle.cpp
@ -12,13 +12,13 @@ static bool _handle_toggle_options(Minecraft *minecraft, int key) {
    if (key == 0x70) {
        // Toggle Hide GUI
        options->hide_gui = options->hide_gui ^ 1;
-        return 1;
+        return true;
    } else if (key == 0x74) {
        // Toggle Third Person
        options->third_person = (options->third_person + 1) % 3;
-        return 1;
+        return true;
    } else {
-        return 0;
+        return false;
    }
 }
 static void _fix_third_person(Minecraft *minecraft) {
@ -49,7 +49,7 @@ static void revert_rotation(Entity *entity) {
 }
 static int is_front_facing = 0;
 static LocalPlayer *stored_player = nullptr;
-static void GameRenderer_setupCamera_injection(GameRenderer *game_renderer, float param_1, int param_2) {
+static void GameRenderer_setupCamera_injection(GameRenderer_setupCamera_t original, GameRenderer *game_renderer, float param_1, int param_2) {
    // Get Objects
    Minecraft *minecraft = game_renderer->minecraft;
    stored_player = minecraft->player;
@ -64,21 +64,21 @@ static void GameRenderer_setupCamera_injection(GameRenderer *game_renderer, floa
    }

    // Call Original Method
-    GameRenderer_setupCamera(game_renderer, param_1, param_2);
+    original(game_renderer, param_1, param_2);

    // Revert
    if (is_front_facing) {
        revert_rotation((Entity *) stored_player);
    }
 }
-static void ParticleEngine_render_injection(ParticleEngine *particle_engine, Entity *entity, float param_2) {
+static void ParticleEngine_render_injection(ParticleEngine_render_t original, ParticleEngine *particle_engine, Entity *entity, float param_2) {
    // Invert Rotation
    if (is_front_facing && (Entity *) stored_player == entity) {
        invert_rotation((Entity *) stored_player);
    }

    // Call Original Method
-    ParticleEngine_render(particle_engine, entity, param_2);
+    original(particle_engine, entity, param_2);

    // Revert
    if (is_front_facing && (Entity *) stored_player == entity) {
@ -93,7 +93,7 @@ void _init_toggle() {
        misc_run_on_update(_fix_third_person);

        // Font-Facing View
-        overwrite_calls((void *) GameRenderer_setupCamera, (void *) GameRenderer_setupCamera_injection);
-        overwrite_calls((void *) ParticleEngine_render, (void *) ParticleEngine_render_injection);
+        overwrite_calls(GameRenderer_setupCamera, GameRenderer_setupCamera_injection);
+        overwrite_calls(ParticleEngine_render, ParticleEngine_render_injection);
    }
 }
--- a/mods/src/misc/api.cpp
+++ b/mods/src/misc/api.cpp
@ -1,3 +1,4 @@
+#include <utility>
 #include <vector>

 #include <libreborn/libreborn.h>
@ -26,9 +27,9 @@
 // Run Functions On Update
 SETUP_CALLBACK(update, Minecraft);
 // Handle Custom Update Behavior
-static void Minecraft_update_injection(Minecraft *minecraft) {
+static void Minecraft_update_injection(Minecraft_update_t original, Minecraft *minecraft) {
    // Call Original Method
-    Minecraft_update_non_virtual(minecraft);
+    original(minecraft);

    // Run Functions
    handle_misc_update(minecraft);
@ -37,9 +38,9 @@ static void Minecraft_update_injection(Minecraft *minecraft) {
 // Run Functions On Tick
 SETUP_CALLBACK(tick, Minecraft);
 // Handle Custom Tick Behavior
-static void Minecraft_tick_injection(Minecraft *minecraft, int32_t param_1, int32_t param_2) {
+static void Minecraft_tick_injection(Minecraft_tick_t original, Minecraft *minecraft, int32_t param_1, int32_t param_2) {
    // Call Original Method
-    Minecraft_tick(minecraft, param_1, param_2);
+    original(minecraft, param_1, param_2);

    // Run Functions
    handle_misc_tick(minecraft);
@ -48,9 +49,9 @@ static void Minecraft_tick_injection(Minecraft *minecraft, int32_t param_1, int3
 // Run Functions On Recipes Setup
 SETUP_CALLBACK(recipes_setup, Recipes);
 // Handle Custom Recipes Setup Behavior
-static Recipes *Recipes_injection(Recipes *recipes) {
+static Recipes *Recipes_injection(Recipes_constructor_t original, Recipes *recipes) {
    // Call Original Method
-    Recipes_constructor(recipes);
+    original(recipes);

    // Run Functions
    handle_misc_recipes_setup(recipes);
@ -62,9 +63,9 @@ static Recipes *Recipes_injection(Recipes *recipes) {
 // Run Functions On Furnace Recipes Setup
 SETUP_CALLBACK(furnace_recipes_setup, FurnaceRecipes);
 // Handle Custom Furnace Recipes Setup Behavior
-static FurnaceRecipes *FurnaceRecipes_injection(FurnaceRecipes *recipes) {
+static FurnaceRecipes *FurnaceRecipes_injection(FurnaceRecipes_constructor_t original, FurnaceRecipes *recipes) {
    // Call Original Method
-    FurnaceRecipes_constructor(recipes);
+    original(recipes);

    // Run Functions
    handle_misc_furnace_recipes_setup(recipes);
@ -87,20 +88,20 @@ static void Inventory_setupDefault_FillingContainer_addItem_call_injection(Filli
 // Run Functions On Tiles Setup
 SETUP_CALLBACK(tiles_setup, void);
 // Handle Custom Tiles Setup Behavior
-static void Tile_initTiles_injection() {
+static void Tile_initTiles_injection(Tile_initTiles_t original) {
    // Run Functions
    handle_misc_tiles_setup(nullptr);

    // Call Original Method
-    Tile_initTiles();
+    original();
 }

 // Run Functions On Items Setup
 SETUP_CALLBACK(items_setup, void);
 // Handle Custom Items Setup Behavior
-static void Item_initItems_injection() {
+static void Item_initItems_injection(Item_initItems_t original) {
    // Call Original Method
-    Item_initItems();
+    original();

    // Run Functions
    handle_misc_items_setup(nullptr);
@ -109,9 +110,9 @@ static void Item_initItems_injection() {
 // Run Functions On Language Setup
 SETUP_CALLBACK(language_setup, void);
 // Handle Custom Items Setup Behavior
-static void I18n_loadLanguage_injection(AppPlatform *app, std::string language_name) {
+static void I18n_loadLanguage_injection(I18n_loadLanguage_t original, AppPlatform *app, std::string language_name) {
    // Call Original Method
-    I18n_loadLanguage(app, language_name);
+    original(app, std::move(language_name));

    // Run Functions
    handle_misc_language_setup(nullptr);
@ -128,32 +129,32 @@ static bool handle_misc_game_key_press(Minecraft *minecraft, int key) {
    return false;
 }
 // Handle Key Presses
-static void Gui_handleKeyPressed_injection(Gui *self, int key) {
+static void Gui_handleKeyPressed_injection(Gui_handleKeyPressed_t original, Gui *self, int key) {
    // Run Functions
    if (handle_misc_game_key_press(self->minecraft, key)) {
        return;
    }

    // Call Original Method
-    Gui_handleKeyPressed(self, key);
+    original(self, key);
 }

 // Init
 void _init_misc_api() {
    // Handle Custom Update Behavior
-    overwrite_calls((void *) Minecraft_update_non_virtual, (void *) Minecraft_update_injection);
+    overwrite_virtual_calls(Minecraft_update, Minecraft_update_injection);
    // Handle Custom Tick Behavior
-    overwrite_calls((void *) Minecraft_tick, (void *) Minecraft_tick_injection);
+    overwrite_calls(Minecraft_tick, Minecraft_tick_injection);
    // Handle Custom Recipe Setup Behavior
-    overwrite_calls((void *) Recipes_constructor, (void *) Recipes_injection);
-    overwrite_calls((void *) FurnaceRecipes_constructor, (void *) FurnaceRecipes_injection);
+    overwrite_calls(Recipes_constructor, Recipes_injection);
+    overwrite_calls(FurnaceRecipes_constructor, FurnaceRecipes_injection);
    // Handle Custom Creative Inventory Setup Behavior
    overwrite_call((void *) 0x8e0fc, (void *) Inventory_setupDefault_FillingContainer_addItem_call_injection);
    // Handle Custom Item/Tile Init Behavior
-    overwrite_calls((void *) Tile_initTiles, (void *) Tile_initTiles_injection);
-    overwrite_calls((void *) Item_initItems, (void *) Item_initItems_injection);
+    overwrite_calls(Tile_initTiles, Tile_initTiles_injection);
+    overwrite_calls(Item_initItems, Item_initItems_injection);
    // Handle Custom Language Entries
-    overwrite_calls((void *) I18n_loadLanguage, (void *) I18n_loadLanguage_injection);
+    overwrite_calls(I18n_loadLanguage, I18n_loadLanguage_injection);
    // Handle Key Presses
-    overwrite_calls((void *) Gui_handleKeyPressed, (void *) Gui_handleKeyPressed_injection);
+    overwrite_calls(Gui_handleKeyPressed, Gui_handleKeyPressed_injection);
 }
--- a/mods/src/misc/logging.cpp
+++ b/mods/src/misc/logging.cpp
@ -8,7 +8,7 @@

 // Print Chat To Log
 static bool Gui_addMessage_recursing = false;
-static void Gui_addMessage_injection(Gui *gui, std::string *text) {
+static void Gui_addMessage_injection(Gui_addMessage_t original, Gui *gui, std::string *text) {
    // Sanitize Message
    char *new_message = strdup(text->c_str());
    ALLOC_CHECK(new_message);
@ -26,22 +26,18 @@ static void Gui_addMessage_injection(Gui *gui, std::string *text) {
        free(safe_message);

        // Call Original Method
-        Gui_addMessage(gui, &cpp_str);
+        original(gui, &cpp_str);

        // End Recursing
        Gui_addMessage_recursing = false;
    } else {
        // Call Original Method
-        Gui_addMessage(gui, &cpp_str);
+        original(gui, &cpp_str);
    }

    // Free
    free(new_message);
 }
-void misc_add_message(Gui *gui, const char *text) {
-    std::string str = text;
-    Gui_addMessage_injection(gui, &str);
-}

 // Print Progress Reports
 static int last_progress = -1;
@ -79,24 +75,24 @@ static void Minecraft_update_injection(Minecraft *minecraft) {
 }

 // Log When Game Is Saved
-void Level_saveLevelData_injection(Level *level) {
+static void Level_saveLevelData_injection(Level_saveLevelData_t original, Level *level) {
    // Print Log Message
    DEBUG("Saving Game");

    // Call Original Method
-    Level_saveLevelData(level);
+    original(level);
 }

 // Init
 void _init_misc_logging() {
    // Print Chat To Log
-    overwrite_calls((void *) Gui_addMessage, (void *) Gui_addMessage_injection);
+    overwrite_calls(Gui_addMessage, Gui_addMessage_injection);

    // Print Progress Reports
    misc_run_on_update(Minecraft_update_injection);

    // Print Log On Game Save
-    overwrite_calls((void *) Level_saveLevelData, (void *) Level_saveLevelData_injection);
+    overwrite_calls(Level_saveLevelData, Level_saveLevelData_injection);

    // Disable stdout Buffering
    setvbuf(stdout, nullptr, _IONBF, 0);
--- a/mods/src/misc/misc.cpp
+++ b/mods/src/misc/misc.cpp
@ -26,7 +26,7 @@

 // Heart food overlay
 static int heal_amount = 0, heal_amount_drawing = 0;
-void Gui_renderHearts_injection(Gui *gui) {
+static void Gui_renderHearts_injection(Gui_renderHearts_t original, Gui *gui) {
    // Get heal_amount
    heal_amount = heal_amount_drawing = 0;

@ -43,13 +43,13 @@ void Gui_renderHearts_injection(Gui *gui) {
    }

    // Call original
-    Gui_renderHearts(gui);
+    original(gui);
 }

 #define PINK_HEART_FULL 70
 #define PINK_HEART_HALF 79
-Gui_blit_t Gui_blit_renderHearts_original = nullptr;
-void Gui_renderHearts_GuiComponent_blit_overlay_empty_injection(Gui *gui, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t w1, int32_t h1, int32_t w2, int32_t h2) {
+static Gui_blit_t Gui_blit_renderHearts_original = nullptr;
+static void Gui_renderHearts_GuiComponent_blit_overlay_empty_injection(Gui *gui, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t w1, int32_t h1, int32_t w2, int32_t h2) {
    // Call original
    Gui_blit_renderHearts_original(gui, x1, y1, x2, y2, w1, h1, w2, h2);
    // Render the overlay
@ -64,7 +64,7 @@ void Gui_renderHearts_GuiComponent_blit_overlay_empty_injection(Gui *gui, int32_
    }
 }

-void Gui_renderHearts_GuiComponent_blit_overlay_hearts_injection(Gui *gui, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t w1, int32_t h1, int32_t w2, int32_t h2) {
+static void Gui_renderHearts_GuiComponent_blit_overlay_hearts_injection(Gui *gui, int32_t x1, int32_t y1, int32_t x2, int32_t y2, int32_t w1, int32_t h1, int32_t w2, int32_t h2) {
    // Offset the overlay
    if (x2 == 52) {
        heal_amount_drawing += 2;
@ -126,7 +126,7 @@ static void Gui_renderBubbles_GuiComponent_blit_injection(Gui *component, int32_
 static int hide_chat_messages = 0;
 bool is_in_chat = 0;
 static int render_selected_item_text = 0;
-static void Gui_renderChatMessages_injection(Gui *gui, int32_t y_offset, uint32_t max_messages, bool disable_fading, Font *font) {
+static void Gui_renderChatMessages_injection(Gui_renderChatMessages_t original, Gui *gui, int32_t y_offset, uint32_t max_messages, bool disable_fading, Font *font) {
    // Handle Classic HUD
    if (use_classic_hud) {
        Minecraft *minecraft = gui->minecraft;
@ -137,7 +137,7 @@ static void Gui_renderChatMessages_injection(Gui *gui, int32_t y_offset, uint32_

    // Call Original Method
    if (!hide_chat_messages && !is_in_chat) {
-        Gui_renderChatMessages(gui, y_offset, max_messages, disable_fading, font);
+        original(gui, y_offset, max_messages, disable_fading, font);
    }

    // Render Selected Item Text
@ -156,9 +156,9 @@ static void Gui_renderChatMessages_injection(Gui *gui, int32_t y_offset, uint32_
 }
 // Reset Selected Item Text Timer On Slot Select
 static uint32_t reset_selected_item_text_timer = 0;
-static void Gui_tick_injection(Gui *gui) {
+static void Gui_tick_injection(Gui_tick_t original, Gui *gui) {
    // Call Original Method
-    Gui_tick(gui);
+    original(gui);

    // Handle Reset
    if (render_selected_item_text) {
@ -171,9 +171,9 @@ static void Gui_tick_injection(Gui *gui) {
    }
 }
 // Trigger Reset Selected Item Text Timer On Slot Select
-static void Inventory_selectSlot_injection(Inventory *inventory, int32_t slot) {
+static void Inventory_selectSlot_injection(Inventory_selectSlot_t original, Inventory *inventory, int32_t slot) {
    // Call Original Method
-    Inventory_selectSlot(inventory, slot);
+    original(inventory, slot);

    // Trigger Reset Selected Item Text Timer
    if (render_selected_item_text) {
@ -182,7 +182,7 @@ static void Inventory_selectSlot_injection(Inventory *inventory, int32_t slot) {
 }

 // Translucent Toolbar
-static void Gui_renderToolBar_injection(Gui *gui, float param_1, int32_t param_2, int32_t param_3) {
+static void Gui_renderToolBar_injection(Gui_renderToolBar_t original, Gui *gui, float param_1, int32_t param_2, int32_t param_3) {
    // Call Original Method
 #ifndef MCPI_HEADLESS_MODE
    int was_blend_enabled = glIsEnabled(GL_BLEND);
@ -191,7 +191,7 @@ static void Gui_renderToolBar_injection(Gui *gui, float param_1, int32_t param_2
    }
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 #endif
-    Gui_renderToolBar(gui, param_1, param_2, param_3);
+    original(gui, param_1, param_2, param_3);
 #ifndef MCPI_HEADLESS_MODE
    if (!was_blend_enabled) {
        glDisable(GL_BLEND);
@ -210,20 +210,20 @@ static void Gui_renderToolBar_glColor4f_injection(GLfloat red, GLfloat green, GL
 }

 // Fix Screen Rendering When GUI is Hidden
-static void Screen_render_injection(Screen *screen, int32_t param_1, int32_t param_2, float param_3) {
+static void Screen_render_injection(Screen_render_t original, Screen *screen, int32_t param_1, int32_t param_2, float param_3) {
    // Fix
 #ifndef MCPI_HEADLESS_MODE
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 #endif
    // Call Original Method
-    Screen_render_non_virtual(screen, param_1, param_2, param_3);
+    original(screen, param_1, param_2, param_3);
 }

 // Sanitize Username
 #define MAX_USERNAME_LENGTH 16
-static void LoginPacket_read_injection(LoginPacket *packet, RakNet_BitStream *bit_stream) {
+static void LoginPacket_read_injection(LoginPacket_read_t original, LoginPacket *packet, RakNet_BitStream *bit_stream) {
    // Call Original Method
-    LoginPacket_read_non_virtual(packet, bit_stream);
+    original(packet, bit_stream);

    // Prepare
    RakNet_RakString *rak_string = &packet->username;
@ -284,9 +284,9 @@ static RakNet_StartupResult RakNetInstance_host_RakNet_RakPeer_Startup_injection
 }

 // Fix Bug Where RakNetInstance Starts Pinging Potential Servers Before The "Join Game" Screen Is Opened
-static RakNetInstance *RakNetInstance_injection(RakNetInstance *rak_net_instance) {
+static RakNetInstance *RakNetInstance_injection(RakNetInstance_constructor_t original, RakNetInstance *rak_net_instance) {
    // Call Original Method
-    RakNetInstance *result = RakNetInstance_constructor(rak_net_instance);
+    RakNetInstance *result = original(rak_net_instance);
    // Fix
    rak_net_instance->pinging_for_hosts = 0;
    // Return
@ -294,17 +294,17 @@ static RakNetInstance *RakNetInstance_injection(RakNetInstance *rak_net_instance
 }

 // Close Current Screen On Death To Prevent Bugs
-static void LocalPlayer_die_injection(LocalPlayer *entity, Entity *cause) {
+static void LocalPlayer_die_injection(LocalPlayer_die_t original, LocalPlayer *entity, Entity *cause) {
    // Close Screen
    Minecraft *minecraft = entity->minecraft;
    Minecraft_setScreen(minecraft, nullptr);

    // Call Original Method
-    LocalPlayer_die_non_virtual(entity, cause);
+    original(entity, cause);
 }

 // Fix Furnace Not Checking Item Auxiliary When Inserting New Item
-static int32_t FurnaceScreen_handleAddItem_injection(FurnaceScreen *furnace_screen, int32_t slot, ItemInstance *item) {
+static int32_t FurnaceScreen_handleAddItem_injection(FurnaceScreen_handleAddItem_t original, FurnaceScreen *furnace_screen, int32_t slot, ItemInstance *item) {
    // Get Existing Item
    FurnaceTileEntity *tile_entity = furnace_screen->tile_entity;
    ItemInstance *existing_item = tile_entity->vtable->getItem(tile_entity, slot);
@ -328,7 +328,7 @@ static int32_t FurnaceScreen_handleAddItem_injection(FurnaceScreen *furnace_scre
    // Call Original Method
    if (valid) {
        // Valid
-        return FurnaceScreen_handleAddItem(furnace_screen, slot, item);
+        return original(furnace_screen, slot, item);
    } else {
        // Invalid
        return 0;
@ -340,9 +340,9 @@ static int32_t FurnaceScreen_handleAddItem_injection(FurnaceScreen *furnace_scre
 // The default behavior for Touch GUI is to only render the cursor when the mouse is clicking, this fixes that.
 // This also makes the cursor always render if the mouse is unlocked, instead of just when there is a Screen showing.
 #ifndef MCPI_HEADLESS_MODE
-static void GameRenderer_render_injection(GameRenderer *game_renderer, float param_1) {
+static void GameRenderer_render_injection(GameRenderer_render_t original, GameRenderer *game_renderer, float param_1) {
    // Call Original Method
-    GameRenderer_render(game_renderer, param_1);
+    original(game_renderer, param_1);

    // Check If Cursor Should Render
    if (SDL_WM_GrabInput(SDL_GRAB_QUERY) == SDL_GRAB_OFF) {
@ -383,8 +383,8 @@ static void anGenBuffers_injection(int32_t count, uint32_t *buffers) {
 #endif

 // Fix Graphics Bug When Switching To First-Person While Sneaking
-static void HumanoidMobRenderer_render_injection(HumanoidMobRenderer *model_renderer, Entity *entity, float param_2, float param_3, float param_4, float param_5, float param_6) {
-    HumanoidMobRenderer_render_non_virtual(model_renderer, entity, param_2, param_3, param_4, param_5, param_6);
+static void PlayerRenderer_render_injection(PlayerRenderer *model_renderer, Entity *entity, float param_2, float param_3, float param_4, float param_5, float param_6) {
+    (*HumanoidMobRenderer_render_vtable_addr)((HumanoidMobRenderer *) model_renderer, entity, param_2, param_3, param_4, param_5, param_6);
    HumanoidModel *model = model_renderer->model;
    model->is_sneaking = false;
 }
@ -438,8 +438,8 @@ static int32_t GrassTile_getColor_injection(__attribute__((unused)) Tile *tile,
    int b_avg = b_sum / color_sum;
    return (r_avg << 16) | (g_avg << 8) | b_avg;
 }
-static int32_t TallGrass_getColor_injection(TallGrass *tile, LevelSource *level_source, int32_t x, int32_t y, int32_t z) {
-    int32_t original_color = TallGrass_getColor_non_virtual(tile, level_source, x, y, z);
+static int32_t TallGrass_getColor_injection(TallGrass_getColor_t original, TallGrass *tile, LevelSource *level_source, int32_t x, int32_t y, int32_t z) {
+    int32_t original_color = original(tile, level_source, x, y, z);
    if (original_color == 0x339933) {
        return GrassTile_getColor_injection((Tile *) tile, level_source, x, y, z);
    } else {
@ -448,9 +448,9 @@ static int32_t TallGrass_getColor_injection(TallGrass *tile, LevelSource *level_
 }

 // Generate Caves
-static void RandomLevelSource_buildSurface_injection(RandomLevelSource *random_level_source, int32_t chunk_x, int32_t chunk_y, unsigned char *chunk_data, Biome **biomes) {
+static void RandomLevelSource_buildSurface_injection(RandomLevelSource_buildSurface_t original, RandomLevelSource *random_level_source, int32_t chunk_x, int32_t chunk_y, unsigned char *chunk_data, Biome **biomes) {
    // Call Original Method
-    RandomLevelSource_buildSurface(random_level_source, chunk_x, chunk_y, chunk_data, biomes);
+    original(random_level_source, chunk_x, chunk_y, chunk_data, biomes);

    // Get Level
    Level *level = random_level_source->level;
@ -501,9 +501,9 @@ static int32_t Tile_getRenderShape_injection(Tile *tile) {
        return tile->vtable->getRenderShape(tile);
    }
 }
-static ChestTileEntity *ChestTileEntity_injection(ChestTileEntity *tile_entity) {
+static ChestTileEntity *ChestTileEntity_injection(ChestTileEntity_constructor_t original, ChestTileEntity *tile_entity) {
    // Call Original Method
-    ChestTileEntity_constructor(tile_entity);
+    original(tile_entity);

    // Enable Renderer
    tile_entity->renderer_id = 1;
@ -522,23 +522,23 @@ static void ModelPart_render_injection(ModelPart *model_part, float scale) {
    // Stop
    is_rendering_chest = false;
 }
-static void Tesselator_vertexUV_injection(Tesselator *tesselator, float x, float y, float z, float u, float v) {
+static void Tesselator_vertexUV_injection(Tesselator_vertexUV_t original, Tesselator *tesselator, float x, float y, float z, float u, float v) {
    // Fix Chest Texture
    if (is_rendering_chest) {
        v /= 2;
    }

    // Call Original Method
-    Tesselator_vertexUV(tesselator, x, y, z, u, v);
+    original(tesselator, x, y, z, u, v);
 }
 static bool ChestTileEntity_shouldSave_injection(__attribute__((unused)) unsigned char *tile_entity) {
    return true;
 }

 // Animated 3D Chest
-static ContainerMenu *ContainerMenu_injection(ContainerMenu *container_menu, Container *container, int32_t param_1) {
+static ContainerMenu *ContainerMenu_injection(ContainerMenu_constructor_t original, ContainerMenu *container_menu, Container *container, int32_t param_1) {
    // Call Original Method
-    ContainerMenu_constructor(container_menu, container, param_1);
+    original(container_menu, container, param_1);

    // Play Animation
    ChestTileEntity *tile_entity = (ChestTileEntity *) (((unsigned char *) container) - offsetof(ChestTileEntity, container));
@ -550,7 +550,7 @@ static ContainerMenu *ContainerMenu_injection(ContainerMenu *container_menu, Con
    // Return
    return container_menu;
 }
-static ContainerMenu *ContainerMenu_destructor_injection(ContainerMenu *container_menu) {
+static ContainerMenu *ContainerMenu_destructor_injection(ContainerMenu_destructor_complete_t original, ContainerMenu *container_menu) {
    // Play Animation
    Container *container = container_menu->container;
    ChestTileEntity *tile_entity = (ChestTileEntity *) (((unsigned char *) container) - offsetof(ChestTileEntity, container));
@ -560,7 +560,7 @@ static ContainerMenu *ContainerMenu_destructor_injection(ContainerMenu *containe
    }

    // Call Original Method
-    return ContainerMenu_destructor_complete_non_virtual(container_menu);
+    return original(container_menu);
 }

 #ifndef MCPI_HEADLESS_MODE
@ -593,9 +593,9 @@ static void glColor4f_injection(__attribute__((unused)) GLfloat red, __attribute
 #endif

 // Fix Furnace Visual Bug
-static int FurnaceTileEntity_getLitProgress_injection(FurnaceTileEntity *furnace, int max) {
+static int FurnaceTileEntity_getLitProgress_injection(FurnaceTileEntity_getLitProgress_t original, FurnaceTileEntity *furnace, int max) {
    // Call Original Method
-    int ret = FurnaceTileEntity_getLitProgress(furnace, max);
+    int ret = original(furnace, max);

    // Fix Bug
    if (ret > max) {
@ -608,15 +608,15 @@ static int FurnaceTileEntity_getLitProgress_injection(FurnaceTileEntity *furnace

 // Fix used items transferring durability
 static int selected_slot = -1;
-static void Player_startUsingItem_injection(Player *self, ItemInstance *item_instance, int time) {
+static void Player_startUsingItem_injection(Player_startUsingItem_t original, Player *self, ItemInstance *item_instance, int time) {
    selected_slot = self->inventory->selectedSlot;
-    Player_startUsingItem(self, item_instance, time);
+    original(self, item_instance, time);
 }
-static void Player_stopUsingItem_injection(Player *self) {
+static void Player_stopUsingItem_injection(Player_stopUsingItem_t original, Player *self) {
    if (selected_slot != self->inventory->selectedSlot) {
        self->itemBeingUsed.id = 0;
    }
-    Player_stopUsingItem(self);
+    original(self);
 }

 // Java Light Ramp
@ -657,9 +657,9 @@ static AppPlatform_readAssetFile_return_value AppPlatform_readAssetFile_injectio
 }

 // Add Missing Buttons To Pause Menu
-static void PauseScreen_init_injection(PauseScreen *screen) {
+static void PauseScreen_init_injection(PauseScreen_init_t original, PauseScreen *screen) {
    // Call Original Method
-    PauseScreen_init_non_virtual(screen);
+    original(screen);

    // Check If Server
    Minecraft *minecraft = screen->minecraft;
@ -778,7 +778,7 @@ void init_misc() {

    // Food overlay
    if (feature_has("Food Overlay", server_disabled)) {
-        overwrite_calls((void *) Gui_renderHearts, (void *) Gui_renderHearts_injection);
+        overwrite_calls(Gui_renderHearts, Gui_renderHearts_injection);
        overwrite_call((void *) 0x266f8, (void *) Gui_renderHearts_GuiComponent_blit_overlay_empty_injection);
        overwrite_call((void *) 0x267c8, (void *) Gui_renderHearts_GuiComponent_blit_overlay_hearts_injection);
    }
@ -786,47 +786,47 @@ void init_misc() {
    // Render Selected Item Text + Hide Chat Messages
    hide_chat_messages = feature_has("Hide Chat Messages", server_disabled);
    render_selected_item_text = feature_has("Render Selected Item Text", server_disabled);
-    overwrite_calls((void *) Gui_renderChatMessages, (void *) Gui_renderChatMessages_injection);
-    overwrite_calls((void *) Gui_tick, (void *) Gui_tick_injection);
-    overwrite_calls((void *) Inventory_selectSlot, (void *) Inventory_selectSlot_injection);
+    overwrite_calls(Gui_renderChatMessages, Gui_renderChatMessages_injection);
+    overwrite_calls(Gui_tick, Gui_tick_injection);
+    overwrite_calls(Inventory_selectSlot, Inventory_selectSlot_injection);

    // Translucent Toolbar
    if (feature_has("Translucent Toolbar", server_disabled)) {
-        overwrite_calls((void *) Gui_renderToolBar, (void *) Gui_renderToolBar_injection);
+        overwrite_calls(Gui_renderToolBar, Gui_renderToolBar_injection);
        overwrite_call((void *) 0x26c5c, (void *) Gui_renderToolBar_glColor4f_injection);
    }

    // Fix Screen Rendering When GUI is Hidden
-    overwrite_calls((void *) Screen_render_non_virtual, (void *) Screen_render_injection);
+    overwrite_virtual_calls(Screen_render, Screen_render_injection);

    // Sanitize Username
-    patch_address(LoginPacket_read_vtable_addr, (void *) LoginPacket_read_injection);
+    overwrite_virtual_calls(LoginPacket_read, LoginPacket_read_injection);

    // Fix RakNet::RakString Security Bug
-    overwrite_calls((void *) RakNet_RakString_constructor, (void *) RakNet_RakString_injection);
+    overwrite_calls_manual((void *) RakNet_RakString_constructor, (void *) RakNet_RakString_injection);

    // Print Error Message If RakNet Startup Fails
    overwrite_call((void *) 0x73778, (void *) RakNetInstance_host_RakNet_RakPeer_Startup_injection);

    // Fix Bug Where RakNetInstance Starts Pinging Potential Servers Before The "Join Game" Screen Is Opened
-    overwrite_calls((void *) RakNetInstance_constructor, (void *) RakNetInstance_injection);
+    overwrite_calls(RakNetInstance_constructor, RakNetInstance_injection);

    // Close Current Screen On Death To Prevent Bugs
    if (feature_has("Close Current Screen On Death", server_disabled)) {
-        patch_address(LocalPlayer_die_vtable_addr, (void *) LocalPlayer_die_injection);
+        overwrite_virtual_calls(LocalPlayer_die, LocalPlayer_die_injection);
    }

    // Fix Furnace Not Checking Item Auxiliary When Inserting New Item
    if (feature_has("Fix Furnace Not Checking Item Auxiliary", server_disabled)) {
-        overwrite_calls((void *) FurnaceScreen_handleAddItem, (void *) FurnaceScreen_handleAddItem_injection);
+        overwrite_calls(FurnaceScreen_handleAddItem, FurnaceScreen_handleAddItem_injection);
    }

 #ifdef MCPI_HEADLESS_MODE
    // Don't Render Game In Headless Mode
-    overwrite_calls((void *) GameRenderer_render, (void *) nop);
-    overwrite_calls((void *) NinecraftApp_initGLStates, (void *) nop);
-    overwrite_calls((void *) Gui_onConfigChanged, (void *) nop);
-    overwrite_calls((void *) LevelRenderer_generateSky, (void *) nop);
+    overwrite(GameRenderer_render, nop);
+    overwrite(NinecraftApp_initGLStates, nop);
+    overwrite(Gui_onConfigChanged, nop);
+    overwrite(LevelRenderer_generateSky, nop);
 #else
    // Improved Cursor Rendering
    if (feature_has("Improved Cursor Rendering", server_disabled)) {
@ -834,7 +834,7 @@ void init_misc() {
        unsigned char disable_cursor_patch[4] = {0x00, 0xf0, 0x20, 0xe3}; // "nop"
        patch((void *) 0x4a6c0, disable_cursor_patch);
        // Add Custom Cursor Rendering
-        overwrite_calls((void *) GameRenderer_render, (void *) GameRenderer_render_injection);
+        overwrite_calls(GameRenderer_render, GameRenderer_render_injection);
    }
 #endif

@ -850,16 +850,16 @@ void init_misc() {

    // Remove Forced GUI Lag
    if (feature_has("Remove Forced GUI Lag (Can Break Joining Servers)", server_enabled)) {
-        overwrite_calls((void *) Common_sleepMs, (void *) nop);
+        overwrite(Common_sleepMs, nop);
    }

 #ifndef MCPI_HEADLESS_MODE
    // Properly Generate Buffers
-    overwrite((void *) Common_anGenBuffers, (void *) anGenBuffers_injection);
+    overwrite(Common_anGenBuffers, anGenBuffers_injection);
 #endif

    // Fix Graphics Bug When Switching To First-Person While Sneaking
-    patch_address(PlayerRenderer_render_vtable_addr, (void *) HumanoidMobRenderer_render_injection);
+    patch_address(PlayerRenderer_render_vtable_addr, PlayerRenderer_render_injection);

    // Disable Speed Bridging
    if (feature_has("Disable Speed Bridging", server_disabled)) {
@ -875,22 +875,22 @@ void init_misc() {

    // Change Grass Color
    if (feature_has("Add Biome Colors To Grass", server_disabled)) {
-        patch_address((void *) GrassTile_getColor_vtable_addr, (void *) GrassTile_getColor_injection);
-        patch_address((void *) TallGrass_getColor_vtable_addr, (void *) TallGrass_getColor_injection);
+        patch_address(GrassTile_getColor_vtable_addr, GrassTile_getColor_injection);
+        overwrite_virtual_calls(TallGrass_getColor, TallGrass_getColor_injection);
    }

    // Generate Caves
    if (feature_has("Generate Caves", server_auto)) {
-        overwrite_calls((void *) RandomLevelSource_buildSurface, (void *) RandomLevelSource_buildSurface_injection);
+        overwrite_calls(RandomLevelSource_buildSurface, RandomLevelSource_buildSurface_injection);
    }

    // Disable Block Tinting
    if (feature_has("Disable Block Tinting", server_disabled)) {
-        patch_address((void *) GrassTile_getColor_vtable_addr, (void *) Tile_getColor_injection);
-        patch_address((void *) TallGrass_getColor_vtable_addr, (void *) Tile_getColor_injection);
-        patch_address((void *) StemTile_getColor_vtable_addr, (void *) Tile_getColor_injection);
-        patch_address((void *) LeafTile_getColor_vtable_addr, (void *) Tile_getColor_injection);
-        overwrite((void *) LiquidTile_getColor_non_virtual, (void *) Tile_getColor_injection);
+        patch_address(GrassTile_getColor_vtable_addr, Tile_getColor_injection);
+        patch_address(TallGrass_getColor_vtable_addr, Tile_getColor_injection);
+        patch_address(StemTile_getColor_vtable_addr, Tile_getColor_injection);
+        patch_address(LeafTile_getColor_vtable_addr, Tile_getColor_injection);
+        overwrite(*LiquidTile_getColor_vtable_addr, Tile_getColor_injection);
    }

    // Custom GUI Scale
@ -913,19 +913,19 @@ void init_misc() {
    // 3D Chests
    if (feature_has("3D Chest Model", server_disabled)) {
        overwrite_call((void *) 0x5e830, (void *) Tile_getRenderShape_injection);
-        overwrite_calls((void *) ChestTileEntity_constructor, (void *) ChestTileEntity_injection);
+        overwrite_calls(ChestTileEntity_constructor, ChestTileEntity_injection);
        overwrite_call((void *) 0x6655c, (void *) ModelPart_render_injection);
        overwrite_call((void *) 0x66568, (void *) ModelPart_render_injection);
        overwrite_call((void *) 0x66574, (void *) ModelPart_render_injection);
-        overwrite_calls((void *) Tesselator_vertexUV, (void *) Tesselator_vertexUV_injection);
+        overwrite_calls(Tesselator_vertexUV, Tesselator_vertexUV_injection);
        unsigned char chest_model_patch[4] = {0x13, 0x20, 0xa0, 0xe3}; // "mov r2, #0x13"
        patch((void *) 0x66fc8, chest_model_patch);
        unsigned char chest_color_patch[4] = {0x00, 0xf0, 0x20, 0xe3}; // "nop"
        patch((void *) 0x66404, chest_color_patch);

        // Animation
-        overwrite_calls((void *) ContainerMenu_constructor, (void *) ContainerMenu_injection);
-        overwrite_calls((void *) ContainerMenu_destructor_complete_non_virtual, (void *) ContainerMenu_destructor_injection);
+        overwrite_calls(ContainerMenu_constructor, ContainerMenu_injection);
+        overwrite_virtual_calls(ContainerMenu_destructor_complete, ContainerMenu_destructor_injection);
    }
    patch_address((void *) 0x115b48, (void *) ChestTileEntity_shouldSave_injection);

@ -940,7 +940,7 @@ void init_misc() {
 #endif

    // Fix Furnace Visual Bug
-    overwrite_calls((void *) FurnaceTileEntity_getLitProgress, (void *) FurnaceTileEntity_getLitProgress_injection);
+    overwrite_calls(FurnaceTileEntity_getLitProgress, FurnaceTileEntity_getLitProgress_injection);

    // Send the full level, not only changed chunks
    if (feature_has("Send Full Level When Hosting Game", server_enabled)) {
@ -952,12 +952,12 @@ void init_misc() {

    // Java Light Ramp
    if (feature_has("Use Java Beta 1.3 Light Ramp", server_disabled)) {
-        overwrite((void *) Dimension_updateLightRamp_non_virtual, (void *) Dimension_updateLightRamp_injection);
+        overwrite(*Dimension_updateLightRamp_vtable_addr, Dimension_updateLightRamp_injection);
    }

    // Fix used items transferring durability
-    overwrite_calls((void *) Player_startUsingItem, (void *) Player_startUsingItem_injection);
-    overwrite_calls((void *) Player_stopUsingItem, (void *) Player_stopUsingItem_injection);
+    overwrite_calls(Player_startUsingItem, Player_startUsingItem_injection);
+    overwrite_calls(Player_stopUsingItem, Player_stopUsingItem_injection);

    // Fix invalid ItemInHandRenderer texture cache
    if (feature_has("Disable Buggy Held Item Caching", server_disabled)) {
@ -971,18 +971,18 @@ void init_misc() {

    // Implement AppPlatform::readAssetFile So Translations Work
    if (feature_has("Load Language Files", server_enabled)) {
-        overwrite((void *) *AppPlatform_readAssetFile_vtable_addr, (void *) AppPlatform_readAssetFile_injection);
+        overwrite(*AppPlatform_readAssetFile_vtable_addr, AppPlatform_readAssetFile_injection);
    }

    // Fix Pause Menu
    if (feature_has("Fix Pause Menu", server_disabled)) {
        // Add Missing Buttons To Pause Menu
-        patch_address(PauseScreen_init_vtable_addr, (void *) PauseScreen_init_injection);
+        overwrite_virtual_calls(PauseScreen_init, PauseScreen_init_injection);
    }

    // Implement Crafting Remainders
    overwrite_call((void *) 0x2e230, (void *) PaneCraftingScreen_craftSelectedItem_PaneCraftingScreen_recheckRecipes_injection);
-    overwrite((void *) Item_getCraftingRemainingItem_non_virtual, (void *) Item_getCraftingRemainingItem_injection);
+    overwrite(*Item_getCraftingRemainingItem_vtable_addr, Item_getCraftingRemainingItem_injection);

    // Replace 2011 std::sort With Optimized(TM) Code
    if (feature_has("Optimized Chunk Sorting", server_enabled)) {
@ -991,7 +991,7 @@ void init_misc() {

    // Display Date In Select World Screen
    if (feature_has("Display Date In Select World Screen", server_disabled)) {
-        patch_address(AppPlatform_linux_getDateString_vtable_addr, (void *) AppPlatform_linux_getDateString_injection);
+        patch_address(AppPlatform_linux_getDateString_vtable_addr, AppPlatform_linux_getDateString_injection);
    }

    // Init Logging
--- a/mods/src/multiplayer/multiplayer.cpp
+++ b/mods/src/multiplayer/multiplayer.cpp
@ -113,9 +113,9 @@ static void iterate_servers(std::function<void(const char *address, int port)> c
 }

 // Ping External Servers
-static void RakNetInstance_pingForHosts_injection(RakNetInstance *rak_net_instance, int32_t base_port) {
+static void RakNetInstance_pingForHosts_injection(RakNetInstance_pingForHosts_t original, RakNetInstance *rak_net_instance, int32_t base_port) {
    // Call Original Method
-    RakNetInstance_pingForHosts_non_virtual(rak_net_instance, base_port);
+    original(rak_net_instance, base_port);

    // Get RakNet::RakPeer
    RakNet_RakPeer *rak_peer = rak_net_instance->peer;
@ -130,6 +130,6 @@ static void RakNetInstance_pingForHosts_injection(RakNetInstance *rak_net_instan
 void init_multiplayer() {
    // Inject Code
    if (feature_has("External Server Support", server_disabled)) {
-        patch_address(RakNetInstance_pingForHosts_vtable_addr, (void *) RakNetInstance_pingForHosts_injection);
+        overwrite_virtual_calls(RakNetInstance_pingForHosts, RakNetInstance_pingForHosts_injection);
    }
 }
--- a/mods/src/options/options.cpp
+++ b/mods/src/options/options.cpp
@ -49,10 +49,10 @@ __attribute__((destructor)) static void _free_safe_username() {

 static int render_distance;
 // Configure Options
-Options *stored_options = nullptr;
-static void Options_initDefaultValue_injection(Options *options) {
+static Options *stored_options = nullptr;
+static void Options_initDefaultValue_injection(Options_initDefaultValue_t original, Options *options) {
    // Call Original Method
-    Options_initDefaultValue(options);
+    original(options);

    // Default Graphics Settings
 #ifndef MCPI_SERVER_MODE
@ -63,9 +63,9 @@ static void Options_initDefaultValue_injection(Options *options) {
    // Store
    stored_options = options;
 }
-static void Minecraft_init_injection(Minecraft *minecraft) {
+static void Minecraft_init_injection(Minecraft_init_t original, Minecraft *minecraft) {
    // Call Original Method
-    Minecraft_init_non_virtual(minecraft);
+    original(minecraft);

    Options *options = &minecraft->options;
    // Enable Crosshair In Touch GUI
@ -75,12 +75,12 @@ static void Minecraft_init_injection(Minecraft *minecraft) {
 }

 // Smooth Lighting
-static void TileRenderer_tesselateBlockInWorld_injection(TileRenderer *tile_renderer, Tile *tile, int32_t x, int32_t y, int32_t z) {
+static bool TileRenderer_tesselateBlockInWorld_injection(TileRenderer_tesselateBlockInWorld_t original, TileRenderer *tile_renderer, Tile *tile, int32_t x, int32_t y, int32_t z) {
    // Set Variable
    Minecraft_useAmbientOcclusion = stored_options->ambient_occlusion;

    // Call Original Method
-    TileRenderer_tesselateBlockInWorld(tile_renderer, tile, x, y, z);
+    return original(tile_renderer, tile, x, y, z);
 }

 // Fix Initial Option Button Rendering
@ -166,7 +166,7 @@ static char *get_new_options_txt_path() {
 #endif

 // Modify Option Toggles
-static void OptionsPane_unknown_toggle_creating_function_injection(OptionsPane *options_pane, uint32_t group_id, std::string *name_ptr, Options_Option *option) {
+static void OptionsPane_unknown_toggle_creating_function_injection(OptionsPane_unknown_toggle_creating_function_t original, OptionsPane *options_pane, uint32_t group_id, std::string *name_ptr, Options_Option *option) {
    // Modify
    std::string name = *name_ptr;
    std::string new_name = name;
@ -192,23 +192,23 @@ static void OptionsPane_unknown_toggle_creating_function_injection(OptionsPane *
    }

    // Call Original Method
-    OptionsPane_unknown_toggle_creating_function(options_pane, group_id, &new_name, option);
+    original(options_pane, group_id, &new_name, option);

    // Add 3D Anaglyph
    if (option == &Options_Option_GRAPHICS) {
        std::string cpp_string = "3D Anaglyph";
-        OptionsPane_unknown_toggle_creating_function(options_pane, group_id, &cpp_string, &Options_Option_ANAGLYPH);
+        original(options_pane, group_id, &cpp_string, &Options_Option_ANAGLYPH);
    }

    // Add Peaceful Mode
    if (option == &Options_Option_SERVER_VISIBLE) {
        std::string cpp_string = "Peaceful mode";
-        OptionsPane_unknown_toggle_creating_function(options_pane, group_id, &cpp_string, &Options_Option_DIFFICULTY);
+        original(options_pane, group_id, &cpp_string, &Options_Option_DIFFICULTY);
    }
 }

 // Add Missing Options To Options::getBooleanValue
-static bool Options_getBooleanValue_injection(Options *options, Options_Option *option) {
+static bool Options_getBooleanValue_injection(Options_getBooleanValue_t original, Options *options, Options_Option *option) {
    // Check
    if (option == &Options_Option_GRAPHICS) {
        return options->fancy_graphics;
@ -216,7 +216,7 @@ static bool Options_getBooleanValue_injection(Options *options, Options_Option *
        return options->game_difficulty == 0;
    } else {
        // Call Original Method
-        return Options_getBooleanValue(options, option);
+        return original(options, option);
    }
 }

@ -246,8 +246,8 @@ void init_options() {
    DEBUG("Setting Render Distance: %i", render_distance);

    // Set Options
-    overwrite_calls((void *) Options_initDefaultValue, (void *) Options_initDefaultValue_injection);
-    overwrite_calls((void *) Minecraft_init_non_virtual, (void *) Minecraft_init_injection);
+    overwrite_calls(Options_initDefaultValue, Options_initDefaultValue_injection);
+    overwrite_virtual_calls(Minecraft_init, Minecraft_init_injection);

    // Change Username
    const char *username = get_username();
@ -272,7 +272,7 @@ void init_options() {
    }

    // Smooth Lighting
-    overwrite_calls((void *) TileRenderer_tesselateBlockInWorld, (void *) TileRenderer_tesselateBlockInWorld_injection);
+    overwrite_calls(TileRenderer_tesselateBlockInWorld, TileRenderer_tesselateBlockInWorld_injection);

    // NOP
    unsigned char nop_patch[4] = {0x00, 0xf0, 0x20, 0xe3}; // "nop"
@ -292,10 +292,10 @@ void init_options() {
        patch((void *) 0x3577c, this_works_slider_patch);

        // Modify Option Toggles
-        overwrite_calls((void *) OptionsPane_unknown_toggle_creating_function, (void *) OptionsPane_unknown_toggle_creating_function_injection);
+        overwrite_calls(OptionsPane_unknown_toggle_creating_function, OptionsPane_unknown_toggle_creating_function_injection);

        // Add Missing Options To Options::getBooleanValue
-        overwrite_calls((void *) Options_getBooleanValue, (void *) Options_getBooleanValue_injection);
+        overwrite_calls(Options_getBooleanValue, Options_getBooleanValue_injection);

        // Fix Difficulty When Toggling
        overwrite_call((void *) 0x1cd00, (void *) OptionButton_toggle_Options_save_injection);
@ -308,7 +308,7 @@ void init_options() {
    // When Loading, options.txt Should Be Opened In Read Mode
    patch_address((void *) Strings_options_txt_fopen_mode_when_loading_pointer, (void *) "r");
    // Fix OptionsFile::getOptionStrings
-    overwrite_calls((void *) OptionsFile_getOptionStrings, (void *) OptionsFile_getOptionStrings_injection);
+    overwrite(OptionsFile_getOptionStrings, OptionsFile_getOptionStrings_injection);

    // Sensitivity Loading/Saving Is Broken, Disable It
    patch((void *) 0x1931c, nop_patch);
--- a/mods/src/sign/sign.cpp
+++ b/mods/src/sign/sign.cpp
@ -10,7 +10,7 @@
 #include <mods/sign/sign.h>

 // Handle Backspace
-static int32_t sdl_key_to_minecraft_key_injection(int32_t sdl_key) {
+static int32_t sdl_key_to_minecraft_key_injection(Common_sdl_key_to_minecraft_key_t original, int32_t sdl_key) {
    if (sdl_key == SDLK_BACKSPACE) {
        return 0x8;
    } else if (sdl_key == SDLK_DELETE) {
@ -25,7 +25,7 @@ static int32_t sdl_key_to_minecraft_key_injection(int32_t sdl_key) {
        return 0x74;
    } else {
        // Call Original Method
-        return Common_sdl_key_to_minecraft_key(sdl_key);
+        return original(sdl_key);
    }
 }

@ -53,5 +53,5 @@ void init_sign() {
    }

    // Handle Backspace
-    overwrite_calls((void *) Common_sdl_key_to_minecraft_key, (void *) sdl_key_to_minecraft_key_injection);
+    overwrite_calls(Common_sdl_key_to_minecraft_key, sdl_key_to_minecraft_key_injection);
 }
--- a/mods/src/skin/loader.cpp
+++ b/mods/src/skin/loader.cpp
@ -114,9 +114,9 @@ static void *loader_thread(void *user_data) {
 }

 // Intercept Texture Creation
-static int32_t Textures_assignTexture_injection(Textures *textures, std::string *name, unsigned char *data) {
+static int32_t Textures_assignTexture_injection(Textures_assignTexture_t original, Textures *textures, std::string *name, unsigned char *data) {
    // Call Original Method
-    int32_t id = Textures_assignTexture(textures, name, data);
+    int32_t id = original(textures, name, data);

    // Load Skin
    if (starts_with(name->c_str(), "$")) {
@ -136,7 +136,7 @@ static int32_t Textures_assignTexture_injection(Textures *textures, std::string
 // Init
 void _init_skin_loader() {
    // Intercept Texture Creation
-    overwrite_calls((void *) Textures_assignTexture, (void *) Textures_assignTexture_injection);
+    overwrite_calls(Textures_assignTexture, Textures_assignTexture_injection);
    // Pending Skins
    misc_run_on_tick(load_pending_skins);
    // Log
--- a/mods/src/sound/sound.cpp
+++ b/mods/src/sound/sound.cpp
@ -104,9 +104,9 @@ static void SoundEngine_update_injection(SoundEngine *sound_engine, Mob *listene

 // Resolve All Sounds On Init
 // SoundEngine::init Is Called After The Audio Engine Has Been Loaded
-static void SoundEngine_init_injection(SoundEngine *sound_engine, Minecraft *minecraft, Options *options) {
+static void SoundEngine_init_injection(SoundEngine_init_t original, SoundEngine *sound_engine, Minecraft *minecraft, Options *options) {
    // Call Original Method
-    SoundEngine_init(sound_engine, minecraft, options);
+    original(sound_engine, minecraft, options);

    // Resolve Sounds
    _sound_resolve_all();
@ -116,9 +116,9 @@ static void SoundEngine_init_injection(SoundEngine *sound_engine, Minecraft *min
 void init_sound() {
    // Implement Sound Engine
    if (feature_has("Implement Sound Engine", server_disabled)) {
-        overwrite((void *) SoundEngine_playUI, (void *) SoundEngine_playUI_injection);
-        overwrite((void *) SoundEngine_play, (void *) SoundEngine_play_injection);
-        overwrite((void *) SoundEngine_update, (void *) SoundEngine_update_injection);
-        overwrite_calls((void *) SoundEngine_init, (void *) SoundEngine_init_injection);
+        overwrite(SoundEngine_playUI, SoundEngine_playUI_injection);
+        overwrite(SoundEngine_play, SoundEngine_play_injection);
+        overwrite(SoundEngine_update, SoundEngine_update_injection);
+        overwrite_calls(SoundEngine_init, SoundEngine_init_injection);
    }
 }
--- a/mods/src/text-input-box/TextInputScreen.cpp
+++ b/mods/src/text-input-box/TextInputScreen.cpp
@ -4,32 +4,36 @@

 // VTable
 void TextInputScreen::setup(Screen_vtable *vtable) {
+    static Screen_keyPressed_t original_keyPressed = vtable->keyPressed;
    vtable->keyPressed = [](Screen *super2, int key) {
-        Screen_keyPressed_non_virtual(super2, key);
+        original_keyPressed(super2, key);
        TextInputScreen *self = (TextInputScreen *) super2;
        for (int i = 0; i < int(self->m_textInputs->size()); i++) {
            TextInputBox *textInput = (*self->m_textInputs)[i];
            textInput->keyPressed(key);
        }
    };
+    static Screen_keyboardNewChar_t original_keyboardNewChar = vtable->keyboardNewChar;
    vtable->keyboardNewChar = [](Screen *super2, char key) {
-        Screen_keyboardNewChar_non_virtual(super2, key);
+        original_keyboardNewChar(super2, key);
        TextInputScreen *self = (TextInputScreen *) super2;
        for (int i = 0; i < int(self->m_textInputs->size()); i++) {
            TextInputBox *textInput = (*self->m_textInputs)[i];
            textInput->charPressed(key);
        }
    };
+    static Screen_mouseClicked_t original_mouseClicked = vtable->mouseClicked;
    vtable->mouseClicked = [](Screen *super2, int x, int y, int param_1) {
-        Screen_mouseClicked_non_virtual(super2, x, y, param_1);
+        original_mouseClicked(super2, x, y, param_1);
        TextInputScreen *self = (TextInputScreen *) super2;
        for (int i = 0; i < int(self->m_textInputs->size()); i++) {
            TextInputBox *textInput = (*self->m_textInputs)[i];
            textInput->onClick(x, y);
        }
    };
+    static Screen_render_t original_render = vtable->render;
    vtable->render = [](Screen *super2, int x, int y, float param_1) {
-        Screen_render_non_virtual(super2, x, y, param_1);
+        original_render(super2, x, y, param_1);
        TextInputScreen *self = (TextInputScreen *) super2;
        for (int i = 0; i < int(self->m_textInputs->size()); i++) {
            TextInputBox *textInput = (*self->m_textInputs)[i];
@ -37,13 +41,15 @@ void TextInputScreen::setup(Screen_vtable *vtable) {
            textInput->render();
        }
    };
+    static Screen_init_t original_init = vtable->init;
    vtable->init = [](Screen *super2) {
-        Screen_init_non_virtual(super2);
+        original_init(super2);
        TextInputScreen *self = (TextInputScreen *) super2;
        self->m_textInputs = new std::vector<TextInputBox *>;
    };
+    static Screen_removed_t original_removed = vtable->removed;
    vtable->removed = [](Screen *super2) {
-        Screen_removed_non_virtual(super2);
+        original_removed(super2);
        TextInputScreen *self = (TextInputScreen *) super2;
        delete self->m_textInputs;
    };
--- a/mods/src/textures/textures.cpp
+++ b/mods/src/textures/textures.cpp
@ -234,5 +234,5 @@ void init_textures() {
    overwrite_call((void *) 0x53274, (void *) Textures_tick_glTexSubImage2D_injection);

    // Load Textures
-    overwrite((void *) AppPlatform_linux_loadTexture_non_virtual, (void *) AppPlatform_linux_loadTexture_injection);
+    overwrite(*AppPlatform_linux_loadTexture_vtable_addr, AppPlatform_linux_loadTexture_injection);
 }
--- a/mods/src/title-screen/title-screen.cpp
+++ b/mods/src/title-screen/title-screen.cpp
@ -22,9 +22,9 @@ static void StartMenuScreen_render_Screen_renderBackground_injection(Screen *scr
 }

 // Add Buttons Back To Classic Start Screen
-static void StartMenuScreen_init_injection(StartMenuScreen *screen) {
+static void StartMenuScreen_init_injection(StartMenuScreen_init_t original, StartMenuScreen *screen) {
    // Call Original Method
-    StartMenuScreen_init_non_virtual(screen);
+    original(screen);

    // Add Button
    std::vector<Button *> *rendered_buttons = &screen->rendered_buttons;
@ -38,14 +38,14 @@ static void StartMenuScreen_init_injection(StartMenuScreen *screen) {
 }

 // Add Functionality To Quit Button
-static void StartMenuScreen_buttonClicked_injection(StartMenuScreen *screen, Button *button) {
+static void StartMenuScreen_buttonClicked_injection(StartMenuScreen_buttonClicked_t original, StartMenuScreen *screen, Button *button) {
    Button *quit_button = &screen->create_button;
    if (button == quit_button) {
        // Quit
        compat_request_exit();
    } else {
        // Call Original Method
-        StartMenuScreen_buttonClicked_non_virtual(screen, button);
+        original(screen, button);
    }
 }

@ -68,7 +68,7 @@ static Screen *last_screen = nullptr;
 static std::string current_splash;
 static void StartMenuScreen_render_Screen_render_injection(Screen *screen, int x, int y, float param_1) {
    // Call Original Method
-    Screen_render_non_virtual(screen, x, y, param_1);
+    (*Screen_render_vtable_addr)(screen, x, y, param_1);

    // Load Splashes
    static std::vector<std::string> splashes;
@ -130,7 +130,7 @@ void init_title_screen() {
    // Improved Classic Title Screen
    if (feature_has("Improved Classic Title Screen", server_disabled)) {
        // Add Options Button Back To Classic Start Screen
-        patch_address(StartMenuScreen_init_vtable_addr, (void *) StartMenuScreen_init_injection);
+        overwrite_virtual_calls(StartMenuScreen_init, StartMenuScreen_init_injection);

        // Fix Classic UI Button Size
        unsigned char classic_button_height_patch[4] = {0x18, 0x30, 0xa0, 0xe3}; // "mov r3, #0x18"
@ -154,7 +154,7 @@ void init_title_screen() {
        patch_address((void *) Strings_classic_create_button_text_pointer, (void *) "Quit");

        // Add Functionality To Quit Button
-        patch_address(StartMenuScreen_buttonClicked_vtable_addr, (void *) StartMenuScreen_buttonClicked_injection);
+        overwrite_virtual_calls(StartMenuScreen_buttonClicked, StartMenuScreen_buttonClicked_injection);
    }

    // Add Splashes
--- a/symbols/src/entity/Entity.def
+++ b/symbols/src/entity/Entity.def
@ -1,3 +1,5 @@
+vtable 0x10a548;
+
 virtual-method void remove() = 0x10;
 virtual-method void tick() = 0x34;
 virtual-method float getBrightness(float param_1) = 0x64;
--- a/symbols/src/input/IBuildInput.def
+++ b/symbols/src/input/IBuildInput.def
@ -1 +1,3 @@
+vtable 0x102540;
+
 virtual-method int tickBuild(Player *player, uint *build_action_intention_return) = 0xc;
--- a/symbols/src/network/NetEventCallback.def
+++ b/symbols/src/network/NetEventCallback.def
@ -1,3 +1,7 @@
+vtable-destructor-offset 0x4; // Why
+vtable 0x1090f0;
+
+virtual-method void levelGenerated(Level *level) = 0x0;
 virtual-method void onDisconnect(RakNet_RakNetGUID *guid) = 0x18;
 virtual-method void handle_SignUpdatePacket(RakNet_RakNetGUID *guid, SignUpdatePacket *packet) = 0xcc;
-virtual-method void handle_ChatPacket(RakNet_RakNetGUID *rak_net_guid, uchar *packet) = 0xc8;
+virtual-method void handle_ChatPacket(RakNet_RakNetGUID *rak_net_guid, ChatPacket *packet) = 0xc8;