Huge protection improvements and other stuff (#1963)

* feat(protections): add a fuzzer
* feat(protections): improve protections
* feat(spoofing): add warning
* feat(world): force object cleanup
* fix(weapons): fix custom weapon code
* fix(weapons): fix for #1983

scripts/gtav-classes.cmake

@@ -3,7 +3,7 @@ include(FetchContent)
 FetchContent_Declare(
     gtav_classes
     GIT_REPOSITORY https://github.com/Yimura/GTAV-Classes.git
-    GIT_TAG        9da68ec82769c684068023c00ac5e5acd7836c97
+    GIT_TAG        0f88abb93d1499c04f440b77095ae4e02e5144ae
     GIT_PROGRESS TRUE
     CONFIGURE_COMMAND ""
     BUILD_COMMAND ""

src/backend/commands/player/kick/end_session_kick.cpp

@@ -25,6 +25,8 @@ namespace big
 
 			g_player_service->m_player_to_use_end_session_kick = player;
 			*scr_globals::gsbd.as<int*>() = (int)(__rdtsc() % 50000) + 6; // making the game trigger the broadcast is a bit difficult and requires a little bit of tampering with the value and some luck
+			script::get_current()->yield(5s);
+			*scr_globals::gsbd.as<int*>() = 4;
 		}
 	};
 

src/backend/commands/player/toxic/set_wanted_level.cpp

@@ -55,16 +55,11 @@ namespace big
 
 				if (wanted_level > 0)
 				{
-					auto& gpbd = scr_globals::globalplayer_bd.as<GlobalPlayerBD*>()->Entries[self::id];
-
-					gpbd.RemoteWantedLevelPlayer = id;
-					gpbd.RemoteWantedLevelAmount = wanted_level;
-
-					for (int i = 0; PLAYER::GET_PLAYER_WANTED_LEVEL(id) < wanted_level && i < 3600; i++)
-						script::get_current()->yield(1ms);
-
-					gpbd.RemoteWantedLevelPlayer = -1;
-					gpbd.RemoteWantedLevelAmount = -1;
+					for (int i = 0; PLAYER::GET_PLAYER_WANTED_LEVEL(id) < wanted_level && player->is_valid() && i < 10; i++)
+					{
+						g_pointers->m_gta.m_set_wanted_level(player->get_net_game_player(), wanted_level, 0, -1);
+						script::get_current()->yield(200ms);
+					}
 				}
 			}
 		}

src/backend/commands/player/vehicle/break_doors.cpp

@@ -0,0 +1,46 @@
+#include "backend/player_command.hpp"
+#include "gta/net_game_event.hpp"
+#include "natives.hpp"
+#include "pointers.hpp"
+#include "util/teleport.hpp"
+
+namespace big
+{
+	inline void break_vehicle_door(CVehicle* vehicle, std::uint8_t door_index)
+	{
+		if (!vehicle->m_net_object)
+			return;
+
+		int object_id = vehicle->m_net_object->m_object_id;
+
+		g_pointers->m_gta.m_check_event_queue(*g_pointers->m_gta.m_net_event_manager, true);
+
+		CDoorBreakEvent* event =
+		    reinterpret_cast<CDoorBreakEvent*>(g_pointers->m_gta.m_get_new_pool_item(*g_pointers->m_gta.m_net_event_pool));
+
+		if (!event)
+			return;
+
+		g_pointers->m_gta.m_construct_door_break_event(event);
+
+		event->m_vehicle_id = object_id;
+		event->m_door_id    = door_index;
+
+		g_pointers->m_gta.m_queue_network_event(*g_pointers->m_gta.m_net_event_manager, event);
+	}
+
+	class break_doors : player_command
+	{
+		using player_command::player_command;
+
+		virtual void execute(player_ptr player, const command_arguments& _args, const std::shared_ptr<command_context> ctx)
+		{
+			Ped ped         = PLAYER::GET_PLAYER_PED_SCRIPT_INDEX(player->id());
+			Vehicle vehicle = PED::GET_VEHICLE_PED_IS_IN(ped, false);
+			for (int i = 0; i < VEHICLE::GET_NUMBER_OF_VEHICLE_DOORS(vehicle); i++)
+				break_vehicle_door(player->get_current_vehicle(), i);
+		}
+	};
+
+	break_doors g_break_doors("breakdoors", "Break Vehicle Doors", "Breaks all vehicle doors", 0);
+}

src/backend/commands/player/vehicle/burst_tyres.cpp

@@ -33,5 +33,5 @@ namespace big
 		}
 	};
 
-	burst_tyres g_burst_tyres("burstwheels", "Burst Vehicle Tyres", "Removes their tyres.", 0);
+	burst_tyres g_burst_tyres("burstwheels", "Burst Vehicle Tyres", "Removes their tyres", 0);
 }

src/backend/commands/player/vehicle/flip_180.cpp

@@ -41,6 +41,6 @@ namespace big
 	};
 
 	flip_180
-		g_flip_180("flip180", "Rotate 180", "Rotates their car around", 0)
+		g_flip_180("flip180", "Rotate 180", "Rotates the player's car around", 0)
 			;
 }

src/backend/commands/player/vehicle/flying_vehicle.cpp

@@ -29,5 +29,5 @@ namespace big
 		}
 	};
 
-	flying_vehicle g_flying_vehicle("flyingveh", "Flying Vehicle", "Catapults their car to  the sky.", 0);
+	flying_vehicle g_flying_vehicle("flyingveh", "Flying Vehicle", "Catapults the player's car to the sky", 0);
 }

src/backend/commands/player/vehicle/open_doors.cpp

@@ -22,7 +22,7 @@ namespace big
 
 				if (entity::take_control_of(vehicle))
 				{
-					for (int i = 0; i < VEHICLE::GET_NUMBER_OF_VEHICLE_DOORS(i); i++)
+					for (int i = 0; i < VEHICLE::GET_NUMBER_OF_VEHICLE_DOORS(vehicle); i++)
 					{
 						VEHICLE::SET_VEHICLE_DOOR_OPEN(vehicle, i, true, false);
 					}

src/backend/commands/player/vehicle/special_ability.cpp

@@ -0,0 +1,31 @@
+#include "backend/player_command.hpp"
+#include "natives.hpp"
+#include "pointers.hpp"
+#include "util/teleport.hpp"
+
+namespace big
+{
+	template<int ability_type>
+	class vehicle_special_ability : player_command
+	{
+		using player_command::player_command;
+
+		virtual void execute(player_ptr player, const command_arguments& _args, const std::shared_ptr<command_context> ctx)
+		{
+			Ped ped = PLAYER::GET_PLAYER_PED_SCRIPT_INDEX(player->id());
+			if (!PED::IS_PED_IN_ANY_VEHICLE(ped, true))
+			{
+				g_notification_service->push_warning("TOXIC"_T.data(), "ERROR_PLAYER_IS_NOT_IN_VEHICLE"_T.data());
+			}
+			else
+			{
+				g_pointers->m_gta.m_activate_special_ability(player->get_current_vehicle(), ability_type);
+			}
+		}
+	};
+
+	vehicle_special_ability<0> g_special_jump_vehicle("svehjump", "Special: Jump", "Activates the vehicle jump on the player's vehicle. This may cause undefined behavior if the vehicle cannot jump", 0);
+	vehicle_special_ability<1> g_special_boost_vehicle("svehboost", "Special: Boost", "Activates the boost on the player's vehicle. This may cause undefined behavior if the vehicle cannot boost", 0);
+	vehicle_special_ability<3> g_special_shunt_left("sshuntleft", "Special: Shunt Left", "Shunts the player's vehicle to the left", 0);
+	vehicle_special_ability<2> g_special_shunt_right("sshuntright", "Special: Shunt Right", "Shunts the player's vehicle to the right", 0);
+}

src/backend/commands/player/vehicle/stop_vehicle.cpp

@@ -31,5 +31,5 @@ namespace big
 		}
 	};
 
-	stop_vehicle g_stop_vehicle("stopveh", "Stop Vehicle", "Stops players vehicle", 0);
+	stop_vehicle g_stop_vehicle("stopveh", "Stop Vehicle", "Stops the player's vehicle", 0);
 }

src/backend/commands/player/vehicle/unlock_doors.cpp

@@ -18,5 +18,5 @@ namespace big
 		}
 	};
 
-	unlock_vehicle g_unlock_vehicle("unlockveh", "Unlock Vehicle Doors", "Unlocks Vehicle Doors", 0);
+	unlock_vehicle g_unlock_vehicle("unlockveh", "Unlock Vehicle Doors", "Unlocks all vehicle doors", 0);
 }

src/backend/commands/player/vehicle/window_tint.cpp

@@ -24,5 +24,5 @@ namespace big
 		}
 	};
 
-	black_tint g_black_tint("blacktint", "Black Window Tint", "Makes their windows black.", 0);
+	black_tint g_black_tint("blacktint", "Black Window Tint", "Makes the player's vehicle windows black", 0);
 }

src/backend/looped/player/good_options.cpp

@@ -61,5 +61,17 @@ namespace big
 				}
 			});
 		}
+
+		if (g.session.vehicle_fix_all)
+		{
+			g_pointers->m_gta.m_give_pickup_rewards(-1, REWARD_VEHICLE_FIX);
+		}
+		else
+		{
+			g_player_service->iterate([](const player_entry& entry) {
+				if (entry.second->fix_vehicle)
+					g_pointers->m_gta.m_give_pickup_rewards(-1, REWARD_VEHICLE_FIX);
+			});
+		}
 	}
 }

src/backend/looped/self/persist_outfit.cpp

@@ -1,8 +1,9 @@
 #include "backend/looped/looped.hpp"
-#include "services/outfit/outfit_service.hpp"
-#include "natives.hpp"
 #include "file_manager.hpp"
 #include "logger/logger.hpp"
+#include "natives.hpp"
+#include "pointers.hpp"
+#include "services/outfit/outfit_service.hpp"
 
 namespace big
 {
@@ -32,6 +33,7 @@ namespace big
 			i >> outfit;
 		}
 
-		outfit_service::apply_outfit(outfit, false);
+		if (outfit.contains("model") && outfit["model"].get<uint32_t>() == ENTITY::GET_ENTITY_MODEL(self::ped))
+			outfit_service::apply_outfit(outfit, false);
 	}
 }

src/backend/looped/weapons/increase_damage.cpp

@@ -3,17 +3,25 @@
 
 namespace big
 {
-
 	class increased_damage : looped_command
 	{
 		using looped_command::looped_command;
 
+		Hash ped_weapon;
+
 		virtual void on_tick() override
 		{
 			if (g.weapons.increased_damage != 1)
 			{
 				Hash weapon{};
 				WEAPON::GET_CURRENT_PED_WEAPON(self::ped, &weapon, 0);
+
+				if (weapon != ped_weapon)
+				{
+					WEAPON::SET_WEAPON_DAMAGE_MODIFIER(weapon, 1);
+					ped_weapon = weapon;
+				}
+
 				WEAPON::SET_WEAPON_DAMAGE_MODIFIER(weapon, g.weapons.increased_damage);
 			}
 		}

src/backend/looped/weapons/tpgun.cpp

@@ -9,13 +9,13 @@ namespace big
 	{
 		if (g.weapons.custom_weapon == CustomWeapon::TP_GUN && (!g.self.custom_weapon_stop || WEAPON::IS_PED_ARMED(self::ped, 4 | 2)))
 		{
-			Vector3 c; entity::raycast(&c);
-
 			if (PAD::IS_DISABLED_CONTROL_PRESSED(0, (int)ControllerInputs::INPUT_AIM))
 			{
 				if (PAD::IS_DISABLED_CONTROL_JUST_RELEASED(0, (int)ControllerInputs::INPUT_ATTACK))
 				{
-					ENTITY::SET_ENTITY_COORDS(self::ped, c.x, c.y, c.z, 0, 0, 0, 0);
+					Vector3 c;
+					entity::raycast(&c);
+					PED::SET_PED_COORDS_KEEP_VEHICLE(self::ped, c.x, c.y, c.z);
 				}
 			}
 		}

src/backend/looped/world/blackout.cpp

@@ -0,0 +1,29 @@
+#include "backend/looped_command.hpp"
+#include "core/data/weathers.hpp"
+#include "fiber_pool.hpp"
+#include "gta_util.hpp"
+#include "natives.hpp"
+#include "pointers.hpp"
+#include "script.hpp"
+#include "services/tunables/tunables_service.hpp"
+
+namespace big
+{
+	class blackout : looped_command
+	{
+		using looped_command::looped_command;
+
+		virtual void on_tick() override
+		{
+			GRAPHICS::SET_ARTIFICIAL_LIGHTS_STATE(true);
+		}
+
+		virtual void on_disable() override
+		{
+			GRAPHICS::SET_ARTIFICIAL_LIGHTS_STATE(false);
+		}
+	};
+
+	blackout g_blackout("blackout", "Blackout", "Enables blackout mode. This is local and cannot be seen by other players",
+	    g.world.blackout);
+}

src/benchmark.hpp

@@ -1,35 +0,0 @@
-#pragma once
-
-#include "logger.hpp"
-
-namespace big
-{
-	using namespace std::chrono;
-	class benchmark
-	{
-	public:
-		explicit benchmark(std::string name = "") :
-		    m_start(high_resolution_clock::now()),
-		    m_name(name)
-		{
-		}
-
-		void get_runtime()
-		{
-			auto now                  = high_resolution_clock::now();
-			auto milliseconds_elapsed = duration_cast<milliseconds>(now - m_start);
-			auto microseconds_elapsed = duration_cast<microseconds>(now - m_start);
-			LOG(INFO) << m_name << " finished with a resulting time of: " << milliseconds_elapsed.count() << "ms "
-			          << microseconds_elapsed.count() % 1000 << "us";
-		}
-
-		void reset()
-		{
-			m_start = high_resolution_clock::now();
-		}
-
-	private:
-		high_resolution_clock::time_point m_start;
-		std::string m_name;
-	};
-}

src/byte_patch_manager.cpp

@@ -80,6 +80,9 @@ namespace big
 
 		// Prevent the game from crashing when flooded with outgoing events
 		memory::byte_patch::make(g_pointers->m_gta.m_free_event_error, std::vector{0x90, 0x90, 0x90, 0x90, 0x90})->apply();
+
+		// Always send the special ability event
+		memory::byte_patch::make(g_pointers->m_gta.m_activate_special_ability_patch, std::to_array({0xB0, 0x01, 0xC3}))->apply();
 	}
 
 	byte_patch_manager::byte_patch_manager()

src/core/data/infractions.hpp

@@ -6,12 +6,12 @@ namespace big
 	// Add new values to the bottom
 	enum class Infraction
 	{
-		DESYNC_PROTECTION,
+		DESYNC_PROTECTION,             // do not use
 		BREAKUP_KICK_DETECTED,         // do not use
 		LOST_CONNECTION_KICK_DETECTED, // do not use
 		SPOOFED_ROCKSTAR_ID,           // do not use
 		TRIGGERED_ANTICHEAT,
-		TRIED_CRASH_PLAYER, // do not use
+		TRIED_CRASH_PLAYER,
 		TRIED_KICK_PLAYER,
 		BLAME_EXPLOSION_DETECTED, // do not use (for now)
 		ATTACKING_WITH_GODMODE,
@@ -20,6 +20,8 @@ namespace big
 		SPOOFED_DATA,
 		SPOOFED_HOST_TOKEN,
 		INVALID_PLAYER_MODEL,
+		SUPER_JUMP,
+		UNDEAD_OTR,
 	};
 
 	inline std::unordered_map<Infraction, const char*> infraction_desc = {
@@ -37,5 +39,7 @@ namespace big
 	    {Infraction::SPOOFED_DATA, "Had spoofed data"},
 	    {Infraction::SPOOFED_HOST_TOKEN, "Had spoofed their host token"},
 	    {Infraction::INVALID_PLAYER_MODEL, "Had used an invalid player model"},
+	    {Infraction::SUPER_JUMP, "Had used super jump"},
+	    {Infraction::UNDEAD_OTR, "Had used undead OTR"},
 	};
 }

src/core/enums.hpp

@@ -191,6 +191,8 @@ namespace big
 		NotificationMoneyBanked  = 94410750,   // TICK_TC_BANK
 		NotificationMoneyRemoved = -242911964, // TICK_TC_REMO
 		NotificationMoneyStolen  = -295926414, // TICK_TC_STOL
+		NotificationCrash1       = -994541138, // AMCH_ATTEMPT2
+		NotificationCrash2       = 782258655,  // GBSAL_COLL
 
 		DestroyPersonalVehicle = 109434679, // CnC_PV_THEFT
 		TriggerCEORaid         = -1906536929,

src/core/settings.hpp

@@ -16,6 +16,7 @@
 
 
 class CNetGamePlayer;
+enum class eNetObjType;
 
 namespace rage
 {
@@ -67,18 +68,12 @@ namespace big
 		int friend_count = 0;
 		int player_count = 0;
 
-		CNetGamePlayer* m_syncing_player = nullptr;
-		std::unordered_map<uint64_t, uint64_t> m_spoofed_peer_ids;
+		CNetGamePlayer* m_syncing_player  = nullptr;
+		eNetObjType m_syncing_object_type = (eNetObjType)-1;
 
 		int m_remote_controller_vehicle = -1;
 		int m_remote_controlled_vehicle = -1;
 
-		/*
-		uint16_t m_tp_veh_net_id;
-		uint16_t m_tp_player_net_id;
-		rage::fvector3 m_tp_position;
-		*/
-
 		std::unordered_map<uint16_t, remote_player_teleport> m_remote_player_teleports;
 
 		rage::scrThread* m_hunt_the_beast_thread = nullptr;
@@ -120,6 +115,14 @@ namespace big
 				NLOHMANN_DEFINE_TYPE_INTRUSIVE(logs, metric_logs, packet_logs, script_hook_logs, script_event)
 			} logs{};
 
+			struct fuzzer
+			{
+				bool enabled = false;
+				bool enabled_object_types[14];
+				bool active                    = false;
+				int thread_id                  = 0;
+				std::int16_t syncing_object_id = -1;
+			} fuzzer{};
 			bool window_hook = false;
 
 			NLOHMANN_DEFINE_TYPE_INTRUSIVE(debug, logs, window_hook)
@@ -255,7 +258,6 @@ namespace big
 				bool bounty                     = true;
 				bool ceo_money                  = true;
 				bool clear_wanted_level         = true;
-				bool fake_deposit               = true;
 				bool force_mission              = true;
 				bool force_teleport             = true;
 				bool gta_banner                 = false;
@@ -273,7 +275,7 @@ namespace big
 				bool start_activity             = true;
 				bool send_sms                   = true;
 
-				NLOHMANN_DEFINE_TYPE_INTRUSIVE(script_events, bounty, ceo_money, clear_wanted_level, fake_deposit, force_mission, force_teleport, gta_banner, mc_teleport, personal_vehicle_destroyed, remote_off_radar, rotate_cam, send_to_cutscene, send_to_location, sound_spam, spectate, give_collectible, vehicle_kick, teleport_to_warehouse, start_activity, send_sms)
+				NLOHMANN_DEFINE_TYPE_INTRUSIVE(script_events, bounty, ceo_money, clear_wanted_level, force_mission, force_teleport, gta_banner, mc_teleport, personal_vehicle_destroyed, remote_off_radar, rotate_cam, send_to_cutscene, send_to_location, sound_spam, spectate, give_collectible, vehicle_kick, teleport_to_warehouse, start_activity, send_sms)
 			} script_events{};
 
 			bool rid_join                = false;
@@ -305,46 +307,46 @@ namespace big
 				NLOHMANN_DEFINE_TYPE_INTRUSIVE(ipls, select)
 			} ipls{};
 
-			bool clean_player          = false;
-			bool force_wanted_level    = false;
-			bool free_cam              = false;
-			bool invisibility          = false;
-			bool local_visibility      = true;
-			bool never_wanted          = false;
-			bool no_ragdoll            = false;
-			bool noclip                = false;
+			bool clean_player                 = false;
+			bool force_wanted_level           = false;
+			bool free_cam                     = false;
+			bool invisibility                 = false;
+			bool local_visibility             = true;
+			bool never_wanted                 = false;
+			bool no_ragdoll                   = false;
+			bool noclip                       = false;
 			float noclip_aim_speed_multiplier = 0.25f;
 			float noclip_speed_multiplier     = 20.f;
-			bool off_radar             = false;
-			bool ghost_org             = false;
-			bool super_run             = false;
-			bool no_collision          = false;
-			bool unlimited_oxygen      = false;
-			bool no_water_collision    = false;
-			int wanted_level           = 0;
-			bool god_mode              = false;
-			bool part_water            = false;
-			bool proof_bullet          = false;
-			bool proof_fire            = false;
-			bool proof_collision       = false;
-			bool proof_melee           = false;
-			bool proof_explosion       = false;
-			bool proof_steam           = false;
-			bool proof_drown           = false;
-			bool proof_water           = false;
-			uint32_t proof_mask        = 0;
-			bool mobile_radio          = false;
-			bool fast_respawn          = false;
-			bool auto_tp               = false;
-			bool super_jump            = false;
-			bool beast_jump            = false;
-			bool healthregen           = false;
-			float healthregenrate      = 1.0f;
-			bool superman              = false;
-			bool custom_weapon_stop    = true;
-			bool prompt_ambient_animations = false;
-			std::string persist_outfit = "";
-			bool persist_outfits_mis   = false;
+			bool off_radar                    = false;
+			bool ghost_org                    = false;
+			bool super_run                    = false;
+			bool no_collision                 = false;
+			bool unlimited_oxygen             = false;
+			bool no_water_collision           = false;
+			int wanted_level                  = 0;
+			bool god_mode                     = false;
+			bool part_water                   = false;
+			bool proof_bullet                 = false;
+			bool proof_fire                   = false;
+			bool proof_collision              = false;
+			bool proof_melee                  = false;
+			bool proof_explosion              = false;
+			bool proof_steam                  = false;
+			bool proof_drown                  = false;
+			bool proof_water                  = false;
+			uint32_t proof_mask               = 0;
+			bool mobile_radio                 = false;
+			bool fast_respawn                 = false;
+			bool auto_tp                      = false;
+			bool super_jump                   = false;
+			bool beast_jump                   = false;
+			bool healthregen                  = false;
+			float healthregenrate             = 1.0f;
+			bool superman                     = false;
+			bool custom_weapon_stop           = true;
+			bool prompt_ambient_animations    = false;
+			std::string persist_outfit        = "";
+			bool persist_outfits_mis          = false;
 
 			struct hud
 			{
@@ -415,6 +417,7 @@ namespace big
 			bool off_radar_all    = false;
 			bool semi_godmode_all = false;
 			bool wanted_level_all = false;
+			bool vehicle_fix_all  = false;
 
 			bool show_cheating_message = false;
 			bool anonymous_bounty      = true;
@@ -574,7 +577,9 @@ namespace big
 			bool override_weather = false;
 			int local_weather     = 0;
 
-			NLOHMANN_DEFINE_TYPE_INTRUSIVE(world, water, spawn_ped, custom_time, blackhole, model_swapper, nearby, orbital_drone, local_weather, override_weather)
+			bool blackout = false;
+
+			NLOHMANN_DEFINE_TYPE_INTRUSIVE(world, water, spawn_ped, custom_time, blackhole, model_swapper, nearby, orbital_drone, local_weather, override_weather, blackout)
 		} world{};
 
 		struct spoofing
@@ -596,8 +601,9 @@ namespace big
 			bool spoof_bad_sport = false;
 			int badsport_type    = 0;
 
-			bool spoof_player_model  = false;
-			std::string player_model = "";
+			bool spoof_player_model   = false;
+			std::string player_model  = "";
+			std::string player_outfit = "";
 
 			bool spoof_cheater = false;
 

src/function_types.hpp

@@ -7,6 +7,8 @@ class sCloudFile;
 class CPlayerGameStateDataNode;
 class CVehicleGadgetDataNode;
 class CGameScriptHandlerNetComponent;
+class CDoorBreakEvent;
+class GenericPool;
 enum eVehicleGadgetType : uint32_t;
 
 namespace rage
@@ -28,6 +30,9 @@ namespace rage
 	class rlQueryPresenceAttributesContext;
 	enum class eThreadState : uint32_t;
 	class netArrayHandlerBase;
+	class fwRefAwareBase;
+	class netGameEvent;
+	class netEventMgr;
 }
 
 namespace datafile_commands
@@ -160,4 +165,18 @@ namespace big::functions
 	using connection_manager_try_free_memory = void (*)(rage::netConnectionManager* mgr);
 	using remove_message_from_queue          = void (*)(rage::netMessageQueue* queue, rage::netQueuedMessage* message);
 	using remove_message_from_unacked_reliables = void (*)(void* list, uint16_t* unk);
+
+	using remove_reference = void (*)(rage::fwRefAwareBase* object, void* reference);
+
+	using activate_special_ability = void (*)(CVehicle* vehicle, int special_ability_type);
+	using set_wanted_level = void (*)(CNetGamePlayer* player, int wanted_level, int unk, std::uint8_t unk_player_id);
+
+	using check_event_queue          = bool (*)(rage::netEventMgr* mgr, bool free);
+	using get_new_pool_item          = void* (*)(GenericPool* pool);
+	using construct_door_break_event = CDoorBreakEvent* (*)(CDoorBreakEvent* _this);
+	using queue_network_event        = void (*)(rage::netEventMgr* mgr, rage::netGameEvent* event);
+
+	using delete_ped     = bool (*)(CPed* ped);
+	using delete_vehicle = bool (*)(CVehicle* veh);
+	using delete_object  = bool (*)(CObject* object, bool unk);
 }

src/gta/enums.hpp

@@ -1029,13 +1029,13 @@ enum class BlipColors
 
 enum BlipDisplayBits
 {
-	BlipShowCheckmark            = (1 << 16),
-	BlipShowDollarSign           = (1 << 17),
-	BlipShowHeadingIndicator     = (1 << 18),
-	BlipShowFullCircle           = (1 << 19),
-	BlipIsFriend                 = (1 << 20),
-	BlipIsCrew                   = (1 << 21),
-	BlipIsSelected               = (1 << 23),
+	BlipShowCheckmark        = (1 << 16),
+	BlipShowDollarSign       = (1 << 17),
+	BlipShowHeadingIndicator = (1 << 18),
+	BlipShowFullCircle       = (1 << 19),
+	BlipIsFriend             = (1 << 20),
+	BlipIsCrew               = (1 << 21),
+	BlipIsSelected           = (1 << 23),
 };
 
 enum class BlipRenderBits
@@ -1069,6 +1069,23 @@ enum class eNetObjType
 	NET_OBJ_TYPE_TRAIN
 };
 
+constexpr const auto net_object_type_strs = std::to_array({
+    "AUTOMOBILE",
+    "BIKE",
+    "BOAT",
+    "DOOR",
+    "HELI",
+    "OBJECT",
+    "PED",
+    "PICKUP",
+    "PICKUP_PLACEMENT",
+    "PLANE",
+    "SUBMARINE",
+    "PLAYER",
+    "TRAILER",
+    "TRAIN",
+});
+
 enum class eNetObjectFlags : uint16_t
 {
 	NET_OBJ_FLAGS_FROM_SCRIPT = 1 << 2,

src/gta/natives.hpp

@@ -10,47 +10,47 @@ namespace rage
 	class scrNativeCallContext
 	{
 	public:
-		void reset()
+		constexpr void reset()
 		{
 			m_arg_count  = 0;
 			m_data_count = 0;
 		}
 
 		template<typename T>
-		void push_arg(T&& value)
+		constexpr void push_arg(T&& value)
 		{
 			static_assert(sizeof(T) <= sizeof(uint64_t));
 			*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(reinterpret_cast<uint64_t*>(m_args) + (m_arg_count++)) = std::forward<T>(value);
 		}
 
 		template<typename T>
-		T& get_arg(std::size_t index)
+		constexpr T& get_arg(std::size_t index)
 		{
 			static_assert(sizeof(T) <= sizeof(uint64_t));
 			return *reinterpret_cast<T*>(reinterpret_cast<uint64_t*>(m_args) + index);
 		}
 
 		template<typename T>
-		void set_arg(std::size_t index, T&& value)
+		constexpr void set_arg(std::size_t index, T&& value)
 		{
 			static_assert(sizeof(T) <= sizeof(uint64_t));
 			*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(reinterpret_cast<uint64_t*>(m_args) + index) = std::forward<T>(value);
 		}
 
 		template<typename T>
-		T* get_return_value()
+		constexpr T* get_return_value()
 		{
 			return reinterpret_cast<T*>(m_return_value);
 		}
 
 		template<typename T>
-		void set_return_value(T&& value)
+		constexpr void set_return_value(T&& value)
 		{
 			*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(m_return_value) = std::forward<T>(value);
 		}
 
 		template<typename T>
-		void set_return_value(T& value)
+		constexpr void set_return_value(T& value)
 		{
 			*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(m_return_value) = std::forward<T>(value);
 		}

src/gta/net_game_event.hpp

@@ -8,41 +8,51 @@
 #pragma pack(push, 1)
 namespace rage
 {
+#pragma pack(push, 8)
 	class CSyncDataBase
 	{
 	public:
 		virtual ~CSyncDataBase()                                                     = default;
-		virtual bool SerializeDword(uint32_t* dword, int size)                       = 0;
-		virtual bool SerializeWord(uint16_t* word, int size)                         = 0;
-		virtual bool SerializeByte(uint8_t* byte, int size)                          = 0;
-		virtual bool SerializeInt32(int32_t* i, int size)                            = 0;
-		virtual bool SerializeInt16(int16_t* i, int size)                            = 0;
-		virtual bool SerializeSignedByte(int8_t* byte, int size)                     = 0;
-		virtual bool SerializeBool(bool* flag)                                       = 0;
-		virtual bool SerializeInt64(int64_t* i, int size)                            = 0;
-		virtual bool SerializeInt32Alt(int32_t* i, int size)                         = 0;
-		virtual bool SerializeInt16Alt(int16_t* i, int size)                         = 0;
-		virtual bool SerializeSignedByteAlt(int8_t* byte, int size)                  = 0;
-		virtual bool SerializeQword(uint64_t* qword, int size)                       = 0;
-		virtual bool SerializeDwordAlt(uint32_t* dword, int size)                    = 0;
-		virtual bool SerializeWordAlt(uint16_t* word, int size)                      = 0;
-		virtual bool SerializeByteAlt(uint8_t* byte, int size)                       = 0;
-		virtual bool SerializeSignedFloat(float* flt, float divisor, int size)       = 0;
-		virtual bool SerializeFloat(float* flt, float divisor, int size)             = 0;
-		virtual bool SerializeNetworkId(uint16_t* net_id)                            = 0;
-		virtual bool SerializeVector3(rage::fvector3* vec3, float divisor, int size) = 0;
+		virtual bool SerializeDword(uint32_t* dword, int size)                       = 0; // 1
+		virtual bool SerializeWord(uint16_t* word, int size)                         = 0; // 2
+		virtual bool SerializeByte(uint8_t* byte, int size)                          = 0; // 3
+		virtual bool SerializeInt32(int32_t* i, int size)                            = 0; // 4
+		virtual bool SerializeInt16(int16_t* i, int size)                            = 0; // 5
+		virtual bool SerializeSignedByte(int8_t* byte, int size)                     = 0; // 6
+		virtual bool SerializeBool(bool* flag)                                       = 0; // 7
+		virtual bool SerializeInt64(int64_t* i, int size)                            = 0; // 8
+		virtual bool SerializeInt32Alt(int32_t* i, int size)                         = 0; // 9
+		virtual bool SerializeInt16Alt(int16_t* i, int size)                         = 0; // 10
+		virtual bool SerializeSignedByteAlt(int8_t* byte, int size)                  = 0; // 11
+		virtual bool SerializeQword(uint64_t* qword, int size)                       = 0; // 12
+		virtual bool SerializeDwordAlt(uint32_t* dword, int size)                    = 0; // 13
+		virtual bool SerializeWordAlt(uint16_t* word, int size)                      = 0; // 14
+		virtual bool SerializeByteAlt(uint8_t* byte, int size)                       = 0; // 15
+		virtual bool SerializeSignedFloat(float* flt, float divisor, int size)       = 0; // 16
+		virtual bool SerializeFloat(float* flt, float divisor, int size)             = 0; // 17
+		virtual bool SerializeNetworkId(uint16_t* net_id)                            = 0; // 18
+		virtual bool SerializeVector3(rage::fvector3* vec3, float divisor, int size) = 0; // 19
 		virtual bool SerializeQuaternion(void* unk)                                  = 0; // i have no clue what that is
-		virtual bool SerializeVector3SignedZComponent(rage::fvector3* vec3, float divisor, int size) = 0;
+		virtual bool SerializeVector3SignedZComponent(rage::fvector3* vec3, float divisor, int size) = 0; // 21
 		virtual bool SerializeOrientation(rage::fvector4* vec4, float size) = 0; // yes, the size is a float
 		virtual bool SerializeArray(void* array, int size)                  = 0;
 		virtual bool SerializeString(char* str, int max_length)             = 0;
 		virtual bool IsSizeCalculator()                                     = 0;
 		virtual bool IsSizeCalculator2()                                    = 0;
 
-		void* unk_0x8;
-		void* syncLog;
-		datBitBuffer* buffer;
+		enum class Type
+		{
+			Reader = 1,
+			Writer,
+			SizeCalculator,
+			Logger
+		};
+
+		Type m_type;
+		void* m_sync_log;
+		datBitBuffer* m_buffer;
 	};
+#pragma pack(pop)
 
 	class netPlayer;
 
@@ -627,6 +637,7 @@ namespace rage
 		uint32_t m_0x28; // 0x28
 		char m_padding2[0x04];
 	};
+	static_assert(sizeof(rage::netGameEvent) == 0x30);
 }
 
 class CScriptedGameEvent : public rage::netGameEvent
@@ -644,4 +655,11 @@ public:
 	Hash m_stat;       // 0x30
 	uint32_t m_amount; // 0x34
 };
+
+class CDoorBreakEvent : public rage::netGameEvent
+{
+public:
+	std::uint16_t m_vehicle_id; // 0x30
+	std::uint8_t m_door_id;     // 0x32
+};
 #pragma pack(pop)

src/gta/pools.hpp

@@ -112,7 +112,7 @@ public:
 
 	inline UINT64 get_address(UINT32 i)
 	{
-		return mask(i) & (m_pool_address + i * m_item_size);
+		return mask(i) & (m_pool_address + (uint64_t)i * m_item_size);
 	}
 
 	inline int get_item_count()

src/gta_pointers.hpp

@@ -13,11 +13,16 @@ class CVehicleSeatMetadataMgr;
 class CVehicleDriveByMetadataMgr;
 class CBlipList;
 class TimecycleKeyframeData;
+class CTrainConfig;
 
 namespace rage
 {
 	template<typename T>
 	class atSingleton;
+
+	template<typename T>
+	class atArray;
+
 	class RageSecurity;
 	class netTime;
 	class rlGamerInfo;
@@ -162,7 +167,8 @@ namespace big
 
 		PVOID m_invalid_mods_crash_detour;
 		PVOID m_invalid_decal_crash;
-		PVOID m_task_parachute_object_0x270;
+		PVOID m_task_parachute_object;
+		PVOID m_task_ambient_clips;
 
 		int64_t** m_send_chat_ptr;
 		functions::send_chat_message m_send_chat_message;
@@ -209,6 +215,7 @@ namespace big
 		PVOID m_send_session_matchmaking_attributes;
 
 		PVOID m_serialize_take_off_ped_variation_task;
+		PVOID m_serialize_parachute_task;
 
 		functions::encode_session_info m_encode_session_info;
 		functions::decode_session_info m_decode_session_info;
@@ -300,6 +307,31 @@ namespace big
 		PVOID m_render_big_ped;
 
 		bool* m_force_relay_connections;
+
+		functions::remove_reference m_remove_reference;
+
+		PVOID m_read_bits_single;
+		void** m_sync_data_reader_vtable;
+
+		GenericPool** m_interior_proxy_pool;
+
+		rage::atArray<CTrainConfig>* m_train_config_array;
+
+		functions::activate_special_ability m_activate_special_ability;
+		PVOID m_activate_special_ability_patch;
+
+		functions::set_wanted_level m_set_wanted_level;
+
+		rage::netEventMgr** m_net_event_manager;
+		GenericPool** m_net_event_pool;
+		functions::check_event_queue m_check_event_queue;
+		functions::get_new_pool_item m_get_new_pool_item;
+		functions::construct_door_break_event m_construct_door_break_event;
+		functions::queue_network_event m_queue_network_event;
+
+		functions::delete_ped m_delete_ped;
+		functions::delete_vehicle m_delete_vehicle;
+		functions::delete_object m_delete_object;
 	};
 #pragma pack(pop)
 	static_assert(sizeof(gta_pointers) % 8 == 0, "Pointers are not properly aligned");

src/hooking.cpp

@@ -16,12 +16,32 @@
 namespace big
 {
 	hooking::hooking() :
-	    // Swapchain
-	    m_swapchain_hook(*g_pointers->m_gta.m_swapchain, hooks::swapchain_num_funcs)
+	    m_swapchain_hook(*g_pointers->m_gta.m_swapchain, hooks::swapchain_num_funcs),
+	    m_sync_data_reader_hook(g_pointers->m_gta.m_sync_data_reader_vtable, 27)
 	{
 		m_swapchain_hook.hook(hooks::swapchain_present_index, &hooks::swapchain_present);
 		m_swapchain_hook.hook(hooks::swapchain_resizebuffers_index, &hooks::swapchain_resizebuffers);
 
+		m_sync_data_reader_hook.hook(1, &hooks::sync_reader_serialize_dword);
+		m_sync_data_reader_hook.hook(2, &hooks::sync_reader_serialize_word);
+		m_sync_data_reader_hook.hook(3, &hooks::sync_reader_serialize_byte);
+		m_sync_data_reader_hook.hook(4, &hooks::sync_reader_serialize_int32);
+		m_sync_data_reader_hook.hook(5, &hooks::sync_reader_serialize_int16);
+		m_sync_data_reader_hook.hook(6, &hooks::sync_reader_serialize_signed_byte);
+		m_sync_data_reader_hook.hook(7, &hooks::sync_reader_serialize_bool);
+		m_sync_data_reader_hook.hook(9, &hooks::sync_reader_serialize_int32);
+		m_sync_data_reader_hook.hook(10, &hooks::sync_reader_serialize_int16);
+		m_sync_data_reader_hook.hook(11, &hooks::sync_reader_serialize_signed_byte);
+		m_sync_data_reader_hook.hook(13, &hooks::sync_reader_serialize_dword);
+		m_sync_data_reader_hook.hook(14, &hooks::sync_reader_serialize_word);
+		m_sync_data_reader_hook.hook(15, &hooks::sync_reader_serialize_byte);
+		m_sync_data_reader_hook.hook(16, &hooks::sync_reader_serialize_signed_float);
+		m_sync_data_reader_hook.hook(17, &hooks::sync_reader_serialize_float);
+		m_sync_data_reader_hook.hook(18, &hooks::sync_reader_serialize_net_id);
+		m_sync_data_reader_hook.hook(19, &hooks::sync_reader_serialize_vec3);
+		m_sync_data_reader_hook.hook(21, &hooks::sync_reader_serialize_vec3_signed);
+		m_sync_data_reader_hook.hook(23, &hooks::sync_reader_serialize_array);
+
 		// The only instances in that vector at this point should only be the "lazy" hooks
 		// aka the ones that still don't have their m_target assigned
 		for (auto& detour_hook_helper : m_detour_hook_helpers)
@@ -58,7 +78,8 @@ namespace big
 
 		detour_hook_helper::add<hooks::invalid_mods_crash_detour>("IMCD", g_pointers->m_gta.m_invalid_mods_crash_detour);
 		detour_hook_helper::add<hooks::invalid_decal>("IDC", g_pointers->m_gta.m_invalid_decal_crash);
-		detour_hook_helper::add<hooks::task_parachute_object_0x270>("TPO270", g_pointers->m_gta.m_task_parachute_object_0x270);
+		detour_hook_helper::add<hooks::task_parachute_object>("TPO", g_pointers->m_gta.m_task_parachute_object);
+		detour_hook_helper::add<hooks::task_ambient_clips>("TAC", g_pointers->m_gta.m_task_ambient_clips);
 
 		detour_hook_helper::add<hooks::update_presence_attribute_int>("UPAI", g_pointers->m_sc.m_update_presence_attribute_int);
 		detour_hook_helper::add<hooks::update_presence_attribute_string>("UPAS", g_pointers->m_sc.m_update_presence_attribute_string);
@@ -81,6 +102,7 @@ namespace big
 		detour_hook_helper::add<hooks::send_session_matchmaking_attributes>("SSMA", g_pointers->m_gta.m_send_session_matchmaking_attributes);
 
 		detour_hook_helper::add<hooks::serialize_take_off_ped_variation_task>("STOPVT", g_pointers->m_gta.m_serialize_take_off_ped_variation_task);
+		detour_hook_helper::add<hooks::serialize_parachute_task>("SPT", g_pointers->m_gta.m_serialize_parachute_task);
 
 		detour_hook_helper::add<hooks::queue_dependency>("QD", g_pointers->m_gta.m_queue_dependency);
 		detour_hook_helper::add<hooks::prepare_metric_for_sending>("PMFS", g_pointers->m_gta.m_prepare_metric_for_sending);
@@ -122,6 +144,8 @@ namespace big
 		detour_hook_helper::add<hooks::render_entity>("RE", g_pointers->m_gta.m_render_entity);
 		detour_hook_helper::add<hooks::render_big_ped>("RBP", g_pointers->m_gta.m_render_big_ped);
 
+		detour_hook_helper::add<hooks::read_bits_single>("RBS", g_pointers->m_gta.m_read_bits_single);
+
 		g_hooking = this;
 	}
 
@@ -138,6 +162,7 @@ namespace big
 	void hooking::enable()
 	{
 		m_swapchain_hook.enable();
+		m_sync_data_reader_hook.enable();
 		m_og_wndproc = WNDPROC(SetWindowLongPtrW(g_pointers->m_hwnd, GWLP_WNDPROC, LONG_PTR(&hooks::wndproc)));
 
 		for (auto& detour_hook_helper : m_detour_hook_helpers)
@@ -160,6 +185,7 @@ namespace big
 		}
 
 		SetWindowLongPtrW(g_pointers->m_hwnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(m_og_wndproc));
+		m_sync_data_reader_hook.disable();
 		m_swapchain_hook.disable();
 
 		MH_ApplyQueued();

src/hooking.hpp

@@ -6,6 +6,7 @@
 #include "gta/fwddec.hpp"
 #include "gta/script_thread.hpp"
 #include "vmt_hook.hpp"
+#include "vtable_hook.hpp"
 
 #include <network/netConnection.hpp>
 
@@ -34,6 +35,8 @@ class IDirectSoundCapture;
 class CVehicleProximityMigrationDataNode;
 class CNonPhysicalPlayerData;
 class TimecycleKeyframeData;
+class CPedTaskSpecificDataNode;
+class CPedTaskSequenceDataNode;
 
 namespace rage
 {
@@ -96,7 +99,8 @@ namespace big
 
 		static void invalid_mods_crash_detour(int64_t a1, int64_t a2, int a3, char a4);
 		static void invalid_decal(uintptr_t a1, int a2);
-		static int task_parachute_object_0x270(uint64_t _this, int a2, int a3);
+		static int task_parachute_object(uint64_t _this, int a2, int a3);
+		static int task_ambient_clips(uint64_t _this, int a2, int a3);
 
 		static bool update_presence_attribute_int(void* presence_data, int profile_index, char* attr, uint64_t value);
 		static bool update_presence_attribute_string(void* presence_data, int profile_index, char* attr, char* value);
@@ -119,6 +123,7 @@ namespace big
 		static bool send_session_matchmaking_attributes(void* a1, rage::rlSessionInfo* info, uint64_t session_id, bool use_session_id, MatchmakingAttributes* attributes);
 
 		static void serialize_take_off_ped_variation_task(ClonedTakeOffPedVariationInfo* info, rage::CSyncDataBase* serializer);
+		static void serialize_parachute_task(__int64 info, rage::CSyncDataBase* serializer);
 
 		static int nt_query_virtual_memory(void* _this, HANDLE handle, PVOID base_addr, int info_class, MEMORY_BASIC_INFORMATION* info, int size, size_t* return_len);
 		static void queue_dependency(void* dependency);
@@ -158,6 +163,22 @@ namespace big
 		static void* render_ped(__int64 renderer, CPed* ped, __int64 a3, __int64 a4);
 		static void render_entity(__int64 renderer, rage::fwEntity* entity, int unk, bool a4);
 		static __int64 render_big_ped(__int64 renderer, CPed* ped, __int64 a3, __int64 a4);
+
+		static bool read_bits_single(void* data, int* out_value, int size, int offset);
+
+		static bool sync_reader_serialize_dword(void* _this, uint32_t* dword, int size);
+		static bool sync_reader_serialize_word(void* _this, uint16_t* word, int size);
+		static bool sync_reader_serialize_byte(void* _this, uint8_t* byte, int size);
+		static bool sync_reader_serialize_int32(void* _this, int32_t* i, int size);
+		static bool sync_reader_serialize_int16(void* _this, int16_t* i, int size);
+		static bool sync_reader_serialize_signed_byte(void* _this, int8_t* i, int size);
+		static bool sync_reader_serialize_bool(void* _this, bool* flag, int size);
+		static bool sync_reader_serialize_signed_float(void* _this, float* flt, float divisor, int size);
+		static bool sync_reader_serialize_float(void* _this, float* flt, float divisor, int size);
+		static bool sync_reader_serialize_net_id(void* _this, uint16_t* id);
+		static bool sync_reader_serialize_vec3(void* _this, rage::fvector3* vec, float divisor, int size);
+		static bool sync_reader_serialize_vec3_signed(void* _this, rage::fvector3* vec, float divisor, int size);
+		static bool sync_reader_serialize_array(void* _this, void* array, int size);
 	};
 
 	class minhook_keepalive
@@ -246,6 +267,7 @@ namespace big
 		minhook_keepalive m_minhook_keepalive;
 
 		vmt_hook m_swapchain_hook;
+		vtable_hook m_sync_data_reader_hook;
 
 		WNDPROC m_og_wndproc = nullptr;
 

src/hooks/fuzzer/read_bits_single.cpp

@@ -0,0 +1,20 @@
+#include "hooking.hpp"
+#include "natives.hpp"
+#include "util/fuzzer.hpp"
+
+namespace big
+{
+	bool hooks::read_bits_single(void* data, int* out_value, int size, int offset)
+	{
+		auto orig = g_hooking->get_original<hooks::read_bits_single>()(data, out_value, size, offset);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(out_value, sizeof(int), __FUNCTION__);
+			*out_value = fuzzer::fuzz_bits(*out_value, size);
+			return true;
+		}
+
+		return orig;
+	}
+}

src/hooks/fuzzer/sync_data_reader.cpp

@@ -0,0 +1,187 @@
+#include "hooking.hpp"
+#include "util/fuzzer.hpp"
+
+namespace big
+{
+	bool hooks::sync_reader_serialize_dword(void* _this, uint32_t* dword, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_dword)>(1)(_this, dword, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(dword, sizeof(uint32_t), __FUNCTION__);
+			*dword = fuzzer::fuzz_bits(*dword, size);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_word(void* _this, uint16_t* word, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_word)>(2)(_this, word, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(word, sizeof(uint16_t), __FUNCTION__);
+			*word = fuzzer::fuzz_bits(*word, size);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_byte(void* _this, uint8_t* byte, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_byte)>(3)(_this, byte, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(byte, sizeof(uint8_t), __FUNCTION__);
+			*byte = fuzzer::fuzz_bits(*byte, size);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_int32(void* _this, int32_t* i, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_int32)>(4)(_this, i, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(i, sizeof(int32_t), __FUNCTION__);
+			*i = fuzzer::fuzz_signed_bits(*i, size);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_int16(void* _this, int16_t* i, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_int16)>(5)(_this, i, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(i, sizeof(int16_t), __FUNCTION__);
+			*i = fuzzer::fuzz_signed_bits(*i, size);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_signed_byte(void* _this, int8_t* i, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_signed_byte)>(6)(_this, i, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(i, sizeof(int8_t), __FUNCTION__);
+			*i = fuzzer::fuzz_signed_bits(*i, size);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_bool(void* _this, bool* flag, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_bool)>(7)(_this, flag, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(flag, sizeof(bool), __FUNCTION__);
+			*flag = fuzzer::fuzz_bool(*flag);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_signed_float(void* _this, float* flt, float divisor, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_signed_float)>(16)(_this, flt, divisor, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(flt, sizeof(float), __FUNCTION__);
+			*flt = fuzzer::fuzz_float(*flt, size, divisor, true);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_float(void* _this, float* flt, float divisor, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_float)>(17)(_this, flt, divisor, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(flt, sizeof(float), __FUNCTION__);
+			*flt = fuzzer::fuzz_float(*flt, size, divisor, false);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_net_id(void* _this, uint16_t* id)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_net_id)>(18)(_this, id);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(id, sizeof(uint16_t), __FUNCTION__);
+			*id = fuzzer::fuzz_network_id(*id);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_vec3(void* _this, rage::fvector3* vec, float divisor, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_vec3)>(19)(_this, vec, divisor, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(vec, sizeof(rage::fvector3), __FUNCTION__);
+			*vec = fuzzer::fuzz_vector(*vec, size, divisor, false);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_vec3_signed(void* _this, rage::fvector3* vec, float divisor, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_vec3_signed)>(21)(_this, vec, divisor, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(vec, sizeof(rage::fvector3), __FUNCTION__);
+			*vec = fuzzer::fuzz_vector(*vec, size, divisor, true);
+			return true;
+		}
+
+		return orig;
+	}
+
+	bool hooks::sync_reader_serialize_array(void* _this, void* array, int size)
+	{
+		auto orig = g_hooking->m_sync_data_reader_hook.get_original<decltype(&hooks::sync_reader_serialize_array)>(23)(_this, array, size);
+
+		if (fuzzer::is_fuzzer_enabled())
+		{
+			fuzzer::handle_vtable_write(array, size / 8, __FUNCTION__);
+			fuzzer::fuzz_data(array, size / 8);
+			return true;
+		}
+
+		return orig;
+	}
+}

src/hooks/player_management/assign_physical_index.cpp

@@ -29,7 +29,6 @@ namespace big
 
 		if (new_index == static_cast<uint8_t>(-1))
 		{
-			g.m_spoofed_peer_ids.erase(player->get_net_data()->m_host_token);
 			g_player_service->player_leave(player);
 
 			if (net_player_data)

src/hooks/player_management/network_player_mgr.cpp

@@ -1,8 +1,8 @@
+#include "core/data/menu_event.hpp"
 #include "hooking.hpp"
 #include "lua/lua_manager.hpp"
 #include "pointers.hpp"
 #include "services/players/player_service.hpp"
-#include "core/data/menu_event.hpp"
 
 #include <network/CNetworkPlayerMgr.hpp>
 
@@ -25,7 +25,6 @@ namespace big
 
 	void hooks::network_player_mgr_shutdown(CNetworkPlayerMgr* _this)
 	{
-		g.m_spoofed_peer_ids.clear();
 		g_player_service->do_cleanup();
 
 		if (g.notifications.network_player_mgr_shutdown.log)

src/hooks/protections/receive_net_message.cpp

@@ -167,17 +167,6 @@ namespace big
 				}
 				break;
 			}
-			case rage::eNetMessage::MsgNetComplaint:
-			{
-				uint64_t host_token{};
-				buffer.ReadQWord(&host_token, 64);
-				if (player && host_token != player->get_net_data()->m_host_token && !player->exposed_desync_protection)
-				{
-					session::add_infraction(player, Infraction::DESYNC_PROTECTION);
-					player->exposed_desync_protection = true;
-				}
-				return true;
-			}
 			case rage::eNetMessage::MsgScriptHostRequest:
 			{
 				CGameScriptId script;
@@ -205,16 +194,6 @@ namespace big
 				}
 				break;
 			}
-			case rage::eNetMessage::MsgTransitionGamerInstruction:
-			{
-				// it doesn't work but a certain p2c uses it
-				if (is_kick_instruction(buffer))
-				{
-					g.reactions.gamer_instruction_kick.process(player);
-					return true;
-				}
-				break;
-			}
 			case rage::eNetMessage::MsgKickPlayer:
 			{
 				KickReason reason = buffer.Read<KickReason>(3);

src/hooks/protections/received_clone_create.cpp

@@ -17,7 +17,14 @@ namespace big
 		if (plyr && plyr->block_clone_create)
 			return;
 
-		g.m_syncing_player = src;
+		g.m_syncing_player      = src;
+		g.m_syncing_object_type = object_type;
+
+		g.debug.fuzzer.thread_id = GetCurrentThreadId();
+		if (g.debug.fuzzer.enabled_object_types[(int)object_type])
+			g.debug.fuzzer.active = true;
+		g.debug.fuzzer.syncing_object_id = object_id;
 		g_hooking->get_original<hooks::received_clone_create>()(mgr, src, dst, object_type, object_id, object_flag, buffer, timestamp);
+		g.debug.fuzzer.active = false;
 	}
 }

src/hooks/protections/received_clone_sync.cpp

@@ -23,7 +23,16 @@ namespace big
 		if (plyr && plyr->block_clone_sync)
 			return eAckCode::ACKCODE_FAIL;
 
-		g.m_syncing_player = src;
-		return g_hooking->get_original<received_clone_sync>()(mgr, src, dst, object_type, object_id, buffer, unk, timestamp);
+		g.m_syncing_player      = src;
+		g.m_syncing_object_type = object_type;
+
+		g.debug.fuzzer.thread_id = GetCurrentThreadId();
+		if (g.debug.fuzzer.enabled_object_types[(int)object_type])
+			g.debug.fuzzer.active = true;
+		g.debug.fuzzer.syncing_object_id = object_id;
+		auto ret = g_hooking->get_original<received_clone_sync>()(mgr, src, dst, object_type, object_id, buffer, unk, timestamp);
+		g.debug.fuzzer.active = false;
+
+		return ret;
 	}
 }

src/hooks/protections/received_event.cpp

@@ -4,9 +4,9 @@
 #include "hooking.hpp"
 #include "script/scriptIdBase.hpp"
 #include "util/math.hpp"
+#include "util/mobile.hpp"
 #include "util/notify.hpp"
 #include "util/toxic.hpp"
-#include "util/mobile.hpp"
 
 #include <base/CObject.hpp>
 #include <network/CNetGamePlayer.hpp>
@@ -506,8 +506,8 @@ namespace big
 				Vehicle personal_vehicle = mobile::mechanic::get_personal_vehicle();
 				Vehicle veh              = g_pointers->m_gta.m_ptr_to_handle(g_local_player->m_vehicle);
 				if (!NETWORK::NETWORK_IS_ACTIVITY_SESSION() //If we're in Freemode.
-					|| personal_vehicle == veh //Or we're in our personal vehicle.
-					|| DECORATOR::DECOR_GET_INT(veh, "RandomId") == g_local_player->m_net_object->m_object_id) // Or it's a vehicle we spawned.
+				    || personal_vehicle == veh              //Or we're in our personal vehicle.
+				    || DECORATOR::DECOR_GET_INT(veh, "RandomId") == g_local_player->m_net_object->m_object_id) // Or it's a vehicle we spawned.
 				{
 					g_pointers->m_gta.m_send_event_ack(event_manager, source_player, target_player, event_index, event_handled_bitset); // Tell them to get bent.
 					g.reactions.request_control_event.process(plyr);
@@ -611,6 +611,7 @@ namespace big
 			uint32_t timestamp                = buffer->Read<uint32_t>(32);
 			int count                         = buffer->Read<int>(2);
 			bool all_objects_migrate_together = buffer->Read<bool>(1);
+			eNetObjType sync_type;
 
 			if (count > 3)
 			{
@@ -629,10 +630,17 @@ namespace big
 					g_pointers->m_gta.m_send_event_ack(event_manager, source_player, target_player, event_index, event_handled_bitset);
 					return;
 				}
+
+				sync_type = object_type;
 			}
 
 			buffer->Seek(0);
-			g.m_syncing_player = source_player;
+
+			if (count)
+			{
+				g.m_syncing_player      = source_player;
+				g.m_syncing_object_type = sync_type;
+			}
 			break;
 		}
 		case eNetworkEvents::NETWORK_PLAY_SOUND_EVENT:

src/hooks/protections/script_event_handler.cpp

@@ -127,19 +127,27 @@ namespace big
 			break;
 		}
 		case eRemoteEvent::Notification:
+		{
 			switch (static_cast<eRemoteEvent>(args[2]))
 			{
-			case eRemoteEvent::NotificationMoneyBanked:
+			case eRemoteEvent::NotificationMoneyBanked: // never used
 			case eRemoteEvent::NotificationMoneyRemoved:
-			case eRemoteEvent::NotificationMoneyStolen:
-				if (g.protections.script_events.fake_deposit)
+			case eRemoteEvent::NotificationMoneyStolen: g.reactions.fake_deposit.process(plyr); return true;
+			case eRemoteEvent::NotificationCrash1:                             // this isn't used by the game
+				session::add_infraction(plyr, Infraction::TRIED_CRASH_PLAYER); // stand user detected
+				return true;
+			case eRemoteEvent::NotificationCrash2:
+				if (!gta_util::find_script_thread(RAGE_JOAAT("gb_salvage")))
 				{
-					g.reactions.fake_deposit.process(plyr);
+					// This looks like it's meant to trigger a sound crash by spamming too many notifications. We've already patched it, but the notifications are still annoying
+					session::add_infraction(plyr, Infraction::TRIED_CRASH_PLAYER); // stand user detected
 					return true;
 				}
 				break;
 			}
+
 			break;
+		}
 		case eRemoteEvent::ForceMission:
 			if (g.protections.script_events.force_mission)
 			{
@@ -365,8 +373,8 @@ namespace big
 
 			if (!plyr->get_ped() || math::distance_between_vectors(*plyr->get_ped()->get_position(), *g_local_player->get_position()) > 75.0f)
 			{
-				g.reactions.send_to_interior.process(plyr);
-				return true;
+				// g.reactions.send_to_interior.process(plyr); false positives
+				return true; // this is fine, the game will reject our false positives anyway
 			}
 
 			break;
@@ -383,7 +391,8 @@ namespace big
 		{
 			if (auto script = gta_util::find_script_thread(RAGE_JOAAT("freemode")))
 			{
-				if (script->m_net_component && ((CGameScriptHandlerNetComponent*)script->m_net_component)->m_host && ((CGameScriptHandlerNetComponent*)script->m_net_component)->m_host->m_net_game_player != player)
+				if (script->m_net_component && ((CGameScriptHandlerNetComponent*)script->m_net_component)->m_host
+				    && ((CGameScriptHandlerNetComponent*)script->m_net_component)->m_host->m_net_game_player != player)
 				{
 					g.reactions.trigger_business_raid.process(plyr);
 				}
@@ -396,7 +405,8 @@ namespace big
 			// TODO: Breaks stuff
 			if (auto script = gta_util::find_script_thread(RAGE_JOAAT("freemode")))
 			{
-				if (script->m_net_component && ((CGameScriptHandlerNetComponent*)script->m_net_component)->m_host && ((CGameScriptHandlerNetComponent*)script->m_net_component)->m_host->m_net_game_player != player)
+				if (script->m_net_component && ((CGameScriptHandlerNetComponent*)script->m_net_component)->m_host
+				    && ((CGameScriptHandlerNetComponent*)script->m_net_component)->m_host->m_net_game_player != player)
 				{
 					g.reactions.start_script.process(plyr);
 					return true;

src/hooks/protections/serialize_parachute_task.cpp

@@ -0,0 +1,29 @@
+#include "hooking.hpp"
+#include "util/notify.hpp"
+
+#include <entities/CDynamicEntity.hpp>
+
+namespace big
+{
+#pragma pack(push, 8)
+	struct TaskObject
+	{
+		uint16_t m_net_id;
+		rage::CDynamicEntity* m_entity;
+	};
+#pragma pack(pop)
+
+	void hooks::serialize_parachute_task(__int64 info, rage::CSyncDataBase* serializer)
+	{
+		auto object = reinterpret_cast<TaskObject*>(info + 0x30);
+		g_hooking->get_original<hooks::serialize_parachute_task>()(info, serializer);
+
+		if (object->m_entity && object->m_entity->m_entity_type != 5)
+		{
+			g_pointers->m_gta.m_remove_reference(object->m_entity, &object->m_entity);
+			notify::crash_blocked(g.m_syncing_player, "invalid parachute object type");
+			object->m_entity = nullptr;
+			object->m_net_id = 0;
+		}
+	}
+}

src/hooks/protections/serialize_take_off_ped_variation_task.cpp

@@ -30,7 +30,7 @@ namespace big
 		g_hooking->get_original<hooks::serialize_take_off_ped_variation_task>()(info, serializer);
 		if (!is_valid_parachute_model(info->m_prop_hash))
 		{
-			notify::crash_blocked(g.m_syncing_player, "invalid parachute");
+			notify::crash_blocked(g.m_syncing_player, "invalid parachute model");
 			info->m_prop_hash = 0;
 		}
 	}

src/hooks/protections/task_ambient_clips.cpp

@@ -0,0 +1,15 @@
+#include "hooking.hpp"
+
+namespace big
+{
+	int hooks::task_ambient_clips(uint64_t _this, int a2, int a3)
+	{
+		// enter crash func
+		// TODO: this doesn't block the crash completely
+
+		if (*(uint64_t*)(_this + 0x100))
+			return g_hooking->get_original<hooks::task_ambient_clips>()(_this, a2, a3);
+
+		return 0;
+	}
+}

src/hooks/protections/task_parachute_object.cpp

@@ -2,16 +2,16 @@
 
 namespace big
 {
-	int hooks::task_parachute_object_0x270(uint64_t _this, int a2, int a3)
+	int hooks::task_parachute_object(uint64_t _this, int a2, int a3)
 	{
-		if (a2 == 1 && a3 == 1)// enter crash func
+		if (a2 == 1 && a3 == 1) // enter crash func
 		{
 			if (auto ptr = *(uint64_t*)(_this + 16))
 				if (auto ptr2 = *(uint64_t*)(ptr + 80))
 					if (auto ptr3 = *(uint64_t*)(ptr2 + 64))
-						return g_hooking->get_original<hooks::task_parachute_object_0x270>()(_this, a2, a3);
+						return g_hooking->get_original<hooks::task_parachute_object>()(_this, a2, a3);
 			return 0;
 		}
-		return g_hooking->get_original<hooks::task_parachute_object_0x270>()(_this, a2, a3);
+		return g_hooking->get_original<hooks::task_parachute_object>()(_this, a2, a3);
 	}
 }

src/hooks/script/init_native_tables.cpp

@@ -7,8 +7,12 @@ namespace big
 	bool hooks::init_native_tables(rage::scrProgram* program)
 	{
 		bool ret = g_hooking->get_original<hooks::init_native_tables>()(program);
-		g_script_patcher_service->on_script_load(program);
-		g_native_hooks->hook_program(program);
+
+		if (program->m_code_size && program->m_code_blocks) // ensure that we aren't hooking SHV threads
+		{
+			g_script_patcher_service->on_script_load(program);
+			g_native_hooks->hook_program(program);
+		}
 
 		return ret;
 	}

src/logger/stack_trace.cpp

@@ -140,7 +140,12 @@ namespace big
 					continue;
 				}
 				const auto module_info = get_module_by_address(addr);
-				m_dump << module_info->m_path.filename().string() << " " << std::string_view(symbol->Name, symbol->NameLen);
+
+				if (module_info->m_base == (uint64_t)GetModuleHandle(0))
+					m_dump << module_info->m_path.filename().string() << " " << std::string_view(symbol->Name, symbol->NameLen) << " ("
+					       << module_info->m_path.filename().string() << "+" << HEX_TO_UPPER(addr - module_info->m_base) << ")";
+				else
+					m_dump << module_info->m_path.filename().string() << " " << std::string_view(symbol->Name, symbol->NameLen);
 
 				continue;
 			}

src/lua/bindings/script.cpp

@@ -65,7 +65,10 @@ namespace lua::script
 				    auto res = func(dummy_script_util);
 
 				    if (!res.valid())
+				    {
 					    big::g_lua_manager->handle_error(res, res.lua_state());
+					    break;
+				    }
 
 				    if (func.runnable())
 				    {
@@ -128,7 +131,10 @@ namespace lua::script
 				    auto res = func(dummy_script_util);
 
 				    if (!res.valid())
+				    {
 					    big::g_lua_manager->handle_error(res, res.lua_state());
+					    break;
+				    }
 
 				    if (func.runnable())
 				    {

src/lua/natives/lua_native_binding_APP.cpp

@@ -3,94 +3,94 @@
 
 namespace lua::native
 {
-	static bool LUA_NATIVE_APP_APP_DATA_VALID(  )
+	static bool LUA_NATIVE_APP_APP_DATA_VALID()
 	{
 		auto retval = (bool)APP::APP_DATA_VALID();
 		return retval;
 	}
 
-	static int LUA_NATIVE_APP_APP_GET_INT( const char* property )
+	static int LUA_NATIVE_APP_APP_GET_INT(const char* property)
 	{
 		auto retval = APP::APP_GET_INT(property);
 		return retval;
 	}
 
-	static float LUA_NATIVE_APP_APP_GET_FLOAT( const char* property )
+	static float LUA_NATIVE_APP_APP_GET_FLOAT(const char* property)
 	{
 		auto retval = APP::APP_GET_FLOAT(property);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_APP_APP_GET_STRING( const char* property )
+	static const char* LUA_NATIVE_APP_APP_GET_STRING(const char* property)
 	{
 		auto retval = APP::APP_GET_STRING(property);
 		return retval;
 	}
 
-	static void LUA_NATIVE_APP_APP_SET_INT( const char* property, int value )
+	static void LUA_NATIVE_APP_APP_SET_INT(const char* property, int value)
 	{
 		APP::APP_SET_INT(property, value);
 	}
 
-	static void LUA_NATIVE_APP_APP_SET_FLOAT( const char* property, float value )
+	static void LUA_NATIVE_APP_APP_SET_FLOAT(const char* property, float value)
 	{
 		APP::APP_SET_FLOAT(property, value);
 	}
 
-	static void LUA_NATIVE_APP_APP_SET_STRING( const char* property, const char* value )
+	static void LUA_NATIVE_APP_APP_SET_STRING(const char* property, const char* value)
 	{
 		APP::APP_SET_STRING(property, value);
 	}
 
-	static void LUA_NATIVE_APP_APP_SET_APP( const char* appName )
+	static void LUA_NATIVE_APP_APP_SET_APP(const char* appName)
 	{
 		APP::APP_SET_APP(appName);
 	}
 
-	static void LUA_NATIVE_APP_APP_SET_BLOCK( const char* blockName )
+	static void LUA_NATIVE_APP_APP_SET_BLOCK(const char* blockName)
 	{
 		APP::APP_SET_BLOCK(blockName);
 	}
 
-	static void LUA_NATIVE_APP_APP_CLEAR_BLOCK(  )
+	static void LUA_NATIVE_APP_APP_CLEAR_BLOCK()
 	{
 		APP::APP_CLEAR_BLOCK();
 	}
 
-	static void LUA_NATIVE_APP_APP_CLOSE_APP(  )
+	static void LUA_NATIVE_APP_APP_CLOSE_APP()
 	{
 		APP::APP_CLOSE_APP();
 	}
 
-	static void LUA_NATIVE_APP_APP_CLOSE_BLOCK(  )
+	static void LUA_NATIVE_APP_APP_CLOSE_BLOCK()
 	{
 		APP::APP_CLOSE_BLOCK();
 	}
 
-	static bool LUA_NATIVE_APP_APP_HAS_LINKED_SOCIAL_CLUB_ACCOUNT(  )
+	static bool LUA_NATIVE_APP_APP_HAS_LINKED_SOCIAL_CLUB_ACCOUNT()
 	{
 		auto retval = (bool)APP::APP_HAS_LINKED_SOCIAL_CLUB_ACCOUNT();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_APP_APP_HAS_SYNCED_DATA( const char* appName )
+	static bool LUA_NATIVE_APP_APP_HAS_SYNCED_DATA(const char* appName)
 	{
 		auto retval = (bool)APP::APP_HAS_SYNCED_DATA(appName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_APP_APP_SAVE_DATA(  )
+	static void LUA_NATIVE_APP_APP_SAVE_DATA()
 	{
 		APP::APP_SAVE_DATA();
 	}
 
-	static int LUA_NATIVE_APP_APP_GET_DELETED_FILE_STATUS(  )
+	static int LUA_NATIVE_APP_APP_GET_DELETED_FILE_STATUS()
 	{
 		auto retval = APP::APP_GET_DELETED_FILE_STATUS();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_APP_APP_DELETE_APP_DATA( const char* appName )
+	static bool LUA_NATIVE_APP_APP_DELETE_APP_DATA(const char* appName)
 	{
 		auto retval = (bool)APP::APP_DELETE_APP_DATA(appName);
 		return retval;

src/lua/natives/lua_native_binding_BRAIN.cpp

@@ -3,59 +3,59 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_BRAIN_ADD_SCRIPT_TO_RANDOM_PED( const char* name, Hash model, float p2, float p3 )
+	static void LUA_NATIVE_BRAIN_ADD_SCRIPT_TO_RANDOM_PED(const char* name, Hash model, float p2, float p3)
 	{
 		BRAIN::ADD_SCRIPT_TO_RANDOM_PED(name, model, p2, p3);
 	}
 
-	static void LUA_NATIVE_BRAIN_REGISTER_OBJECT_SCRIPT_BRAIN( const char* scriptName, Hash modelHash, int p2, float activationRange, int p4, int p5 )
+	static void LUA_NATIVE_BRAIN_REGISTER_OBJECT_SCRIPT_BRAIN(const char* scriptName, Hash modelHash, int p2, float activationRange, int p4, int p5)
 	{
 		BRAIN::REGISTER_OBJECT_SCRIPT_BRAIN(scriptName, modelHash, p2, activationRange, p4, p5);
 	}
 
-	static bool LUA_NATIVE_BRAIN_IS_OBJECT_WITHIN_BRAIN_ACTIVATION_RANGE( Object object )
+	static bool LUA_NATIVE_BRAIN_IS_OBJECT_WITHIN_BRAIN_ACTIVATION_RANGE(Object object)
 	{
 		auto retval = (bool)BRAIN::IS_OBJECT_WITHIN_BRAIN_ACTIVATION_RANGE(object);
 		return retval;
 	}
 
-	static void LUA_NATIVE_BRAIN_REGISTER_WORLD_POINT_SCRIPT_BRAIN( const char* scriptName, float activationRange, int p2 )
+	static void LUA_NATIVE_BRAIN_REGISTER_WORLD_POINT_SCRIPT_BRAIN(const char* scriptName, float activationRange, int p2)
 	{
 		BRAIN::REGISTER_WORLD_POINT_SCRIPT_BRAIN(scriptName, activationRange, p2);
 	}
 
-	static bool LUA_NATIVE_BRAIN_IS_WORLD_POINT_WITHIN_BRAIN_ACTIVATION_RANGE(  )
+	static bool LUA_NATIVE_BRAIN_IS_WORLD_POINT_WITHIN_BRAIN_ACTIVATION_RANGE()
 	{
 		auto retval = (bool)BRAIN::IS_WORLD_POINT_WITHIN_BRAIN_ACTIVATION_RANGE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_BRAIN_ENABLE_SCRIPT_BRAIN_SET( int brainSet )
+	static void LUA_NATIVE_BRAIN_ENABLE_SCRIPT_BRAIN_SET(int brainSet)
 	{
 		BRAIN::ENABLE_SCRIPT_BRAIN_SET(brainSet);
 	}
 
-	static void LUA_NATIVE_BRAIN_DISABLE_SCRIPT_BRAIN_SET( int brainSet )
+	static void LUA_NATIVE_BRAIN_DISABLE_SCRIPT_BRAIN_SET(int brainSet)
 	{
 		BRAIN::DISABLE_SCRIPT_BRAIN_SET(brainSet);
 	}
 
-	static void LUA_NATIVE_BRAIN_REACTIVATE_ALL_WORLD_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE(  )
+	static void LUA_NATIVE_BRAIN_REACTIVATE_ALL_WORLD_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE()
 	{
 		BRAIN::REACTIVATE_ALL_WORLD_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE();
 	}
 
-	static void LUA_NATIVE_BRAIN_REACTIVATE_ALL_OBJECT_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE(  )
+	static void LUA_NATIVE_BRAIN_REACTIVATE_ALL_OBJECT_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE()
 	{
 		BRAIN::REACTIVATE_ALL_OBJECT_BRAINS_THAT_ARE_WAITING_TILL_OUT_OF_RANGE();
 	}
 
-	static void LUA_NATIVE_BRAIN_REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE( const char* scriptName )
+	static void LUA_NATIVE_BRAIN_REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE(const char* scriptName)
 	{
 		BRAIN::REACTIVATE_NAMED_WORLD_BRAINS_WAITING_TILL_OUT_OF_RANGE(scriptName);
 	}
 
-	static void LUA_NATIVE_BRAIN_REACTIVATE_NAMED_OBJECT_BRAINS_WAITING_TILL_OUT_OF_RANGE( const char* scriptName )
+	static void LUA_NATIVE_BRAIN_REACTIVATE_NAMED_OBJECT_BRAINS_WAITING_TILL_OUT_OF_RANGE(const char* scriptName)
 	{
 		BRAIN::REACTIVATE_NAMED_OBJECT_BRAINS_WAITING_TILL_OUT_OF_RANGE(scriptName);
 	}

src/lua/natives/lua_native_binding_CLOCK.cpp

@@ -3,80 +3,80 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_CLOCK_SET_CLOCK_TIME( int hour, int minute, int second )
+	static void LUA_NATIVE_CLOCK_SET_CLOCK_TIME(int hour, int minute, int second)
 	{
 		CLOCK::SET_CLOCK_TIME(hour, minute, second);
 	}
 
-	static void LUA_NATIVE_CLOCK_PAUSE_CLOCK( bool toggle )
+	static void LUA_NATIVE_CLOCK_PAUSE_CLOCK(bool toggle)
 	{
 		CLOCK::PAUSE_CLOCK(toggle);
 	}
 
-	static void LUA_NATIVE_CLOCK_ADVANCE_CLOCK_TIME_TO( int hour, int minute, int second )
+	static void LUA_NATIVE_CLOCK_ADVANCE_CLOCK_TIME_TO(int hour, int minute, int second)
 	{
 		CLOCK::ADVANCE_CLOCK_TIME_TO(hour, minute, second);
 	}
 
-	static void LUA_NATIVE_CLOCK_ADD_TO_CLOCK_TIME( int hours, int minutes, int seconds )
+	static void LUA_NATIVE_CLOCK_ADD_TO_CLOCK_TIME(int hours, int minutes, int seconds)
 	{
 		CLOCK::ADD_TO_CLOCK_TIME(hours, minutes, seconds);
 	}
 
-	static int LUA_NATIVE_CLOCK_GET_CLOCK_HOURS(  )
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_HOURS()
 	{
 		auto retval = CLOCK::GET_CLOCK_HOURS();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CLOCK_GET_CLOCK_MINUTES(  )
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_MINUTES()
 	{
 		auto retval = CLOCK::GET_CLOCK_MINUTES();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CLOCK_GET_CLOCK_SECONDS(  )
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_SECONDS()
 	{
 		auto retval = CLOCK::GET_CLOCK_SECONDS();
 		return retval;
 	}
 
-	static void LUA_NATIVE_CLOCK_SET_CLOCK_DATE( int day, int month, int year )
+	static void LUA_NATIVE_CLOCK_SET_CLOCK_DATE(int day, int month, int year)
 	{
 		CLOCK::SET_CLOCK_DATE(day, month, year);
 	}
 
-	static int LUA_NATIVE_CLOCK_GET_CLOCK_DAY_OF_WEEK(  )
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_DAY_OF_WEEK()
 	{
 		auto retval = CLOCK::GET_CLOCK_DAY_OF_WEEK();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CLOCK_GET_CLOCK_DAY_OF_MONTH(  )
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_DAY_OF_MONTH()
 	{
 		auto retval = CLOCK::GET_CLOCK_DAY_OF_MONTH();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CLOCK_GET_CLOCK_MONTH(  )
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_MONTH()
 	{
 		auto retval = CLOCK::GET_CLOCK_MONTH();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CLOCK_GET_CLOCK_YEAR(  )
+	static int LUA_NATIVE_CLOCK_GET_CLOCK_YEAR()
 	{
 		auto retval = CLOCK::GET_CLOCK_YEAR();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CLOCK_GET_MILLISECONDS_PER_GAME_MINUTE(  )
+	static int LUA_NATIVE_CLOCK_GET_MILLISECONDS_PER_GAME_MINUTE()
 	{
 		auto retval = CLOCK::GET_MILLISECONDS_PER_GAME_MINUTE();
 		return retval;
 	}
 
-	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_POSIX_TIME( int year, int month, int day, int hour, int minute, int second )
+	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_POSIX_TIME(int year, int month, int day, int hour, int minute, int second)
 	{
 		std::tuple<int, int, int, int, int, int> return_values;
 		CLOCK::GET_POSIX_TIME(&year, &month, &day, &hour, &minute, &second);
@@ -90,7 +90,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_UTC_TIME( int year, int month, int day, int hour, int minute, int second )
+	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_UTC_TIME(int year, int month, int day, int hour, int minute, int second)
 	{
 		std::tuple<int, int, int, int, int, int> return_values;
 		CLOCK::GET_UTC_TIME(&year, &month, &day, &hour, &minute, &second);
@@ -104,7 +104,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_LOCAL_TIME( int year, int month, int day, int hour, int minute, int second )
+	static std::tuple<int, int, int, int, int, int> LUA_NATIVE_CLOCK_GET_LOCAL_TIME(int year, int month, int day, int hour, int minute, int second)
 	{
 		std::tuple<int, int, int, int, int, int> return_values;
 		CLOCK::GET_LOCAL_TIME(&year, &month, &day, &hour, &minute, &second);

src/lua/natives/lua_native_binding_CUTSCENE.cpp

@@ -3,298 +3,298 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_CUTSCENE_REQUEST_CUTSCENE( const char* cutsceneName, int flags )
+	static void LUA_NATIVE_CUTSCENE_REQUEST_CUTSCENE(const char* cutsceneName, int flags)
 	{
 		CUTSCENE::REQUEST_CUTSCENE(cutsceneName, flags);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_REQUEST_CUTSCENE_WITH_PLAYBACK_LIST( const char* cutsceneName, int playbackFlags, int flags )
+	static void LUA_NATIVE_CUTSCENE_REQUEST_CUTSCENE_WITH_PLAYBACK_LIST(const char* cutsceneName, int playbackFlags, int flags)
 	{
 		CUTSCENE::REQUEST_CUTSCENE_WITH_PLAYBACK_LIST(cutsceneName, playbackFlags, flags);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_REMOVE_CUTSCENE(  )
+	static void LUA_NATIVE_CUTSCENE_REMOVE_CUTSCENE()
 	{
 		CUTSCENE::REMOVE_CUTSCENE();
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_LOADED(  )
+	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_LOADED()
 	{
 		auto retval = (bool)CUTSCENE::HAS_CUTSCENE_LOADED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_HAS_THIS_CUTSCENE_LOADED( const char* cutsceneName )
+	static bool LUA_NATIVE_CUTSCENE_HAS_THIS_CUTSCENE_LOADED(const char* cutsceneName)
 	{
 		auto retval = (bool)CUTSCENE::HAS_THIS_CUTSCENE_LOADED(cutsceneName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_SCRIPT_CAN_START_CUTSCENE( int threadId )
+	static void LUA_NATIVE_CUTSCENE_SET_SCRIPT_CAN_START_CUTSCENE(int threadId)
 	{
 		CUTSCENE::SET_SCRIPT_CAN_START_CUTSCENE(threadId);
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY(  )
+	static bool LUA_NATIVE_CUTSCENE_CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY()
 	{
 		auto retval = (bool)CUTSCENE::CAN_REQUEST_ASSETS_FOR_CUTSCENE_ENTITY();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_PLAYBACK_FLAG_SET( int flag )
+	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_PLAYBACK_FLAG_SET(int flag)
 	{
 		auto retval = (bool)CUTSCENE::IS_CUTSCENE_PLAYBACK_FLAG_SET(flag);
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ENTITY_STREAMING_FLAGS( const char* cutsceneEntName, int p1, int p2 )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ENTITY_STREAMING_FLAGS(const char* cutsceneEntName, int p1, int p2)
 	{
 		CUTSCENE::SET_CUTSCENE_ENTITY_STREAMING_FLAGS(cutsceneEntName, p1, p2);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_REQUEST_CUT_FILE( const char* cutsceneName )
+	static void LUA_NATIVE_CUTSCENE_REQUEST_CUT_FILE(const char* cutsceneName)
 	{
 		CUTSCENE::REQUEST_CUT_FILE(cutsceneName);
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_HAS_CUT_FILE_LOADED( const char* cutsceneName )
+	static bool LUA_NATIVE_CUTSCENE_HAS_CUT_FILE_LOADED(const char* cutsceneName)
 	{
 		auto retval = (bool)CUTSCENE::HAS_CUT_FILE_LOADED(cutsceneName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_REMOVE_CUT_FILE( const char* cutsceneName )
+	static void LUA_NATIVE_CUTSCENE_REMOVE_CUT_FILE(const char* cutsceneName)
 	{
 		CUTSCENE::REMOVE_CUT_FILE(cutsceneName);
 	}
 
-	static int LUA_NATIVE_CUTSCENE_GET_CUT_FILE_CONCAT_COUNT( const char* cutsceneName )
+	static int LUA_NATIVE_CUTSCENE_GET_CUT_FILE_CONCAT_COUNT(const char* cutsceneName)
 	{
 		auto retval = CUTSCENE::GET_CUT_FILE_CONCAT_COUNT(cutsceneName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_START_CUTSCENE( int flags )
+	static void LUA_NATIVE_CUTSCENE_START_CUTSCENE(int flags)
 	{
 		CUTSCENE::START_CUTSCENE(flags);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_START_CUTSCENE_AT_COORDS( float x, float y, float z, int flags )
+	static void LUA_NATIVE_CUTSCENE_START_CUTSCENE_AT_COORDS(float x, float y, float z, int flags)
 	{
 		CUTSCENE::START_CUTSCENE_AT_COORDS(x, y, z, flags);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_STOP_CUTSCENE( bool p0 )
+	static void LUA_NATIVE_CUTSCENE_STOP_CUTSCENE(bool p0)
 	{
 		CUTSCENE::STOP_CUTSCENE(p0);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_STOP_CUTSCENE_IMMEDIATELY(  )
+	static void LUA_NATIVE_CUTSCENE_STOP_CUTSCENE_IMMEDIATELY()
 	{
 		CUTSCENE::STOP_CUTSCENE_IMMEDIATELY();
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ORIGIN( float x, float y, float z, float p3, int p4 )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ORIGIN(float x, float y, float z, float p3, int p4)
 	{
 		CUTSCENE::SET_CUTSCENE_ORIGIN(x, y, z, p3, p4);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ORIGIN_AND_ORIENTATION( float x1, float y1, float z1, float x2, float y2, float z2, int p6 )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_ORIGIN_AND_ORIENTATION(float x1, float y1, float z1, float x2, float y2, float z2, int p6)
 	{
 		CUTSCENE::SET_CUTSCENE_ORIGIN_AND_ORIENTATION(x1, y1, z1, x2, y2, z2, p6);
 	}
 
-	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_TIME(  )
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_TIME()
 	{
 		auto retval = CUTSCENE::GET_CUTSCENE_TIME();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_TOTAL_DURATION(  )
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_TOTAL_DURATION()
 	{
 		auto retval = CUTSCENE::GET_CUTSCENE_TOTAL_DURATION();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_END_TIME(  )
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_END_TIME()
 	{
 		auto retval = CUTSCENE::GET_CUTSCENE_END_TIME();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_PLAY_DURATION(  )
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_PLAY_DURATION()
 	{
 		auto retval = CUTSCENE::GET_CUTSCENE_PLAY_DURATION();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_WAS_CUTSCENE_SKIPPED(  )
+	static bool LUA_NATIVE_CUTSCENE_WAS_CUTSCENE_SKIPPED()
 	{
 		auto retval = (bool)CUTSCENE::WAS_CUTSCENE_SKIPPED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_FINISHED(  )
+	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_FINISHED()
 	{
 		auto retval = (bool)CUTSCENE::HAS_CUTSCENE_FINISHED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_ACTIVE(  )
+	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_ACTIVE()
 	{
 		auto retval = (bool)CUTSCENE::IS_CUTSCENE_ACTIVE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_PLAYING(  )
+	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_PLAYING()
 	{
 		auto retval = (bool)CUTSCENE::IS_CUTSCENE_PLAYING();
 		return retval;
 	}
 
-	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_SECTION_PLAYING(  )
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_SECTION_PLAYING()
 	{
 		auto retval = CUTSCENE::GET_CUTSCENE_SECTION_PLAYING();
 		return retval;
 	}
 
-	static Entity LUA_NATIVE_CUTSCENE_GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY( const char* cutsceneEntName, Hash modelHash )
+	static Entity LUA_NATIVE_CUTSCENE_GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY(const char* cutsceneEntName, Hash modelHash)
 	{
 		auto retval = CUTSCENE::GET_ENTITY_INDEX_OF_CUTSCENE_ENTITY(cutsceneEntName, modelHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_CONCAT_SECTION_PLAYING(  )
+	static int LUA_NATIVE_CUTSCENE_GET_CUTSCENE_CONCAT_SECTION_PLAYING()
 	{
 		auto retval = CUTSCENE::GET_CUTSCENE_CONCAT_SECTION_PLAYING();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_AUTHORIZED( const char* cutsceneName )
+	static bool LUA_NATIVE_CUTSCENE_IS_CUTSCENE_AUTHORIZED(const char* cutsceneName)
 	{
 		auto retval = (bool)CUTSCENE::IS_CUTSCENE_AUTHORIZED(cutsceneName);
 		return retval;
 	}
 
-	static int LUA_NATIVE_CUTSCENE_DOES_CUTSCENE_HANDLE_EXIST( int cutsceneHandle )
+	static int LUA_NATIVE_CUTSCENE_DOES_CUTSCENE_HANDLE_EXIST(int cutsceneHandle)
 	{
 		auto retval = CUTSCENE::DOES_CUTSCENE_HANDLE_EXIST(cutsceneHandle);
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_REGISTER_ENTITY_FOR_CUTSCENE( Ped cutscenePed, const char* cutsceneEntName, int p2, Hash modelHash, int p4 )
+	static void LUA_NATIVE_CUTSCENE_REGISTER_ENTITY_FOR_CUTSCENE(Ped cutscenePed, const char* cutsceneEntName, int p2, Hash modelHash, int p4)
 	{
 		CUTSCENE::REGISTER_ENTITY_FOR_CUTSCENE(cutscenePed, cutsceneEntName, p2, modelHash, p4);
 	}
 
-	static Entity LUA_NATIVE_CUTSCENE_GET_ENTITY_INDEX_OF_REGISTERED_ENTITY( const char* cutsceneEntName, Hash modelHash )
+	static Entity LUA_NATIVE_CUTSCENE_GET_ENTITY_INDEX_OF_REGISTERED_ENTITY(const char* cutsceneEntName, Hash modelHash)
 	{
 		auto retval = CUTSCENE::GET_ENTITY_INDEX_OF_REGISTERED_ENTITY(cutsceneEntName, modelHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE( Hash modelHash )
+	static void LUA_NATIVE_CUTSCENE_SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE(Hash modelHash)
 	{
 		CUTSCENE::SET_VEHICLE_MODEL_PLAYER_WILL_EXIT_SCENE(modelHash);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_TRIGGER_AREA( float x1, float y1, float z1, float x2, float y2, float z2 )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_TRIGGER_AREA(float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		CUTSCENE::SET_CUTSCENE_TRIGGER_AREA(x1, y1, z1, x2, y2, z2);
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY( const char* cutsceneEntName, Hash modelHash )
+	static bool LUA_NATIVE_CUTSCENE_CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY(const char* cutsceneEntName, Hash modelHash)
 	{
 		auto retval = (bool)CUTSCENE::CAN_SET_ENTER_STATE_FOR_REGISTERED_ENTITY(cutsceneEntName, modelHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY( const char* cutsceneEntName, Hash modelHash )
+	static bool LUA_NATIVE_CUTSCENE_CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(const char* cutsceneEntName, Hash modelHash)
 	{
 		auto retval = (bool)CUTSCENE::CAN_SET_EXIT_STATE_FOR_REGISTERED_ENTITY(cutsceneEntName, modelHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_CAN_SET_EXIT_STATE_FOR_CAMERA( bool p0 )
+	static bool LUA_NATIVE_CUTSCENE_CAN_SET_EXIT_STATE_FOR_CAMERA(bool p0)
 	{
 		auto retval = (bool)CUTSCENE::CAN_SET_EXIT_STATE_FOR_CAMERA(p0);
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_PAD_CAN_SHAKE_DURING_CUTSCENE( bool toggle )
+	static void LUA_NATIVE_CUTSCENE_SET_PAD_CAN_SHAKE_DURING_CUTSCENE(bool toggle)
 	{
 		CUTSCENE::SET_PAD_CAN_SHAKE_DURING_CUTSCENE(toggle);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_FADE_VALUES( bool p0, bool p1, bool p2, bool p3 )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_FADE_VALUES(bool p0, bool p1, bool p2, bool p3)
 	{
 		CUTSCENE::SET_CUTSCENE_FADE_VALUES(p0, p1, p2, p3);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_MULTIHEAD_FADE( bool p0, bool p1, bool p2, bool p3 )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_MULTIHEAD_FADE(bool p0, bool p1, bool p2, bool p3)
 	{
 		CUTSCENE::SET_CUTSCENE_MULTIHEAD_FADE(p0, p1, p2, p3);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_MULTIHEAD_FADE_MANUAL( bool p0 )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_MULTIHEAD_FADE_MANUAL(bool p0)
 	{
 		CUTSCENE::SET_CUTSCENE_MULTIHEAD_FADE_MANUAL(p0);
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_IS_MULTIHEAD_FADE_UP(  )
+	static bool LUA_NATIVE_CUTSCENE_IS_MULTIHEAD_FADE_UP()
 	{
 		auto retval = (bool)CUTSCENE::IS_MULTIHEAD_FADE_UP();
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_NETWORK_SET_MOCAP_CUTSCENE_CAN_BE_SKIPPED( bool p0 )
+	static void LUA_NATIVE_CUTSCENE_NETWORK_SET_MOCAP_CUTSCENE_CAN_BE_SKIPPED(bool p0)
 	{
 		CUTSCENE::NETWORK_SET_MOCAP_CUTSCENE_CAN_BE_SKIPPED(p0);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CAR_GENERATORS_CAN_UPDATE_DURING_CUTSCENE( bool p0 )
+	static void LUA_NATIVE_CUTSCENE_SET_CAR_GENERATORS_CAN_UPDATE_DURING_CUTSCENE(bool p0)
 	{
 		CUTSCENE::SET_CAR_GENERATORS_CAN_UPDATE_DURING_CUTSCENE(p0);
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_CAN_USE_MOBILE_PHONE_DURING_CUTSCENE(  )
+	static bool LUA_NATIVE_CUTSCENE_CAN_USE_MOBILE_PHONE_DURING_CUTSCENE()
 	{
 		auto retval = (bool)CUTSCENE::CAN_USE_MOBILE_PHONE_DURING_CUTSCENE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_CAN_BE_SKIPPED( bool p0 )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_CAN_BE_SKIPPED(bool p0)
 	{
 		CUTSCENE::SET_CUTSCENE_CAN_BE_SKIPPED(p0);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CAN_DISPLAY_MINIMAP_DURING_CUTSCENE_THIS_UPDATE(  )
+	static void LUA_NATIVE_CUTSCENE_SET_CAN_DISPLAY_MINIMAP_DURING_CUTSCENE_THIS_UPDATE()
 	{
 		CUTSCENE::SET_CAN_DISPLAY_MINIMAP_DURING_CUTSCENE_THIS_UPDATE();
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_COMPONENT_VARIATION( const char* cutsceneEntName, int componentId, int drawableId, int textureId, Hash modelHash )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_COMPONENT_VARIATION(const char* cutsceneEntName, int componentId, int drawableId, int textureId, Hash modelHash)
 	{
 		CUTSCENE::SET_CUTSCENE_PED_COMPONENT_VARIATION(cutsceneEntName, componentId, drawableId, textureId, modelHash);
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED( const char* cutsceneEntName, Ped ped, Hash modelHash )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED(const char* cutsceneEntName, Ped ped, Hash modelHash)
 	{
 		CUTSCENE::SET_CUTSCENE_PED_COMPONENT_VARIATION_FROM_PED(cutsceneEntName, ped, modelHash);
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_DOES_CUTSCENE_ENTITY_EXIST( const char* cutsceneEntName, Hash modelHash )
+	static bool LUA_NATIVE_CUTSCENE_DOES_CUTSCENE_ENTITY_EXIST(const char* cutsceneEntName, Hash modelHash)
 	{
 		auto retval = (bool)CUTSCENE::DOES_CUTSCENE_ENTITY_EXIST(cutsceneEntName, modelHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_PROP_VARIATION( const char* cutsceneEntName, int componentId, int drawableId, int textureId, Hash modelHash )
+	static void LUA_NATIVE_CUTSCENE_SET_CUTSCENE_PED_PROP_VARIATION(const char* cutsceneEntName, int componentId, int drawableId, int textureId, Hash modelHash)
 	{
 		CUTSCENE::SET_CUTSCENE_PED_PROP_VARIATION(cutsceneEntName, componentId, drawableId, textureId, modelHash);
 	}
 
-	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_CUT_THIS_FRAME(  )
+	static bool LUA_NATIVE_CUTSCENE_HAS_CUTSCENE_CUT_THIS_FRAME()
 	{
 		auto retval = (bool)CUTSCENE::HAS_CUTSCENE_CUT_THIS_FRAME();
 		return retval;

src/lua/natives/lua_native_binding_DATAFILE.cpp

@@ -3,47 +3,47 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_DATAFILE_DATAFILE_WATCH_REQUEST_ID( int requestId )
+	static void LUA_NATIVE_DATAFILE_DATAFILE_WATCH_REQUEST_ID(int requestId)
 	{
 		DATAFILE::DATAFILE_WATCH_REQUEST_ID(requestId);
 	}
 
-	static void LUA_NATIVE_DATAFILE_DATAFILE_CLEAR_WATCH_LIST(  )
+	static void LUA_NATIVE_DATAFILE_DATAFILE_CLEAR_WATCH_LIST()
 	{
 		DATAFILE::DATAFILE_CLEAR_WATCH_LIST();
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_IS_VALID_REQUEST_ID( int index )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_IS_VALID_REQUEST_ID(int index)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_IS_VALID_REQUEST_ID(index);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_HAS_LOADED_FILE_DATA( int requestId )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_HAS_LOADED_FILE_DATA(int requestId)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_HAS_LOADED_FILE_DATA(requestId);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_HAS_VALID_FILE_DATA( int requestId )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_HAS_VALID_FILE_DATA(int requestId)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_HAS_VALID_FILE_DATA(requestId);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_ACTIVE_FILE( int requestId, Any p1 )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_ACTIVE_FILE(int requestId, Any p1)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_SELECT_ACTIVE_FILE(requestId, p1);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_DELETE_REQUESTED_FILE( int requestId )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_DELETE_REQUESTED_FILE(int requestId)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_DELETE_REQUESTED_FILE(requestId);
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_UGC_CREATE_CONTENT( Any data, int dataCount, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, bool publish, Any p7 )
+	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_UGC_CREATE_CONTENT(Any data, int dataCount, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, bool publish, Any p7)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)DATAFILE::UGC_CREATE_CONTENT(&data, dataCount, contentName, description, tagsCsv, contentTypeName, publish, p7);
@@ -52,13 +52,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_UGC_CREATE_MISSION( const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, bool publish, Any p5 )
+	static bool LUA_NATIVE_DATAFILE_UGC_CREATE_MISSION(const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, bool publish, Any p5)
 	{
 		auto retval = (bool)DATAFILE::UGC_CREATE_MISSION(contentName, description, tagsCsv, contentTypeName, publish, p5);
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_UGC_UPDATE_CONTENT( const char* contentId, Any data, int dataCount, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, Any p7 )
+	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_UGC_UPDATE_CONTENT(const char* contentId, Any data, int dataCount, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, Any p7)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)DATAFILE::UGC_UPDATE_CONTENT(contentId, &data, dataCount, contentName, description, tagsCsv, contentTypeName, p7);
@@ -67,81 +67,81 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_UGC_UPDATE_MISSION( const char* contentId, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, Any p5 )
+	static bool LUA_NATIVE_DATAFILE_UGC_UPDATE_MISSION(const char* contentId, const char* contentName, const char* description, const char* tagsCsv, const char* contentTypeName, Any p5)
 	{
 		auto retval = (bool)DATAFILE::UGC_UPDATE_MISSION(contentId, contentName, description, tagsCsv, contentTypeName, p5);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_UGC_SET_PLAYER_DATA( const char* contentId, float rating, const char* contentTypeName, Any p3 )
+	static bool LUA_NATIVE_DATAFILE_UGC_SET_PLAYER_DATA(const char* contentId, float rating, const char* contentTypeName, Any p3)
 	{
 		auto retval = (bool)DATAFILE::UGC_SET_PLAYER_DATA(contentId, rating, contentTypeName, p3);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_DATA( int p0, Any p1 )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_DATA(int p0, Any p1)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_SELECT_UGC_DATA(p0, p1);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_STATS( int p0, bool p1, Any p2 )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_STATS(int p0, bool p1, Any p2)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_SELECT_UGC_STATS(p0, p1, p2);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_PLAYER_DATA( int p0, Any p1 )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_UGC_PLAYER_DATA(int p0, Any p1)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_SELECT_UGC_PLAYER_DATA(p0, p1);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_CREATOR_STATS( int p0, Any p1 )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_SELECT_CREATOR_STATS(int p0, Any p1)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_SELECT_CREATOR_STATS(p0, p1);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_LOAD_OFFLINE_UGC( const char* filename, Any p1 )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_LOAD_OFFLINE_UGC(const char* filename, Any p1)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_LOAD_OFFLINE_UGC(filename, p1);
 		return retval;
 	}
 
-	static void LUA_NATIVE_DATAFILE_DATAFILE_CREATE( int p0 )
+	static void LUA_NATIVE_DATAFILE_DATAFILE_CREATE(int p0)
 	{
 		DATAFILE::DATAFILE_CREATE(p0);
 	}
 
-	static void LUA_NATIVE_DATAFILE_DATAFILE_DELETE( int p0 )
+	static void LUA_NATIVE_DATAFILE_DATAFILE_DELETE(int p0)
 	{
 		DATAFILE::DATAFILE_DELETE(p0);
 	}
 
-	static void LUA_NATIVE_DATAFILE_DATAFILE_STORE_MISSION_HEADER( int p0 )
+	static void LUA_NATIVE_DATAFILE_DATAFILE_STORE_MISSION_HEADER(int p0)
 	{
 		DATAFILE::DATAFILE_STORE_MISSION_HEADER(p0);
 	}
 
-	static void LUA_NATIVE_DATAFILE_DATAFILE_FLUSH_MISSION_HEADER(  )
+	static void LUA_NATIVE_DATAFILE_DATAFILE_FLUSH_MISSION_HEADER()
 	{
 		DATAFILE::DATAFILE_FLUSH_MISSION_HEADER();
 	}
 
-	static Any* LUA_NATIVE_DATAFILE_DATAFILE_GET_FILE_DICT( int p0 )
+	static Any* LUA_NATIVE_DATAFILE_DATAFILE_GET_FILE_DICT(int p0)
 	{
 		auto retval = DATAFILE::DATAFILE_GET_FILE_DICT(p0);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_START_SAVE_TO_CLOUD( const char* filename, Any p1 )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_START_SAVE_TO_CLOUD(const char* filename, Any p1)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_START_SAVE_TO_CLOUD(filename, p1);
 		return retval;
 	}
 
-	static std::tuple<bool, bool> LUA_NATIVE_DATAFILE_DATAFILE_UPDATE_SAVE_TO_CLOUD( bool p0 )
+	static std::tuple<bool, bool> LUA_NATIVE_DATAFILE_DATAFILE_UPDATE_SAVE_TO_CLOUD(bool p0)
 	{
 		std::tuple<bool, bool> return_values;
 		std::get<0>(return_values) = (bool)DATAFILE::DATAFILE_UPDATE_SAVE_TO_CLOUD((BOOL*)&p0);
@@ -150,60 +150,60 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_IS_SAVE_PENDING(  )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_IS_SAVE_PENDING()
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_IS_SAVE_PENDING();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DATAFILE_DATAFILE_LOAD_OFFLINE_UGC_FOR_ADDITIONAL_DATA_FILE( Any p0, Any p1 )
+	static bool LUA_NATIVE_DATAFILE_DATAFILE_LOAD_OFFLINE_UGC_FOR_ADDITIONAL_DATA_FILE(Any p0, Any p1)
 	{
 		auto retval = (bool)DATAFILE::DATAFILE_LOAD_OFFLINE_UGC_FOR_ADDITIONAL_DATA_FILE(p0, p1);
 		return retval;
 	}
 
-	static void LUA_NATIVE_DATAFILE_DATAFILE_DELETE_FOR_ADDITIONAL_DATA_FILE( Any p0 )
+	static void LUA_NATIVE_DATAFILE_DATAFILE_DELETE_FOR_ADDITIONAL_DATA_FILE(Any p0)
 	{
 		DATAFILE::DATAFILE_DELETE_FOR_ADDITIONAL_DATA_FILE(p0);
 	}
 
-	static Any* LUA_NATIVE_DATAFILE_DATAFILE_GET_FILE_DICT_FOR_ADDITIONAL_DATA_FILE( Any p0 )
+	static Any* LUA_NATIVE_DATAFILE_DATAFILE_GET_FILE_DICT_FOR_ADDITIONAL_DATA_FILE(Any p0)
 	{
 		auto retval = DATAFILE::DATAFILE_GET_FILE_DICT_FOR_ADDITIONAL_DATA_FILE(p0);
 		return retval;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_BOOL( Any objectData, const char* key, bool value )
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_BOOL(Any objectData, const char* key, bool value)
 	{
 		DATAFILE::DATADICT_SET_BOOL(&objectData, key, value);
 		return objectData;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_INT( Any objectData, const char* key, int value )
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_INT(Any objectData, const char* key, int value)
 	{
 		DATAFILE::DATADICT_SET_INT(&objectData, key, value);
 		return objectData;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_FLOAT( Any objectData, const char* key, float value )
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_FLOAT(Any objectData, const char* key, float value)
 	{
 		DATAFILE::DATADICT_SET_FLOAT(&objectData, key, value);
 		return objectData;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_STRING( Any objectData, const char* key, const char* value )
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_STRING(Any objectData, const char* key, const char* value)
 	{
 		DATAFILE::DATADICT_SET_STRING(&objectData, key, value);
 		return objectData;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_VECTOR( Any objectData, const char* key, float valueX, float valueY, float valueZ )
+	static Any LUA_NATIVE_DATAFILE_DATADICT_SET_VECTOR(Any objectData, const char* key, float valueX, float valueY, float valueZ)
 	{
 		DATAFILE::DATADICT_SET_VECTOR(&objectData, key, valueX, valueY, valueZ);
 		return objectData;
 	}
 
-	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_CREATE_DICT( Any objectData, const char* key )
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_CREATE_DICT(Any objectData, const char* key)
 	{
 		std::tuple<Any*, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_CREATE_DICT(&objectData, key);
@@ -212,7 +212,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_CREATE_ARRAY( Any objectData, const char* key )
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_CREATE_ARRAY(Any objectData, const char* key)
 	{
 		std::tuple<Any*, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_CREATE_ARRAY(&objectData, key);
@@ -221,7 +221,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_BOOL( Any objectData, const char* key )
+	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_BOOL(Any objectData, const char* key)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)DATAFILE::DATADICT_GET_BOOL(&objectData, key);
@@ -230,7 +230,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_INT( Any objectData, const char* key )
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_INT(Any objectData, const char* key)
 	{
 		std::tuple<int, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_GET_INT(&objectData, key);
@@ -239,7 +239,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<float, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_FLOAT( Any objectData, const char* key )
+	static std::tuple<float, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_FLOAT(Any objectData, const char* key)
 	{
 		std::tuple<float, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_GET_FLOAT(&objectData, key);
@@ -248,7 +248,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<const char*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_STRING( Any objectData, const char* key )
+	static std::tuple<const char*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_STRING(Any objectData, const char* key)
 	{
 		std::tuple<const char*, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_GET_STRING(&objectData, key);
@@ -257,7 +257,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Vector3, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_VECTOR( Any objectData, const char* key )
+	static std::tuple<Vector3, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_VECTOR(Any objectData, const char* key)
 	{
 		std::tuple<Vector3, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_GET_VECTOR(&objectData, key);
@@ -266,7 +266,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_DICT( Any objectData, const char* key )
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_DICT(Any objectData, const char* key)
 	{
 		std::tuple<Any*, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_GET_DICT(&objectData, key);
@@ -275,7 +275,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_ARRAY( Any objectData, const char* key )
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_ARRAY(Any objectData, const char* key)
 	{
 		std::tuple<Any*, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_GET_ARRAY(&objectData, key);
@@ -284,7 +284,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_TYPE( Any objectData, const char* key )
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATADICT_GET_TYPE(Any objectData, const char* key)
 	{
 		std::tuple<int, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATADICT_GET_TYPE(&objectData, key);
@@ -293,37 +293,37 @@ namespace lua::native
 		return return_values;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_BOOL( Any arrayData, bool value )
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_BOOL(Any arrayData, bool value)
 	{
 		DATAFILE::DATAARRAY_ADD_BOOL(&arrayData, value);
 		return arrayData;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_INT( Any arrayData, int value )
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_INT(Any arrayData, int value)
 	{
 		DATAFILE::DATAARRAY_ADD_INT(&arrayData, value);
 		return arrayData;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_FLOAT( Any arrayData, float value )
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_FLOAT(Any arrayData, float value)
 	{
 		DATAFILE::DATAARRAY_ADD_FLOAT(&arrayData, value);
 		return arrayData;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_STRING( Any arrayData, const char* value )
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_STRING(Any arrayData, const char* value)
 	{
 		DATAFILE::DATAARRAY_ADD_STRING(&arrayData, value);
 		return arrayData;
 	}
 
-	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_VECTOR( Any arrayData, float valueX, float valueY, float valueZ )
+	static Any LUA_NATIVE_DATAFILE_DATAARRAY_ADD_VECTOR(Any arrayData, float valueX, float valueY, float valueZ)
 	{
 		DATAFILE::DATAARRAY_ADD_VECTOR(&arrayData, valueX, valueY, valueZ);
 		return arrayData;
 	}
 
-	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_ADD_DICT( Any arrayData )
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_ADD_DICT(Any arrayData)
 	{
 		std::tuple<Any*, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATAARRAY_ADD_DICT(&arrayData);
@@ -332,7 +332,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_BOOL( Any arrayData, int arrayIndex )
+	static std::tuple<bool, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_BOOL(Any arrayData, int arrayIndex)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)DATAFILE::DATAARRAY_GET_BOOL(&arrayData, arrayIndex);
@@ -341,7 +341,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_INT( Any arrayData, int arrayIndex )
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_INT(Any arrayData, int arrayIndex)
 	{
 		std::tuple<int, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_INT(&arrayData, arrayIndex);
@@ -350,7 +350,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<float, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_FLOAT( Any arrayData, int arrayIndex )
+	static std::tuple<float, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_FLOAT(Any arrayData, int arrayIndex)
 	{
 		std::tuple<float, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_FLOAT(&arrayData, arrayIndex);
@@ -359,7 +359,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<const char*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_STRING( Any arrayData, int arrayIndex )
+	static std::tuple<const char*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_STRING(Any arrayData, int arrayIndex)
 	{
 		std::tuple<const char*, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_STRING(&arrayData, arrayIndex);
@@ -368,7 +368,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Vector3, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_VECTOR( Any arrayData, int arrayIndex )
+	static std::tuple<Vector3, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_VECTOR(Any arrayData, int arrayIndex)
 	{
 		std::tuple<Vector3, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_VECTOR(&arrayData, arrayIndex);
@@ -377,7 +377,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_DICT( Any arrayData, int arrayIndex )
+	static std::tuple<Any*, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_DICT(Any arrayData, int arrayIndex)
 	{
 		std::tuple<Any*, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_DICT(&arrayData, arrayIndex);
@@ -386,7 +386,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_COUNT( Any arrayData )
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_COUNT(Any arrayData)
 	{
 		std::tuple<int, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_COUNT(&arrayData);
@@ -395,7 +395,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_TYPE( Any arrayData, int arrayIndex )
+	static std::tuple<int, Any> LUA_NATIVE_DATAFILE_DATAARRAY_GET_TYPE(Any arrayData, int arrayIndex)
 	{
 		std::tuple<int, Any> return_values;
 		std::get<0>(return_values) = DATAFILE::DATAARRAY_GET_TYPE(&arrayData, arrayIndex);

src/lua/natives/lua_native_binding_DECORATOR.cpp

@@ -3,72 +3,72 @@
 
 namespace lua::native
 {
-	static bool LUA_NATIVE_DECORATOR_DECOR_SET_TIME( Entity entity, const char* propertyName, int timestamp )
+	static bool LUA_NATIVE_DECORATOR_DECOR_SET_TIME(Entity entity, const char* propertyName, int timestamp)
 	{
 		auto retval = (bool)DECORATOR::DECOR_SET_TIME(entity, propertyName, timestamp);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DECORATOR_DECOR_SET_BOOL( Entity entity, const char* propertyName, bool value )
+	static bool LUA_NATIVE_DECORATOR_DECOR_SET_BOOL(Entity entity, const char* propertyName, bool value)
 	{
 		auto retval = (bool)DECORATOR::DECOR_SET_BOOL(entity, propertyName, value);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DECORATOR_DECOR_SET_FLOAT( Entity entity, const char* propertyName, float value )
+	static bool LUA_NATIVE_DECORATOR_DECOR_SET_FLOAT(Entity entity, const char* propertyName, float value)
 	{
 		auto retval = (bool)DECORATOR::DECOR_SET_FLOAT(entity, propertyName, value);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DECORATOR_DECOR_SET_INT( Entity entity, const char* propertyName, int value )
+	static bool LUA_NATIVE_DECORATOR_DECOR_SET_INT(Entity entity, const char* propertyName, int value)
 	{
 		auto retval = (bool)DECORATOR::DECOR_SET_INT(entity, propertyName, value);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DECORATOR_DECOR_GET_BOOL( Entity entity, const char* propertyName )
+	static bool LUA_NATIVE_DECORATOR_DECOR_GET_BOOL(Entity entity, const char* propertyName)
 	{
 		auto retval = (bool)DECORATOR::DECOR_GET_BOOL(entity, propertyName);
 		return retval;
 	}
 
-	static float LUA_NATIVE_DECORATOR_DECOR_GET_FLOAT( Entity entity, const char* propertyName )
+	static float LUA_NATIVE_DECORATOR_DECOR_GET_FLOAT(Entity entity, const char* propertyName)
 	{
 		auto retval = DECORATOR::DECOR_GET_FLOAT(entity, propertyName);
 		return retval;
 	}
 
-	static int LUA_NATIVE_DECORATOR_DECOR_GET_INT( Entity entity, const char* propertyName )
+	static int LUA_NATIVE_DECORATOR_DECOR_GET_INT(Entity entity, const char* propertyName)
 	{
 		auto retval = DECORATOR::DECOR_GET_INT(entity, propertyName);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DECORATOR_DECOR_EXIST_ON( Entity entity, const char* propertyName )
+	static bool LUA_NATIVE_DECORATOR_DECOR_EXIST_ON(Entity entity, const char* propertyName)
 	{
 		auto retval = (bool)DECORATOR::DECOR_EXIST_ON(entity, propertyName);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DECORATOR_DECOR_REMOVE( Entity entity, const char* propertyName )
+	static bool LUA_NATIVE_DECORATOR_DECOR_REMOVE(Entity entity, const char* propertyName)
 	{
 		auto retval = (bool)DECORATOR::DECOR_REMOVE(entity, propertyName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_DECORATOR_DECOR_REGISTER( const char* propertyName, int type )
+	static void LUA_NATIVE_DECORATOR_DECOR_REGISTER(const char* propertyName, int type)
 	{
 		DECORATOR::DECOR_REGISTER(propertyName, type);
 	}
 
-	static bool LUA_NATIVE_DECORATOR_DECOR_IS_REGISTERED_AS_TYPE( const char* propertyName, int type )
+	static bool LUA_NATIVE_DECORATOR_DECOR_IS_REGISTERED_AS_TYPE(const char* propertyName, int type)
 	{
 		auto retval = (bool)DECORATOR::DECOR_IS_REGISTERED_AS_TYPE(propertyName, type);
 		return retval;
 	}
 
-	static void LUA_NATIVE_DECORATOR_DECOR_REGISTER_LOCK(  )
+	static void LUA_NATIVE_DECORATOR_DECOR_REGISTER_LOCK()
 	{
 		DECORATOR::DECOR_REGISTER_LOCK();
 	}

src/lua/natives/lua_native_binding_DLC.cpp

@@ -3,55 +3,55 @@
 
 namespace lua::native
 {
-	static bool LUA_NATIVE_DLC_ARE_ANY_CCS_PENDING(  )
+	static bool LUA_NATIVE_DLC_ARE_ANY_CCS_PENDING()
 	{
 		auto retval = (bool)DLC::ARE_ANY_CCS_PENDING();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DLC_IS_DLC_PRESENT( Hash dlcHash )
+	static bool LUA_NATIVE_DLC_IS_DLC_PRESENT(Hash dlcHash)
 	{
 		auto retval = (bool)DLC::IS_DLC_PRESENT(dlcHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DLC_DLC_CHECK_CLOUD_DATA_CORRECT(  )
+	static bool LUA_NATIVE_DLC_DLC_CHECK_CLOUD_DATA_CORRECT()
 	{
 		auto retval = (bool)DLC::DLC_CHECK_CLOUD_DATA_CORRECT();
 		return retval;
 	}
 
-	static int LUA_NATIVE_DLC_GET_EXTRACONTENT_CLOUD_RESULT(  )
+	static int LUA_NATIVE_DLC_GET_EXTRACONTENT_CLOUD_RESULT()
 	{
 		auto retval = DLC::GET_EXTRACONTENT_CLOUD_RESULT();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DLC_DLC_CHECK_COMPAT_PACK_CONFIGURATION(  )
+	static bool LUA_NATIVE_DLC_DLC_CHECK_COMPAT_PACK_CONFIGURATION()
 	{
 		auto retval = (bool)DLC::DLC_CHECK_COMPAT_PACK_CONFIGURATION();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DLC_GET_EVER_HAD_BAD_PACK_ORDER(  )
+	static bool LUA_NATIVE_DLC_GET_EVER_HAD_BAD_PACK_ORDER()
 	{
 		auto retval = (bool)DLC::GET_EVER_HAD_BAD_PACK_ORDER();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DLC_GET_IS_LOADING_SCREEN_ACTIVE(  )
+	static bool LUA_NATIVE_DLC_GET_IS_LOADING_SCREEN_ACTIVE()
 	{
 		auto retval = (bool)DLC::GET_IS_LOADING_SCREEN_ACTIVE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_DLC_GET_IS_INITIAL_LOADING_SCREEN_ACTIVE(  )
+	static bool LUA_NATIVE_DLC_GET_IS_INITIAL_LOADING_SCREEN_ACTIVE()
 	{
 		auto retval = (bool)DLC::GET_IS_INITIAL_LOADING_SCREEN_ACTIVE();
 		return retval;
 	}
 
-	static std::tuple<bool, bool> LUA_NATIVE_DLC_HAS_CLOUD_REQUESTS_FINISHED( bool p0, int unused )
+	static std::tuple<bool, bool> LUA_NATIVE_DLC_HAS_CLOUD_REQUESTS_FINISHED(bool p0, int unused)
 	{
 		std::tuple<bool, bool> return_values;
 		std::get<0>(return_values) = (bool)DLC::HAS_CLOUD_REQUESTS_FINISHED((BOOL*)&p0, unused);
@@ -60,12 +60,12 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_DLC_ON_ENTER_SP(  )
+	static void LUA_NATIVE_DLC_ON_ENTER_SP()
 	{
 		DLC::ON_ENTER_SP();
 	}
 
-	static void LUA_NATIVE_DLC_ON_ENTER_MP(  )
+	static void LUA_NATIVE_DLC_ON_ENTER_MP()
 	{
 		DLC::ON_ENTER_MP();
 	}

src/lua/natives/lua_native_binding_EVENT.cpp

@@ -3,71 +3,71 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_EVENT_SET_DECISION_MAKER( Ped ped, Hash name )
+	static void LUA_NATIVE_EVENT_SET_DECISION_MAKER(Ped ped, Hash name)
 	{
 		EVENT::SET_DECISION_MAKER(ped, name);
 	}
 
-	static void LUA_NATIVE_EVENT_CLEAR_DECISION_MAKER_EVENT_RESPONSE( Hash name, int eventType )
+	static void LUA_NATIVE_EVENT_CLEAR_DECISION_MAKER_EVENT_RESPONSE(Hash name, int eventType)
 	{
 		EVENT::CLEAR_DECISION_MAKER_EVENT_RESPONSE(name, eventType);
 	}
 
-	static void LUA_NATIVE_EVENT_BLOCK_DECISION_MAKER_EVENT( Hash name, int eventType )
+	static void LUA_NATIVE_EVENT_BLOCK_DECISION_MAKER_EVENT(Hash name, int eventType)
 	{
 		EVENT::BLOCK_DECISION_MAKER_EVENT(name, eventType);
 	}
 
-	static void LUA_NATIVE_EVENT_UNBLOCK_DECISION_MAKER_EVENT( Hash name, int eventType )
+	static void LUA_NATIVE_EVENT_UNBLOCK_DECISION_MAKER_EVENT(Hash name, int eventType)
 	{
 		EVENT::UNBLOCK_DECISION_MAKER_EVENT(name, eventType);
 	}
 
-	static int LUA_NATIVE_EVENT_ADD_SHOCKING_EVENT_AT_POSITION( int eventType, float x, float y, float z, float duration )
+	static int LUA_NATIVE_EVENT_ADD_SHOCKING_EVENT_AT_POSITION(int eventType, float x, float y, float z, float duration)
 	{
 		auto retval = EVENT::ADD_SHOCKING_EVENT_AT_POSITION(eventType, x, y, z, duration);
 		return retval;
 	}
 
-	static int LUA_NATIVE_EVENT_ADD_SHOCKING_EVENT_FOR_ENTITY( int eventType, Entity entity, float duration )
+	static int LUA_NATIVE_EVENT_ADD_SHOCKING_EVENT_FOR_ENTITY(int eventType, Entity entity, float duration)
 	{
 		auto retval = EVENT::ADD_SHOCKING_EVENT_FOR_ENTITY(eventType, entity, duration);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_EVENT_IS_SHOCKING_EVENT_IN_SPHERE( int eventType, float x, float y, float z, float radius )
+	static bool LUA_NATIVE_EVENT_IS_SHOCKING_EVENT_IN_SPHERE(int eventType, float x, float y, float z, float radius)
 	{
 		auto retval = (bool)EVENT::IS_SHOCKING_EVENT_IN_SPHERE(eventType, x, y, z, radius);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_EVENT_REMOVE_SHOCKING_EVENT( ScrHandle event )
+	static bool LUA_NATIVE_EVENT_REMOVE_SHOCKING_EVENT(ScrHandle event)
 	{
 		auto retval = (bool)EVENT::REMOVE_SHOCKING_EVENT(event);
 		return retval;
 	}
 
-	static void LUA_NATIVE_EVENT_REMOVE_ALL_SHOCKING_EVENTS( bool p0 )
+	static void LUA_NATIVE_EVENT_REMOVE_ALL_SHOCKING_EVENTS(bool p0)
 	{
 		EVENT::REMOVE_ALL_SHOCKING_EVENTS(p0);
 	}
 
-	static void LUA_NATIVE_EVENT_REMOVE_SHOCKING_EVENT_SPAWN_BLOCKING_AREAS(  )
+	static void LUA_NATIVE_EVENT_REMOVE_SHOCKING_EVENT_SPAWN_BLOCKING_AREAS()
 	{
 		EVENT::REMOVE_SHOCKING_EVENT_SPAWN_BLOCKING_AREAS();
 	}
 
-	static void LUA_NATIVE_EVENT_SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME(  )
+	static void LUA_NATIVE_EVENT_SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME()
 	{
 		EVENT::SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME();
 	}
 
-	static void LUA_NATIVE_EVENT_SUPPRESS_SHOCKING_EVENT_TYPE_NEXT_FRAME( int eventType )
+	static void LUA_NATIVE_EVENT_SUPPRESS_SHOCKING_EVENT_TYPE_NEXT_FRAME(int eventType)
 	{
 		EVENT::SUPPRESS_SHOCKING_EVENT_TYPE_NEXT_FRAME(eventType);
 	}
 
-	static void LUA_NATIVE_EVENT_SUPPRESS_AGITATION_EVENTS_NEXT_FRAME(  )
+	static void LUA_NATIVE_EVENT_SUPPRESS_AGITATION_EVENTS_NEXT_FRAME()
 	{
 		EVENT::SUPPRESS_AGITATION_EVENTS_NEXT_FRAME();
 	}

src/lua/natives/lua_native_binding_FILES.cpp

@@ -3,13 +3,13 @@
 
 namespace lua::native
 {
-	static int LUA_NATIVE_FILES_GET_NUM_TATTOO_SHOP_DLC_ITEMS( int character )
+	static int LUA_NATIVE_FILES_GET_NUM_TATTOO_SHOP_DLC_ITEMS(int character)
 	{
 		auto retval = FILES::GET_NUM_TATTOO_SHOP_DLC_ITEMS(character);
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_TATTOO_SHOP_DLC_ITEM_DATA( int characterType, int decorationIndex, Any outComponent )
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_TATTOO_SHOP_DLC_ITEM_DATA(int characterType, int decorationIndex, Any outComponent)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)FILES::GET_TATTOO_SHOP_DLC_ITEM_DATA(characterType, decorationIndex, &outComponent);
@@ -18,97 +18,97 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_FILES_GET_TATTOO_SHOP_DLC_ITEM_INDEX( Hash overlayHash, Any p1, int character )
+	static int LUA_NATIVE_FILES_GET_TATTOO_SHOP_DLC_ITEM_INDEX(Hash overlayHash, Any p1, int character)
 	{
 		auto retval = FILES::GET_TATTOO_SHOP_DLC_ITEM_INDEX(overlayHash, p1, character);
 		return retval;
 	}
 
-	static Any LUA_NATIVE_FILES_INIT_SHOP_PED_COMPONENT( Any outComponent )
+	static Any LUA_NATIVE_FILES_INIT_SHOP_PED_COMPONENT(Any outComponent)
 	{
 		FILES::INIT_SHOP_PED_COMPONENT(&outComponent);
 		return outComponent;
 	}
 
-	static Any LUA_NATIVE_FILES_INIT_SHOP_PED_PROP( Any outProp )
+	static Any LUA_NATIVE_FILES_INIT_SHOP_PED_PROP(Any outProp)
 	{
 		FILES::INIT_SHOP_PED_PROP(&outProp);
 		return outProp;
 	}
 
-	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_APPAREL_QUERY( int p0, int p1, int p2, int p3 )
+	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_APPAREL_QUERY(int p0, int p1, int p2, int p3)
 	{
 		auto retval = FILES::SETUP_SHOP_PED_APPAREL_QUERY(p0, p1, p2, p3);
 		return retval;
 	}
 
-	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_APPAREL_QUERY_TU( int character, int p1, int p2, bool p3, int p4, int componentId )
+	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_APPAREL_QUERY_TU(int character, int p1, int p2, bool p3, int p4, int componentId)
 	{
 		auto retval = FILES::SETUP_SHOP_PED_APPAREL_QUERY_TU(character, p1, p2, p3, p4, componentId);
 		return retval;
 	}
 
-	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_COMPONENT( int componentId, Any outComponent )
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_COMPONENT(int componentId, Any outComponent)
 	{
 		FILES::GET_SHOP_PED_QUERY_COMPONENT(componentId, &outComponent);
 		return outComponent;
 	}
 
-	static int LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_COMPONENT_INDEX( Hash componentHash )
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_COMPONENT_INDEX(Hash componentHash)
 	{
 		auto retval = FILES::GET_SHOP_PED_QUERY_COMPONENT_INDEX(componentHash);
 		return retval;
 	}
 
-	static Any LUA_NATIVE_FILES_GET_SHOP_PED_COMPONENT( Hash componentHash, Any outComponent )
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_COMPONENT(Hash componentHash, Any outComponent)
 	{
 		FILES::GET_SHOP_PED_COMPONENT(componentHash, &outComponent);
 		return outComponent;
 	}
 
-	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_PROP( int componentId, Any outProp )
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_PROP(int componentId, Any outProp)
 	{
 		FILES::GET_SHOP_PED_QUERY_PROP(componentId, &outProp);
 		return outProp;
 	}
 
-	static int LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_PROP_INDEX( Hash componentHash )
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_PROP_INDEX(Hash componentHash)
 	{
 		auto retval = FILES::GET_SHOP_PED_QUERY_PROP_INDEX(componentHash);
 		return retval;
 	}
 
-	static Any LUA_NATIVE_FILES_GET_SHOP_PED_PROP( Hash componentHash, Any outProp )
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_PROP(Hash componentHash, Any outProp)
 	{
 		FILES::GET_SHOP_PED_PROP(componentHash, &outProp);
 		return outProp;
 	}
 
-	static Hash LUA_NATIVE_FILES_GET_HASH_NAME_FOR_COMPONENT( Entity entity, int componentId, int drawableVariant, int textureVariant )
+	static Hash LUA_NATIVE_FILES_GET_HASH_NAME_FOR_COMPONENT(Entity entity, int componentId, int drawableVariant, int textureVariant)
 	{
 		auto retval = FILES::GET_HASH_NAME_FOR_COMPONENT(entity, componentId, drawableVariant, textureVariant);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_FILES_GET_HASH_NAME_FOR_PROP( Entity entity, int componentId, int propIndex, int propTextureIndex )
+	static Hash LUA_NATIVE_FILES_GET_HASH_NAME_FOR_PROP(Entity entity, int componentId, int propIndex, int propTextureIndex)
 	{
 		auto retval = FILES::GET_HASH_NAME_FOR_PROP(entity, componentId, propIndex, propTextureIndex);
 		return retval;
 	}
 
-	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_VARIANT_COMPONENT_COUNT( Hash componentHash )
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_VARIANT_COMPONENT_COUNT(Hash componentHash)
 	{
 		auto retval = FILES::GET_SHOP_PED_APPAREL_VARIANT_COMPONENT_COUNT(componentHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_VARIANT_PROP_COUNT( Hash propHash )
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_VARIANT_PROP_COUNT(Hash propHash)
 	{
 		auto retval = FILES::GET_SHOP_PED_APPAREL_VARIANT_PROP_COUNT(propHash);
 		return retval;
 	}
 
-	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_VARIANT_COMPONENT( Hash componentHash, int variantComponentIndex, Hash nameHash, int enumValue, int componentType )
+	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_VARIANT_COMPONENT(Hash componentHash, int variantComponentIndex, Hash nameHash, int enumValue, int componentType)
 	{
 		std::tuple<Hash, int, int> return_values;
 		FILES::GET_VARIANT_COMPONENT(componentHash, variantComponentIndex, &nameHash, &enumValue, &componentType);
@@ -119,7 +119,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_VARIANT_PROP( Hash componentHash, int variantPropIndex, Hash nameHash, int enumValue, int anchorPoint )
+	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_VARIANT_PROP(Hash componentHash, int variantPropIndex, Hash nameHash, int enumValue, int anchorPoint)
 	{
 		std::tuple<Hash, int, int> return_values;
 		FILES::GET_VARIANT_PROP(componentHash, variantPropIndex, &nameHash, &enumValue, &anchorPoint);
@@ -130,19 +130,19 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_FORCED_COMPONENT_COUNT( Hash componentHash )
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_FORCED_COMPONENT_COUNT(Hash componentHash)
 	{
 		auto retval = FILES::GET_SHOP_PED_APPAREL_FORCED_COMPONENT_COUNT(componentHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_FORCED_PROP_COUNT( Hash componentHash )
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_APPAREL_FORCED_PROP_COUNT(Hash componentHash)
 	{
 		auto retval = FILES::GET_SHOP_PED_APPAREL_FORCED_PROP_COUNT(componentHash);
 		return retval;
 	}
 
-	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_FORCED_COMPONENT( Hash componentHash, int forcedComponentIndex, Hash nameHash, int enumValue, int componentType )
+	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_FORCED_COMPONENT(Hash componentHash, int forcedComponentIndex, Hash nameHash, int enumValue, int componentType)
 	{
 		std::tuple<Hash, int, int> return_values;
 		FILES::GET_FORCED_COMPONENT(componentHash, forcedComponentIndex, &nameHash, &enumValue, &componentType);
@@ -153,7 +153,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_FORCED_PROP( Hash componentHash, int forcedPropIndex, Hash nameHash, int enumValue, int anchorPoint )
+	static std::tuple<Hash, int, int> LUA_NATIVE_FILES_GET_FORCED_PROP(Hash componentHash, int forcedPropIndex, Hash nameHash, int enumValue, int anchorPoint)
 	{
 		std::tuple<Hash, int, int> return_values;
 		FILES::GET_FORCED_PROP(componentHash, forcedPropIndex, &nameHash, &enumValue, &anchorPoint);
@@ -164,49 +164,49 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_FILES_DOES_SHOP_PED_APPAREL_HAVE_RESTRICTION_TAG( Hash componentHash, Hash restrictionTagHash, int componentId )
+	static bool LUA_NATIVE_FILES_DOES_SHOP_PED_APPAREL_HAVE_RESTRICTION_TAG(Hash componentHash, Hash restrictionTagHash, int componentId)
 	{
 		auto retval = (bool)FILES::DOES_SHOP_PED_APPAREL_HAVE_RESTRICTION_TAG(componentHash, restrictionTagHash, componentId);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_FILES_DOES_CURRENT_PED_COMPONENT_HAVE_RESTRICTION_TAG( Ped ped, int componentId, Hash restrictionTagHash )
+	static bool LUA_NATIVE_FILES_DOES_CURRENT_PED_COMPONENT_HAVE_RESTRICTION_TAG(Ped ped, int componentId, Hash restrictionTagHash)
 	{
 		auto retval = (bool)FILES::DOES_CURRENT_PED_COMPONENT_HAVE_RESTRICTION_TAG(ped, componentId, restrictionTagHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_FILES_DOES_CURRENT_PED_PROP_HAVE_RESTRICTION_TAG( Ped ped, int componentId, Hash restrictionTagHash )
+	static bool LUA_NATIVE_FILES_DOES_CURRENT_PED_PROP_HAVE_RESTRICTION_TAG(Ped ped, int componentId, Hash restrictionTagHash)
 	{
 		auto retval = (bool)FILES::DOES_CURRENT_PED_PROP_HAVE_RESTRICTION_TAG(ped, componentId, restrictionTagHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_OUTFIT_QUERY( int character, bool p1 )
+	static int LUA_NATIVE_FILES_SETUP_SHOP_PED_OUTFIT_QUERY(int character, bool p1)
 	{
 		auto retval = FILES::SETUP_SHOP_PED_OUTFIT_QUERY(character, p1);
 		return retval;
 	}
 
-	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_OUTFIT( int outfitIndex, Any outfit )
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_QUERY_OUTFIT(int outfitIndex, Any outfit)
 	{
 		FILES::GET_SHOP_PED_QUERY_OUTFIT(outfitIndex, &outfit);
 		return outfit;
 	}
 
-	static Any LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT( Any p0, Any p1 )
+	static Any LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT(Any p0, Any p1)
 	{
 		FILES::GET_SHOP_PED_OUTFIT(p0, &p1);
 		return p1;
 	}
 
-	static int LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_LOCATE( Any p0 )
+	static int LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_LOCATE(Any p0)
 	{
 		auto retval = FILES::GET_SHOP_PED_OUTFIT_LOCATE(p0);
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_PROP_VARIANT( Hash outfitHash, int variantIndex, Any outPropVariant )
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_PROP_VARIANT(Hash outfitHash, int variantIndex, Any outPropVariant)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)FILES::GET_SHOP_PED_OUTFIT_PROP_VARIANT(outfitHash, variantIndex, &outPropVariant);
@@ -215,7 +215,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_COMPONENT_VARIANT( Hash outfitHash, int variantIndex, Any outComponentVariant )
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_SHOP_PED_OUTFIT_COMPONENT_VARIANT(Hash outfitHash, int variantIndex, Any outComponentVariant)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)FILES::GET_SHOP_PED_OUTFIT_COMPONENT_VARIANT(outfitHash, variantIndex, &outComponentVariant);
@@ -224,19 +224,19 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_FILES_GET_NUM_DLC_VEHICLES(  )
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_VEHICLES()
 	{
 		auto retval = FILES::GET_NUM_DLC_VEHICLES();
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_FILES_GET_DLC_VEHICLE_MODEL( int dlcVehicleIndex )
+	static Hash LUA_NATIVE_FILES_GET_DLC_VEHICLE_MODEL(int dlcVehicleIndex)
 	{
 		auto retval = FILES::GET_DLC_VEHICLE_MODEL(dlcVehicleIndex);
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_VEHICLE_DATA( int dlcVehicleIndex, Any outData )
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_VEHICLE_DATA(int dlcVehicleIndex, Any outData)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)FILES::GET_DLC_VEHICLE_DATA(dlcVehicleIndex, &outData);
@@ -245,25 +245,25 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_FILES_GET_DLC_VEHICLE_FLAGS( int dlcVehicleIndex )
+	static int LUA_NATIVE_FILES_GET_DLC_VEHICLE_FLAGS(int dlcVehicleIndex)
 	{
 		auto retval = FILES::GET_DLC_VEHICLE_FLAGS(dlcVehicleIndex);
 		return retval;
 	}
 
-	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPONS(  )
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPONS()
 	{
 		auto retval = FILES::GET_NUM_DLC_WEAPONS();
 		return retval;
 	}
 
-	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPONS_SP(  )
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPONS_SP()
 	{
 		auto retval = FILES::GET_NUM_DLC_WEAPONS_SP();
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_DATA( int dlcWeaponIndex, Any outData )
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_DATA(int dlcWeaponIndex, Any outData)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)FILES::GET_DLC_WEAPON_DATA(dlcWeaponIndex, &outData);
@@ -272,7 +272,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_DATA_SP( int dlcWeaponIndex, Any outData )
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_DATA_SP(int dlcWeaponIndex, Any outData)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)FILES::GET_DLC_WEAPON_DATA_SP(dlcWeaponIndex, &outData);
@@ -281,19 +281,19 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPON_COMPONENTS( int dlcWeaponIndex )
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPON_COMPONENTS(int dlcWeaponIndex)
 	{
 		auto retval = FILES::GET_NUM_DLC_WEAPON_COMPONENTS(dlcWeaponIndex);
 		return retval;
 	}
 
-	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPON_COMPONENTS_SP( int dlcWeaponIndex )
+	static int LUA_NATIVE_FILES_GET_NUM_DLC_WEAPON_COMPONENTS_SP(int dlcWeaponIndex)
 	{
 		auto retval = FILES::GET_NUM_DLC_WEAPON_COMPONENTS_SP(dlcWeaponIndex);
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_COMPONENT_DATA( int dlcWeaponIndex, int dlcWeapCompIndex, Any ComponentDataPtr )
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_COMPONENT_DATA(int dlcWeaponIndex, int dlcWeapCompIndex, Any ComponentDataPtr)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)FILES::GET_DLC_WEAPON_COMPONENT_DATA(dlcWeaponIndex, dlcWeapCompIndex, &ComponentDataPtr);
@@ -302,7 +302,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_COMPONENT_DATA_SP( int dlcWeaponIndex, int dlcWeapCompIndex, Any ComponentDataPtr )
+	static std::tuple<bool, Any> LUA_NATIVE_FILES_GET_DLC_WEAPON_COMPONENT_DATA_SP(int dlcWeaponIndex, int dlcWeapCompIndex, Any ComponentDataPtr)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)FILES::GET_DLC_WEAPON_COMPONENT_DATA_SP(dlcWeaponIndex, dlcWeapCompIndex, &ComponentDataPtr);
@@ -311,30 +311,30 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_FILES_IS_CONTENT_ITEM_LOCKED( Hash itemHash )
+	static bool LUA_NATIVE_FILES_IS_CONTENT_ITEM_LOCKED(Hash itemHash)
 	{
 		auto retval = (bool)FILES::IS_CONTENT_ITEM_LOCKED(itemHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_FILES_IS_DLC_VEHICLE_MOD( Hash hash )
+	static bool LUA_NATIVE_FILES_IS_DLC_VEHICLE_MOD(Hash hash)
 	{
 		auto retval = (bool)FILES::IS_DLC_VEHICLE_MOD(hash);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_FILES_GET_DLC_VEHICLE_MOD_LOCK_HASH( Hash hash )
+	static Hash LUA_NATIVE_FILES_GET_DLC_VEHICLE_MOD_LOCK_HASH(Hash hash)
 	{
 		auto retval = FILES::GET_DLC_VEHICLE_MOD_LOCK_HASH(hash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_FILES_EXECUTE_CONTENT_CHANGESET_GROUP_FOR_ALL( Hash hash )
+	static void LUA_NATIVE_FILES_EXECUTE_CONTENT_CHANGESET_GROUP_FOR_ALL(Hash hash)
 	{
 		FILES::EXECUTE_CONTENT_CHANGESET_GROUP_FOR_ALL(hash);
 	}
 
-	static void LUA_NATIVE_FILES_REVERT_CONTENT_CHANGESET_GROUP_FOR_ALL( Hash hash )
+	static void LUA_NATIVE_FILES_REVERT_CONTENT_CHANGESET_GROUP_FOR_ALL(Hash hash)
 	{
 		FILES::REVERT_CONTENT_CHANGESET_GROUP_FOR_ALL(hash);
 	}

src/lua/natives/lua_native_binding_FIRE.cpp

@@ -3,51 +3,51 @@
 
 namespace lua::native
 {
-	static FireId LUA_NATIVE_FIRE_START_SCRIPT_FIRE( float X, float Y, float Z, int maxChildren, bool isGasFire )
+	static FireId LUA_NATIVE_FIRE_START_SCRIPT_FIRE(float X, float Y, float Z, int maxChildren, bool isGasFire)
 	{
 		auto retval = FIRE::START_SCRIPT_FIRE(X, Y, Z, maxChildren, isGasFire);
 		return retval;
 	}
 
-	static void LUA_NATIVE_FIRE_REMOVE_SCRIPT_FIRE( FireId fireHandle )
+	static void LUA_NATIVE_FIRE_REMOVE_SCRIPT_FIRE(FireId fireHandle)
 	{
 		FIRE::REMOVE_SCRIPT_FIRE(fireHandle);
 	}
 
-	static FireId LUA_NATIVE_FIRE_START_ENTITY_FIRE( Entity entity )
+	static FireId LUA_NATIVE_FIRE_START_ENTITY_FIRE(Entity entity)
 	{
 		auto retval = FIRE::START_ENTITY_FIRE(entity);
 		return retval;
 	}
 
-	static void LUA_NATIVE_FIRE_STOP_ENTITY_FIRE( Entity entity )
+	static void LUA_NATIVE_FIRE_STOP_ENTITY_FIRE(Entity entity)
 	{
 		FIRE::STOP_ENTITY_FIRE(entity);
 	}
 
-	static bool LUA_NATIVE_FIRE_IS_ENTITY_ON_FIRE( Entity entity )
+	static bool LUA_NATIVE_FIRE_IS_ENTITY_ON_FIRE(Entity entity)
 	{
 		auto retval = (bool)FIRE::IS_ENTITY_ON_FIRE(entity);
 		return retval;
 	}
 
-	static int LUA_NATIVE_FIRE_GET_NUMBER_OF_FIRES_IN_RANGE( float x, float y, float z, float radius )
+	static int LUA_NATIVE_FIRE_GET_NUMBER_OF_FIRES_IN_RANGE(float x, float y, float z, float radius)
 	{
 		auto retval = FIRE::GET_NUMBER_OF_FIRES_IN_RANGE(x, y, z, radius);
 		return retval;
 	}
 
-	static void LUA_NATIVE_FIRE_SET_FLAMMABILITY_MULTIPLIER( float p0 )
+	static void LUA_NATIVE_FIRE_SET_FLAMMABILITY_MULTIPLIER(float p0)
 	{
 		FIRE::SET_FLAMMABILITY_MULTIPLIER(p0);
 	}
 
-	static void LUA_NATIVE_FIRE_STOP_FIRE_IN_RANGE( float x, float y, float z, float radius )
+	static void LUA_NATIVE_FIRE_STOP_FIRE_IN_RANGE(float x, float y, float z, float radius)
 	{
 		FIRE::STOP_FIRE_IN_RANGE(x, y, z, radius);
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_FIRE_GET_CLOSEST_FIRE_POS( Vector3 outPosition, float x, float y, float z )
+	static std::tuple<bool, Vector3> LUA_NATIVE_FIRE_GET_CLOSEST_FIRE_POS(Vector3 outPosition, float x, float y, float z)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)FIRE::GET_CLOSEST_FIRE_POS(&outPosition, x, y, z);
@@ -56,52 +56,52 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_FIRE_ADD_EXPLOSION( float x, float y, float z, int explosionType, float damageScale, bool isAudible, bool isInvisible, float cameraShake, bool noDamage )
+	static void LUA_NATIVE_FIRE_ADD_EXPLOSION(float x, float y, float z, int explosionType, float damageScale, bool isAudible, bool isInvisible, float cameraShake, bool noDamage)
 	{
 		FIRE::ADD_EXPLOSION(x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake, noDamage);
 	}
 
-	static void LUA_NATIVE_FIRE_ADD_OWNED_EXPLOSION( Ped ped, float x, float y, float z, int explosionType, float damageScale, bool isAudible, bool isInvisible, float cameraShake )
+	static void LUA_NATIVE_FIRE_ADD_OWNED_EXPLOSION(Ped ped, float x, float y, float z, int explosionType, float damageScale, bool isAudible, bool isInvisible, float cameraShake)
 	{
 		FIRE::ADD_OWNED_EXPLOSION(ped, x, y, z, explosionType, damageScale, isAudible, isInvisible, cameraShake);
 	}
 
-	static void LUA_NATIVE_FIRE_ADD_EXPLOSION_WITH_USER_VFX( float x, float y, float z, int explosionType, Hash explosionFx, float damageScale, bool isAudible, bool isInvisible, float cameraShake )
+	static void LUA_NATIVE_FIRE_ADD_EXPLOSION_WITH_USER_VFX(float x, float y, float z, int explosionType, Hash explosionFx, float damageScale, bool isAudible, bool isInvisible, float cameraShake)
 	{
 		FIRE::ADD_EXPLOSION_WITH_USER_VFX(x, y, z, explosionType, explosionFx, damageScale, isAudible, isInvisible, cameraShake);
 	}
 
-	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_AREA( int explosionType, float x1, float y1, float z1, float x2, float y2, float z2 )
+	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_AREA(int explosionType, float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		auto retval = (bool)FIRE::IS_EXPLOSION_IN_AREA(explosionType, x1, y1, z1, x2, y2, z2);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_ACTIVE_IN_AREA( int explosionType, float x1, float y1, float z1, float x2, float y2, float z2 )
+	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_ACTIVE_IN_AREA(int explosionType, float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		auto retval = (bool)FIRE::IS_EXPLOSION_ACTIVE_IN_AREA(explosionType, x1, y1, z1, x2, y2, z2);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_SPHERE( int explosionType, float x, float y, float z, float radius )
+	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_SPHERE(int explosionType, float x, float y, float z, float radius)
 	{
 		auto retval = (bool)FIRE::IS_EXPLOSION_IN_SPHERE(explosionType, x, y, z, radius);
 		return retval;
 	}
 
-	static Entity LUA_NATIVE_FIRE_GET_OWNER_OF_EXPLOSION_IN_SPHERE( int explosionType, float x, float y, float z, float radius )
+	static Entity LUA_NATIVE_FIRE_GET_OWNER_OF_EXPLOSION_IN_SPHERE(int explosionType, float x, float y, float z, float radius)
 	{
 		auto retval = FIRE::GET_OWNER_OF_EXPLOSION_IN_SPHERE(explosionType, x, y, z, radius);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_ANGLED_AREA( int explosionType, float x1, float y1, float z1, float x2, float y2, float z2, float width )
+	static bool LUA_NATIVE_FIRE_IS_EXPLOSION_IN_ANGLED_AREA(int explosionType, float x1, float y1, float z1, float x2, float y2, float z2, float width)
 	{
 		auto retval = (bool)FIRE::IS_EXPLOSION_IN_ANGLED_AREA(explosionType, x1, y1, z1, x2, y2, z2, width);
 		return retval;
 	}
 
-	static Entity LUA_NATIVE_FIRE_GET_OWNER_OF_EXPLOSION_IN_ANGLED_AREA( int explosionType, float x1, float y1, float z1, float x2, float y2, float z2, float radius )
+	static Entity LUA_NATIVE_FIRE_GET_OWNER_OF_EXPLOSION_IN_ANGLED_AREA(int explosionType, float x1, float y1, float z1, float x2, float y2, float z2, float radius)
 	{
 		auto retval = FIRE::GET_OWNER_OF_EXPLOSION_IN_ANGLED_AREA(explosionType, x1, y1, z1, x2, y2, z2, radius);
 		return retval;

src/lua/natives/lua_native_binding_INTERIOR.cpp

@@ -3,13 +3,13 @@
 
 namespace lua::native
 {
-	static float LUA_NATIVE_INTERIOR_GET_INTERIOR_HEADING( Interior interior )
+	static float LUA_NATIVE_INTERIOR_GET_INTERIOR_HEADING(Interior interior)
 	{
 		auto retval = INTERIOR::GET_INTERIOR_HEADING(interior);
 		return retval;
 	}
 
-	static std::tuple<Vector3, Hash> LUA_NATIVE_INTERIOR_GET_INTERIOR_LOCATION_AND_NAMEHASH( Interior interior, Vector3 position, Hash nameHash )
+	static std::tuple<Vector3, Hash> LUA_NATIVE_INTERIOR_GET_INTERIOR_LOCATION_AND_NAMEHASH(Interior interior, Vector3 position, Hash nameHash)
 	{
 		std::tuple<Vector3, Hash> return_values;
 		INTERIOR::GET_INTERIOR_LOCATION_AND_NAMEHASH(interior, &position, &nameHash);
@@ -19,236 +19,236 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_INTERIOR_GET_INTERIOR_GROUP_ID( Interior interior )
+	static int LUA_NATIVE_INTERIOR_GET_INTERIOR_GROUP_ID(Interior interior)
 	{
 		auto retval = INTERIOR::GET_INTERIOR_GROUP_ID(interior);
 		return retval;
 	}
 
-	static Vector3 LUA_NATIVE_INTERIOR_GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS( Interior interior, float x, float y, float z )
+	static Vector3 LUA_NATIVE_INTERIOR_GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS(Interior interior, float x, float y, float z)
 	{
 		auto retval = INTERIOR::GET_OFFSET_FROM_INTERIOR_IN_WORLD_COORDS(interior, x, y, z);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_SCENE(  )
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_SCENE()
 	{
 		auto retval = (bool)INTERIOR::IS_INTERIOR_SCENE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_INTERIOR_IS_VALID_INTERIOR( Interior interior )
+	static bool LUA_NATIVE_INTERIOR_IS_VALID_INTERIOR(Interior interior)
 	{
 		auto retval = (bool)INTERIOR::IS_VALID_INTERIOR(interior);
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_CLEAR_ROOM_FOR_ENTITY( Entity entity )
+	static void LUA_NATIVE_INTERIOR_CLEAR_ROOM_FOR_ENTITY(Entity entity)
 	{
 		INTERIOR::CLEAR_ROOM_FOR_ENTITY(entity);
 	}
 
-	static void LUA_NATIVE_INTERIOR_FORCE_ROOM_FOR_ENTITY( Entity entity, Interior interior, Hash roomHashKey )
+	static void LUA_NATIVE_INTERIOR_FORCE_ROOM_FOR_ENTITY(Entity entity, Interior interior, Hash roomHashKey)
 	{
 		INTERIOR::FORCE_ROOM_FOR_ENTITY(entity, interior, roomHashKey);
 	}
 
-	static Hash LUA_NATIVE_INTERIOR_GET_ROOM_KEY_FROM_ENTITY( Entity entity )
+	static Hash LUA_NATIVE_INTERIOR_GET_ROOM_KEY_FROM_ENTITY(Entity entity)
 	{
 		auto retval = INTERIOR::GET_ROOM_KEY_FROM_ENTITY(entity);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_INTERIOR_GET_KEY_FOR_ENTITY_IN_ROOM( Entity entity )
+	static Hash LUA_NATIVE_INTERIOR_GET_KEY_FOR_ENTITY_IN_ROOM(Entity entity)
 	{
 		auto retval = INTERIOR::GET_KEY_FOR_ENTITY_IN_ROOM(entity);
 		return retval;
 	}
 
-	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_ENTITY( Entity entity )
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_ENTITY(Entity entity)
 	{
 		auto retval = INTERIOR::GET_INTERIOR_FROM_ENTITY(entity);
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_RETAIN_ENTITY_IN_INTERIOR( Entity entity, Interior interior )
+	static void LUA_NATIVE_INTERIOR_RETAIN_ENTITY_IN_INTERIOR(Entity entity, Interior interior)
 	{
 		INTERIOR::RETAIN_ENTITY_IN_INTERIOR(entity, interior);
 	}
 
-	static void LUA_NATIVE_INTERIOR_CLEAR_INTERIOR_STATE_OF_ENTITY( Entity entity )
+	static void LUA_NATIVE_INTERIOR_CLEAR_INTERIOR_STATE_OF_ENTITY(Entity entity)
 	{
 		INTERIOR::CLEAR_INTERIOR_STATE_OF_ENTITY(entity);
 	}
 
-	static void LUA_NATIVE_INTERIOR_FORCE_ACTIVATING_TRACKING_ON_ENTITY( Any p0, Any p1 )
+	static void LUA_NATIVE_INTERIOR_FORCE_ACTIVATING_TRACKING_ON_ENTITY(Any p0, Any p1)
 	{
 		INTERIOR::FORCE_ACTIVATING_TRACKING_ON_ENTITY(p0, p1);
 	}
 
-	static void LUA_NATIVE_INTERIOR_FORCE_ROOM_FOR_GAME_VIEWPORT( int interiorID, Hash roomHashKey )
+	static void LUA_NATIVE_INTERIOR_FORCE_ROOM_FOR_GAME_VIEWPORT(int interiorID, Hash roomHashKey)
 	{
 		INTERIOR::FORCE_ROOM_FOR_GAME_VIEWPORT(interiorID, roomHashKey);
 	}
 
-	static void LUA_NATIVE_INTERIOR_SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME( const char* roomName )
+	static void LUA_NATIVE_INTERIOR_SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME(const char* roomName)
 	{
 		INTERIOR::SET_ROOM_FOR_GAME_VIEWPORT_BY_NAME(roomName);
 	}
 
-	static void LUA_NATIVE_INTERIOR_SET_ROOM_FOR_GAME_VIEWPORT_BY_KEY( Hash roomHashKey )
+	static void LUA_NATIVE_INTERIOR_SET_ROOM_FOR_GAME_VIEWPORT_BY_KEY(Hash roomHashKey)
 	{
 		INTERIOR::SET_ROOM_FOR_GAME_VIEWPORT_BY_KEY(roomHashKey);
 	}
 
-	static Hash LUA_NATIVE_INTERIOR_GET_ROOM_KEY_FOR_GAME_VIEWPORT(  )
+	static Hash LUA_NATIVE_INTERIOR_GET_ROOM_KEY_FOR_GAME_VIEWPORT()
 	{
 		auto retval = INTERIOR::GET_ROOM_KEY_FOR_GAME_VIEWPORT();
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_CLEAR_ROOM_FOR_GAME_VIEWPORT(  )
+	static void LUA_NATIVE_INTERIOR_CLEAR_ROOM_FOR_GAME_VIEWPORT()
 	{
 		INTERIOR::CLEAR_ROOM_FOR_GAME_VIEWPORT();
 	}
 
-	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_PRIMARY_VIEW(  )
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_PRIMARY_VIEW()
 	{
 		auto retval = INTERIOR::GET_INTERIOR_FROM_PRIMARY_VIEW();
 		return retval;
 	}
 
-	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS( float x, float y, float z )
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS(float x, float y, float z)
 	{
 		auto retval = INTERIOR::GET_INTERIOR_AT_COORDS(x, y, z);
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_ADD_PICKUP_TO_INTERIOR_ROOM_BY_NAME( Pickup pickup, const char* roomName )
+	static void LUA_NATIVE_INTERIOR_ADD_PICKUP_TO_INTERIOR_ROOM_BY_NAME(Pickup pickup, const char* roomName)
 	{
 		INTERIOR::ADD_PICKUP_TO_INTERIOR_ROOM_BY_NAME(pickup, roomName);
 	}
 
-	static void LUA_NATIVE_INTERIOR_PIN_INTERIOR_IN_MEMORY( Interior interior )
+	static void LUA_NATIVE_INTERIOR_PIN_INTERIOR_IN_MEMORY(Interior interior)
 	{
 		INTERIOR::PIN_INTERIOR_IN_MEMORY(interior);
 	}
 
-	static void LUA_NATIVE_INTERIOR_UNPIN_INTERIOR( Interior interior )
+	static void LUA_NATIVE_INTERIOR_UNPIN_INTERIOR(Interior interior)
 	{
 		INTERIOR::UNPIN_INTERIOR(interior);
 	}
 
-	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_READY( Interior interior )
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_READY(Interior interior)
 	{
 		auto retval = (bool)INTERIOR::IS_INTERIOR_READY(interior);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_INTERIOR_SET_INTERIOR_IN_USE( Interior interior )
+	static bool LUA_NATIVE_INTERIOR_SET_INTERIOR_IN_USE(Interior interior)
 	{
 		auto retval = (bool)INTERIOR::SET_INTERIOR_IN_USE(interior);
 		return retval;
 	}
 
-	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS_WITH_TYPE( float x, float y, float z, const char* interiorType )
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS_WITH_TYPE(float x, float y, float z, const char* interiorType)
 	{
 		auto retval = INTERIOR::GET_INTERIOR_AT_COORDS_WITH_TYPE(x, y, z, interiorType);
 		return retval;
 	}
 
-	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS_WITH_TYPEHASH( float x, float y, float z, Hash typeHash )
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_AT_COORDS_WITH_TYPEHASH(float x, float y, float z, Hash typeHash)
 	{
 		auto retval = INTERIOR::GET_INTERIOR_AT_COORDS_WITH_TYPEHASH(x, y, z, typeHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_ACTIVATE_INTERIOR_GROUPS_USING_CAMERA(  )
+	static void LUA_NATIVE_INTERIOR_ACTIVATE_INTERIOR_GROUPS_USING_CAMERA()
 	{
 		INTERIOR::ACTIVATE_INTERIOR_GROUPS_USING_CAMERA();
 	}
 
-	static bool LUA_NATIVE_INTERIOR_IS_COLLISION_MARKED_OUTSIDE( float x, float y, float z )
+	static bool LUA_NATIVE_INTERIOR_IS_COLLISION_MARKED_OUTSIDE(float x, float y, float z)
 	{
 		auto retval = (bool)INTERIOR::IS_COLLISION_MARKED_OUTSIDE(x, y, z);
 		return retval;
 	}
 
-	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_COLLISION( float x, float y, float z )
+	static Interior LUA_NATIVE_INTERIOR_GET_INTERIOR_FROM_COLLISION(float x, float y, float z)
 	{
 		auto retval = INTERIOR::GET_INTERIOR_FROM_COLLISION(x, y, z);
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_ENABLE_STADIUM_PROBES_THIS_FRAME( bool toggle )
+	static void LUA_NATIVE_INTERIOR_ENABLE_STADIUM_PROBES_THIS_FRAME(bool toggle)
 	{
 		INTERIOR::ENABLE_STADIUM_PROBES_THIS_FRAME(toggle);
 	}
 
-	static void LUA_NATIVE_INTERIOR_ACTIVATE_INTERIOR_ENTITY_SET( Interior interior, const char* entitySetName )
+	static void LUA_NATIVE_INTERIOR_ACTIVATE_INTERIOR_ENTITY_SET(Interior interior, const char* entitySetName)
 	{
 		INTERIOR::ACTIVATE_INTERIOR_ENTITY_SET(interior, entitySetName);
 	}
 
-	static void LUA_NATIVE_INTERIOR_DEACTIVATE_INTERIOR_ENTITY_SET( Interior interior, const char* entitySetName )
+	static void LUA_NATIVE_INTERIOR_DEACTIVATE_INTERIOR_ENTITY_SET(Interior interior, const char* entitySetName)
 	{
 		INTERIOR::DEACTIVATE_INTERIOR_ENTITY_SET(interior, entitySetName);
 	}
 
-	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_ENTITY_SET_ACTIVE( Interior interior, const char* entitySetName )
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_ENTITY_SET_ACTIVE(Interior interior, const char* entitySetName)
 	{
 		auto retval = (bool)INTERIOR::IS_INTERIOR_ENTITY_SET_ACTIVE(interior, entitySetName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_SET_INTERIOR_ENTITY_SET_TINT_INDEX( Interior interior, const char* entitySetName, int color )
+	static void LUA_NATIVE_INTERIOR_SET_INTERIOR_ENTITY_SET_TINT_INDEX(Interior interior, const char* entitySetName, int color)
 	{
 		INTERIOR::SET_INTERIOR_ENTITY_SET_TINT_INDEX(interior, entitySetName, color);
 	}
 
-	static void LUA_NATIVE_INTERIOR_REFRESH_INTERIOR( Interior interior )
+	static void LUA_NATIVE_INTERIOR_REFRESH_INTERIOR(Interior interior)
 	{
 		INTERIOR::REFRESH_INTERIOR(interior);
 	}
 
-	static void LUA_NATIVE_INTERIOR_ENABLE_EXTERIOR_CULL_MODEL_THIS_FRAME( Hash mapObjectHash )
+	static void LUA_NATIVE_INTERIOR_ENABLE_EXTERIOR_CULL_MODEL_THIS_FRAME(Hash mapObjectHash)
 	{
 		INTERIOR::ENABLE_EXTERIOR_CULL_MODEL_THIS_FRAME(mapObjectHash);
 	}
 
-	static void LUA_NATIVE_INTERIOR_ENABLE_SHADOW_CULL_MODEL_THIS_FRAME( Hash mapObjectHash )
+	static void LUA_NATIVE_INTERIOR_ENABLE_SHADOW_CULL_MODEL_THIS_FRAME(Hash mapObjectHash)
 	{
 		INTERIOR::ENABLE_SHADOW_CULL_MODEL_THIS_FRAME(mapObjectHash);
 	}
 
-	static void LUA_NATIVE_INTERIOR_DISABLE_INTERIOR( Interior interior, bool toggle )
+	static void LUA_NATIVE_INTERIOR_DISABLE_INTERIOR(Interior interior, bool toggle)
 	{
 		INTERIOR::DISABLE_INTERIOR(interior, toggle);
 	}
 
-	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_DISABLED( Interior interior )
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_DISABLED(Interior interior)
 	{
 		auto retval = (bool)INTERIOR::IS_INTERIOR_DISABLED(interior);
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_CAP_INTERIOR( Interior interior, bool toggle )
+	static void LUA_NATIVE_INTERIOR_CAP_INTERIOR(Interior interior, bool toggle)
 	{
 		INTERIOR::CAP_INTERIOR(interior, toggle);
 	}
 
-	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_CAPPED( Interior interior )
+	static bool LUA_NATIVE_INTERIOR_IS_INTERIOR_CAPPED(Interior interior)
 	{
 		auto retval = (bool)INTERIOR::IS_INTERIOR_CAPPED(interior);
 		return retval;
 	}
 
-	static void LUA_NATIVE_INTERIOR_DISABLE_METRO_SYSTEM( bool toggle )
+	static void LUA_NATIVE_INTERIOR_DISABLE_METRO_SYSTEM(bool toggle)
 	{
 		INTERIOR::DISABLE_METRO_SYSTEM(toggle);
 	}
 
-	static void LUA_NATIVE_INTERIOR_SET_IS_EXTERIOR_ONLY( Entity entity, bool toggle )
+	static void LUA_NATIVE_INTERIOR_SET_IS_EXTERIOR_ONLY(Entity entity, bool toggle)
 	{
 		INTERIOR::SET_IS_EXTERIOR_ONLY(entity, toggle);
 	}

src/lua/natives/lua_native_binding_ITEMSET.cpp

@@ -3,53 +3,53 @@
 
 namespace lua::native
 {
-	static ScrHandle LUA_NATIVE_ITEMSET_CREATE_ITEMSET( bool p0 )
+	static ScrHandle LUA_NATIVE_ITEMSET_CREATE_ITEMSET(bool p0)
 	{
 		auto retval = ITEMSET::CREATE_ITEMSET(p0);
 		return retval;
 	}
 
-	static void LUA_NATIVE_ITEMSET_DESTROY_ITEMSET( ScrHandle itemset )
+	static void LUA_NATIVE_ITEMSET_DESTROY_ITEMSET(ScrHandle itemset)
 	{
 		ITEMSET::DESTROY_ITEMSET(itemset);
 	}
 
-	static bool LUA_NATIVE_ITEMSET_IS_ITEMSET_VALID( ScrHandle itemset )
+	static bool LUA_NATIVE_ITEMSET_IS_ITEMSET_VALID(ScrHandle itemset)
 	{
 		auto retval = (bool)ITEMSET::IS_ITEMSET_VALID(itemset);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_ITEMSET_ADD_TO_ITEMSET( ScrHandle item, ScrHandle itemset )
+	static bool LUA_NATIVE_ITEMSET_ADD_TO_ITEMSET(ScrHandle item, ScrHandle itemset)
 	{
 		auto retval = (bool)ITEMSET::ADD_TO_ITEMSET(item, itemset);
 		return retval;
 	}
 
-	static void LUA_NATIVE_ITEMSET_REMOVE_FROM_ITEMSET( ScrHandle item, ScrHandle itemset )
+	static void LUA_NATIVE_ITEMSET_REMOVE_FROM_ITEMSET(ScrHandle item, ScrHandle itemset)
 	{
 		ITEMSET::REMOVE_FROM_ITEMSET(item, itemset);
 	}
 
-	static int LUA_NATIVE_ITEMSET_GET_ITEMSET_SIZE( ScrHandle itemset )
+	static int LUA_NATIVE_ITEMSET_GET_ITEMSET_SIZE(ScrHandle itemset)
 	{
 		auto retval = ITEMSET::GET_ITEMSET_SIZE(itemset);
 		return retval;
 	}
 
-	static ScrHandle LUA_NATIVE_ITEMSET_GET_INDEXED_ITEM_IN_ITEMSET( int index, ScrHandle itemset )
+	static ScrHandle LUA_NATIVE_ITEMSET_GET_INDEXED_ITEM_IN_ITEMSET(int index, ScrHandle itemset)
 	{
 		auto retval = ITEMSET::GET_INDEXED_ITEM_IN_ITEMSET(index, itemset);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_ITEMSET_IS_IN_ITEMSET( ScrHandle item, ScrHandle itemset )
+	static bool LUA_NATIVE_ITEMSET_IS_IN_ITEMSET(ScrHandle item, ScrHandle itemset)
 	{
 		auto retval = (bool)ITEMSET::IS_IN_ITEMSET(item, itemset);
 		return retval;
 	}
 
-	static void LUA_NATIVE_ITEMSET_CLEAN_ITEMSET( ScrHandle itemset )
+	static void LUA_NATIVE_ITEMSET_CLEAN_ITEMSET(ScrHandle itemset)
 	{
 		ITEMSET::CLEAN_ITEMSET(itemset);
 	}

src/lua/natives/lua_native_binding_LOADINGSCREEN.cpp

@@ -3,46 +3,46 @@
 
 namespace lua::native
 {
-	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_MENU(  )
+	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_MENU()
 	{
 		auto retval = (bool)LOADINGSCREEN::LOBBY_AUTO_MULTIPLAYER_MENU();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_FREEMODE(  )
+	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_FREEMODE()
 	{
 		auto retval = (bool)LOADINGSCREEN::LOBBY_AUTO_MULTIPLAYER_FREEMODE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MULTIPLAYER( bool toggle )
+	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MULTIPLAYER(bool toggle)
 	{
 		LOADINGSCREEN::LOBBY_SET_AUTO_MULTIPLAYER(toggle);
 	}
 
-	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_EVENT(  )
+	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_EVENT()
 	{
 		auto retval = (bool)LOADINGSCREEN::LOBBY_AUTO_MULTIPLAYER_EVENT();
 		return retval;
 	}
 
-	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MULTIPLAYER_EVENT( bool toggle )
+	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MULTIPLAYER_EVENT(bool toggle)
 	{
 		LOADINGSCREEN::LOBBY_SET_AUTO_MULTIPLAYER_EVENT(toggle);
 	}
 
-	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_RANDOM_JOB(  )
+	static bool LUA_NATIVE_LOADINGSCREEN_LOBBY_AUTO_MULTIPLAYER_RANDOM_JOB()
 	{
 		auto retval = (bool)LOADINGSCREEN::LOBBY_AUTO_MULTIPLAYER_RANDOM_JOB();
 		return retval;
 	}
 
-	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MP_RANDOM_JOB( bool toggle )
+	static void LUA_NATIVE_LOADINGSCREEN_LOBBY_SET_AUTO_MP_RANDOM_JOB(bool toggle)
 	{
 		LOADINGSCREEN::LOBBY_SET_AUTO_MP_RANDOM_JOB(toggle);
 	}
 
-	static void LUA_NATIVE_LOADINGSCREEN_SHUTDOWN_SESSION_CLEARS_AUTO_MULTIPLAYER( bool toggle )
+	static void LUA_NATIVE_LOADINGSCREEN_SHUTDOWN_SESSION_CLEARS_AUTO_MULTIPLAYER(bool toggle)
 	{
 		LOADINGSCREEN::SHUTDOWN_SESSION_CLEARS_AUTO_MULTIPLAYER(toggle);
 	}

src/lua/natives/lua_native_binding_LOCALIZATION.cpp

@@ -3,19 +3,19 @@
 
 namespace lua::native
 {
-	static int LUA_NATIVE_LOCALIZATION_LOCALIZATION_GET_SYSTEM_LANGUAGE(  )
+	static int LUA_NATIVE_LOCALIZATION_LOCALIZATION_GET_SYSTEM_LANGUAGE()
 	{
 		auto retval = LOCALIZATION::LOCALIZATION_GET_SYSTEM_LANGUAGE();
 		return retval;
 	}
 
-	static int LUA_NATIVE_LOCALIZATION_GET_CURRENT_LANGUAGE(  )
+	static int LUA_NATIVE_LOCALIZATION_GET_CURRENT_LANGUAGE()
 	{
 		auto retval = LOCALIZATION::GET_CURRENT_LANGUAGE();
 		return retval;
 	}
 
-	static int LUA_NATIVE_LOCALIZATION_LOCALIZATION_GET_SYSTEM_DATE_TYPE(  )
+	static int LUA_NATIVE_LOCALIZATION_LOCALIZATION_GET_SYSTEM_DATE_TYPE()
 	{
 		auto retval = LOCALIZATION::LOCALIZATION_GET_SYSTEM_DATE_TYPE();
 		return retval;

src/lua/natives/lua_native_binding_MOBILE.cpp

@@ -3,131 +3,131 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_MOBILE_CREATE_MOBILE_PHONE( int phoneType )
+	static void LUA_NATIVE_MOBILE_CREATE_MOBILE_PHONE(int phoneType)
 	{
 		MOBILE::CREATE_MOBILE_PHONE(phoneType);
 	}
 
-	static void LUA_NATIVE_MOBILE_DESTROY_MOBILE_PHONE(  )
+	static void LUA_NATIVE_MOBILE_DESTROY_MOBILE_PHONE()
 	{
 		MOBILE::DESTROY_MOBILE_PHONE();
 	}
 
-	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_SCALE( float scale )
+	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_SCALE(float scale)
 	{
 		MOBILE::SET_MOBILE_PHONE_SCALE(scale);
 	}
 
-	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_ROTATION( float rotX, float rotY, float rotZ, Any p3 )
+	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_ROTATION(float rotX, float rotY, float rotZ, Any p3)
 	{
 		MOBILE::SET_MOBILE_PHONE_ROTATION(rotX, rotY, rotZ, p3);
 	}
 
-	static Vector3 LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_ROTATION( Vector3 rotation, Vehicle p1 )
+	static Vector3 LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_ROTATION(Vector3 rotation, Vehicle p1)
 	{
 		MOBILE::GET_MOBILE_PHONE_ROTATION(&rotation, p1);
 		return rotation;
 	}
 
-	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_POSITION( float posX, float posY, float posZ )
+	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_POSITION(float posX, float posY, float posZ)
 	{
 		MOBILE::SET_MOBILE_PHONE_POSITION(posX, posY, posZ);
 	}
 
-	static Vector3 LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_POSITION( Vector3 position )
+	static Vector3 LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_POSITION(Vector3 position)
 	{
 		MOBILE::GET_MOBILE_PHONE_POSITION(&position);
 		return position;
 	}
 
-	static void LUA_NATIVE_MOBILE_SCRIPT_IS_MOVING_MOBILE_PHONE_OFFSCREEN( bool toggle )
+	static void LUA_NATIVE_MOBILE_SCRIPT_IS_MOVING_MOBILE_PHONE_OFFSCREEN(bool toggle)
 	{
 		MOBILE::SCRIPT_IS_MOVING_MOBILE_PHONE_OFFSCREEN(toggle);
 	}
 
-	static bool LUA_NATIVE_MOBILE_CAN_PHONE_BE_SEEN_ON_SCREEN(  )
+	static bool LUA_NATIVE_MOBILE_CAN_PHONE_BE_SEEN_ON_SCREEN()
 	{
 		auto retval = (bool)MOBILE::CAN_PHONE_BE_SEEN_ON_SCREEN();
 		return retval;
 	}
 
-	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_DOF_STATE( bool toggle )
+	static void LUA_NATIVE_MOBILE_SET_MOBILE_PHONE_DOF_STATE(bool toggle)
 	{
 		MOBILE::SET_MOBILE_PHONE_DOF_STATE(toggle);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_SET_INPUT( int direction )
+	static void LUA_NATIVE_MOBILE_CELL_SET_INPUT(int direction)
 	{
 		MOBILE::CELL_SET_INPUT(direction);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_HORIZONTAL_MODE_TOGGLE( bool toggle )
+	static void LUA_NATIVE_MOBILE_CELL_HORIZONTAL_MODE_TOGGLE(bool toggle)
 	{
 		MOBILE::CELL_HORIZONTAL_MODE_TOGGLE(toggle);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE( bool p0, bool p1 )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE(bool p0, bool p1)
 	{
 		MOBILE::CELL_CAM_ACTIVATE(p0, p1);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE_SELFIE_MODE( bool toggle )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE_SELFIE_MODE(bool toggle)
 	{
 		MOBILE::CELL_CAM_ACTIVATE_SELFIE_MODE(toggle);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE_SHALLOW_DOF_MODE( bool toggle )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_ACTIVATE_SHALLOW_DOF_MODE(bool toggle)
 	{
 		MOBILE::CELL_CAM_ACTIVATE_SHALLOW_DOF_MODE(toggle);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_SIDE_OFFSET_SCALING( float p0 )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_SIDE_OFFSET_SCALING(float p0)
 	{
 		MOBILE::CELL_CAM_SET_SELFIE_MODE_SIDE_OFFSET_SCALING(p0);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HORZ_PAN_OFFSET( float horizontalPan )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HORZ_PAN_OFFSET(float horizontalPan)
 	{
 		MOBILE::CELL_CAM_SET_SELFIE_MODE_HORZ_PAN_OFFSET(horizontalPan);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_VERT_PAN_OFFSET( float vertPan )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_VERT_PAN_OFFSET(float vertPan)
 	{
 		MOBILE::CELL_CAM_SET_SELFIE_MODE_VERT_PAN_OFFSET(vertPan);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_ROLL_OFFSET( float roll )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_ROLL_OFFSET(float roll)
 	{
 		MOBILE::CELL_CAM_SET_SELFIE_MODE_ROLL_OFFSET(roll);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_DISTANCE_SCALING( float distanceScaling )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_DISTANCE_SCALING(float distanceScaling)
 	{
 		MOBILE::CELL_CAM_SET_SELFIE_MODE_DISTANCE_SCALING(distanceScaling);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_YAW_OFFSET( float yaw )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_YAW_OFFSET(float yaw)
 	{
 		MOBILE::CELL_CAM_SET_SELFIE_MODE_HEAD_YAW_OFFSET(yaw);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_ROLL_OFFSET( float roll )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_ROLL_OFFSET(float roll)
 	{
 		MOBILE::CELL_CAM_SET_SELFIE_MODE_HEAD_ROLL_OFFSET(roll);
 	}
 
-	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_PITCH_OFFSET( float pitch )
+	static void LUA_NATIVE_MOBILE_CELL_CAM_SET_SELFIE_MODE_HEAD_PITCH_OFFSET(float pitch)
 	{
 		MOBILE::CELL_CAM_SET_SELFIE_MODE_HEAD_PITCH_OFFSET(pitch);
 	}
 
-	static bool LUA_NATIVE_MOBILE_CELL_CAM_IS_CHAR_VISIBLE_NO_FACE_CHECK( Entity entity )
+	static bool LUA_NATIVE_MOBILE_CELL_CAM_IS_CHAR_VISIBLE_NO_FACE_CHECK(Entity entity)
 	{
 		auto retval = (bool)MOBILE::CELL_CAM_IS_CHAR_VISIBLE_NO_FACE_CHECK(entity);
 		return retval;
 	}
 
-	static int LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_RENDER_ID( int renderId )
+	static int LUA_NATIVE_MOBILE_GET_MOBILE_PHONE_RENDER_ID(int renderId)
 	{
 		MOBILE::GET_MOBILE_PHONE_RENDER_ID(&renderId);
 		return renderId;

src/lua/natives/lua_native_binding_NETSHOPPING.cpp

@@ -3,55 +3,55 @@
 
 namespace lua::native
 {
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_USE_SERVER_TRANSACTIONS(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_USE_SERVER_TRANSACTIONS()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_USE_SERVER_TRANSACTIONS();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_ITEM_IS_VALID( const char* name )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_ITEM_IS_VALID(const char* name)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CATALOG_ITEM_IS_VALID(name);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_ITEM_KEY_IS_VALID( Hash hash )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_ITEM_KEY_IS_VALID(Hash hash)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CATALOG_ITEM_KEY_IS_VALID(hash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_PRICE( Hash itemHash, Hash categoryHash, bool p2 )
+	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_PRICE(Hash itemHash, Hash categoryHash, bool p2)
 	{
 		auto retval = NETSHOPPING::NET_GAMESERVER_GET_PRICE(itemHash, categoryHash, p2);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_IS_VALID(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CATALOG_IS_VALID()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CATALOG_IS_VALID();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_CATALOG_CURRENT(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_CATALOG_CURRENT()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_IS_CATALOG_CURRENT();
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_CATALOG_CLOUD_CRC(  )
+	static Hash LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_CATALOG_CLOUD_CRC()
 	{
 		auto retval = NETSHOPPING::NET_GAMESERVER_GET_CATALOG_CLOUD_CRC();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_REFRESH_SERVER_CATALOG(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_REFRESH_SERVER_CATALOG()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_REFRESH_SERVER_CATALOG();
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_CATALOG_REFRESH_STATUS( int state )
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_CATALOG_REFRESH_STATUS(int state)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_RETRIEVE_CATALOG_REFRESH_STATUS(&state);
@@ -60,13 +60,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_INIT_SESSION(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_INIT_SESSION()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_INIT_SESSION();
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_INIT_SESSION_STATUS( int p0 )
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_INIT_SESSION_STATUS(int p0)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_RETRIEVE_INIT_SESSION_STATUS(&p0);
@@ -75,19 +75,19 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION( int charSlot )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION(int charSlot)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_START_SESSION(charSlot);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION_PENDING(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION_PENDING()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_START_SESSION_PENDING();
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_START_SESSION_STATUS( int p0 )
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_START_SESSION_STATUS(int p0)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_RETRIEVE_START_SESSION_STATUS(&p0);
@@ -96,7 +96,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_SESSION_ERROR_CODE( int p0 )
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_RETRIEVE_SESSION_ERROR_CODE(int p0)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_RETRIEVE_SESSION_ERROR_CODE(&p0);
@@ -105,43 +105,43 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_SESSION_VALID( int charSlot )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_SESSION_VALID(int charSlot)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_IS_SESSION_VALID(charSlot);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CLEAR_SESSION( int p0 )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CLEAR_SESSION(int p0)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CLEAR_SESSION(p0);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_SESSION_APPLY_RECEIVED_DATA( int charSlot )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_SESSION_APPLY_RECEIVED_DATA(int charSlot)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_SESSION_APPLY_RECEIVED_DATA(charSlot);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_SESSION_REFRESH_PENDING(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_IS_SESSION_REFRESH_PENDING()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_IS_SESSION_REFRESH_PENDING();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION_RESTART( bool inventory, bool playerbalance )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_START_SESSION_RESTART(bool inventory, bool playerbalance)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_START_SESSION_RESTART(inventory, playerbalance);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSACTION_IN_PROGRESS(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSACTION_IN_PROGRESS()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_TRANSACTION_IN_PROGRESS();
 		return retval;
 	}
 
-	static std::tuple<bool, int, bool> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_SESSION_STATE_AND_STATUS( int p0, bool p1 )
+	static std::tuple<bool, int, bool> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_GET_SESSION_STATE_AND_STATUS(int p0, bool p1)
 	{
 		std::tuple<bool, int, bool> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_GET_SESSION_STATE_AND_STATUS(&p0, (BOOL*)&p1);
@@ -151,7 +151,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_START( int transactionId, Hash categoryHash, Hash actionHash, int flags )
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_START(int transactionId, Hash categoryHash, Hash actionHash, int flags)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_START(&transactionId, categoryHash, actionHash, flags);
@@ -160,19 +160,19 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_END(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_END()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_END();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_IS_ACTIVE(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_IS_ACTIVE()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_IS_ACTIVE();
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_ADD_ITEM( Any itemData, int quantity )
+	static std::tuple<bool, Any> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_ADD_ITEM(Any itemData, int quantity)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_ADD_ITEM(&itemData, quantity);
@@ -181,13 +181,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_IS_FULL(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_IS_FULL()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_IS_FULL();
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_APPLY_SERVER_DATA( Any p0, Any p1 )
+	static std::tuple<bool, Any> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BASKET_APPLY_SERVER_DATA(Any p0, Any p1)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_BASKET_APPLY_SERVER_DATA(p0, &p1);
@@ -196,13 +196,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CHECKOUT_START( int transactionId )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_CHECKOUT_START(int transactionId)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_CHECKOUT_START(transactionId);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BEGIN_SERVICE( int transactionId, Hash categoryHash, Hash itemHash, Hash actionTypeHash, int value, int flags )
+	static std::tuple<bool, int> LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_BEGIN_SERVICE(int transactionId, Hash categoryHash, Hash itemHash, Hash actionTypeHash, int value, int flags)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)NETSHOPPING::NET_GAMESERVER_BEGIN_SERVICE(&transactionId, categoryHash, itemHash, actionTypeHash, value, flags);
@@ -211,61 +211,61 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_END_SERVICE( int transactionId )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_END_SERVICE(int transactionId)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_END_SERVICE(transactionId);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_CHARACTER( int slot, bool transfer, Hash reason )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_CHARACTER(int slot, bool transfer, Hash reason)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_DELETE_CHARACTER(slot, transfer, reason);
 		return retval;
 	}
 
-	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_CHARACTER_GET_STATUS(  )
+	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_CHARACTER_GET_STATUS()
 	{
 		auto retval = NETSHOPPING::NET_GAMESERVER_DELETE_CHARACTER_GET_STATUS();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_SET_TELEMETRY_NONCE_SEED(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_DELETE_SET_TELEMETRY_NONCE_SEED()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_DELETE_SET_TELEMETRY_NONCE_SEED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_BANK_TO_WALLET( int charSlot, int amount )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_BANK_TO_WALLET(int charSlot, int amount)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_TRANSFER_BANK_TO_WALLET(charSlot, amount);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_WALLET_TO_BANK( int charSlot, int amount )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_WALLET_TO_BANK(int charSlot, int amount)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_TRANSFER_WALLET_TO_BANK(charSlot, amount);
 		return retval;
 	}
 
-	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_BANK_TO_WALLET_GET_STATUS(  )
+	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_BANK_TO_WALLET_GET_STATUS()
 	{
 		auto retval = NETSHOPPING::NET_GAMESERVER_TRANSFER_BANK_TO_WALLET_GET_STATUS();
 		return retval;
 	}
 
-	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_WALLET_TO_BANK_GET_STATUS(  )
+	static int LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_WALLET_TO_BANK_GET_STATUS()
 	{
 		auto retval = NETSHOPPING::NET_GAMESERVER_TRANSFER_WALLET_TO_BANK_GET_STATUS();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_CASH_SET_TELEMETRY_NONCE_SEED(  )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_TRANSFER_CASH_SET_TELEMETRY_NONCE_SEED()
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_TRANSFER_CASH_SET_TELEMETRY_NONCE_SEED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_SET_TELEMETRY_NONCE_SEED( int p0 )
+	static bool LUA_NATIVE_NETSHOPPING_NET_GAMESERVER_SET_TELEMETRY_NONCE_SEED(int p0)
 	{
 		auto retval = (bool)NETSHOPPING::NET_GAMESERVER_SET_TELEMETRY_NONCE_SEED(p0);
 		return retval;

src/lua/natives/lua_native_binding_PAD.cpp

@@ -3,274 +3,274 @@
 
 namespace lua::native
 {
-	static bool LUA_NATIVE_PAD_IS_CONTROL_ENABLED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_CONTROL_ENABLED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_CONTROL_ENABLED(control, action);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_CONTROL_PRESSED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_CONTROL_PRESSED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_CONTROL_PRESSED(control, action);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_CONTROL_RELEASED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_CONTROL_RELEASED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_CONTROL_RELEASED(control, action);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_CONTROL_JUST_PRESSED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_CONTROL_JUST_PRESSED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_CONTROL_JUST_PRESSED(control, action);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_CONTROL_JUST_RELEASED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_CONTROL_JUST_RELEASED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_CONTROL_JUST_RELEASED(control, action);
 		return retval;
 	}
 
-	static int LUA_NATIVE_PAD_GET_CONTROL_VALUE( int control, int action )
+	static int LUA_NATIVE_PAD_GET_CONTROL_VALUE(int control, int action)
 	{
 		auto retval = PAD::GET_CONTROL_VALUE(control, action);
 		return retval;
 	}
 
-	static float LUA_NATIVE_PAD_GET_CONTROL_NORMAL( int control, int action )
+	static float LUA_NATIVE_PAD_GET_CONTROL_NORMAL(int control, int action)
 	{
 		auto retval = PAD::GET_CONTROL_NORMAL(control, action);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PAD_SET_USE_ADJUSTED_MOUSE_COORDS( bool toggle )
+	static void LUA_NATIVE_PAD_SET_USE_ADJUSTED_MOUSE_COORDS(bool toggle)
 	{
 		PAD::SET_USE_ADJUSTED_MOUSE_COORDS(toggle);
 	}
 
-	static float LUA_NATIVE_PAD_GET_CONTROL_UNBOUND_NORMAL( int control, int action )
+	static float LUA_NATIVE_PAD_GET_CONTROL_UNBOUND_NORMAL(int control, int action)
 	{
 		auto retval = PAD::GET_CONTROL_UNBOUND_NORMAL(control, action);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_SET_CONTROL_VALUE_NEXT_FRAME( int control, int action, float value )
+	static bool LUA_NATIVE_PAD_SET_CONTROL_VALUE_NEXT_FRAME(int control, int action, float value)
 	{
 		auto retval = (bool)PAD::SET_CONTROL_VALUE_NEXT_FRAME(control, action, value);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_PRESSED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_PRESSED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_DISABLED_CONTROL_PRESSED(control, action);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_RELEASED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_RELEASED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_DISABLED_CONTROL_RELEASED(control, action);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_JUST_PRESSED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_JUST_PRESSED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_DISABLED_CONTROL_JUST_PRESSED(control, action);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_JUST_RELEASED( int control, int action )
+	static bool LUA_NATIVE_PAD_IS_DISABLED_CONTROL_JUST_RELEASED(int control, int action)
 	{
 		auto retval = (bool)PAD::IS_DISABLED_CONTROL_JUST_RELEASED(control, action);
 		return retval;
 	}
 
-	static float LUA_NATIVE_PAD_GET_DISABLED_CONTROL_NORMAL( int control, int action )
+	static float LUA_NATIVE_PAD_GET_DISABLED_CONTROL_NORMAL(int control, int action)
 	{
 		auto retval = PAD::GET_DISABLED_CONTROL_NORMAL(control, action);
 		return retval;
 	}
 
-	static float LUA_NATIVE_PAD_GET_DISABLED_CONTROL_UNBOUND_NORMAL( int control, int action )
+	static float LUA_NATIVE_PAD_GET_DISABLED_CONTROL_UNBOUND_NORMAL(int control, int action)
 	{
 		auto retval = PAD::GET_DISABLED_CONTROL_UNBOUND_NORMAL(control, action);
 		return retval;
 	}
 
-	static int LUA_NATIVE_PAD_GET_CONTROL_HOW_LONG_AGO( int control )
+	static int LUA_NATIVE_PAD_GET_CONTROL_HOW_LONG_AGO(int control)
 	{
 		auto retval = PAD::GET_CONTROL_HOW_LONG_AGO(control);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_USING_KEYBOARD_AND_MOUSE( int control )
+	static bool LUA_NATIVE_PAD_IS_USING_KEYBOARD_AND_MOUSE(int control)
 	{
 		auto retval = (bool)PAD::IS_USING_KEYBOARD_AND_MOUSE(control);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_USING_CURSOR( int control )
+	static bool LUA_NATIVE_PAD_IS_USING_CURSOR(int control)
 	{
 		auto retval = (bool)PAD::IS_USING_CURSOR(control);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_SET_CURSOR_POSITION( float x, float y )
+	static bool LUA_NATIVE_PAD_SET_CURSOR_POSITION(float x, float y)
 	{
 		auto retval = (bool)PAD::SET_CURSOR_POSITION(x, y);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_USING_REMOTE_PLAY( int control )
+	static bool LUA_NATIVE_PAD_IS_USING_REMOTE_PLAY(int control)
 	{
 		auto retval = (bool)PAD::IS_USING_REMOTE_PLAY(control);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_HAVE_CONTROLS_CHANGED( int control )
+	static bool LUA_NATIVE_PAD_HAVE_CONTROLS_CHANGED(int control)
 	{
 		auto retval = (bool)PAD::HAVE_CONTROLS_CHANGED(control);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_PAD_GET_CONTROL_INSTRUCTIONAL_BUTTONS_STRING( int control, int action, bool allowXOSwap )
+	static const char* LUA_NATIVE_PAD_GET_CONTROL_INSTRUCTIONAL_BUTTONS_STRING(int control, int action, bool allowXOSwap)
 	{
 		auto retval = PAD::GET_CONTROL_INSTRUCTIONAL_BUTTONS_STRING(control, action, allowXOSwap);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_PAD_GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTONS_STRING( int control, int controlGroup, bool allowXOSwap )
+	static const char* LUA_NATIVE_PAD_GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTONS_STRING(int control, int controlGroup, bool allowXOSwap)
 	{
 		auto retval = PAD::GET_CONTROL_GROUP_INSTRUCTIONAL_BUTTONS_STRING(control, controlGroup, allowXOSwap);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PAD_SET_CONTROL_LIGHT_EFFECT_COLOR( int control, int red, int green, int blue )
+	static void LUA_NATIVE_PAD_SET_CONTROL_LIGHT_EFFECT_COLOR(int control, int red, int green, int blue)
 	{
 		PAD::SET_CONTROL_LIGHT_EFFECT_COLOR(control, red, green, blue);
 	}
 
-	static void LUA_NATIVE_PAD_CLEAR_CONTROL_LIGHT_EFFECT( int control )
+	static void LUA_NATIVE_PAD_CLEAR_CONTROL_LIGHT_EFFECT(int control)
 	{
 		PAD::CLEAR_CONTROL_LIGHT_EFFECT(control);
 	}
 
-	static void LUA_NATIVE_PAD_SET_CONTROL_SHAKE( int control, int duration, int frequency )
+	static void LUA_NATIVE_PAD_SET_CONTROL_SHAKE(int control, int duration, int frequency)
 	{
 		PAD::SET_CONTROL_SHAKE(control, duration, frequency);
 	}
 
-	static void LUA_NATIVE_PAD_SET_CONTROL_TRIGGER_SHAKE( int control, int leftDuration, int leftFrequency, int rightDuration, int rightFrequency )
+	static void LUA_NATIVE_PAD_SET_CONTROL_TRIGGER_SHAKE(int control, int leftDuration, int leftFrequency, int rightDuration, int rightFrequency)
 	{
 		PAD::SET_CONTROL_TRIGGER_SHAKE(control, leftDuration, leftFrequency, rightDuration, rightFrequency);
 	}
 
-	static void LUA_NATIVE_PAD_STOP_CONTROL_SHAKE( int control )
+	static void LUA_NATIVE_PAD_STOP_CONTROL_SHAKE(int control)
 	{
 		PAD::STOP_CONTROL_SHAKE(control);
 	}
 
-	static void LUA_NATIVE_PAD_SET_CONTROL_SHAKE_SUPPRESSED_ID( int control, int uniqueId )
+	static void LUA_NATIVE_PAD_SET_CONTROL_SHAKE_SUPPRESSED_ID(int control, int uniqueId)
 	{
 		PAD::SET_CONTROL_SHAKE_SUPPRESSED_ID(control, uniqueId);
 	}
 
-	static void LUA_NATIVE_PAD_CLEAR_CONTROL_SHAKE_SUPPRESSED_ID( int control )
+	static void LUA_NATIVE_PAD_CLEAR_CONTROL_SHAKE_SUPPRESSED_ID(int control)
 	{
 		PAD::CLEAR_CONTROL_SHAKE_SUPPRESSED_ID(control);
 	}
 
-	static bool LUA_NATIVE_PAD_IS_LOOK_INVERTED(  )
+	static bool LUA_NATIVE_PAD_IS_LOOK_INVERTED()
 	{
 		auto retval = (bool)PAD::IS_LOOK_INVERTED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_IS_MOUSE_LOOK_INVERTED(  )
+	static bool LUA_NATIVE_PAD_IS_MOUSE_LOOK_INVERTED()
 	{
 		auto retval = (bool)PAD::IS_MOUSE_LOOK_INVERTED();
 		return retval;
 	}
 
-	static int LUA_NATIVE_PAD_GET_LOCAL_PLAYER_AIM_STATE(  )
+	static int LUA_NATIVE_PAD_GET_LOCAL_PLAYER_AIM_STATE()
 	{
 		auto retval = PAD::GET_LOCAL_PLAYER_AIM_STATE();
 		return retval;
 	}
 
-	static int LUA_NATIVE_PAD_GET_LOCAL_PLAYER_GAMEPAD_AIM_STATE(  )
+	static int LUA_NATIVE_PAD_GET_LOCAL_PLAYER_GAMEPAD_AIM_STATE()
 	{
 		auto retval = PAD::GET_LOCAL_PLAYER_GAMEPAD_AIM_STATE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_GET_IS_USING_ALTERNATE_HANDBRAKE(  )
+	static bool LUA_NATIVE_PAD_GET_IS_USING_ALTERNATE_HANDBRAKE()
 	{
 		auto retval = (bool)PAD::GET_IS_USING_ALTERNATE_HANDBRAKE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_GET_IS_USING_ALTERNATE_DRIVEBY(  )
+	static bool LUA_NATIVE_PAD_GET_IS_USING_ALTERNATE_DRIVEBY()
 	{
 		auto retval = (bool)PAD::GET_IS_USING_ALTERNATE_DRIVEBY();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_GET_ALLOW_MOVEMENT_WHILE_ZOOMED(  )
+	static bool LUA_NATIVE_PAD_GET_ALLOW_MOVEMENT_WHILE_ZOOMED()
 	{
 		auto retval = (bool)PAD::GET_ALLOW_MOVEMENT_WHILE_ZOOMED();
 		return retval;
 	}
 
-	static void LUA_NATIVE_PAD_SET_PLAYERPAD_SHAKES_WHEN_CONTROLLER_DISABLED( bool toggle )
+	static void LUA_NATIVE_PAD_SET_PLAYERPAD_SHAKES_WHEN_CONTROLLER_DISABLED(bool toggle)
 	{
 		PAD::SET_PLAYERPAD_SHAKES_WHEN_CONTROLLER_DISABLED(toggle);
 	}
 
-	static void LUA_NATIVE_PAD_SET_INPUT_EXCLUSIVE( int control, int action )
+	static void LUA_NATIVE_PAD_SET_INPUT_EXCLUSIVE(int control, int action)
 	{
 		PAD::SET_INPUT_EXCLUSIVE(control, action);
 	}
 
-	static void LUA_NATIVE_PAD_DISABLE_CONTROL_ACTION( int control, int action, bool disableRelatedActions )
+	static void LUA_NATIVE_PAD_DISABLE_CONTROL_ACTION(int control, int action, bool disableRelatedActions)
 	{
 		PAD::DISABLE_CONTROL_ACTION(control, action, disableRelatedActions);
 	}
 
-	static void LUA_NATIVE_PAD_ENABLE_CONTROL_ACTION( int control, int action, bool enableRelatedActions )
+	static void LUA_NATIVE_PAD_ENABLE_CONTROL_ACTION(int control, int action, bool enableRelatedActions)
 	{
 		PAD::ENABLE_CONTROL_ACTION(control, action, enableRelatedActions);
 	}
 
-	static void LUA_NATIVE_PAD_DISABLE_ALL_CONTROL_ACTIONS( int control )
+	static void LUA_NATIVE_PAD_DISABLE_ALL_CONTROL_ACTIONS(int control)
 	{
 		PAD::DISABLE_ALL_CONTROL_ACTIONS(control);
 	}
 
-	static void LUA_NATIVE_PAD_ENABLE_ALL_CONTROL_ACTIONS( int control )
+	static void LUA_NATIVE_PAD_ENABLE_ALL_CONTROL_ACTIONS(int control)
 	{
 		PAD::ENABLE_ALL_CONTROL_ACTIONS(control);
 	}
 
-	static bool LUA_NATIVE_PAD_INIT_PC_SCRIPTED_CONTROLS( const char* schemeName )
+	static bool LUA_NATIVE_PAD_INIT_PC_SCRIPTED_CONTROLS(const char* schemeName)
 	{
 		auto retval = (bool)PAD::INIT_PC_SCRIPTED_CONTROLS(schemeName);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PAD_SWITCH_PC_SCRIPTED_CONTROLS( const char* schemeName )
+	static bool LUA_NATIVE_PAD_SWITCH_PC_SCRIPTED_CONTROLS(const char* schemeName)
 	{
 		auto retval = (bool)PAD::SWITCH_PC_SCRIPTED_CONTROLS(schemeName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PAD_SHUTDOWN_PC_SCRIPTED_CONTROLS(  )
+	static void LUA_NATIVE_PAD_SHUTDOWN_PC_SCRIPTED_CONTROLS()
 	{
 		PAD::SHUTDOWN_PC_SCRIPTED_CONTROLS();
 	}
 
-	static void LUA_NATIVE_PAD_ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT( int control )
+	static void LUA_NATIVE_PAD_ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT(int control)
 	{
 		PAD::ALLOW_ALTERNATIVE_SCRIPT_CONTROLS_LAYOUT(control);
 	}

src/lua/natives/lua_native_binding_PATHFIND.cpp

@@ -3,22 +3,22 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_PATHFIND_SET_ROADS_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2, bool nodeEnabled, bool unknown2 )
+	static void LUA_NATIVE_PATHFIND_SET_ROADS_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, bool nodeEnabled, bool unknown2)
 	{
 		PATHFIND::SET_ROADS_IN_AREA(x1, y1, z1, x2, y2, z2, nodeEnabled, unknown2);
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_ROADS_IN_ANGLED_AREA( float x1, float y1, float z1, float x2, float y2, float z2, float width, bool unknown1, bool unknown2, bool unknown3 )
+	static void LUA_NATIVE_PATHFIND_SET_ROADS_IN_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width, bool unknown1, bool unknown2, bool unknown3)
 	{
 		PATHFIND::SET_ROADS_IN_ANGLED_AREA(x1, y1, z1, x2, y2, z2, width, unknown1, unknown2, unknown3);
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_PED_PATHS_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2, bool p6, Any p7 )
+	static void LUA_NATIVE_PATHFIND_SET_PED_PATHS_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, bool p6, Any p7)
 	{
 		PATHFIND::SET_PED_PATHS_IN_AREA(x1, y1, z1, x2, y2, z2, p6, p7);
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_SAFE_COORD_FOR_PED( float x, float y, float z, bool onGround, Vector3 outPosition, int flags )
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_SAFE_COORD_FOR_PED(float x, float y, float z, bool onGround, Vector3 outPosition, int flags)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_SAFE_COORD_FOR_PED(x, y, z, onGround, &outPosition, flags);
@@ -27,7 +27,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_CLOSEST_VEHICLE_NODE( float x, float y, float z, Vector3 outPosition, int nodeFlags, float p5, float p6 )
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_CLOSEST_VEHICLE_NODE(float x, float y, float z, Vector3 outPosition, int nodeFlags, float p5, float p6)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_CLOSEST_VEHICLE_NODE(x, y, z, &outPosition, nodeFlags, p5, p6);
@@ -36,7 +36,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_CLOSEST_MAJOR_VEHICLE_NODE( float x, float y, float z, Vector3 outPosition, float unknown1, float unknown2 )
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_CLOSEST_MAJOR_VEHICLE_NODE(float x, float y, float z, Vector3 outPosition, float unknown1, float unknown2)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_CLOSEST_MAJOR_VEHICLE_NODE(x, y, z, &outPosition, unknown1, unknown2);
@@ -45,7 +45,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Vector3, float> LUA_NATIVE_PATHFIND_GET_CLOSEST_VEHICLE_NODE_WITH_HEADING( float x, float y, float z, Vector3 outPosition, float outHeading, int nodeType, float p6, float p7 )
+	static std::tuple<bool, Vector3, float> LUA_NATIVE_PATHFIND_GET_CLOSEST_VEHICLE_NODE_WITH_HEADING(float x, float y, float z, Vector3 outPosition, float outHeading, int nodeType, float p6, float p7)
 	{
 		std::tuple<bool, Vector3, float> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_CLOSEST_VEHICLE_NODE_WITH_HEADING(x, y, z, &outPosition, &outHeading, nodeType, p6, p7);
@@ -55,7 +55,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE( float x, float y, float z, int nthClosest, Vector3 outPosition, int nodeFlags, float unknown1, float unknown2 )
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE(float x, float y, float z, int nthClosest, Vector3 outPosition, int nodeFlags, float unknown1, float unknown2)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE(x, y, z, nthClosest, &outPosition, nodeFlags, unknown1, unknown2);
@@ -64,13 +64,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_ID( float x, float y, float z, int nth, int nodeFlags, float p5, float p6 )
+	static int LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_ID(float x, float y, float z, int nth, int nodeFlags, float p5, float p6)
 	{
 		auto retval = PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE_ID(x, y, z, nth, nodeFlags, p5, p6);
 		return retval;
 	}
 
-	static std::tuple<bool, Vector3, float, int> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_WITH_HEADING( float x, float y, float z, int nthClosest, Vector3 outPosition, float outHeading, int outNumLanes, int nodeFlags, float unknown3, float unknown4 )
+	static std::tuple<bool, Vector3, float, int> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_WITH_HEADING(float x, float y, float z, int nthClosest, Vector3 outPosition, float outHeading, int outNumLanes, int nodeFlags, float unknown3, float unknown4)
 	{
 		std::tuple<bool, Vector3, float, int> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE_WITH_HEADING(x, y, z, nthClosest, &outPosition, &outHeading, &outNumLanes, nodeFlags, unknown3, unknown4);
@@ -81,7 +81,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, Vector3, float> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_ID_WITH_HEADING( float x, float y, float z, int nthClosest, Vector3 outPosition, float outHeading, int nodeFlags, float p7, float p8 )
+	static std::tuple<int, Vector3, float> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_ID_WITH_HEADING(float x, float y, float z, int nthClosest, Vector3 outPosition, float outHeading, int nodeFlags, float p7, float p8)
 	{
 		std::tuple<int, Vector3, float> return_values;
 		std::get<0>(return_values) = PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE_ID_WITH_HEADING(x, y, z, nthClosest, &outPosition, &outHeading, nodeFlags, p7, p8);
@@ -91,7 +91,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Vector3, float> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_FAVOUR_DIRECTION( float x, float y, float z, float desiredX, float desiredY, float desiredZ, int nthClosest, Vector3 outPosition, float outHeading, int nodeFlags, float p10, float p11 )
+	static std::tuple<bool, Vector3, float> LUA_NATIVE_PATHFIND_GET_NTH_CLOSEST_VEHICLE_NODE_FAVOUR_DIRECTION(float x, float y, float z, float desiredX, float desiredY, float desiredZ, int nthClosest, Vector3 outPosition, float outHeading, int nodeFlags, float p10, float p11)
 	{
 		std::tuple<bool, Vector3, float> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_NTH_CLOSEST_VEHICLE_NODE_FAVOUR_DIRECTION(x, y, z, desiredX, desiredY, desiredZ, nthClosest, &outPosition, &outHeading, nodeFlags, p10, p11);
@@ -101,7 +101,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, int, int> LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_PROPERTIES( float x, float y, float z, int density, int flags )
+	static std::tuple<bool, int, int> LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_PROPERTIES(float x, float y, float z, int density, int flags)
 	{
 		std::tuple<bool, int, int> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_VEHICLE_NODE_PROPERTIES(x, y, z, &density, &flags);
@@ -111,31 +111,31 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_PATHFIND_IS_VEHICLE_NODE_ID_VALID( int vehicleNodeId )
+	static bool LUA_NATIVE_PATHFIND_IS_VEHICLE_NODE_ID_VALID(int vehicleNodeId)
 	{
 		auto retval = (bool)PATHFIND::IS_VEHICLE_NODE_ID_VALID(vehicleNodeId);
 		return retval;
 	}
 
-	static Vector3 LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_POSITION( int nodeId, Vector3 outPosition )
+	static Vector3 LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_POSITION(int nodeId, Vector3 outPosition)
 	{
 		PATHFIND::GET_VEHICLE_NODE_POSITION(nodeId, &outPosition);
 		return outPosition;
 	}
 
-	static bool LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_IS_GPS_ALLOWED( int nodeID )
+	static bool LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_IS_GPS_ALLOWED(int nodeID)
 	{
 		auto retval = (bool)PATHFIND::GET_VEHICLE_NODE_IS_GPS_ALLOWED(nodeID);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_IS_SWITCHED_OFF( int nodeID )
+	static bool LUA_NATIVE_PATHFIND_GET_VEHICLE_NODE_IS_SWITCHED_OFF(int nodeID)
 	{
 		auto retval = (bool)PATHFIND::GET_VEHICLE_NODE_IS_SWITCHED_OFF(nodeID);
 		return retval;
 	}
 
-	static std::tuple<bool, Vector3, Vector3, Any, Any, float> LUA_NATIVE_PATHFIND_GET_CLOSEST_ROAD( float x, float y, float z, float p3, int p4, Vector3 p5, Vector3 p6, Any p7, Any p8, float p9, bool p10 )
+	static std::tuple<bool, Vector3, Vector3, Any, Any, float> LUA_NATIVE_PATHFIND_GET_CLOSEST_ROAD(float x, float y, float z, float p3, int p4, Vector3 p5, Vector3 p6, Any p7, Any p8, float p9, bool p10)
 	{
 		std::tuple<bool, Vector3, Vector3, Any, Any, float> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_CLOSEST_ROAD(x, y, z, p3, p4, &p5, &p6, &p7, &p8, &p9, p10);
@@ -148,60 +148,60 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_PATHFIND_LOAD_ALL_PATH_NODES( bool set )
+	static bool LUA_NATIVE_PATHFIND_LOAD_ALL_PATH_NODES(bool set)
 	{
 		auto retval = (bool)PATHFIND::LOAD_ALL_PATH_NODES(set);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_ALLOW_STREAM_PROLOGUE_NODES( bool toggle )
+	static void LUA_NATIVE_PATHFIND_SET_ALLOW_STREAM_PROLOGUE_NODES(bool toggle)
 	{
 		PATHFIND::SET_ALLOW_STREAM_PROLOGUE_NODES(toggle);
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_ALLOW_STREAM_HEIST_ISLAND_NODES( int type )
+	static void LUA_NATIVE_PATHFIND_SET_ALLOW_STREAM_HEIST_ISLAND_NODES(int type)
 	{
 		PATHFIND::SET_ALLOW_STREAM_HEIST_ISLAND_NODES(type);
 	}
 
-	static bool LUA_NATIVE_PATHFIND_ARE_NODES_LOADED_FOR_AREA( float x1, float y1, float x2, float y2 )
+	static bool LUA_NATIVE_PATHFIND_ARE_NODES_LOADED_FOR_AREA(float x1, float y1, float x2, float y2)
 	{
 		auto retval = (bool)PATHFIND::ARE_NODES_LOADED_FOR_AREA(x1, y1, x2, y2);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PATHFIND_REQUEST_PATH_NODES_IN_AREA_THIS_FRAME( float x1, float y1, float x2, float y2 )
+	static bool LUA_NATIVE_PATHFIND_REQUEST_PATH_NODES_IN_AREA_THIS_FRAME(float x1, float y1, float x2, float y2)
 	{
 		auto retval = (bool)PATHFIND::REQUEST_PATH_NODES_IN_AREA_THIS_FRAME(x1, y1, x2, y2);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_ROADS_BACK_TO_ORIGINAL( float p0, float p1, float p2, float p3, float p4, float p5, Any p6 )
+	static void LUA_NATIVE_PATHFIND_SET_ROADS_BACK_TO_ORIGINAL(float p0, float p1, float p2, float p3, float p4, float p5, Any p6)
 	{
 		PATHFIND::SET_ROADS_BACK_TO_ORIGINAL(p0, p1, p2, p3, p4, p5, p6);
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA( float x1, float y1, float z1, float x2, float y2, float z2, float width, Any p7 )
+	static void LUA_NATIVE_PATHFIND_SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA(float x1, float y1, float z1, float x2, float y2, float z2, float width, Any p7)
 	{
 		PATHFIND::SET_ROADS_BACK_TO_ORIGINAL_IN_ANGLED_AREA(x1, y1, z1, x2, y2, z2, width, p7);
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_AMBIENT_PED_RANGE_MULTIPLIER_THIS_FRAME( float multiplier )
+	static void LUA_NATIVE_PATHFIND_SET_AMBIENT_PED_RANGE_MULTIPLIER_THIS_FRAME(float multiplier)
 	{
 		PATHFIND::SET_AMBIENT_PED_RANGE_MULTIPLIER_THIS_FRAME(multiplier);
 	}
 
-	static void LUA_NATIVE_PATHFIND_ADJUST_AMBIENT_PED_SPAWN_DENSITIES_THIS_FRAME( Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6 )
+	static void LUA_NATIVE_PATHFIND_ADJUST_AMBIENT_PED_SPAWN_DENSITIES_THIS_FRAME(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5, Any p6)
 	{
 		PATHFIND::ADJUST_AMBIENT_PED_SPAWN_DENSITIES_THIS_FRAME(p0, p1, p2, p3, p4, p5, p6);
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_PED_PATHS_BACK_TO_ORIGINAL( float x1, float y1, float z1, float x2, float y2, float z2, Any p6 )
+	static void LUA_NATIVE_PATHFIND_SET_PED_PATHS_BACK_TO_ORIGINAL(float x1, float y1, float z1, float x2, float y2, float z2, Any p6)
 	{
 		PATHFIND::SET_PED_PATHS_BACK_TO_ORIGINAL(x1, y1, z1, x2, y2, z2, p6);
 	}
 
-	static std::tuple<bool, Vector3, int> LUA_NATIVE_PATHFIND_GET_RANDOM_VEHICLE_NODE( float x, float y, float z, float radius, bool p4, bool p5, bool p6, Vector3 outPosition, int nodeId )
+	static std::tuple<bool, Vector3, int> LUA_NATIVE_PATHFIND_GET_RANDOM_VEHICLE_NODE(float x, float y, float z, float radius, bool p4, bool p5, bool p6, Vector3 outPosition, int nodeId)
 	{
 		std::tuple<bool, Vector3, int> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_RANDOM_VEHICLE_NODE(x, y, z, radius, p4, p5, p6, &outPosition, &nodeId);
@@ -211,7 +211,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Vector3, Vector3, float> LUA_NATIVE_PATHFIND_GET_SPAWN_COORDS_FOR_VEHICLE_NODE( int nodeAddress, float towardsCoorsX, float towardsCoorsY, float towardsCoorsZ, Vector3 centrePoint, float heading )
+	static std::tuple<Vector3, Vector3, float> LUA_NATIVE_PATHFIND_GET_SPAWN_COORDS_FOR_VEHICLE_NODE(int nodeAddress, float towardsCoorsX, float towardsCoorsY, float towardsCoorsZ, Vector3 centrePoint, float heading)
 	{
 		std::tuple<Vector3, Vector3, float> return_values;
 		std::get<0>(return_values) = PATHFIND::GET_SPAWN_COORDS_FOR_VEHICLE_NODE(nodeAddress, towardsCoorsX, towardsCoorsY, towardsCoorsZ, &centrePoint, &heading);
@@ -221,7 +221,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<Hash, Hash> LUA_NATIVE_PATHFIND_GET_STREET_NAME_AT_COORD( float x, float y, float z, Hash streetName, Hash crossingRoad )
+	static std::tuple<Hash, Hash> LUA_NATIVE_PATHFIND_GET_STREET_NAME_AT_COORD(float x, float y, float z, Hash streetName, Hash crossingRoad)
 	{
 		std::tuple<Hash, Hash> return_values;
 		PATHFIND::GET_STREET_NAME_AT_COORD(x, y, z, &streetName, &crossingRoad);
@@ -231,7 +231,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, int, float, float> LUA_NATIVE_PATHFIND_GENERATE_DIRECTIONS_TO_COORD( float x, float y, float z, bool p3, int direction, float p5, float distToNxJunction )
+	static std::tuple<int, int, float, float> LUA_NATIVE_PATHFIND_GENERATE_DIRECTIONS_TO_COORD(float x, float y, float z, bool p3, int direction, float p5, float distToNxJunction)
 	{
 		std::tuple<int, int, float, float> return_values;
 		std::get<0>(return_values) = PATHFIND::GENERATE_DIRECTIONS_TO_COORD(x, y, z, p3, &direction, &p5, &distToNxJunction);
@@ -242,28 +242,28 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_IGNORE_NO_GPS_FLAG( bool toggle )
+	static void LUA_NATIVE_PATHFIND_SET_IGNORE_NO_GPS_FLAG(bool toggle)
 	{
 		PATHFIND::SET_IGNORE_NO_GPS_FLAG(toggle);
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_IGNORE_NO_GPS_FLAG_UNTIL_FIRST_NORMAL_NODE( bool toggle )
+	static void LUA_NATIVE_PATHFIND_SET_IGNORE_NO_GPS_FLAG_UNTIL_FIRST_NORMAL_NODE(bool toggle)
 	{
 		PATHFIND::SET_IGNORE_NO_GPS_FLAG_UNTIL_FIRST_NORMAL_NODE(toggle);
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_GPS_DISABLED_ZONE( float x1, float y1, float z1, float x2, float y2, float z3 )
+	static void LUA_NATIVE_PATHFIND_SET_GPS_DISABLED_ZONE(float x1, float y1, float z1, float x2, float y2, float z3)
 	{
 		PATHFIND::SET_GPS_DISABLED_ZONE(x1, y1, z1, x2, y2, z3);
 	}
 
-	static int LUA_NATIVE_PATHFIND_GET_GPS_BLIP_ROUTE_LENGTH(  )
+	static int LUA_NATIVE_PATHFIND_GET_GPS_BLIP_ROUTE_LENGTH()
 	{
 		auto retval = PATHFIND::GET_GPS_BLIP_ROUTE_LENGTH();
 		return retval;
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_POS_ALONG_GPS_TYPE_ROUTE( Vector3 result, bool p1, float p2, int p3 )
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_POS_ALONG_GPS_TYPE_ROUTE(Vector3 result, bool p1, float p2, int p3)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_POS_ALONG_GPS_TYPE_ROUTE(&result, p1, p2, p3);
@@ -272,13 +272,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_PATHFIND_GET_GPS_BLIP_ROUTE_FOUND(  )
+	static bool LUA_NATIVE_PATHFIND_GET_GPS_BLIP_ROUTE_FOUND()
 	{
 		auto retval = (bool)PATHFIND::GET_GPS_BLIP_ROUTE_FOUND();
 		return retval;
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_ROAD_BOUNDARY_USING_HEADING( float x, float y, float z, float heading, Vector3 outPosition )
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_ROAD_BOUNDARY_USING_HEADING(float x, float y, float z, float heading, Vector3 outPosition)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_ROAD_BOUNDARY_USING_HEADING(x, y, z, heading, &outPosition);
@@ -287,7 +287,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_POSITION_BY_SIDE_OF_ROAD( float x, float y, float z, int p3, Vector3 outPosition )
+	static std::tuple<bool, Vector3> LUA_NATIVE_PATHFIND_GET_POSITION_BY_SIDE_OF_ROAD(float x, float y, float z, int p3, Vector3 outPosition)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)PATHFIND::GET_POSITION_BY_SIDE_OF_ROAD(x, y, z, p3, &outPosition);
@@ -296,114 +296,114 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_PATHFIND_IS_POINT_ON_ROAD( float x, float y, float z, Vehicle vehicle )
+	static bool LUA_NATIVE_PATHFIND_IS_POINT_ON_ROAD(float x, float y, float z, Vehicle vehicle)
 	{
 		auto retval = (bool)PATHFIND::IS_POINT_ON_ROAD(x, y, z, vehicle);
 		return retval;
 	}
 
-	static int LUA_NATIVE_PATHFIND_GET_NEXT_GPS_DISABLED_ZONE_INDEX(  )
+	static int LUA_NATIVE_PATHFIND_GET_NEXT_GPS_DISABLED_ZONE_INDEX()
 	{
 		auto retval = PATHFIND::GET_NEXT_GPS_DISABLED_ZONE_INDEX();
 		return retval;
 	}
 
-	static void LUA_NATIVE_PATHFIND_SET_GPS_DISABLED_ZONE_AT_INDEX( float x1, float y1, float z1, float x2, float y2, float z2, int index )
+	static void LUA_NATIVE_PATHFIND_SET_GPS_DISABLED_ZONE_AT_INDEX(float x1, float y1, float z1, float x2, float y2, float z2, int index)
 	{
 		PATHFIND::SET_GPS_DISABLED_ZONE_AT_INDEX(x1, y1, z1, x2, y2, z2, index);
 	}
 
-	static void LUA_NATIVE_PATHFIND_CLEAR_GPS_DISABLED_ZONE_AT_INDEX( int index )
+	static void LUA_NATIVE_PATHFIND_CLEAR_GPS_DISABLED_ZONE_AT_INDEX(int index)
 	{
 		PATHFIND::CLEAR_GPS_DISABLED_ZONE_AT_INDEX(index);
 	}
 
-	static void LUA_NATIVE_PATHFIND_ADD_NAVMESH_REQUIRED_REGION( float x, float y, float radius )
+	static void LUA_NATIVE_PATHFIND_ADD_NAVMESH_REQUIRED_REGION(float x, float y, float radius)
 	{
 		PATHFIND::ADD_NAVMESH_REQUIRED_REGION(x, y, radius);
 	}
 
-	static void LUA_NATIVE_PATHFIND_REMOVE_NAVMESH_REQUIRED_REGIONS(  )
+	static void LUA_NATIVE_PATHFIND_REMOVE_NAVMESH_REQUIRED_REGIONS()
 	{
 		PATHFIND::REMOVE_NAVMESH_REQUIRED_REGIONS();
 	}
 
-	static bool LUA_NATIVE_PATHFIND_IS_NAVMESH_REQUIRED_REGION_IN_USE(  )
+	static bool LUA_NATIVE_PATHFIND_IS_NAVMESH_REQUIRED_REGION_IN_USE()
 	{
 		auto retval = (bool)PATHFIND::IS_NAVMESH_REQUIRED_REGION_IN_USE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_PATHFIND_DISABLE_NAVMESH_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2, bool toggle )
+	static void LUA_NATIVE_PATHFIND_DISABLE_NAVMESH_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2, bool toggle)
 	{
 		PATHFIND::DISABLE_NAVMESH_IN_AREA(x1, y1, z1, x2, y2, z2, toggle);
 	}
 
-	static bool LUA_NATIVE_PATHFIND_ARE_ALL_NAVMESH_REGIONS_LOADED(  )
+	static bool LUA_NATIVE_PATHFIND_ARE_ALL_NAVMESH_REGIONS_LOADED()
 	{
 		auto retval = (bool)PATHFIND::ARE_ALL_NAVMESH_REGIONS_LOADED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_PATHFIND_IS_NAVMESH_LOADED_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2 )
+	static bool LUA_NATIVE_PATHFIND_IS_NAVMESH_LOADED_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		auto retval = (bool)PATHFIND::IS_NAVMESH_LOADED_IN_AREA(x1, y1, z1, x2, y2, z2);
 		return retval;
 	}
 
-	static int LUA_NATIVE_PATHFIND_GET_NUM_NAVMESHES_EXISTING_IN_AREA( float x1, float y1, float z1, float x2, float y2, float z2 )
+	static int LUA_NATIVE_PATHFIND_GET_NUM_NAVMESHES_EXISTING_IN_AREA(float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		auto retval = PATHFIND::GET_NUM_NAVMESHES_EXISTING_IN_AREA(x1, y1, z1, x2, y2, z2);
 		return retval;
 	}
 
-	static int LUA_NATIVE_PATHFIND_ADD_NAVMESH_BLOCKING_OBJECT( float p0, float p1, float p2, float p3, float p4, float p5, float p6, bool p7, Any p8 )
+	static int LUA_NATIVE_PATHFIND_ADD_NAVMESH_BLOCKING_OBJECT(float p0, float p1, float p2, float p3, float p4, float p5, float p6, bool p7, Any p8)
 	{
 		auto retval = PATHFIND::ADD_NAVMESH_BLOCKING_OBJECT(p0, p1, p2, p3, p4, p5, p6, p7, p8);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PATHFIND_UPDATE_NAVMESH_BLOCKING_OBJECT( Any p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, Any p8 )
+	static void LUA_NATIVE_PATHFIND_UPDATE_NAVMESH_BLOCKING_OBJECT(Any p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, Any p8)
 	{
 		PATHFIND::UPDATE_NAVMESH_BLOCKING_OBJECT(p0, p1, p2, p3, p4, p5, p6, p7, p8);
 	}
 
-	static void LUA_NATIVE_PATHFIND_REMOVE_NAVMESH_BLOCKING_OBJECT( Any p0 )
+	static void LUA_NATIVE_PATHFIND_REMOVE_NAVMESH_BLOCKING_OBJECT(Any p0)
 	{
 		PATHFIND::REMOVE_NAVMESH_BLOCKING_OBJECT(p0);
 	}
 
-	static bool LUA_NATIVE_PATHFIND_DOES_NAVMESH_BLOCKING_OBJECT_EXIST( Any p0 )
+	static bool LUA_NATIVE_PATHFIND_DOES_NAVMESH_BLOCKING_OBJECT_EXIST(Any p0)
 	{
 		auto retval = (bool)PATHFIND::DOES_NAVMESH_BLOCKING_OBJECT_EXIST(p0);
 		return retval;
 	}
 
-	static float LUA_NATIVE_PATHFIND_GET_APPROX_HEIGHT_FOR_POINT( float x, float y )
+	static float LUA_NATIVE_PATHFIND_GET_APPROX_HEIGHT_FOR_POINT(float x, float y)
 	{
 		auto retval = PATHFIND::GET_APPROX_HEIGHT_FOR_POINT(x, y);
 		return retval;
 	}
 
-	static float LUA_NATIVE_PATHFIND_GET_APPROX_HEIGHT_FOR_AREA( float x1, float y1, float x2, float y2 )
+	static float LUA_NATIVE_PATHFIND_GET_APPROX_HEIGHT_FOR_AREA(float x1, float y1, float x2, float y2)
 	{
 		auto retval = PATHFIND::GET_APPROX_HEIGHT_FOR_AREA(x1, y1, x2, y2);
 		return retval;
 	}
 
-	static float LUA_NATIVE_PATHFIND_GET_APPROX_FLOOR_FOR_POINT( float x, float y )
+	static float LUA_NATIVE_PATHFIND_GET_APPROX_FLOOR_FOR_POINT(float x, float y)
 	{
 		auto retval = PATHFIND::GET_APPROX_FLOOR_FOR_POINT(x, y);
 		return retval;
 	}
 
-	static float LUA_NATIVE_PATHFIND_GET_APPROX_FLOOR_FOR_AREA( float x1, float y1, float x2, float y2 )
+	static float LUA_NATIVE_PATHFIND_GET_APPROX_FLOOR_FOR_AREA(float x1, float y1, float x2, float y2)
 	{
 		auto retval = PATHFIND::GET_APPROX_FLOOR_FOR_AREA(x1, y1, x2, y2);
 		return retval;
 	}
 
-	static float LUA_NATIVE_PATHFIND_CALCULATE_TRAVEL_DISTANCE_BETWEEN_POINTS( float x1, float y1, float z1, float x2, float y2, float z2 )
+	static float LUA_NATIVE_PATHFIND_CALCULATE_TRAVEL_DISTANCE_BETWEEN_POINTS(float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		auto retval = PATHFIND::CALCULATE_TRAVEL_DISTANCE_BETWEEN_POINTS(x1, y1, z1, x2, y2, z2);
 		return retval;

src/lua/natives/lua_native_binding_PHYSICS.cpp

@@ -3,7 +3,7 @@
 
 namespace lua::native
 {
-	static std::tuple<int, Any> LUA_NATIVE_PHYSICS_ADD_ROPE( float x, float y, float z, float rotX, float rotY, float rotZ, float length, int ropeType, float maxLength, float minLength, float windingSpeed, bool p11, bool p12, bool rigid, float p14, bool breakWhenShot, Any unkPtr )
+	static std::tuple<int, Any> LUA_NATIVE_PHYSICS_ADD_ROPE(float x, float y, float z, float rotX, float rotY, float rotZ, float length, int ropeType, float maxLength, float minLength, float windingSpeed, bool p11, bool p12, bool rigid, float p14, bool breakWhenShot, Any unkPtr)
 	{
 		std::tuple<int, Any> return_values;
 		std::get<0>(return_values) = PHYSICS::ADD_ROPE(x, y, z, rotX, rotY, rotZ, length, ropeType, maxLength, minLength, windingSpeed, p11, p12, rigid, p14, breakWhenShot, &unkPtr);
@@ -12,18 +12,18 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_PHYSICS_DELETE_ROPE( int ropeId )
+	static int LUA_NATIVE_PHYSICS_DELETE_ROPE(int ropeId)
 	{
 		PHYSICS::DELETE_ROPE(&ropeId);
 		return ropeId;
 	}
 
-	static void LUA_NATIVE_PHYSICS_DELETE_CHILD_ROPE( int ropeId )
+	static void LUA_NATIVE_PHYSICS_DELETE_CHILD_ROPE(int ropeId)
 	{
 		PHYSICS::DELETE_CHILD_ROPE(ropeId);
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_PHYSICS_DOES_ROPE_EXIST( int ropeId )
+	static std::tuple<bool, int> LUA_NATIVE_PHYSICS_DOES_ROPE_EXIST(int ropeId)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)PHYSICS::DOES_ROPE_EXIST(&ropeId);
@@ -32,40 +32,40 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_PHYSICS_ROPE_DRAW_ENABLED( int ropeId, bool p1 )
+	static int LUA_NATIVE_PHYSICS_ROPE_DRAW_ENABLED(int ropeId, bool p1)
 	{
 		PHYSICS::ROPE_DRAW_ENABLED(&ropeId, p1);
 		return ropeId;
 	}
 
-	static int LUA_NATIVE_PHYSICS_ROPE_DRAW_SHADOW_ENABLED( int ropeId, bool toggle )
+	static int LUA_NATIVE_PHYSICS_ROPE_DRAW_SHADOW_ENABLED(int ropeId, bool toggle)
 	{
 		PHYSICS::ROPE_DRAW_SHADOW_ENABLED(&ropeId, toggle);
 		return ropeId;
 	}
 
-	static void LUA_NATIVE_PHYSICS_LOAD_ROPE_DATA( int ropeId, const char* rope_preset )
+	static void LUA_NATIVE_PHYSICS_LOAD_ROPE_DATA(int ropeId, const char* rope_preset)
 	{
 		PHYSICS::LOAD_ROPE_DATA(ropeId, rope_preset);
 	}
 
-	static void LUA_NATIVE_PHYSICS_PIN_ROPE_VERTEX( int ropeId, int vertex, float x, float y, float z )
+	static void LUA_NATIVE_PHYSICS_PIN_ROPE_VERTEX(int ropeId, int vertex, float x, float y, float z)
 	{
 		PHYSICS::PIN_ROPE_VERTEX(ropeId, vertex, x, y, z);
 	}
 
-	static void LUA_NATIVE_PHYSICS_UNPIN_ROPE_VERTEX( int ropeId, int vertex )
+	static void LUA_NATIVE_PHYSICS_UNPIN_ROPE_VERTEX(int ropeId, int vertex)
 	{
 		PHYSICS::UNPIN_ROPE_VERTEX(ropeId, vertex);
 	}
 
-	static int LUA_NATIVE_PHYSICS_GET_ROPE_VERTEX_COUNT( int ropeId )
+	static int LUA_NATIVE_PHYSICS_GET_ROPE_VERTEX_COUNT(int ropeId)
 	{
 		auto retval = PHYSICS::GET_ROPE_VERTEX_COUNT(ropeId);
 		return retval;
 	}
 
-	static std::tuple<Any, Any> LUA_NATIVE_PHYSICS_ATTACH_ENTITIES_TO_ROPE( int ropeId, Entity ent1, Entity ent2, float ent1_x, float ent1_y, float ent1_z, float ent2_x, float ent2_y, float ent2_z, float length, bool p10, bool p11, Any p12, Any p13 )
+	static std::tuple<Any, Any> LUA_NATIVE_PHYSICS_ATTACH_ENTITIES_TO_ROPE(int ropeId, Entity ent1, Entity ent2, float ent1_x, float ent1_y, float ent1_z, float ent2_x, float ent2_y, float ent2_z, float length, bool p10, bool p11, Any p12, Any p13)
 	{
 		std::tuple<Any, Any> return_values;
 		PHYSICS::ATTACH_ENTITIES_TO_ROPE(ropeId, ent1, ent2, ent1_x, ent1_y, ent1_z, ent2_x, ent2_y, ent2_z, length, p10, p11, &p12, &p13);
@@ -75,32 +75,32 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_PHYSICS_ATTACH_ROPE_TO_ENTITY( int ropeId, Entity entity, float x, float y, float z, bool p5 )
+	static void LUA_NATIVE_PHYSICS_ATTACH_ROPE_TO_ENTITY(int ropeId, Entity entity, float x, float y, float z, bool p5)
 	{
 		PHYSICS::ATTACH_ROPE_TO_ENTITY(ropeId, entity, x, y, z, p5);
 	}
 
-	static void LUA_NATIVE_PHYSICS_DETACH_ROPE_FROM_ENTITY( int ropeId, Entity entity )
+	static void LUA_NATIVE_PHYSICS_DETACH_ROPE_FROM_ENTITY(int ropeId, Entity entity)
 	{
 		PHYSICS::DETACH_ROPE_FROM_ENTITY(ropeId, entity);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_SET_UPDATE_PINVERTS( int ropeId )
+	static void LUA_NATIVE_PHYSICS_ROPE_SET_UPDATE_PINVERTS(int ropeId)
 	{
 		PHYSICS::ROPE_SET_UPDATE_PINVERTS(ropeId);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_SET_UPDATE_ORDER( int ropeId, Any p1 )
+	static void LUA_NATIVE_PHYSICS_ROPE_SET_UPDATE_ORDER(int ropeId, Any p1)
 	{
 		PHYSICS::ROPE_SET_UPDATE_ORDER(ropeId, p1);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_SET_SMOOTH_REELIN( int ropeId, bool p1 )
+	static void LUA_NATIVE_PHYSICS_ROPE_SET_SMOOTH_REELIN(int ropeId, bool p1)
 	{
 		PHYSICS::ROPE_SET_SMOOTH_REELIN(ropeId, p1);
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_PHYSICS_IS_ROPE_ATTACHED_AT_BOTH_ENDS( int ropeId )
+	static std::tuple<bool, int> LUA_NATIVE_PHYSICS_IS_ROPE_ATTACHED_AT_BOTH_ENDS(int ropeId)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)PHYSICS::IS_ROPE_ATTACHED_AT_BOTH_ENDS(&ropeId);
@@ -109,164 +109,164 @@ namespace lua::native
 		return return_values;
 	}
 
-	static Vector3 LUA_NATIVE_PHYSICS_GET_ROPE_LAST_VERTEX_COORD( int ropeId )
+	static Vector3 LUA_NATIVE_PHYSICS_GET_ROPE_LAST_VERTEX_COORD(int ropeId)
 	{
 		auto retval = PHYSICS::GET_ROPE_LAST_VERTEX_COORD(ropeId);
 		return retval;
 	}
 
-	static Vector3 LUA_NATIVE_PHYSICS_GET_ROPE_VERTEX_COORD( int ropeId, int vertex )
+	static Vector3 LUA_NATIVE_PHYSICS_GET_ROPE_VERTEX_COORD(int ropeId, int vertex)
 	{
 		auto retval = PHYSICS::GET_ROPE_VERTEX_COORD(ropeId, vertex);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PHYSICS_START_ROPE_WINDING( int ropeId )
+	static void LUA_NATIVE_PHYSICS_START_ROPE_WINDING(int ropeId)
 	{
 		PHYSICS::START_ROPE_WINDING(ropeId);
 	}
 
-	static void LUA_NATIVE_PHYSICS_STOP_ROPE_WINDING( int ropeId )
+	static void LUA_NATIVE_PHYSICS_STOP_ROPE_WINDING(int ropeId)
 	{
 		PHYSICS::STOP_ROPE_WINDING(ropeId);
 	}
 
-	static void LUA_NATIVE_PHYSICS_START_ROPE_UNWINDING_FRONT( int ropeId )
+	static void LUA_NATIVE_PHYSICS_START_ROPE_UNWINDING_FRONT(int ropeId)
 	{
 		PHYSICS::START_ROPE_UNWINDING_FRONT(ropeId);
 	}
 
-	static void LUA_NATIVE_PHYSICS_STOP_ROPE_UNWINDING_FRONT( int ropeId )
+	static void LUA_NATIVE_PHYSICS_STOP_ROPE_UNWINDING_FRONT(int ropeId)
 	{
 		PHYSICS::STOP_ROPE_UNWINDING_FRONT(ropeId);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_CONVERT_TO_SIMPLE( int ropeId )
+	static void LUA_NATIVE_PHYSICS_ROPE_CONVERT_TO_SIMPLE(int ropeId)
 	{
 		PHYSICS::ROPE_CONVERT_TO_SIMPLE(ropeId);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_LOAD_TEXTURES(  )
+	static void LUA_NATIVE_PHYSICS_ROPE_LOAD_TEXTURES()
 	{
 		PHYSICS::ROPE_LOAD_TEXTURES();
 	}
 
-	static bool LUA_NATIVE_PHYSICS_ROPE_ARE_TEXTURES_LOADED(  )
+	static bool LUA_NATIVE_PHYSICS_ROPE_ARE_TEXTURES_LOADED()
 	{
 		auto retval = (bool)PHYSICS::ROPE_ARE_TEXTURES_LOADED();
 		return retval;
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_UNLOAD_TEXTURES(  )
+	static void LUA_NATIVE_PHYSICS_ROPE_UNLOAD_TEXTURES()
 	{
 		PHYSICS::ROPE_UNLOAD_TEXTURES();
 	}
 
-	static bool LUA_NATIVE_PHYSICS_DOES_SCRIPT_OWN_ROPE( int ropeId )
+	static bool LUA_NATIVE_PHYSICS_DOES_SCRIPT_OWN_ROPE(int ropeId)
 	{
 		auto retval = (bool)PHYSICS::DOES_SCRIPT_OWN_ROPE(ropeId);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_ATTACH_VIRTUAL_BOUND_GEOM( int ropeId, int p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float p9, float p10, float p11, float p12, float p13 )
+	static void LUA_NATIVE_PHYSICS_ROPE_ATTACH_VIRTUAL_BOUND_GEOM(int ropeId, int p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float p9, float p10, float p11, float p12, float p13)
 	{
 		PHYSICS::ROPE_ATTACH_VIRTUAL_BOUND_GEOM(ropeId, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_CHANGE_SCRIPT_OWNER( Any p0, bool p1, bool p2 )
+	static void LUA_NATIVE_PHYSICS_ROPE_CHANGE_SCRIPT_OWNER(Any p0, bool p1, bool p2)
 	{
 		PHYSICS::ROPE_CHANGE_SCRIPT_OWNER(p0, p1, p2);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_SET_REFFRAMEVELOCITY_COLLIDERORDER( int ropeId, int p1 )
+	static void LUA_NATIVE_PHYSICS_ROPE_SET_REFFRAMEVELOCITY_COLLIDERORDER(int ropeId, int p1)
 	{
 		PHYSICS::ROPE_SET_REFFRAMEVELOCITY_COLLIDERORDER(ropeId, p1);
 	}
 
-	static float LUA_NATIVE_PHYSICS_ROPE_GET_DISTANCE_BETWEEN_ENDS( int ropeId )
+	static float LUA_NATIVE_PHYSICS_ROPE_GET_DISTANCE_BETWEEN_ENDS(int ropeId)
 	{
 		auto retval = PHYSICS::ROPE_GET_DISTANCE_BETWEEN_ENDS(ropeId);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_FORCE_LENGTH( int ropeId, float length )
+	static void LUA_NATIVE_PHYSICS_ROPE_FORCE_LENGTH(int ropeId, float length)
 	{
 		PHYSICS::ROPE_FORCE_LENGTH(ropeId, length);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ROPE_RESET_LENGTH( int ropeId, float length )
+	static void LUA_NATIVE_PHYSICS_ROPE_RESET_LENGTH(int ropeId, float length)
 	{
 		PHYSICS::ROPE_RESET_LENGTH(ropeId, length);
 	}
 
-	static void LUA_NATIVE_PHYSICS_APPLY_IMPULSE_TO_CLOTH( float posX, float posY, float posZ, float vecX, float vecY, float vecZ, float impulse )
+	static void LUA_NATIVE_PHYSICS_APPLY_IMPULSE_TO_CLOTH(float posX, float posY, float posZ, float vecX, float vecY, float vecZ, float impulse)
 	{
 		PHYSICS::APPLY_IMPULSE_TO_CLOTH(posX, posY, posZ, vecX, vecY, vecZ, impulse);
 	}
 
-	static void LUA_NATIVE_PHYSICS_SET_DAMPING( Entity entity, int vertex, float value )
+	static void LUA_NATIVE_PHYSICS_SET_DAMPING(Entity entity, int vertex, float value)
 	{
 		PHYSICS::SET_DAMPING(entity, vertex, value);
 	}
 
-	static void LUA_NATIVE_PHYSICS_ACTIVATE_PHYSICS( Entity entity )
+	static void LUA_NATIVE_PHYSICS_ACTIVATE_PHYSICS(Entity entity)
 	{
 		PHYSICS::ACTIVATE_PHYSICS(entity);
 	}
 
-	static void LUA_NATIVE_PHYSICS_SET_CGOFFSET( Entity entity, float x, float y, float z )
+	static void LUA_NATIVE_PHYSICS_SET_CGOFFSET(Entity entity, float x, float y, float z)
 	{
 		PHYSICS::SET_CGOFFSET(entity, x, y, z);
 	}
 
-	static Vector3 LUA_NATIVE_PHYSICS_GET_CGOFFSET( Entity entity )
+	static Vector3 LUA_NATIVE_PHYSICS_GET_CGOFFSET(Entity entity)
 	{
 		auto retval = PHYSICS::GET_CGOFFSET(entity);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PHYSICS_SET_CG_AT_BOUNDCENTER( Entity entity )
+	static void LUA_NATIVE_PHYSICS_SET_CG_AT_BOUNDCENTER(Entity entity)
 	{
 		PHYSICS::SET_CG_AT_BOUNDCENTER(entity);
 	}
 
-	static void LUA_NATIVE_PHYSICS_BREAK_ENTITY_GLASS( Entity entity, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, Any p9, bool p10 )
+	static void LUA_NATIVE_PHYSICS_BREAK_ENTITY_GLASS(Entity entity, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, Any p9, bool p10)
 	{
 		PHYSICS::BREAK_ENTITY_GLASS(entity, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
 	}
 
-	static bool LUA_NATIVE_PHYSICS_GET_IS_ENTITY_A_FRAG( Object object )
+	static bool LUA_NATIVE_PHYSICS_GET_IS_ENTITY_A_FRAG(Object object)
 	{
 		auto retval = (bool)PHYSICS::GET_IS_ENTITY_A_FRAG(object);
 		return retval;
 	}
 
-	static void LUA_NATIVE_PHYSICS_SET_DISABLE_BREAKING( Object object, bool toggle )
+	static void LUA_NATIVE_PHYSICS_SET_DISABLE_BREAKING(Object object, bool toggle)
 	{
 		PHYSICS::SET_DISABLE_BREAKING(object, toggle);
 	}
 
-	static void LUA_NATIVE_PHYSICS_RESET_DISABLE_BREAKING( Object object )
+	static void LUA_NATIVE_PHYSICS_RESET_DISABLE_BREAKING(Object object)
 	{
 		PHYSICS::RESET_DISABLE_BREAKING(object);
 	}
 
-	static void LUA_NATIVE_PHYSICS_SET_DISABLE_FRAG_DAMAGE( Object object, bool toggle )
+	static void LUA_NATIVE_PHYSICS_SET_DISABLE_FRAG_DAMAGE(Object object, bool toggle)
 	{
 		PHYSICS::SET_DISABLE_FRAG_DAMAGE(object, toggle);
 	}
 
-	static void LUA_NATIVE_PHYSICS_SET_USE_KINEMATIC_PHYSICS( Entity entity, bool toggle )
+	static void LUA_NATIVE_PHYSICS_SET_USE_KINEMATIC_PHYSICS(Entity entity, bool toggle)
 	{
 		PHYSICS::SET_USE_KINEMATIC_PHYSICS(entity, toggle);
 	}
 
-	static void LUA_NATIVE_PHYSICS_SET_IN_STUNT_MODE( bool p0 )
+	static void LUA_NATIVE_PHYSICS_SET_IN_STUNT_MODE(bool p0)
 	{
 		PHYSICS::SET_IN_STUNT_MODE(p0);
 	}
 
-	static void LUA_NATIVE_PHYSICS_SET_IN_ARENA_MODE( bool toggle )
+	static void LUA_NATIVE_PHYSICS_SET_IN_ARENA_MODE(bool toggle)
 	{
 		PHYSICS::SET_IN_ARENA_MODE(toggle);
 	}

src/lua/natives/lua_native_binding_RECORDING.cpp

@@ -3,91 +3,91 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_RECORDING_REPLAY_START_EVENT( int p0 )
+	static void LUA_NATIVE_RECORDING_REPLAY_START_EVENT(int p0)
 	{
 		RECORDING::REPLAY_START_EVENT(p0);
 	}
 
-	static void LUA_NATIVE_RECORDING_REPLAY_STOP_EVENT(  )
+	static void LUA_NATIVE_RECORDING_REPLAY_STOP_EVENT()
 	{
 		RECORDING::REPLAY_STOP_EVENT();
 	}
 
-	static void LUA_NATIVE_RECORDING_REPLAY_CANCEL_EVENT(  )
+	static void LUA_NATIVE_RECORDING_REPLAY_CANCEL_EVENT()
 	{
 		RECORDING::REPLAY_CANCEL_EVENT();
 	}
 
-	static void LUA_NATIVE_RECORDING_REPLAY_RECORD_BACK_FOR_TIME( float p0, float p1, int p2 )
+	static void LUA_NATIVE_RECORDING_REPLAY_RECORD_BACK_FOR_TIME(float p0, float p1, int p2)
 	{
 		RECORDING::REPLAY_RECORD_BACK_FOR_TIME(p0, p1, p2);
 	}
 
-	static void LUA_NATIVE_RECORDING_REPLAY_CHECK_FOR_EVENT_THIS_FRAME( const char* missionNameLabel, Any p1 )
+	static void LUA_NATIVE_RECORDING_REPLAY_CHECK_FOR_EVENT_THIS_FRAME(const char* missionNameLabel, Any p1)
 	{
 		RECORDING::REPLAY_CHECK_FOR_EVENT_THIS_FRAME(missionNameLabel, p1);
 	}
 
-	static void LUA_NATIVE_RECORDING_REPLAY_PREVENT_RECORDING_THIS_FRAME(  )
+	static void LUA_NATIVE_RECORDING_REPLAY_PREVENT_RECORDING_THIS_FRAME()
 	{
 		RECORDING::REPLAY_PREVENT_RECORDING_THIS_FRAME();
 	}
 
-	static void LUA_NATIVE_RECORDING_REPLAY_RESET_EVENT_INFO(  )
+	static void LUA_NATIVE_RECORDING_REPLAY_RESET_EVENT_INFO()
 	{
 		RECORDING::REPLAY_RESET_EVENT_INFO();
 	}
 
-	static void LUA_NATIVE_RECORDING_REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME(  )
+	static void LUA_NATIVE_RECORDING_REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME()
 	{
 		RECORDING::REPLAY_DISABLE_CAMERA_MOVEMENT_THIS_FRAME();
 	}
 
-	static void LUA_NATIVE_RECORDING_RECORD_GREATEST_MOMENT( int p0, int p1, int p2 )
+	static void LUA_NATIVE_RECORDING_RECORD_GREATEST_MOMENT(int p0, int p1, int p2)
 	{
 		RECORDING::RECORD_GREATEST_MOMENT(p0, p1, p2);
 	}
 
-	static void LUA_NATIVE_RECORDING_START_REPLAY_RECORDING( int mode )
+	static void LUA_NATIVE_RECORDING_START_REPLAY_RECORDING(int mode)
 	{
 		RECORDING::START_REPLAY_RECORDING(mode);
 	}
 
-	static void LUA_NATIVE_RECORDING_STOP_REPLAY_RECORDING(  )
+	static void LUA_NATIVE_RECORDING_STOP_REPLAY_RECORDING()
 	{
 		RECORDING::STOP_REPLAY_RECORDING();
 	}
 
-	static void LUA_NATIVE_RECORDING_CANCEL_REPLAY_RECORDING(  )
+	static void LUA_NATIVE_RECORDING_CANCEL_REPLAY_RECORDING()
 	{
 		RECORDING::CANCEL_REPLAY_RECORDING();
 	}
 
-	static bool LUA_NATIVE_RECORDING_SAVE_REPLAY_RECORDING(  )
+	static bool LUA_NATIVE_RECORDING_SAVE_REPLAY_RECORDING()
 	{
 		auto retval = (bool)RECORDING::SAVE_REPLAY_RECORDING();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_RECORDING_IS_REPLAY_RECORDING(  )
+	static bool LUA_NATIVE_RECORDING_IS_REPLAY_RECORDING()
 	{
 		auto retval = (bool)RECORDING::IS_REPLAY_RECORDING();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_RECORDING_IS_REPLAY_INITIALIZED(  )
+	static bool LUA_NATIVE_RECORDING_IS_REPLAY_INITIALIZED()
 	{
 		auto retval = (bool)RECORDING::IS_REPLAY_INITIALIZED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_RECORDING_IS_REPLAY_AVAILABLE(  )
+	static bool LUA_NATIVE_RECORDING_IS_REPLAY_AVAILABLE()
 	{
 		auto retval = (bool)RECORDING::IS_REPLAY_AVAILABLE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_RECORDING_IS_REPLAY_RECORD_SPACE_AVAILABLE( bool p0 )
+	static bool LUA_NATIVE_RECORDING_IS_REPLAY_RECORD_SPACE_AVAILABLE(bool p0)
 	{
 		auto retval = (bool)RECORDING::IS_REPLAY_RECORD_SPACE_AVAILABLE(p0);
 		return retval;

src/lua/natives/lua_native_binding_REPLAY.cpp

@@ -3,33 +3,33 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_REPLAY_REGISTER_EFFECT_FOR_REPLAY_EDITOR( const char* p0, bool p1 )
+	static void LUA_NATIVE_REPLAY_REGISTER_EFFECT_FOR_REPLAY_EDITOR(const char* p0, bool p1)
 	{
 		REPLAY::REGISTER_EFFECT_FOR_REPLAY_EDITOR(p0, p1);
 	}
 
-	static bool LUA_NATIVE_REPLAY_REPLAY_SYSTEM_HAS_REQUESTED_A_SCRIPT_CLEANUP(  )
+	static bool LUA_NATIVE_REPLAY_REPLAY_SYSTEM_HAS_REQUESTED_A_SCRIPT_CLEANUP()
 	{
 		auto retval = (bool)REPLAY::REPLAY_SYSTEM_HAS_REQUESTED_A_SCRIPT_CLEANUP();
 		return retval;
 	}
 
-	static void LUA_NATIVE_REPLAY_SET_SCRIPTS_HAVE_CLEANED_UP_FOR_REPLAY_SYSTEM(  )
+	static void LUA_NATIVE_REPLAY_SET_SCRIPTS_HAVE_CLEANED_UP_FOR_REPLAY_SYSTEM()
 	{
 		REPLAY::SET_SCRIPTS_HAVE_CLEANED_UP_FOR_REPLAY_SYSTEM();
 	}
 
-	static void LUA_NATIVE_REPLAY_SET_REPLAY_SYSTEM_PAUSED_FOR_SAVE( bool p0 )
+	static void LUA_NATIVE_REPLAY_SET_REPLAY_SYSTEM_PAUSED_FOR_SAVE(bool p0)
 	{
 		REPLAY::SET_REPLAY_SYSTEM_PAUSED_FOR_SAVE(p0);
 	}
 
-	static void LUA_NATIVE_REPLAY_REPLAY_CONTROL_SHUTDOWN(  )
+	static void LUA_NATIVE_REPLAY_REPLAY_CONTROL_SHUTDOWN()
 	{
 		REPLAY::REPLAY_CONTROL_SHUTDOWN();
 	}
 
-	static void LUA_NATIVE_REPLAY_ACTIVATE_ROCKSTAR_EDITOR( int p0 )
+	static void LUA_NATIVE_REPLAY_ACTIVATE_ROCKSTAR_EDITOR(int p0)
 	{
 		REPLAY::ACTIVATE_ROCKSTAR_EDITOR(p0);
 	}

src/lua/natives/lua_native_binding_SAVEMIGRATION.cpp

@@ -3,31 +3,31 @@
 
 namespace lua::native
 {
-	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_IS_MP_ENABLED(  )
+	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_IS_MP_ENABLED()
 	{
 		auto retval = (bool)SAVEMIGRATION::SAVEMIGRATION_IS_MP_ENABLED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_REQUEST_ACCOUNTS(  )
+	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_REQUEST_ACCOUNTS()
 	{
 		auto retval = (bool)SAVEMIGRATION::SAVEMIGRATION_MP_REQUEST_ACCOUNTS();
 		return retval;
 	}
 
-	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_ACCOUNTS_STATUS(  )
+	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_ACCOUNTS_STATUS()
 	{
 		auto retval = SAVEMIGRATION::SAVEMIGRATION_MP_GET_ACCOUNTS_STATUS();
 		return retval;
 	}
 
-	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_NUM_ACCOUNTS(  )
+	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_NUM_ACCOUNTS()
 	{
 		auto retval = SAVEMIGRATION::SAVEMIGRATION_MP_NUM_ACCOUNTS();
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_ACCOUNT( int p0, Any p1 )
+	static std::tuple<bool, Any> LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_ACCOUNT(int p0, Any p1)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)SAVEMIGRATION::SAVEMIGRATION_MP_GET_ACCOUNT(p0, &p1);
@@ -36,13 +36,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_REQUEST_STATUS(  )
+	static bool LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_REQUEST_STATUS()
 	{
 		auto retval = (bool)SAVEMIGRATION::SAVEMIGRATION_MP_REQUEST_STATUS();
 		return retval;
 	}
 
-	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_STATUS(  )
+	static int LUA_NATIVE_SAVEMIGRATION_SAVEMIGRATION_MP_GET_STATUS()
 	{
 		auto retval = SAVEMIGRATION::SAVEMIGRATION_MP_GET_STATUS();
 		return retval;

src/lua/natives/lua_native_binding_SCRIPT.cpp

@@ -3,126 +3,126 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_SCRIPT_REQUEST_SCRIPT( const char* scriptName )
+	static void LUA_NATIVE_SCRIPT_REQUEST_SCRIPT(const char* scriptName)
 	{
 		SCRIPT::REQUEST_SCRIPT(scriptName);
 	}
 
-	static void LUA_NATIVE_SCRIPT_SET_SCRIPT_AS_NO_LONGER_NEEDED( const char* scriptName )
+	static void LUA_NATIVE_SCRIPT_SET_SCRIPT_AS_NO_LONGER_NEEDED(const char* scriptName)
 	{
 		SCRIPT::SET_SCRIPT_AS_NO_LONGER_NEEDED(scriptName);
 	}
 
-	static bool LUA_NATIVE_SCRIPT_HAS_SCRIPT_LOADED( const char* scriptName )
+	static bool LUA_NATIVE_SCRIPT_HAS_SCRIPT_LOADED(const char* scriptName)
 	{
 		auto retval = (bool)SCRIPT::HAS_SCRIPT_LOADED(scriptName);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SCRIPT_DOES_SCRIPT_EXIST( const char* scriptName )
+	static bool LUA_NATIVE_SCRIPT_DOES_SCRIPT_EXIST(const char* scriptName)
 	{
 		auto retval = (bool)SCRIPT::DOES_SCRIPT_EXIST(scriptName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_SCRIPT_REQUEST_SCRIPT_WITH_NAME_HASH( Hash scriptHash )
+	static void LUA_NATIVE_SCRIPT_REQUEST_SCRIPT_WITH_NAME_HASH(Hash scriptHash)
 	{
 		SCRIPT::REQUEST_SCRIPT_WITH_NAME_HASH(scriptHash);
 	}
 
-	static void LUA_NATIVE_SCRIPT_SET_SCRIPT_WITH_NAME_HASH_AS_NO_LONGER_NEEDED( Hash scriptHash )
+	static void LUA_NATIVE_SCRIPT_SET_SCRIPT_WITH_NAME_HASH_AS_NO_LONGER_NEEDED(Hash scriptHash)
 	{
 		SCRIPT::SET_SCRIPT_WITH_NAME_HASH_AS_NO_LONGER_NEEDED(scriptHash);
 	}
 
-	static bool LUA_NATIVE_SCRIPT_HAS_SCRIPT_WITH_NAME_HASH_LOADED( Hash scriptHash )
+	static bool LUA_NATIVE_SCRIPT_HAS_SCRIPT_WITH_NAME_HASH_LOADED(Hash scriptHash)
 	{
 		auto retval = (bool)SCRIPT::HAS_SCRIPT_WITH_NAME_HASH_LOADED(scriptHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SCRIPT_DOES_SCRIPT_WITH_NAME_HASH_EXIST( Hash scriptHash )
+	static bool LUA_NATIVE_SCRIPT_DOES_SCRIPT_WITH_NAME_HASH_EXIST(Hash scriptHash)
 	{
 		auto retval = (bool)SCRIPT::DOES_SCRIPT_WITH_NAME_HASH_EXIST(scriptHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_SCRIPT_TERMINATE_THREAD( int threadId )
+	static void LUA_NATIVE_SCRIPT_TERMINATE_THREAD(int threadId)
 	{
 		SCRIPT::TERMINATE_THREAD(threadId);
 	}
 
-	static bool LUA_NATIVE_SCRIPT_IS_THREAD_ACTIVE( int threadId )
+	static bool LUA_NATIVE_SCRIPT_IS_THREAD_ACTIVE(int threadId)
 	{
 		auto retval = (bool)SCRIPT::IS_THREAD_ACTIVE(threadId);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_SCRIPT_GET_NAME_OF_SCRIPT_WITH_THIS_ID( int threadId )
+	static const char* LUA_NATIVE_SCRIPT_GET_NAME_OF_SCRIPT_WITH_THIS_ID(int threadId)
 	{
 		auto retval = SCRIPT::GET_NAME_OF_SCRIPT_WITH_THIS_ID(threadId);
 		return retval;
 	}
 
-	static void LUA_NATIVE_SCRIPT_SCRIPT_THREAD_ITERATOR_RESET(  )
+	static void LUA_NATIVE_SCRIPT_SCRIPT_THREAD_ITERATOR_RESET()
 	{
 		SCRIPT::SCRIPT_THREAD_ITERATOR_RESET();
 	}
 
-	static int LUA_NATIVE_SCRIPT_SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID(  )
+	static int LUA_NATIVE_SCRIPT_SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID()
 	{
 		auto retval = SCRIPT::SCRIPT_THREAD_ITERATOR_GET_NEXT_THREAD_ID();
 		return retval;
 	}
 
-	static int LUA_NATIVE_SCRIPT_GET_ID_OF_THIS_THREAD(  )
+	static int LUA_NATIVE_SCRIPT_GET_ID_OF_THIS_THREAD()
 	{
 		auto retval = SCRIPT::GET_ID_OF_THIS_THREAD();
 		return retval;
 	}
 
-	static void LUA_NATIVE_SCRIPT_TERMINATE_THIS_THREAD(  )
+	static void LUA_NATIVE_SCRIPT_TERMINATE_THIS_THREAD()
 	{
 		SCRIPT::TERMINATE_THIS_THREAD();
 	}
 
-	static int LUA_NATIVE_SCRIPT_GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH( Hash scriptHash )
+	static int LUA_NATIVE_SCRIPT_GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH(Hash scriptHash)
 	{
 		auto retval = SCRIPT::GET_NUMBER_OF_THREADS_RUNNING_THE_SCRIPT_WITH_THIS_HASH(scriptHash);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_SCRIPT_GET_THIS_SCRIPT_NAME(  )
+	static const char* LUA_NATIVE_SCRIPT_GET_THIS_SCRIPT_NAME()
 	{
 		auto retval = SCRIPT::GET_THIS_SCRIPT_NAME();
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_SCRIPT_GET_HASH_OF_THIS_SCRIPT_NAME(  )
+	static Hash LUA_NATIVE_SCRIPT_GET_HASH_OF_THIS_SCRIPT_NAME()
 	{
 		auto retval = SCRIPT::GET_HASH_OF_THIS_SCRIPT_NAME();
 		return retval;
 	}
 
-	static int LUA_NATIVE_SCRIPT_GET_NUMBER_OF_EVENTS( int eventGroup )
+	static int LUA_NATIVE_SCRIPT_GET_NUMBER_OF_EVENTS(int eventGroup)
 	{
 		auto retval = SCRIPT::GET_NUMBER_OF_EVENTS(eventGroup);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SCRIPT_GET_EVENT_EXISTS( int eventGroup, int eventIndex )
+	static bool LUA_NATIVE_SCRIPT_GET_EVENT_EXISTS(int eventGroup, int eventIndex)
 	{
 		auto retval = (bool)SCRIPT::GET_EVENT_EXISTS(eventGroup, eventIndex);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SCRIPT_GET_EVENT_AT_INDEX( int eventGroup, int eventIndex )
+	static int LUA_NATIVE_SCRIPT_GET_EVENT_AT_INDEX(int eventGroup, int eventIndex)
 	{
 		auto retval = SCRIPT::GET_EVENT_AT_INDEX(eventGroup, eventIndex);
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_SCRIPT_GET_EVENT_DATA( int eventGroup, int eventIndex, Any eventData, int eventDataSize )
+	static std::tuple<bool, Any> LUA_NATIVE_SCRIPT_GET_EVENT_DATA(int eventGroup, int eventIndex, Any eventData, int eventDataSize)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)SCRIPT::GET_EVENT_DATA(eventGroup, eventIndex, &eventData, eventDataSize);
@@ -131,83 +131,83 @@ namespace lua::native
 		return return_values;
 	}
 
-	static Any LUA_NATIVE_SCRIPT_TRIGGER_SCRIPT_EVENT( int eventGroup, Any eventData, int eventDataSize, int playerBits )
+	static Any LUA_NATIVE_SCRIPT_TRIGGER_SCRIPT_EVENT(int eventGroup, Any eventData, int eventDataSize, int playerBits)
 	{
 		SCRIPT::TRIGGER_SCRIPT_EVENT(eventGroup, &eventData, eventDataSize, playerBits);
 		return eventData;
 	}
 
-	static void LUA_NATIVE_SCRIPT_SHUTDOWN_LOADING_SCREEN(  )
+	static void LUA_NATIVE_SCRIPT_SHUTDOWN_LOADING_SCREEN()
 	{
 		SCRIPT::SHUTDOWN_LOADING_SCREEN();
 	}
 
-	static void LUA_NATIVE_SCRIPT_SET_NO_LOADING_SCREEN( bool toggle )
+	static void LUA_NATIVE_SCRIPT_SET_NO_LOADING_SCREEN(bool toggle)
 	{
 		SCRIPT::SET_NO_LOADING_SCREEN(toggle);
 	}
 
-	static bool LUA_NATIVE_SCRIPT_GET_NO_LOADING_SCREEN(  )
+	static bool LUA_NATIVE_SCRIPT_GET_NO_LOADING_SCREEN()
 	{
 		auto retval = (bool)SCRIPT::GET_NO_LOADING_SCREEN();
 		return retval;
 	}
 
-	static void LUA_NATIVE_SCRIPT_COMMIT_TO_LOADINGSCREEN_SELCTION(  )
+	static void LUA_NATIVE_SCRIPT_COMMIT_TO_LOADINGSCREEN_SELCTION()
 	{
 		SCRIPT::COMMIT_TO_LOADINGSCREEN_SELCTION();
 	}
 
-	static bool LUA_NATIVE_SCRIPT_BG_IS_EXITFLAG_SET(  )
+	static bool LUA_NATIVE_SCRIPT_BG_IS_EXITFLAG_SET()
 	{
 		auto retval = (bool)SCRIPT::BG_IS_EXITFLAG_SET();
 		return retval;
 	}
 
-	static void LUA_NATIVE_SCRIPT_BG_SET_EXITFLAG_RESPONSE(  )
+	static void LUA_NATIVE_SCRIPT_BG_SET_EXITFLAG_RESPONSE()
 	{
 		SCRIPT::BG_SET_EXITFLAG_RESPONSE();
 	}
 
-	static void LUA_NATIVE_SCRIPT_BG_START_CONTEXT_HASH( Hash contextHash )
+	static void LUA_NATIVE_SCRIPT_BG_START_CONTEXT_HASH(Hash contextHash)
 	{
 		SCRIPT::BG_START_CONTEXT_HASH(contextHash);
 	}
 
-	static void LUA_NATIVE_SCRIPT_BG_END_CONTEXT_HASH( Hash contextHash )
+	static void LUA_NATIVE_SCRIPT_BG_END_CONTEXT_HASH(Hash contextHash)
 	{
 		SCRIPT::BG_END_CONTEXT_HASH(contextHash);
 	}
 
-	static void LUA_NATIVE_SCRIPT_BG_START_CONTEXT( const char* contextName )
+	static void LUA_NATIVE_SCRIPT_BG_START_CONTEXT(const char* contextName)
 	{
 		SCRIPT::BG_START_CONTEXT(contextName);
 	}
 
-	static void LUA_NATIVE_SCRIPT_BG_END_CONTEXT( const char* contextName )
+	static void LUA_NATIVE_SCRIPT_BG_END_CONTEXT(const char* contextName)
 	{
 		SCRIPT::BG_END_CONTEXT(contextName);
 	}
 
-	static bool LUA_NATIVE_SCRIPT_BG_DOES_LAUNCH_PARAM_EXIST( int scriptIndex, const char* p1 )
+	static bool LUA_NATIVE_SCRIPT_BG_DOES_LAUNCH_PARAM_EXIST(int scriptIndex, const char* p1)
 	{
 		auto retval = (bool)SCRIPT::BG_DOES_LAUNCH_PARAM_EXIST(scriptIndex, p1);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SCRIPT_BG_GET_LAUNCH_PARAM_VALUE( int scriptIndex, const char* p1 )
+	static int LUA_NATIVE_SCRIPT_BG_GET_LAUNCH_PARAM_VALUE(int scriptIndex, const char* p1)
 	{
 		auto retval = SCRIPT::BG_GET_LAUNCH_PARAM_VALUE(scriptIndex, p1);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SCRIPT_BG_GET_SCRIPT_ID_FROM_NAME_HASH( Hash p0 )
+	static int LUA_NATIVE_SCRIPT_BG_GET_SCRIPT_ID_FROM_NAME_HASH(Hash p0)
 	{
 		auto retval = SCRIPT::BG_GET_SCRIPT_ID_FROM_NAME_HASH(p0);
 		return retval;
 	}
 
-	static Any LUA_NATIVE_SCRIPT_SEND_TU_SCRIPT_EVENT( int eventGroup, Any eventData, int eventDataSize, int playerBits )
+	static Any LUA_NATIVE_SCRIPT_SEND_TU_SCRIPT_EVENT(int eventGroup, Any eventData, int eventDataSize, int playerBits)
 	{
 		SCRIPT::SEND_TU_SCRIPT_EVENT(eventGroup, &eventData, eventDataSize, playerBits);
 		return eventData;

src/lua/natives/lua_native_binding_SECURITY.cpp

@@ -3,19 +3,19 @@
 
 namespace lua::native
 {
-	static Any LUA_NATIVE_SECURITY_REGISTER_SCRIPT_VARIABLE( Any variable )
+	static Any LUA_NATIVE_SECURITY_REGISTER_SCRIPT_VARIABLE(Any variable)
 	{
 		SECURITY::REGISTER_SCRIPT_VARIABLE(&variable);
 		return variable;
 	}
 
-	static Any LUA_NATIVE_SECURITY_UNREGISTER_SCRIPT_VARIABLE( Any variable )
+	static Any LUA_NATIVE_SECURITY_UNREGISTER_SCRIPT_VARIABLE(Any variable)
 	{
 		SECURITY::UNREGISTER_SCRIPT_VARIABLE(&variable);
 		return variable;
 	}
 
-	static void LUA_NATIVE_SECURITY_FORCE_CHECK_SCRIPT_VARIABLES(  )
+	static void LUA_NATIVE_SECURITY_FORCE_CHECK_SCRIPT_VARIABLES()
 	{
 		SECURITY::FORCE_CHECK_SCRIPT_VARIABLES();
 	}

src/lua/natives/lua_native_binding_SHAPETEST.cpp

@@ -3,49 +3,49 @@
 
 namespace lua::native
 {
-	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_LOS_PROBE( float x1, float y1, float z1, float x2, float y2, float z2, int flags, Entity entity, int p8 )
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_LOS_PROBE(float x1, float y1, float z1, float x2, float y2, float z2, int flags, Entity entity, int p8)
 	{
 		auto retval = SHAPETEST::START_SHAPE_TEST_LOS_PROBE(x1, y1, z1, x2, y2, z2, flags, entity, p8);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SHAPETEST_START_EXPENSIVE_SYNCHRONOUS_SHAPE_TEST_LOS_PROBE( float x1, float y1, float z1, float x2, float y2, float z2, int flags, Entity entity, int p8 )
+	static int LUA_NATIVE_SHAPETEST_START_EXPENSIVE_SYNCHRONOUS_SHAPE_TEST_LOS_PROBE(float x1, float y1, float z1, float x2, float y2, float z2, int flags, Entity entity, int p8)
 	{
 		auto retval = SHAPETEST::START_EXPENSIVE_SYNCHRONOUS_SHAPE_TEST_LOS_PROBE(x1, y1, z1, x2, y2, z2, flags, entity, p8);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOUNDING_BOX( Entity entity, int flags1, int flags2 )
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOUNDING_BOX(Entity entity, int flags1, int flags2)
 	{
 		auto retval = SHAPETEST::START_SHAPE_TEST_BOUNDING_BOX(entity, flags1, flags2);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOX( float x, float y, float z, float dimX, float dimY, float dimZ, float rotX, float rotY, float rotZ, Any p9, int flags, Entity entity, Any p12 )
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOX(float x, float y, float z, float dimX, float dimY, float dimZ, float rotX, float rotY, float rotZ, Any p9, int flags, Entity entity, Any p12)
 	{
 		auto retval = SHAPETEST::START_SHAPE_TEST_BOX(x, y, z, dimX, dimY, dimZ, rotX, rotY, rotZ, p9, flags, entity, p12);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOUND( Entity entity, int flags1, int flags2 )
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_BOUND(Entity entity, int flags1, int flags2)
 	{
 		auto retval = SHAPETEST::START_SHAPE_TEST_BOUND(entity, flags1, flags2);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_CAPSULE( float x1, float y1, float z1, float x2, float y2, float z2, float radius, int flags, Entity entity, int p9 )
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_CAPSULE(float x1, float y1, float z1, float x2, float y2, float z2, float radius, int flags, Entity entity, int p9)
 	{
 		auto retval = SHAPETEST::START_SHAPE_TEST_CAPSULE(x1, y1, z1, x2, y2, z2, radius, flags, entity, p9);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_SWEPT_SPHERE( float x1, float y1, float z1, float x2, float y2, float z2, float radius, int flags, Entity entity, Any p9 )
+	static int LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_SWEPT_SPHERE(float x1, float y1, float z1, float x2, float y2, float z2, float radius, int flags, Entity entity, Any p9)
 	{
 		auto retval = SHAPETEST::START_SHAPE_TEST_SWEPT_SPHERE(x1, y1, z1, x2, y2, z2, radius, flags, entity, p9);
 		return retval;
 	}
 
-	static std::tuple<int, Vector3, Vector3> LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_MOUSE_CURSOR_LOS_PROBE( Vector3 pVec1, Vector3 pVec2, int flag, Entity entity, int flag2 )
+	static std::tuple<int, Vector3, Vector3> LUA_NATIVE_SHAPETEST_START_SHAPE_TEST_MOUSE_CURSOR_LOS_PROBE(Vector3 pVec1, Vector3 pVec2, int flag, Entity entity, int flag2)
 	{
 		std::tuple<int, Vector3, Vector3> return_values;
 		std::get<0>(return_values) = SHAPETEST::START_SHAPE_TEST_MOUSE_CURSOR_LOS_PROBE(&pVec1, &pVec2, flag, entity, flag2);
@@ -55,7 +55,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, bool, Vector3, Vector3, Entity> LUA_NATIVE_SHAPETEST_GET_SHAPE_TEST_RESULT( int shapeTestHandle, bool hit, Vector3 endCoords, Vector3 surfaceNormal, Entity entityHit )
+	static std::tuple<int, bool, Vector3, Vector3, Entity> LUA_NATIVE_SHAPETEST_GET_SHAPE_TEST_RESULT(int shapeTestHandle, bool hit, Vector3 endCoords, Vector3 surfaceNormal, Entity entityHit)
 	{
 		std::tuple<int, bool, Vector3, Vector3, Entity> return_values;
 		std::get<0>(return_values) = SHAPETEST::GET_SHAPE_TEST_RESULT(shapeTestHandle, (BOOL*)&hit, &endCoords, &surfaceNormal, &entityHit);
@@ -67,7 +67,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, bool, Vector3, Vector3, Hash, Entity> LUA_NATIVE_SHAPETEST_GET_SHAPE_TEST_RESULT_INCLUDING_MATERIAL( int shapeTestHandle, bool hit, Vector3 endCoords, Vector3 surfaceNormal, Hash materialHash, Entity entityHit )
+	static std::tuple<int, bool, Vector3, Vector3, Hash, Entity> LUA_NATIVE_SHAPETEST_GET_SHAPE_TEST_RESULT_INCLUDING_MATERIAL(int shapeTestHandle, bool hit, Vector3 endCoords, Vector3 surfaceNormal, Hash materialHash, Entity entityHit)
 	{
 		std::tuple<int, bool, Vector3, Vector3, Hash, Entity> return_values;
 		std::get<0>(return_values) = SHAPETEST::GET_SHAPE_TEST_RESULT_INCLUDING_MATERIAL(shapeTestHandle, (BOOL*)&hit, &endCoords, &surfaceNormal, &materialHash, &entityHit);
@@ -80,7 +80,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_SHAPETEST_RELEASE_SCRIPT_GUID_FROM_ENTITY( Entity entityHit )
+	static void LUA_NATIVE_SHAPETEST_RELEASE_SCRIPT_GUID_FROM_ENTITY(Entity entityHit)
 	{
 		SHAPETEST::RELEASE_SCRIPT_GUID_FROM_ENTITY(entityHit);
 	}

src/lua/natives/lua_native_binding_SOCIALCLUB.cpp

@@ -3,31 +3,31 @@
 
 namespace lua::native
 {
-	static int LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_TOTAL_NUM_MESSAGES(  )
+	static int LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_TOTAL_NUM_MESSAGES()
 	{
 		auto retval = SOCIALCLUB::SC_INBOX_GET_TOTAL_NUM_MESSAGES();
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_MESSAGE_TYPE_AT_INDEX( int msgIndex )
+	static Hash LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_MESSAGE_TYPE_AT_INDEX(int msgIndex)
 	{
 		auto retval = SOCIALCLUB::SC_INBOX_GET_MESSAGE_TYPE_AT_INDEX(msgIndex);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_MESSAGE_IS_READ_AT_INDEX( int msgIndex )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_MESSAGE_IS_READ_AT_INDEX(int msgIndex)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_INBOX_GET_MESSAGE_IS_READ_AT_INDEX(msgIndex);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_SET_MESSAGE_AS_READ_AT_INDEX( int msgIndex )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_SET_MESSAGE_AS_READ_AT_INDEX(int msgIndex)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_INBOX_SET_MESSAGE_AS_READ_AT_INDEX(msgIndex);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_INT( int p0, const char* context, int out )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_INT(int p0, const char* context, int out)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_GET_DATA_INT(p0, context, &out);
@@ -36,13 +36,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_BOOL( int p0, const char* p1 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_BOOL(int p0, const char* p1)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_GET_DATA_BOOL(p0, p1);
 		return retval;
 	}
 
-	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_STRING( int p0, const char* context, char out )
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_DATA_STRING(int p0, const char* context, char out)
 	{
 		std::tuple<bool, char> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_GET_DATA_STRING(p0, context, &out);
@@ -51,31 +51,31 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_DO_APPLY( int p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_DO_APPLY(int p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_DO_APPLY(p0);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_RAW_TYPE_AT_INDEX( int p0 )
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_RAW_TYPE_AT_INDEX(int p0)
 	{
 		auto retval = SOCIALCLUB::SC_INBOX_MESSAGE_GET_RAW_TYPE_AT_INDEX(p0);
 		return retval;
 	}
 
-	static Any LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_PUSH_GAMER_T0_RECIP_LIST( Any gamerHandle )
+	static Any LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_PUSH_GAMER_T0_RECIP_LIST(Any gamerHandle)
 	{
 		SOCIALCLUB::SC_INBOX_MESSAGE_PUSH_GAMER_T0_RECIP_LIST(&gamerHandle);
 		return gamerHandle;
 	}
 
-	static Any LUA_NATIVE_SOCIALCLUB_SC_INBOX_SEND_UGCSTATUPDATE_TO_RECIP_LIST( Any data )
+	static Any LUA_NATIVE_SOCIALCLUB_SC_INBOX_SEND_UGCSTATUPDATE_TO_RECIP_LIST(Any data)
 	{
 		SOCIALCLUB::SC_INBOX_SEND_UGCSTATUPDATE_TO_RECIP_LIST(&data);
 		return data;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_UGCDATA( int p0, Any p1 )
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_MESSAGE_GET_UGCDATA(int p0, Any p1)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_MESSAGE_GET_UGCDATA(p0, &p1);
@@ -84,7 +84,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_SEND_BOUNTY_TO_RECIP_LIST( Any data )
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_SEND_BOUNTY_TO_RECIP_LIST(Any data)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_SEND_BOUNTY_TO_RECIP_LIST(&data);
@@ -93,7 +93,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_BOUNTY_DATA_AT_INDEX( int index, Any outData )
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_INBOX_GET_BOUNTY_DATA_AT_INDEX(int index, Any outData)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_INBOX_GET_BOUNTY_DATA_AT_INDEX(index, &outData);
@@ -102,24 +102,24 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_RETRIEVE_EMAILS( int offset, int limit )
+	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_RETRIEVE_EMAILS(int offset, int limit)
 	{
 		SOCIALCLUB::SC_EMAIL_RETRIEVE_EMAILS(offset, limit);
 	}
 
-	static int LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_RETRIEVAL_STATUS(  )
+	static int LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_RETRIEVAL_STATUS()
 	{
 		auto retval = SOCIALCLUB::SC_EMAIL_GET_RETRIEVAL_STATUS();
 		return retval;
 	}
 
-	static int LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_NUM_RETRIEVED_EMAILS(  )
+	static int LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_NUM_RETRIEVED_EMAILS()
 	{
 		auto retval = SOCIALCLUB::SC_EMAIL_GET_NUM_RETRIEVED_EMAILS();
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_EMAIL_AT_INDEX( int p0, Any p1 )
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_EMAIL_GET_EMAIL_AT_INDEX(int p0, Any p1)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_EMAIL_GET_EMAIL_AT_INDEX(p0, &p1);
@@ -128,76 +128,76 @@ namespace lua::native
 		return return_values;
 	}
 
-	static Any LUA_NATIVE_SOCIALCLUB_SC_EMAIL_DELETE_EMAILS( Any p0, Any p1 )
+	static Any LUA_NATIVE_SOCIALCLUB_SC_EMAIL_DELETE_EMAILS(Any p0, Any p1)
 	{
 		SOCIALCLUB::SC_EMAIL_DELETE_EMAILS(&p0, p1);
 		return p0;
 	}
 
-	static Any LUA_NATIVE_SOCIALCLUB_SC_EMAIL_MESSAGE_PUSH_GAMER_TO_RECIP_LIST( Any gamerHandle )
+	static Any LUA_NATIVE_SOCIALCLUB_SC_EMAIL_MESSAGE_PUSH_GAMER_TO_RECIP_LIST(Any gamerHandle)
 	{
 		SOCIALCLUB::SC_EMAIL_MESSAGE_PUSH_GAMER_TO_RECIP_LIST(&gamerHandle);
 		return gamerHandle;
 	}
 
-	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_MESSAGE_CLEAR_RECIP_LIST(  )
+	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_MESSAGE_CLEAR_RECIP_LIST()
 	{
 		SOCIALCLUB::SC_EMAIL_MESSAGE_CLEAR_RECIP_LIST();
 	}
 
-	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_SEND_EMAIL( const char* p0 )
+	static void LUA_NATIVE_SOCIALCLUB_SC_EMAIL_SEND_EMAIL(const char* p0)
 	{
 		SOCIALCLUB::SC_EMAIL_SEND_EMAIL(p0);
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_EMAIL_SET_CURRENT_EMAIL_TAG( Any p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_EMAIL_SET_CURRENT_EMAIL_TAG(Any p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_EMAIL_SET_CURRENT_EMAIL_TAG(p0);
 		return retval;
 	}
 
-	static void LUA_NATIVE_SOCIALCLUB_SC_CACHE_NEW_ROCKSTAR_MSGS( bool toggle )
+	static void LUA_NATIVE_SOCIALCLUB_SC_CACHE_NEW_ROCKSTAR_MSGS(bool toggle)
 	{
 		SOCIALCLUB::SC_CACHE_NEW_ROCKSTAR_MSGS(toggle);
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_HAS_NEW_ROCKSTAR_MSG(  )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_HAS_NEW_ROCKSTAR_MSG()
 	{
 		auto retval = (bool)SOCIALCLUB::SC_HAS_NEW_ROCKSTAR_MSG();
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_SOCIALCLUB_SC_GET_NEW_ROCKSTAR_MSG(  )
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_GET_NEW_ROCKSTAR_MSG()
 	{
 		auto retval = SOCIALCLUB::SC_GET_NEW_ROCKSTAR_MSG();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_INT( Hash attrHash, int value )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_INT(Hash attrHash, int value)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PRESENCE_ATTR_SET_INT(attrHash, value);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_FLOAT( Hash attrHash, float value )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_FLOAT(Hash attrHash, float value)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PRESENCE_ATTR_SET_FLOAT(attrHash, value);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_STRING( Hash attrHash, const char* value )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_ATTR_SET_STRING(Hash attrHash, const char* value)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PRESENCE_ATTR_SET_STRING(attrHash, value);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_SET_ACTIVITY_RATING( Any p0, float p1 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PRESENCE_SET_ACTIVITY_RATING(Any p0, float p1)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PRESENCE_SET_ACTIVITY_RATING(p0, p1);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_INT( const char* name, int value )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_INT(const char* name, int value)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_GAMERDATA_GET_INT(name, &value);
@@ -206,7 +206,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_FLOAT( const char* name, float value )
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_FLOAT(const char* name, float value)
 	{
 		std::tuple<bool, float> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_GAMERDATA_GET_FLOAT(name, &value);
@@ -215,13 +215,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_BOOL( const char* name )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_BOOL(const char* name)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_GAMERDATA_GET_BOOL(name);
 		return retval;
 	}
 
-	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_STRING( const char* name, char value )
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_STRING(const char* name, char value)
 	{
 		std::tuple<bool, char> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_GAMERDATA_GET_STRING(name, &value);
@@ -230,7 +230,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_ACTIVE_XP_BONUS( float value )
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_GAMERDATA_GET_ACTIVE_XP_BONUS(float value)
 	{
 		std::tuple<bool, float> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_GAMERDATA_GET_ACTIVE_XP_BONUS(&value);
@@ -239,7 +239,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_CHECK_STRING( const char* string, int token )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_CHECK_STRING(const char* string, int token)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_PROFANITY_CHECK_STRING(string, &token);
@@ -248,7 +248,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_CHECK_STRING_UGC( const char* string, int token )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_CHECK_STRING_UGC(const char* string, int token)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_PROFANITY_CHECK_STRING_UGC(string, &token);
@@ -257,31 +257,31 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_CHECK_IS_VALID( int token )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_CHECK_IS_VALID(int token)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PROFANITY_GET_CHECK_IS_VALID(token);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_CHECK_IS_PENDING( int token )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_CHECK_IS_PENDING(int token)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PROFANITY_GET_CHECK_IS_PENDING(token);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_STRING_PASSED( int token )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_STRING_PASSED(int token)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PROFANITY_GET_STRING_PASSED(token);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_STRING_STATUS( int token )
+	static int LUA_NATIVE_SOCIALCLUB_SC_PROFANITY_GET_STRING_STATUS(int token)
 	{
 		auto retval = SOCIALCLUB::SC_PROFANITY_GET_STRING_STATUS(token);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_CHECK_STRING( const char* p0, int p1 )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_CHECK_STRING(const char* p0, int p1)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_LICENSEPLATE_CHECK_STRING(p0, &p1);
@@ -290,37 +290,37 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_CHECK_IS_VALID( Any p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_CHECK_IS_VALID(Any p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_LICENSEPLATE_GET_CHECK_IS_VALID(p0);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_CHECK_IS_PENDING( Any p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_CHECK_IS_PENDING(Any p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_LICENSEPLATE_GET_CHECK_IS_PENDING(p0);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_COUNT( int token )
+	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_COUNT(int token)
 	{
 		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_COUNT(token);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_PLATE( int token, int plateIndex )
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_PLATE(int token, int plateIndex)
 	{
 		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_PLATE(token, plateIndex);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_PLATE_DATA( int token, int plateIndex )
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_PLATE_DATA(int token, int plateIndex)
 	{
 		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_PLATE_DATA(token, plateIndex);
 		return retval;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_SET_PLATE_DATA( const char* oldPlateText, const char* newPlateText, Any plateData )
+	static std::tuple<bool, Any> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_SET_PLATE_DATA(const char* oldPlateText, const char* newPlateText, Any plateData)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_LICENSEPLATE_SET_PLATE_DATA(oldPlateText, newPlateText, &plateData);
@@ -329,7 +329,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_ADD( const char* plateText, Any plateData, int token )
+	static std::tuple<bool, Any, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_ADD(const char* plateText, Any plateData, int token)
 	{
 		std::tuple<bool, Any, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_LICENSEPLATE_ADD(plateText, &plateData, &token);
@@ -339,19 +339,19 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ADD_IS_PENDING( int token )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ADD_IS_PENDING(int token)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_LICENSEPLATE_GET_ADD_IS_PENDING(token);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ADD_STATUS( int token )
+	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ADD_STATUS(int token)
 	{
 		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_ADD_STATUS(token);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_ISVALID( const char* plateText, int token )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_ISVALID(const char* plateText, int token)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_LICENSEPLATE_ISVALID(plateText, &token);
@@ -360,31 +360,31 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ISVALID_IS_PENDING( int token )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ISVALID_IS_PENDING(int token)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_LICENSEPLATE_GET_ISVALID_IS_PENDING(token);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ISVALID_STATUS( int token )
+	static int LUA_NATIVE_SOCIALCLUB_SC_LICENSEPLATE_GET_ISVALID_STATUS(int token)
 	{
 		auto retval = SOCIALCLUB::SC_LICENSEPLATE_GET_ISVALID_STATUS(token);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE(  )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE()
 	{
 		auto retval = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_IS_ACTIVE();
 		return retval;
 	}
 
-	static int LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EVENT_ID(  )
+	static int LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EVENT_ID()
 	{
 		auto retval = SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EVENT_ID();
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT( const char* p0, int p1 )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT(const char* p0, int p1)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT(p0, &p1);
@@ -393,7 +393,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT( const char* p0, float p1 )
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT(const char* p0, float p1)
 	{
 		std::tuple<bool, float> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT(p0, &p1);
@@ -402,7 +402,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING( const char* p0, char p1 )
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING(const char* p0, char p1)
 	{
 		std::tuple<bool, char> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING(p0, &p1);
@@ -411,7 +411,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME( char p0 )
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME(char p0)
 	{
 		std::tuple<bool, char> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_DISPLAY_NAME(&p0);
@@ -420,19 +420,19 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE_FOR_TYPE( const char* p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE_FOR_TYPE(const char* p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_IS_ACTIVE_FOR_TYPE(p0);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EVENT_ID_FOR_TYPE( const char* p0 )
+	static int LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EVENT_ID_FOR_TYPE(const char* p0)
 	{
 		auto retval = SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EVENT_ID_FOR_TYPE(p0);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_FOR_TYPE( const char* p0, int p1, const char* p2 )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_FOR_TYPE(const char* p0, int p1, const char* p2)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_FOR_TYPE(p0, &p1, p2);
@@ -441,7 +441,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_FOR_TYPE( const char* p0, float p1, const char* p2 )
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_FOR_TYPE(const char* p0, float p1, const char* p2)
 	{
 		std::tuple<bool, float> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_FOR_TYPE(p0, &p1, p2);
@@ -450,7 +450,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_FOR_TYPE( const char* p0, char p1, const char* p2 )
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_FOR_TYPE(const char* p0, char p1, const char* p2)
 	{
 		std::tuple<bool, char> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_FOR_TYPE(p0, &p1, p2);
@@ -459,7 +459,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_FOR_TYPE( char p0, const char* p1 )
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_FOR_TYPE(char p0, const char* p1)
 	{
 		std::tuple<bool, char> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_FOR_TYPE(&p0, p1);
@@ -468,13 +468,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE_BY_ID( int p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_IS_ACTIVE_BY_ID(int p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_IS_ACTIVE_BY_ID(p0);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_BY_ID( int p0, const char* p1, int p2 )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_BY_ID(int p0, const char* p1, int p2)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_INT_BY_ID(p0, p1, &p2);
@@ -483,7 +483,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_BY_ID( int p0, const char* p1, float p2 )
+	static std::tuple<bool, float> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_BY_ID(int p0, const char* p1, float p2)
 	{
 		std::tuple<bool, float> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_FLOAT_BY_ID(p0, p1, &p2);
@@ -492,7 +492,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_BY_ID( int p0, const char* p1, char p2 )
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_BY_ID(int p0, const char* p1, char p2)
 	{
 		std::tuple<bool, char> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_EXTRA_DATA_STRING_BY_ID(p0, p1, &p2);
@@ -501,7 +501,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_BY_ID( int p0, char p1 )
+	static std::tuple<bool, char> LUA_NATIVE_SOCIALCLUB_SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_BY_ID(int p0, char p1)
 	{
 		std::tuple<bool, char> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_COMMUNITY_EVENT_GET_DISPLAY_NAME_BY_ID(p0, &p1);
@@ -510,31 +510,31 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW( Any p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW(Any p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_SHOW(p0);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW_TIMED( Any p0, Any p1 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW_TIMED(Any p0, Any p1)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_SHOW_TIMED(p0, p1);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW_NEXT_ITEM(  )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_SHOW_NEXT_ITEM()
 	{
 		auto retval = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_SHOW_NEXT_ITEM();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_HAS_EXTRA_DATA_TU(  )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_HAS_EXTRA_DATA_TU()
 	{
 		auto retval = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_HAS_EXTRA_DATA_TU();
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_GET_EXTRA_DATA_INT_TU( const char* p0, int p1 )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_GET_EXTRA_DATA_INT_TU(const char* p0, int p1)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_TRANSITION_NEWS_GET_EXTRA_DATA_INT_TU(p0, &p1);
@@ -543,35 +543,35 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_END(  )
+	static void LUA_NATIVE_SOCIALCLUB_SC_TRANSITION_NEWS_END()
 	{
 		SOCIALCLUB::SC_TRANSITION_NEWS_END();
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_INIT_STARTER_PACK( Any p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_INIT_STARTER_PACK(Any p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PAUSE_NEWS_INIT_STARTER_PACK(p0);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_GET_PENDING_STORY( Any p0 )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_GET_PENDING_STORY(Any p0)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_PAUSE_NEWS_GET_PENDING_STORY(p0);
 		return retval;
 	}
 
-	static void LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_SHUTDOWN(  )
+	static void LUA_NATIVE_SOCIALCLUB_SC_PAUSE_NEWS_SHUTDOWN()
 	{
 		SOCIALCLUB::SC_PAUSE_NEWS_SHUTDOWN();
 	}
 
-	static const char* LUA_NATIVE_SOCIALCLUB_SC_ACCOUNT_INFO_GET_NICKNAME(  )
+	static const char* LUA_NATIVE_SOCIALCLUB_SC_ACCOUNT_INFO_GET_NICKNAME()
 	{
 		auto retval = SOCIALCLUB::SC_ACCOUNT_INFO_GET_NICKNAME();
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_ACHIEVEMENT_INFO_STATUS( int p0 )
+	static std::tuple<bool, int> LUA_NATIVE_SOCIALCLUB_SC_ACHIEVEMENT_INFO_STATUS(int p0)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)SOCIALCLUB::SC_ACHIEVEMENT_INFO_STATUS(&p0);
@@ -580,7 +580,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_SOCIALCLUB_SC_HAS_ACHIEVEMENT_BEEN_PASSED( int achievementId )
+	static bool LUA_NATIVE_SOCIALCLUB_SC_HAS_ACHIEVEMENT_BEEN_PASSED(int achievementId)
 	{
 		auto retval = (bool)SOCIALCLUB::SC_HAS_ACHIEVEMENT_BEEN_PASSED(achievementId);
 		return retval;

src/lua/natives/lua_native_binding_STREAMING.cpp

@@ -3,648 +3,648 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_STREAMING_LOAD_ALL_OBJECTS_NOW(  )
+	static void LUA_NATIVE_STREAMING_LOAD_ALL_OBJECTS_NOW()
 	{
 		STREAMING::LOAD_ALL_OBJECTS_NOW();
 	}
 
-	static void LUA_NATIVE_STREAMING_LOAD_SCENE( float x, float y, float z )
+	static void LUA_NATIVE_STREAMING_LOAD_SCENE(float x, float y, float z)
 	{
 		STREAMING::LOAD_SCENE(x, y, z);
 	}
 
-	static bool LUA_NATIVE_STREAMING_NETWORK_UPDATE_LOAD_SCENE(  )
+	static bool LUA_NATIVE_STREAMING_NETWORK_UPDATE_LOAD_SCENE()
 	{
 		auto retval = (bool)STREAMING::NETWORK_UPDATE_LOAD_SCENE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_NETWORK_LOADING_SCENE(  )
+	static bool LUA_NATIVE_STREAMING_IS_NETWORK_LOADING_SCENE()
 	{
 		auto retval = (bool)STREAMING::IS_NETWORK_LOADING_SCENE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_INTERIOR_ACTIVE( int interiorID, bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_INTERIOR_ACTIVE(int interiorID, bool toggle)
 	{
 		STREAMING::SET_INTERIOR_ACTIVE(interiorID, toggle);
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_MODEL( Hash model )
+	static void LUA_NATIVE_STREAMING_REQUEST_MODEL(Hash model)
 	{
 		STREAMING::REQUEST_MODEL(model);
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_MENU_PED_MODEL( Hash model )
+	static void LUA_NATIVE_STREAMING_REQUEST_MENU_PED_MODEL(Hash model)
 	{
 		STREAMING::REQUEST_MENU_PED_MODEL(model);
 	}
 
-	static bool LUA_NATIVE_STREAMING_HAS_MODEL_LOADED( Hash model )
+	static bool LUA_NATIVE_STREAMING_HAS_MODEL_LOADED(Hash model)
 	{
 		auto retval = (bool)STREAMING::HAS_MODEL_LOADED(model);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_MODELS_IN_ROOM( Interior interior, const char* roomName )
+	static void LUA_NATIVE_STREAMING_REQUEST_MODELS_IN_ROOM(Interior interior, const char* roomName)
 	{
 		STREAMING::REQUEST_MODELS_IN_ROOM(interior, roomName);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_MODEL_AS_NO_LONGER_NEEDED( Hash model )
+	static void LUA_NATIVE_STREAMING_SET_MODEL_AS_NO_LONGER_NEEDED(Hash model)
 	{
 		STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(model);
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_MODEL_IN_CDIMAGE( Hash model )
+	static bool LUA_NATIVE_STREAMING_IS_MODEL_IN_CDIMAGE(Hash model)
 	{
 		auto retval = (bool)STREAMING::IS_MODEL_IN_CDIMAGE(model);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_MODEL_VALID( Hash model )
+	static bool LUA_NATIVE_STREAMING_IS_MODEL_VALID(Hash model)
 	{
 		auto retval = (bool)STREAMING::IS_MODEL_VALID(model);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_MODEL_A_PED( Hash model )
+	static bool LUA_NATIVE_STREAMING_IS_MODEL_A_PED(Hash model)
 	{
 		auto retval = (bool)STREAMING::IS_MODEL_A_PED(model);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_MODEL_A_VEHICLE( Hash model )
+	static bool LUA_NATIVE_STREAMING_IS_MODEL_A_VEHICLE(Hash model)
 	{
 		auto retval = (bool)STREAMING::IS_MODEL_A_VEHICLE(model);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_COLLISION_AT_COORD( float x, float y, float z )
+	static void LUA_NATIVE_STREAMING_REQUEST_COLLISION_AT_COORD(float x, float y, float z)
 	{
 		STREAMING::REQUEST_COLLISION_AT_COORD(x, y, z);
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_COLLISION_FOR_MODEL( Hash model )
+	static void LUA_NATIVE_STREAMING_REQUEST_COLLISION_FOR_MODEL(Hash model)
 	{
 		STREAMING::REQUEST_COLLISION_FOR_MODEL(model);
 	}
 
-	static bool LUA_NATIVE_STREAMING_HAS_COLLISION_FOR_MODEL_LOADED( Hash model )
+	static bool LUA_NATIVE_STREAMING_HAS_COLLISION_FOR_MODEL_LOADED(Hash model)
 	{
 		auto retval = (bool)STREAMING::HAS_COLLISION_FOR_MODEL_LOADED(model);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_ADDITIONAL_COLLISION_AT_COORD( float x, float y, float z )
+	static void LUA_NATIVE_STREAMING_REQUEST_ADDITIONAL_COLLISION_AT_COORD(float x, float y, float z)
 	{
 		STREAMING::REQUEST_ADDITIONAL_COLLISION_AT_COORD(x, y, z);
 	}
 
-	static bool LUA_NATIVE_STREAMING_DOES_ANIM_DICT_EXIST( const char* animDict )
+	static bool LUA_NATIVE_STREAMING_DOES_ANIM_DICT_EXIST(const char* animDict)
 	{
 		auto retval = (bool)STREAMING::DOES_ANIM_DICT_EXIST(animDict);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_ANIM_DICT( const char* animDict )
+	static void LUA_NATIVE_STREAMING_REQUEST_ANIM_DICT(const char* animDict)
 	{
 		STREAMING::REQUEST_ANIM_DICT(animDict);
 	}
 
-	static bool LUA_NATIVE_STREAMING_HAS_ANIM_DICT_LOADED( const char* animDict )
+	static bool LUA_NATIVE_STREAMING_HAS_ANIM_DICT_LOADED(const char* animDict)
 	{
 		auto retval = (bool)STREAMING::HAS_ANIM_DICT_LOADED(animDict);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REMOVE_ANIM_DICT( const char* animDict )
+	static void LUA_NATIVE_STREAMING_REMOVE_ANIM_DICT(const char* animDict)
 	{
 		STREAMING::REMOVE_ANIM_DICT(animDict);
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_ANIM_SET( const char* animSet )
+	static void LUA_NATIVE_STREAMING_REQUEST_ANIM_SET(const char* animSet)
 	{
 		STREAMING::REQUEST_ANIM_SET(animSet);
 	}
 
-	static bool LUA_NATIVE_STREAMING_HAS_ANIM_SET_LOADED( const char* animSet )
+	static bool LUA_NATIVE_STREAMING_HAS_ANIM_SET_LOADED(const char* animSet)
 	{
 		auto retval = (bool)STREAMING::HAS_ANIM_SET_LOADED(animSet);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REMOVE_ANIM_SET( const char* animSet )
+	static void LUA_NATIVE_STREAMING_REMOVE_ANIM_SET(const char* animSet)
 	{
 		STREAMING::REMOVE_ANIM_SET(animSet);
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_CLIP_SET( const char* clipSet )
+	static void LUA_NATIVE_STREAMING_REQUEST_CLIP_SET(const char* clipSet)
 	{
 		STREAMING::REQUEST_CLIP_SET(clipSet);
 	}
 
-	static bool LUA_NATIVE_STREAMING_HAS_CLIP_SET_LOADED( const char* clipSet )
+	static bool LUA_NATIVE_STREAMING_HAS_CLIP_SET_LOADED(const char* clipSet)
 	{
 		auto retval = (bool)STREAMING::HAS_CLIP_SET_LOADED(clipSet);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REMOVE_CLIP_SET( const char* clipSet )
+	static void LUA_NATIVE_STREAMING_REMOVE_CLIP_SET(const char* clipSet)
 	{
 		STREAMING::REMOVE_CLIP_SET(clipSet);
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_IPL( const char* iplName )
+	static void LUA_NATIVE_STREAMING_REQUEST_IPL(const char* iplName)
 	{
 		STREAMING::REQUEST_IPL(iplName);
 	}
 
-	static void LUA_NATIVE_STREAMING_REMOVE_IPL( const char* iplName )
+	static void LUA_NATIVE_STREAMING_REMOVE_IPL(const char* iplName)
 	{
 		STREAMING::REMOVE_IPL(iplName);
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_IPL_ACTIVE( const char* iplName )
+	static bool LUA_NATIVE_STREAMING_IS_IPL_ACTIVE(const char* iplName)
 	{
 		auto retval = (bool)STREAMING::IS_IPL_ACTIVE(iplName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_STREAMING( bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_STREAMING(bool toggle)
 	{
 		STREAMING::SET_STREAMING(toggle);
 	}
 
-	static void LUA_NATIVE_STREAMING_LOAD_GLOBAL_WATER_FILE( int waterType )
+	static void LUA_NATIVE_STREAMING_LOAD_GLOBAL_WATER_FILE(int waterType)
 	{
 		STREAMING::LOAD_GLOBAL_WATER_FILE(waterType);
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_GLOBAL_WATER_FILE(  )
+	static int LUA_NATIVE_STREAMING_GET_GLOBAL_WATER_FILE()
 	{
 		auto retval = STREAMING::GET_GLOBAL_WATER_FILE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_GAME_PAUSES_FOR_STREAMING( bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_GAME_PAUSES_FOR_STREAMING(bool toggle)
 	{
 		STREAMING::SET_GAME_PAUSES_FOR_STREAMING(toggle);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_REDUCE_PED_MODEL_BUDGET( bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_REDUCE_PED_MODEL_BUDGET(bool toggle)
 	{
 		STREAMING::SET_REDUCE_PED_MODEL_BUDGET(toggle);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_REDUCE_VEHICLE_MODEL_BUDGET( bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_REDUCE_VEHICLE_MODEL_BUDGET(bool toggle)
 	{
 		STREAMING::SET_REDUCE_VEHICLE_MODEL_BUDGET(toggle);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_DITCH_POLICE_MODELS( bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_DITCH_POLICE_MODELS(bool toggle)
 	{
 		STREAMING::SET_DITCH_POLICE_MODELS(toggle);
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_NUMBER_OF_STREAMING_REQUESTS(  )
+	static int LUA_NATIVE_STREAMING_GET_NUMBER_OF_STREAMING_REQUESTS()
 	{
 		auto retval = STREAMING::GET_NUMBER_OF_STREAMING_REQUESTS();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_PTFX_ASSET(  )
+	static void LUA_NATIVE_STREAMING_REQUEST_PTFX_ASSET()
 	{
 		STREAMING::REQUEST_PTFX_ASSET();
 	}
 
-	static bool LUA_NATIVE_STREAMING_HAS_PTFX_ASSET_LOADED(  )
+	static bool LUA_NATIVE_STREAMING_HAS_PTFX_ASSET_LOADED()
 	{
 		auto retval = (bool)STREAMING::HAS_PTFX_ASSET_LOADED();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REMOVE_PTFX_ASSET(  )
+	static void LUA_NATIVE_STREAMING_REMOVE_PTFX_ASSET()
 	{
 		STREAMING::REMOVE_PTFX_ASSET();
 	}
 
-	static void LUA_NATIVE_STREAMING_REQUEST_NAMED_PTFX_ASSET( const char* fxName )
+	static void LUA_NATIVE_STREAMING_REQUEST_NAMED_PTFX_ASSET(const char* fxName)
 	{
 		STREAMING::REQUEST_NAMED_PTFX_ASSET(fxName);
 	}
 
-	static bool LUA_NATIVE_STREAMING_HAS_NAMED_PTFX_ASSET_LOADED( const char* fxName )
+	static bool LUA_NATIVE_STREAMING_HAS_NAMED_PTFX_ASSET_LOADED(const char* fxName)
 	{
 		auto retval = (bool)STREAMING::HAS_NAMED_PTFX_ASSET_LOADED(fxName);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REMOVE_NAMED_PTFX_ASSET( const char* fxName )
+	static void LUA_NATIVE_STREAMING_REMOVE_NAMED_PTFX_ASSET(const char* fxName)
 	{
 		STREAMING::REMOVE_NAMED_PTFX_ASSET(fxName);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_VEHICLE_POPULATION_BUDGET( int p0 )
+	static void LUA_NATIVE_STREAMING_SET_VEHICLE_POPULATION_BUDGET(int p0)
 	{
 		STREAMING::SET_VEHICLE_POPULATION_BUDGET(p0);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_PED_POPULATION_BUDGET( int p0 )
+	static void LUA_NATIVE_STREAMING_SET_PED_POPULATION_BUDGET(int p0)
 	{
 		STREAMING::SET_PED_POPULATION_BUDGET(p0);
 	}
 
-	static void LUA_NATIVE_STREAMING_CLEAR_FOCUS(  )
+	static void LUA_NATIVE_STREAMING_CLEAR_FOCUS()
 	{
 		STREAMING::CLEAR_FOCUS();
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_FOCUS_POS_AND_VEL( float x, float y, float z, float offsetX, float offsetY, float offsetZ )
+	static void LUA_NATIVE_STREAMING_SET_FOCUS_POS_AND_VEL(float x, float y, float z, float offsetX, float offsetY, float offsetZ)
 	{
 		STREAMING::SET_FOCUS_POS_AND_VEL(x, y, z, offsetX, offsetY, offsetZ);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_FOCUS_ENTITY( Entity entity )
+	static void LUA_NATIVE_STREAMING_SET_FOCUS_ENTITY(Entity entity)
 	{
 		STREAMING::SET_FOCUS_ENTITY(entity);
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_ENTITY_FOCUS( Entity entity )
+	static bool LUA_NATIVE_STREAMING_IS_ENTITY_FOCUS(Entity entity)
 	{
 		auto retval = (bool)STREAMING::IS_ENTITY_FOCUS(entity);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_RESTORE_FOCUS_ENTITY( Entity p0 )
+	static void LUA_NATIVE_STREAMING_SET_RESTORE_FOCUS_ENTITY(Entity p0)
 	{
 		STREAMING::SET_RESTORE_FOCUS_ENTITY(p0);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_MAPDATACULLBOX_ENABLED( const char* name, bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_MAPDATACULLBOX_ENABLED(const char* name, bool toggle)
 	{
 		STREAMING::SET_MAPDATACULLBOX_ENABLED(name, toggle);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_ALL_MAPDATA_CULLED( Any p0 )
+	static void LUA_NATIVE_STREAMING_SET_ALL_MAPDATA_CULLED(Any p0)
 	{
 		STREAMING::SET_ALL_MAPDATA_CULLED(p0);
 	}
 
-	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_SPHERE( float x, float y, float z, float rad, Any p4, Any p5 )
+	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_SPHERE(float x, float y, float z, float rad, Any p4, Any p5)
 	{
 		auto retval = STREAMING::STREAMVOL_CREATE_SPHERE(x, y, z, rad, p4, p5);
 		return retval;
 	}
 
-	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_FRUSTUM( float p0, float p1, float p2, float p3, float p4, float p5, float p6, Any p7, Any p8 )
+	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_FRUSTUM(float p0, float p1, float p2, float p3, float p4, float p5, float p6, Any p7, Any p8)
 	{
 		auto retval = STREAMING::STREAMVOL_CREATE_FRUSTUM(p0, p1, p2, p3, p4, p5, p6, p7, p8);
 		return retval;
 	}
 
-	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_LINE( float p0, float p1, float p2, float p3, float p4, float p5, Any p6 )
+	static int LUA_NATIVE_STREAMING_STREAMVOL_CREATE_LINE(float p0, float p1, float p2, float p3, float p4, float p5, Any p6)
 	{
 		auto retval = STREAMING::STREAMVOL_CREATE_LINE(p0, p1, p2, p3, p4, p5, p6);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_STREAMVOL_DELETE( Any unused )
+	static void LUA_NATIVE_STREAMING_STREAMVOL_DELETE(Any unused)
 	{
 		STREAMING::STREAMVOL_DELETE(unused);
 	}
 
-	static bool LUA_NATIVE_STREAMING_STREAMVOL_HAS_LOADED( Any unused )
+	static bool LUA_NATIVE_STREAMING_STREAMVOL_HAS_LOADED(Any unused)
 	{
 		auto retval = (bool)STREAMING::STREAMVOL_HAS_LOADED(unused);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_STREAMVOL_IS_VALID( Any unused )
+	static bool LUA_NATIVE_STREAMING_STREAMVOL_IS_VALID(Any unused)
 	{
 		auto retval = (bool)STREAMING::STREAMVOL_IS_VALID(unused);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_STREAMVOL_ACTIVE(  )
+	static bool LUA_NATIVE_STREAMING_IS_STREAMVOL_ACTIVE()
 	{
 		auto retval = (bool)STREAMING::IS_STREAMVOL_ACTIVE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_START( float posX, float posY, float posZ, float offsetX, float offsetY, float offsetZ, float radius, int p7 )
+	static bool LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_START(float posX, float posY, float posZ, float offsetX, float offsetY, float offsetZ, float radius, int p7)
 	{
 		auto retval = (bool)STREAMING::NEW_LOAD_SCENE_START(posX, posY, posZ, offsetX, offsetY, offsetZ, radius, p7);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_START_SPHERE( float x, float y, float z, float radius, Any p4 )
+	static bool LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_START_SPHERE(float x, float y, float z, float radius, Any p4)
 	{
 		auto retval = (bool)STREAMING::NEW_LOAD_SCENE_START_SPHERE(x, y, z, radius, p4);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_STOP(  )
+	static void LUA_NATIVE_STREAMING_NEW_LOAD_SCENE_STOP()
 	{
 		STREAMING::NEW_LOAD_SCENE_STOP();
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_NEW_LOAD_SCENE_ACTIVE(  )
+	static bool LUA_NATIVE_STREAMING_IS_NEW_LOAD_SCENE_ACTIVE()
 	{
 		auto retval = (bool)STREAMING::IS_NEW_LOAD_SCENE_ACTIVE();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_NEW_LOAD_SCENE_LOADED(  )
+	static bool LUA_NATIVE_STREAMING_IS_NEW_LOAD_SCENE_LOADED()
 	{
 		auto retval = (bool)STREAMING::IS_NEW_LOAD_SCENE_LOADED();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_SAFE_TO_START_PLAYER_SWITCH(  )
+	static bool LUA_NATIVE_STREAMING_IS_SAFE_TO_START_PLAYER_SWITCH()
 	{
 		auto retval = (bool)STREAMING::IS_SAFE_TO_START_PLAYER_SWITCH();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_START_PLAYER_SWITCH( Ped from, Ped to, int flags, int switchType )
+	static void LUA_NATIVE_STREAMING_START_PLAYER_SWITCH(Ped from, Ped to, int flags, int switchType)
 	{
 		STREAMING::START_PLAYER_SWITCH(from, to, flags, switchType);
 	}
 
-	static void LUA_NATIVE_STREAMING_STOP_PLAYER_SWITCH(  )
+	static void LUA_NATIVE_STREAMING_STOP_PLAYER_SWITCH()
 	{
 		STREAMING::STOP_PLAYER_SWITCH();
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_PLAYER_SWITCH_IN_PROGRESS(  )
+	static bool LUA_NATIVE_STREAMING_IS_PLAYER_SWITCH_IN_PROGRESS()
 	{
 		auto retval = (bool)STREAMING::IS_PLAYER_SWITCH_IN_PROGRESS();
 		return retval;
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_TYPE(  )
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_TYPE()
 	{
 		auto retval = STREAMING::GET_PLAYER_SWITCH_TYPE();
 		return retval;
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_IDEAL_PLAYER_SWITCH_TYPE( float x1, float y1, float z1, float x2, float y2, float z2 )
+	static int LUA_NATIVE_STREAMING_GET_IDEAL_PLAYER_SWITCH_TYPE(float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		auto retval = STREAMING::GET_IDEAL_PLAYER_SWITCH_TYPE(x1, y1, z1, x2, y2, z2);
 		return retval;
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_STATE(  )
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_STATE()
 	{
 		auto retval = STREAMING::GET_PLAYER_SWITCH_STATE();
 		return retval;
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_PLAYER_SHORT_SWITCH_STATE(  )
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SHORT_SWITCH_STATE()
 	{
 		auto retval = STREAMING::GET_PLAYER_SHORT_SWITCH_STATE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_PLAYER_SHORT_SWITCH_STYLE( int p0 )
+	static void LUA_NATIVE_STREAMING_SET_PLAYER_SHORT_SWITCH_STYLE(int p0)
 	{
 		STREAMING::SET_PLAYER_SHORT_SWITCH_STYLE(p0);
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_JUMP_CUT_INDEX(  )
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_JUMP_CUT_INDEX()
 	{
 		auto retval = STREAMING::GET_PLAYER_SWITCH_JUMP_CUT_INDEX();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_PLAYER_SWITCH_OUTRO( float cameraCoordX, float cameraCoordY, float cameraCoordZ, float camRotationX, float camRotationY, float camRotationZ, float camFov, float camFarClip, int rotationOrder )
+	static void LUA_NATIVE_STREAMING_SET_PLAYER_SWITCH_OUTRO(float cameraCoordX, float cameraCoordY, float cameraCoordZ, float camRotationX, float camRotationY, float camRotationZ, float camFov, float camFarClip, int rotationOrder)
 	{
 		STREAMING::SET_PLAYER_SWITCH_OUTRO(cameraCoordX, cameraCoordY, cameraCoordZ, camRotationX, camRotationY, camRotationZ, camFov, camFarClip, rotationOrder);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_PLAYER_SWITCH_ESTABLISHING_SHOT( const char* name )
+	static void LUA_NATIVE_STREAMING_SET_PLAYER_SWITCH_ESTABLISHING_SHOT(const char* name)
 	{
 		STREAMING::SET_PLAYER_SWITCH_ESTABLISHING_SHOT(name);
 	}
 
-	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_PAN(  )
+	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_PAN()
 	{
 		STREAMING::ALLOW_PLAYER_SWITCH_PAN();
 	}
 
-	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_OUTRO(  )
+	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_OUTRO()
 	{
 		STREAMING::ALLOW_PLAYER_SWITCH_OUTRO();
 	}
 
-	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_ASCENT(  )
+	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_ASCENT()
 	{
 		STREAMING::ALLOW_PLAYER_SWITCH_ASCENT();
 	}
 
-	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_DESCENT(  )
+	static void LUA_NATIVE_STREAMING_ALLOW_PLAYER_SWITCH_DESCENT()
 	{
 		STREAMING::ALLOW_PLAYER_SWITCH_DESCENT();
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_SWITCH_READY_FOR_DESCENT(  )
+	static bool LUA_NATIVE_STREAMING_IS_SWITCH_READY_FOR_DESCENT()
 	{
 		auto retval = (bool)STREAMING::IS_SWITCH_READY_FOR_DESCENT();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_ENABLE_SWITCH_PAUSE_BEFORE_DESCENT(  )
+	static void LUA_NATIVE_STREAMING_ENABLE_SWITCH_PAUSE_BEFORE_DESCENT()
 	{
 		STREAMING::ENABLE_SWITCH_PAUSE_BEFORE_DESCENT();
 	}
 
-	static void LUA_NATIVE_STREAMING_DISABLE_SWITCH_OUTRO_FX(  )
+	static void LUA_NATIVE_STREAMING_DISABLE_SWITCH_OUTRO_FX()
 	{
 		STREAMING::DISABLE_SWITCH_OUTRO_FX();
 	}
 
-	static void LUA_NATIVE_STREAMING_SWITCH_TO_MULTI_FIRSTPART( Ped ped, int flags, int switchType )
+	static void LUA_NATIVE_STREAMING_SWITCH_TO_MULTI_FIRSTPART(Ped ped, int flags, int switchType)
 	{
 		STREAMING::SWITCH_TO_MULTI_FIRSTPART(ped, flags, switchType);
 	}
 
-	static void LUA_NATIVE_STREAMING_SWITCH_TO_MULTI_SECONDPART( Ped ped )
+	static void LUA_NATIVE_STREAMING_SWITCH_TO_MULTI_SECONDPART(Ped ped)
 	{
 		STREAMING::SWITCH_TO_MULTI_SECONDPART(ped);
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_SWITCH_TO_MULTI_FIRSTPART_FINISHED(  )
+	static bool LUA_NATIVE_STREAMING_IS_SWITCH_TO_MULTI_FIRSTPART_FINISHED()
 	{
 		auto retval = (bool)STREAMING::IS_SWITCH_TO_MULTI_FIRSTPART_FINISHED();
 		return retval;
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_INTERP_OUT_DURATION(  )
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_INTERP_OUT_DURATION()
 	{
 		auto retval = STREAMING::GET_PLAYER_SWITCH_INTERP_OUT_DURATION();
 		return retval;
 	}
 
-	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_INTERP_OUT_CURRENT_TIME(  )
+	static int LUA_NATIVE_STREAMING_GET_PLAYER_SWITCH_INTERP_OUT_CURRENT_TIME()
 	{
 		auto retval = STREAMING::GET_PLAYER_SWITCH_INTERP_OUT_CURRENT_TIME();
 		return retval;
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_SWITCH_SKIPPING_DESCENT(  )
+	static bool LUA_NATIVE_STREAMING_IS_SWITCH_SKIPPING_DESCENT()
 	{
 		auto retval = (bool)STREAMING::IS_SWITCH_SKIPPING_DESCENT();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_SCENE_STREAMING_TRACKS_CAM_POS_THIS_FRAME(  )
+	static void LUA_NATIVE_STREAMING_SET_SCENE_STREAMING_TRACKS_CAM_POS_THIS_FRAME()
 	{
 		STREAMING::SET_SCENE_STREAMING_TRACKS_CAM_POS_THIS_FRAME();
 	}
 
-	static float LUA_NATIVE_STREAMING_GET_LODSCALE(  )
+	static float LUA_NATIVE_STREAMING_GET_LODSCALE()
 	{
 		auto retval = STREAMING::GET_LODSCALE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_OVERRIDE_LODSCALE_THIS_FRAME( float scaling )
+	static void LUA_NATIVE_STREAMING_OVERRIDE_LODSCALE_THIS_FRAME(float scaling)
 	{
 		STREAMING::OVERRIDE_LODSCALE_THIS_FRAME(scaling);
 	}
 
-	static void LUA_NATIVE_STREAMING_REMAP_LODSCALE_RANGE_THIS_FRAME( float p0, float p1, float p2, float p3 )
+	static void LUA_NATIVE_STREAMING_REMAP_LODSCALE_RANGE_THIS_FRAME(float p0, float p1, float p2, float p3)
 	{
 		STREAMING::REMAP_LODSCALE_RANGE_THIS_FRAME(p0, p1, p2, p3);
 	}
 
-	static void LUA_NATIVE_STREAMING_SUPPRESS_HD_MAP_STREAMING_THIS_FRAME(  )
+	static void LUA_NATIVE_STREAMING_SUPPRESS_HD_MAP_STREAMING_THIS_FRAME()
 	{
 		STREAMING::SUPPRESS_HD_MAP_STREAMING_THIS_FRAME();
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_RENDER_HD_ONLY( bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_RENDER_HD_ONLY(bool toggle)
 	{
 		STREAMING::SET_RENDER_HD_ONLY(toggle);
 	}
 
-	static void LUA_NATIVE_STREAMING_FORCE_ALLOW_TIME_BASED_FADING_THIS_FRAME(  )
+	static void LUA_NATIVE_STREAMING_FORCE_ALLOW_TIME_BASED_FADING_THIS_FRAME()
 	{
 		STREAMING::FORCE_ALLOW_TIME_BASED_FADING_THIS_FRAME();
 	}
 
-	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_START( const char* iplName1, const char* iplName2 )
+	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_START(const char* iplName1, const char* iplName2)
 	{
 		STREAMING::IPL_GROUP_SWAP_START(iplName1, iplName2);
 	}
 
-	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_CANCEL(  )
+	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_CANCEL()
 	{
 		STREAMING::IPL_GROUP_SWAP_CANCEL();
 	}
 
-	static bool LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_IS_READY(  )
+	static bool LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_IS_READY()
 	{
 		auto retval = (bool)STREAMING::IPL_GROUP_SWAP_IS_READY();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_FINISH(  )
+	static void LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_FINISH()
 	{
 		STREAMING::IPL_GROUP_SWAP_FINISH();
 	}
 
-	static bool LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_IS_ACTIVE(  )
+	static bool LUA_NATIVE_STREAMING_IPL_GROUP_SWAP_IS_ACTIVE()
 	{
 		auto retval = (bool)STREAMING::IPL_GROUP_SWAP_IS_ACTIVE();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_PREFETCH_SRL( const char* srl )
+	static void LUA_NATIVE_STREAMING_PREFETCH_SRL(const char* srl)
 	{
 		STREAMING::PREFETCH_SRL(srl);
 	}
 
-	static bool LUA_NATIVE_STREAMING_IS_SRL_LOADED(  )
+	static bool LUA_NATIVE_STREAMING_IS_SRL_LOADED()
 	{
 		auto retval = (bool)STREAMING::IS_SRL_LOADED();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_BEGIN_SRL(  )
+	static void LUA_NATIVE_STREAMING_BEGIN_SRL()
 	{
 		STREAMING::BEGIN_SRL();
 	}
 
-	static void LUA_NATIVE_STREAMING_END_SRL(  )
+	static void LUA_NATIVE_STREAMING_END_SRL()
 	{
 		STREAMING::END_SRL();
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_SRL_TIME( float p0 )
+	static void LUA_NATIVE_STREAMING_SET_SRL_TIME(float p0)
 	{
 		STREAMING::SET_SRL_TIME(p0);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_SRL_POST_CUTSCENE_CAMERA( Any p0, Any p1, Any p2, Any p3, Any p4, Any p5 )
+	static void LUA_NATIVE_STREAMING_SET_SRL_POST_CUTSCENE_CAMERA(Any p0, Any p1, Any p2, Any p3, Any p4, Any p5)
 	{
 		STREAMING::SET_SRL_POST_CUTSCENE_CAMERA(p0, p1, p2, p3, p4, p5);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_SRL_READAHEAD_TIMES( Any p0, Any p1, Any p2, Any p3 )
+	static void LUA_NATIVE_STREAMING_SET_SRL_READAHEAD_TIMES(Any p0, Any p1, Any p2, Any p3)
 	{
 		STREAMING::SET_SRL_READAHEAD_TIMES(p0, p1, p2, p3);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_SRL_LONG_JUMP_MODE( bool p0 )
+	static void LUA_NATIVE_STREAMING_SET_SRL_LONG_JUMP_MODE(bool p0)
 	{
 		STREAMING::SET_SRL_LONG_JUMP_MODE(p0);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_SRL_FORCE_PRESTREAM( Any p0 )
+	static void LUA_NATIVE_STREAMING_SET_SRL_FORCE_PRESTREAM(Any p0)
 	{
 		STREAMING::SET_SRL_FORCE_PRESTREAM(p0);
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_HD_AREA( float x, float y, float z, float radius )
+	static void LUA_NATIVE_STREAMING_SET_HD_AREA(float x, float y, float z, float radius)
 	{
 		STREAMING::SET_HD_AREA(x, y, z, radius);
 	}
 
-	static void LUA_NATIVE_STREAMING_CLEAR_HD_AREA(  )
+	static void LUA_NATIVE_STREAMING_CLEAR_HD_AREA()
 	{
 		STREAMING::CLEAR_HD_AREA();
 	}
 
-	static void LUA_NATIVE_STREAMING_INIT_CREATOR_BUDGET(  )
+	static void LUA_NATIVE_STREAMING_INIT_CREATOR_BUDGET()
 	{
 		STREAMING::INIT_CREATOR_BUDGET();
 	}
 
-	static void LUA_NATIVE_STREAMING_SHUTDOWN_CREATOR_BUDGET(  )
+	static void LUA_NATIVE_STREAMING_SHUTDOWN_CREATOR_BUDGET()
 	{
 		STREAMING::SHUTDOWN_CREATOR_BUDGET();
 	}
 
-	static bool LUA_NATIVE_STREAMING_ADD_MODEL_TO_CREATOR_BUDGET( Hash modelHash )
+	static bool LUA_NATIVE_STREAMING_ADD_MODEL_TO_CREATOR_BUDGET(Hash modelHash)
 	{
 		auto retval = (bool)STREAMING::ADD_MODEL_TO_CREATOR_BUDGET(modelHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_REMOVE_MODEL_FROM_CREATOR_BUDGET( Hash modelHash )
+	static void LUA_NATIVE_STREAMING_REMOVE_MODEL_FROM_CREATOR_BUDGET(Hash modelHash)
 	{
 		STREAMING::REMOVE_MODEL_FROM_CREATOR_BUDGET(modelHash);
 	}
 
-	static float LUA_NATIVE_STREAMING_GET_USED_CREATOR_BUDGET(  )
+	static float LUA_NATIVE_STREAMING_GET_USED_CREATOR_BUDGET()
 	{
 		auto retval = STREAMING::GET_USED_CREATOR_BUDGET();
 		return retval;
 	}
 
-	static void LUA_NATIVE_STREAMING_SET_ISLAND_ENABLED( const char* name, bool toggle )
+	static void LUA_NATIVE_STREAMING_SET_ISLAND_ENABLED(const char* name, bool toggle)
 	{
 		STREAMING::SET_ISLAND_ENABLED(name, toggle);
 	}

src/lua/natives/lua_native_binding_SYSTEM.cpp

@@ -3,18 +3,18 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_SYSTEM_WAIT( int ms )
+	static void LUA_NATIVE_SYSTEM_WAIT(int ms)
 	{
 		SYSTEM::WAIT(ms);
 	}
 
-	static int LUA_NATIVE_SYSTEM_START_NEW_SCRIPT( const char* scriptName, int stackSize )
+	static int LUA_NATIVE_SYSTEM_START_NEW_SCRIPT(const char* scriptName, int stackSize)
 	{
 		auto retval = SYSTEM::START_NEW_SCRIPT(scriptName, stackSize);
 		return retval;
 	}
 
-	static std::tuple<int, Any> LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_ARGS( const char* scriptName, Any args, int argCount, int stackSize )
+	static std::tuple<int, Any> LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_ARGS(const char* scriptName, Any args, int argCount, int stackSize)
 	{
 		std::tuple<int, Any> return_values;
 		std::get<0>(return_values) = SYSTEM::START_NEW_SCRIPT_WITH_ARGS(scriptName, &args, argCount, stackSize);
@@ -23,13 +23,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_NAME_HASH( Hash scriptHash, int stackSize )
+	static int LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_NAME_HASH(Hash scriptHash, int stackSize)
 	{
 		auto retval = SYSTEM::START_NEW_SCRIPT_WITH_NAME_HASH(scriptHash, stackSize);
 		return retval;
 	}
 
-	static std::tuple<int, Any> LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_NAME_HASH_AND_ARGS( Hash scriptHash, Any args, int argCount, int stackSize )
+	static std::tuple<int, Any> LUA_NATIVE_SYSTEM_START_NEW_SCRIPT_WITH_NAME_HASH_AND_ARGS(Hash scriptHash, Any args, int argCount, int stackSize)
 	{
 		std::tuple<int, Any> return_values;
 		std::get<0>(return_values) = SYSTEM::START_NEW_SCRIPT_WITH_NAME_HASH_AND_ARGS(scriptHash, &args, argCount, stackSize);
@@ -38,125 +38,125 @@ namespace lua::native
 		return return_values;
 	}
 
-	static int LUA_NATIVE_SYSTEM_TIMERA(  )
+	static int LUA_NATIVE_SYSTEM_TIMERA()
 	{
 		auto retval = SYSTEM::TIMERA();
 		return retval;
 	}
 
-	static int LUA_NATIVE_SYSTEM_TIMERB(  )
+	static int LUA_NATIVE_SYSTEM_TIMERB()
 	{
 		auto retval = SYSTEM::TIMERB();
 		return retval;
 	}
 
-	static void LUA_NATIVE_SYSTEM_SETTIMERA( int value )
+	static void LUA_NATIVE_SYSTEM_SETTIMERA(int value)
 	{
 		SYSTEM::SETTIMERA(value);
 	}
 
-	static void LUA_NATIVE_SYSTEM_SETTIMERB( int value )
+	static void LUA_NATIVE_SYSTEM_SETTIMERB(int value)
 	{
 		SYSTEM::SETTIMERB(value);
 	}
 
-	static float LUA_NATIVE_SYSTEM_TIMESTEP(  )
+	static float LUA_NATIVE_SYSTEM_TIMESTEP()
 	{
 		auto retval = SYSTEM::TIMESTEP();
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_SIN( float value )
+	static float LUA_NATIVE_SYSTEM_SIN(float value)
 	{
 		auto retval = SYSTEM::SIN(value);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_COS( float value )
+	static float LUA_NATIVE_SYSTEM_COS(float value)
 	{
 		auto retval = SYSTEM::COS(value);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_SQRT( float value )
+	static float LUA_NATIVE_SYSTEM_SQRT(float value)
 	{
 		auto retval = SYSTEM::SQRT(value);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_POW( float base, float exponent )
+	static float LUA_NATIVE_SYSTEM_POW(float base, float exponent)
 	{
 		auto retval = SYSTEM::POW(base, exponent);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_LOG10( float value )
+	static float LUA_NATIVE_SYSTEM_LOG10(float value)
 	{
 		auto retval = SYSTEM::LOG10(value);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_VMAG( float x, float y, float z )
+	static float LUA_NATIVE_SYSTEM_VMAG(float x, float y, float z)
 	{
 		auto retval = SYSTEM::VMAG(x, y, z);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_VMAG2( float x, float y, float z )
+	static float LUA_NATIVE_SYSTEM_VMAG2(float x, float y, float z)
 	{
 		auto retval = SYSTEM::VMAG2(x, y, z);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_VDIST( float x1, float y1, float z1, float x2, float y2, float z2 )
+	static float LUA_NATIVE_SYSTEM_VDIST(float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		auto retval = SYSTEM::VDIST(x1, y1, z1, x2, y2, z2);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_VDIST2( float x1, float y1, float z1, float x2, float y2, float z2 )
+	static float LUA_NATIVE_SYSTEM_VDIST2(float x1, float y1, float z1, float x2, float y2, float z2)
 	{
 		auto retval = SYSTEM::VDIST2(x1, y1, z1, x2, y2, z2);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SYSTEM_SHIFT_LEFT( int value, int bitShift )
+	static int LUA_NATIVE_SYSTEM_SHIFT_LEFT(int value, int bitShift)
 	{
 		auto retval = SYSTEM::SHIFT_LEFT(value, bitShift);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SYSTEM_SHIFT_RIGHT( int value, int bitShift )
+	static int LUA_NATIVE_SYSTEM_SHIFT_RIGHT(int value, int bitShift)
 	{
 		auto retval = SYSTEM::SHIFT_RIGHT(value, bitShift);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SYSTEM_FLOOR( float value )
+	static int LUA_NATIVE_SYSTEM_FLOOR(float value)
 	{
 		auto retval = SYSTEM::FLOOR(value);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SYSTEM_CEIL( float value )
+	static int LUA_NATIVE_SYSTEM_CEIL(float value)
 	{
 		auto retval = SYSTEM::CEIL(value);
 		return retval;
 	}
 
-	static int LUA_NATIVE_SYSTEM_ROUND( float value )
+	static int LUA_NATIVE_SYSTEM_ROUND(float value)
 	{
 		auto retval = SYSTEM::ROUND(value);
 		return retval;
 	}
 
-	static float LUA_NATIVE_SYSTEM_TO_FLOAT( int value )
+	static float LUA_NATIVE_SYSTEM_TO_FLOAT(int value)
 	{
 		auto retval = SYSTEM::TO_FLOAT(value);
 		return retval;
 	}
 
-	static void LUA_NATIVE_SYSTEM_SET_THIS_THREAD_PRIORITY( int priority )
+	static void LUA_NATIVE_SYSTEM_SET_THIS_THREAD_PRIORITY(int priority)
 	{
 		SYSTEM::SET_THIS_THREAD_PRIORITY(priority);
 	}

src/lua/natives/lua_native_binding_WATER.cpp

@@ -3,7 +3,7 @@
 
 namespace lua::native
 {
-	static std::tuple<bool, float> LUA_NATIVE_WATER_GET_WATER_HEIGHT( float x, float y, float z, float height )
+	static std::tuple<bool, float> LUA_NATIVE_WATER_GET_WATER_HEIGHT(float x, float y, float z, float height)
 	{
 		std::tuple<bool, float> return_values;
 		std::get<0>(return_values) = (bool)WATER::GET_WATER_HEIGHT(x, y, z, &height);
@@ -12,7 +12,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, float> LUA_NATIVE_WATER_GET_WATER_HEIGHT_NO_WAVES( float x, float y, float z, float height )
+	static std::tuple<bool, float> LUA_NATIVE_WATER_GET_WATER_HEIGHT_NO_WAVES(float x, float y, float z, float height)
 	{
 		std::tuple<bool, float> return_values;
 		std::get<0>(return_values) = (bool)WATER::GET_WATER_HEIGHT_NO_WAVES(x, y, z, &height);
@@ -21,7 +21,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_WATER_TEST_PROBE_AGAINST_WATER( float x1, float y1, float z1, float x2, float y2, float z2, Vector3 result )
+	static std::tuple<bool, Vector3> LUA_NATIVE_WATER_TEST_PROBE_AGAINST_WATER(float x1, float y1, float z1, float x2, float y2, float z2, Vector3 result)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)WATER::TEST_PROBE_AGAINST_WATER(x1, y1, z1, x2, y2, z2, &result);
@@ -30,7 +30,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, float> LUA_NATIVE_WATER_TEST_PROBE_AGAINST_ALL_WATER( float x1, float y1, float z1, float x2, float y2, float z2, int flags, float waterHeight )
+	static std::tuple<int, float> LUA_NATIVE_WATER_TEST_PROBE_AGAINST_ALL_WATER(float x1, float y1, float z1, float x2, float y2, float z2, int flags, float waterHeight)
 	{
 		std::tuple<int, float> return_values;
 		std::get<0>(return_values) = WATER::TEST_PROBE_AGAINST_ALL_WATER(x1, y1, z1, x2, y2, z2, flags, &waterHeight);
@@ -39,7 +39,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<int, float> LUA_NATIVE_WATER_TEST_VERTICAL_PROBE_AGAINST_ALL_WATER( float x, float y, float z, int flags, float waterHeight )
+	static std::tuple<int, float> LUA_NATIVE_WATER_TEST_VERTICAL_PROBE_AGAINST_ALL_WATER(float x, float y, float z, int flags, float waterHeight)
 	{
 		std::tuple<int, float> return_values;
 		std::get<0>(return_values) = WATER::TEST_VERTICAL_PROBE_AGAINST_ALL_WATER(x, y, z, flags, &waterHeight);
@@ -48,39 +48,39 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_WATER_MODIFY_WATER( float x, float y, float radius, float height )
+	static void LUA_NATIVE_WATER_MODIFY_WATER(float x, float y, float radius, float height)
 	{
 		WATER::MODIFY_WATER(x, y, radius, height);
 	}
 
-	static int LUA_NATIVE_WATER_ADD_EXTRA_CALMING_QUAD( float xLow, float yLow, float xHigh, float yHigh, float height )
+	static int LUA_NATIVE_WATER_ADD_EXTRA_CALMING_QUAD(float xLow, float yLow, float xHigh, float yHigh, float height)
 	{
 		auto retval = WATER::ADD_EXTRA_CALMING_QUAD(xLow, yLow, xHigh, yHigh, height);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WATER_REMOVE_EXTRA_CALMING_QUAD( int calmingQuad )
+	static void LUA_NATIVE_WATER_REMOVE_EXTRA_CALMING_QUAD(int calmingQuad)
 	{
 		WATER::REMOVE_EXTRA_CALMING_QUAD(calmingQuad);
 	}
 
-	static void LUA_NATIVE_WATER_SET_DEEP_OCEAN_SCALER( float intensity )
+	static void LUA_NATIVE_WATER_SET_DEEP_OCEAN_SCALER(float intensity)
 	{
 		WATER::SET_DEEP_OCEAN_SCALER(intensity);
 	}
 
-	static float LUA_NATIVE_WATER_GET_DEEP_OCEAN_SCALER(  )
+	static float LUA_NATIVE_WATER_GET_DEEP_OCEAN_SCALER()
 	{
 		auto retval = WATER::GET_DEEP_OCEAN_SCALER();
 		return retval;
 	}
 
-	static void LUA_NATIVE_WATER_SET_CALMED_WAVE_HEIGHT_SCALER( float height )
+	static void LUA_NATIVE_WATER_SET_CALMED_WAVE_HEIGHT_SCALER(float height)
 	{
 		WATER::SET_CALMED_WAVE_HEIGHT_SCALER(height);
 	}
 
-	static void LUA_NATIVE_WATER_RESET_DEEP_OCEAN_SCALER(  )
+	static void LUA_NATIVE_WATER_RESET_DEEP_OCEAN_SCALER()
 	{
 		WATER::RESET_DEEP_OCEAN_SCALER();
 	}

src/lua/natives/lua_native_binding_WEAPON.cpp

@@ -3,53 +3,53 @@
 
 namespace lua::native
 {
-	static void LUA_NATIVE_WEAPON_ENABLE_LASER_SIGHT_RENDERING( bool toggle )
+	static void LUA_NATIVE_WEAPON_ENABLE_LASER_SIGHT_RENDERING(bool toggle)
 	{
 		WEAPON::ENABLE_LASER_SIGHT_RENDERING(toggle);
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_TYPE_MODEL( Hash componentHash )
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_TYPE_MODEL(Hash componentHash)
 	{
 		auto retval = WEAPON::GET_WEAPON_COMPONENT_TYPE_MODEL(componentHash);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_MODEL( Hash weaponHash )
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_MODEL(Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_WEAPONTYPE_MODEL(weaponHash);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_SLOT( Hash weaponHash )
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_SLOT(Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_WEAPONTYPE_SLOT(weaponHash);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_GROUP( Hash weaponHash )
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPONTYPE_GROUP(Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_WEAPONTYPE_GROUP(weaponHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT( Hash componentHash )
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT(Hash componentHash)
 	{
 		auto retval = WEAPON::GET_WEAPON_COMPONENT_VARIANT_EXTRA_COUNT(componentHash);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL( Hash componentHash, int extraComponentIndex )
+	static Hash LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL(Hash componentHash, int extraComponentIndex)
 	{
 		auto retval = WEAPON::GET_WEAPON_COMPONENT_VARIANT_EXTRA_MODEL(componentHash, extraComponentIndex);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_CURRENT_PED_WEAPON( Ped ped, Hash weaponHash, bool bForceInHand )
+	static void LUA_NATIVE_WEAPON_SET_CURRENT_PED_WEAPON(Ped ped, Hash weaponHash, bool bForceInHand)
 	{
 		WEAPON::SET_CURRENT_PED_WEAPON(ped, weaponHash, bForceInHand);
 	}
 
-	static std::tuple<bool, Hash> LUA_NATIVE_WEAPON_GET_CURRENT_PED_WEAPON( Ped ped, Hash weaponHash, bool p2 )
+	static std::tuple<bool, Hash> LUA_NATIVE_WEAPON_GET_CURRENT_PED_WEAPON(Ped ped, Hash weaponHash, bool p2)
 	{
 		std::tuple<bool, Hash> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::GET_CURRENT_PED_WEAPON(ped, &weaponHash, p2);
@@ -58,25 +58,25 @@ namespace lua::native
 		return return_values;
 	}
 
-	static Entity LUA_NATIVE_WEAPON_GET_CURRENT_PED_WEAPON_ENTITY_INDEX( Ped ped, Any p1 )
+	static Entity LUA_NATIVE_WEAPON_GET_CURRENT_PED_WEAPON_ENTITY_INDEX(Ped ped, Any p1)
 	{
 		auto retval = WEAPON::GET_CURRENT_PED_WEAPON_ENTITY_INDEX(ped, p1);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_BEST_PED_WEAPON( Ped ped, bool p1 )
+	static Hash LUA_NATIVE_WEAPON_GET_BEST_PED_WEAPON(Ped ped, bool p1)
 	{
 		auto retval = WEAPON::GET_BEST_PED_WEAPON(ped, p1);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_SET_CURRENT_PED_VEHICLE_WEAPON( Ped ped, Hash weaponHash )
+	static bool LUA_NATIVE_WEAPON_SET_CURRENT_PED_VEHICLE_WEAPON(Ped ped, Hash weaponHash)
 	{
 		auto retval = (bool)WEAPON::SET_CURRENT_PED_VEHICLE_WEAPON(ped, weaponHash);
 		return retval;
 	}
 
-	static std::tuple<bool, Hash> LUA_NATIVE_WEAPON_GET_CURRENT_PED_VEHICLE_WEAPON( Ped ped, Hash weaponHash )
+	static std::tuple<bool, Hash> LUA_NATIVE_WEAPON_GET_CURRENT_PED_VEHICLE_WEAPON(Ped ped, Hash weaponHash)
 	{
 		std::tuple<bool, Hash> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::GET_CURRENT_PED_VEHICLE_WEAPON(ped, &weaponHash);
@@ -85,146 +85,146 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY( Ped ped )
+	static void LUA_NATIVE_WEAPON_SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY(Ped ped)
 	{
 		WEAPON::SET_PED_CYCLE_VEHICLE_WEAPONS_ONLY(ped);
 	}
 
-	static bool LUA_NATIVE_WEAPON_IS_PED_ARMED( Ped ped, int typeFlags )
+	static bool LUA_NATIVE_WEAPON_IS_PED_ARMED(Ped ped, int typeFlags)
 	{
 		auto retval = (bool)WEAPON::IS_PED_ARMED(ped, typeFlags);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_IS_WEAPON_VALID( Hash weaponHash )
+	static bool LUA_NATIVE_WEAPON_IS_WEAPON_VALID(Hash weaponHash)
 	{
 		auto retval = (bool)WEAPON::IS_WEAPON_VALID(weaponHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_HAS_PED_GOT_WEAPON( Ped ped, Hash weaponHash, bool p2 )
+	static bool LUA_NATIVE_WEAPON_HAS_PED_GOT_WEAPON(Ped ped, Hash weaponHash, bool p2)
 	{
 		auto retval = (bool)WEAPON::HAS_PED_GOT_WEAPON(ped, weaponHash, p2);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_IS_PED_WEAPON_READY_TO_SHOOT( Ped ped )
+	static bool LUA_NATIVE_WEAPON_IS_PED_WEAPON_READY_TO_SHOOT(Ped ped)
 	{
 		auto retval = (bool)WEAPON::IS_PED_WEAPON_READY_TO_SHOOT(ped);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_PED_WEAPONTYPE_IN_SLOT( Ped ped, Hash weaponSlot )
+	static Hash LUA_NATIVE_WEAPON_GET_PED_WEAPONTYPE_IN_SLOT(Ped ped, Hash weaponSlot)
 	{
 		auto retval = WEAPON::GET_PED_WEAPONTYPE_IN_SLOT(ped, weaponSlot);
 		return retval;
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_AMMO_IN_PED_WEAPON( Ped ped, Hash weaponhash )
+	static int LUA_NATIVE_WEAPON_GET_AMMO_IN_PED_WEAPON(Ped ped, Hash weaponhash)
 	{
 		auto retval = WEAPON::GET_AMMO_IN_PED_WEAPON(ped, weaponhash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_ADD_AMMO_TO_PED( Ped ped, Hash weaponHash, int ammo )
+	static void LUA_NATIVE_WEAPON_ADD_AMMO_TO_PED(Ped ped, Hash weaponHash, int ammo)
 	{
 		WEAPON::ADD_AMMO_TO_PED(ped, weaponHash, ammo);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_AMMO( Ped ped, Hash weaponHash, int ammo, bool p3 )
+	static void LUA_NATIVE_WEAPON_SET_PED_AMMO(Ped ped, Hash weaponHash, int ammo, bool p3)
 	{
 		WEAPON::SET_PED_AMMO(ped, weaponHash, ammo, p3);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_INFINITE_AMMO( Ped ped, bool toggle, Hash weaponHash )
+	static void LUA_NATIVE_WEAPON_SET_PED_INFINITE_AMMO(Ped ped, bool toggle, Hash weaponHash)
 	{
 		WEAPON::SET_PED_INFINITE_AMMO(ped, toggle, weaponHash);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_INFINITE_AMMO_CLIP( Ped ped, bool toggle )
+	static void LUA_NATIVE_WEAPON_SET_PED_INFINITE_AMMO_CLIP(Ped ped, bool toggle)
 	{
 		WEAPON::SET_PED_INFINITE_AMMO_CLIP(ped, toggle);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_STUN_GUN_FINITE_AMMO( Any p0, Any p1 )
+	static void LUA_NATIVE_WEAPON_SET_PED_STUN_GUN_FINITE_AMMO(Any p0, Any p1)
 	{
 		WEAPON::SET_PED_STUN_GUN_FINITE_AMMO(p0, p1);
 	}
 
-	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_TO_PED( Ped ped, Hash weaponHash, int ammoCount, bool isHidden, bool bForceInHand )
+	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_TO_PED(Ped ped, Hash weaponHash, int ammoCount, bool isHidden, bool bForceInHand)
 	{
 		WEAPON::GIVE_WEAPON_TO_PED(ped, weaponHash, ammoCount, isHidden, bForceInHand);
 	}
 
-	static void LUA_NATIVE_WEAPON_GIVE_DELAYED_WEAPON_TO_PED( Ped ped, Hash weaponHash, int ammoCount, bool bForceInHand )
+	static void LUA_NATIVE_WEAPON_GIVE_DELAYED_WEAPON_TO_PED(Ped ped, Hash weaponHash, int ammoCount, bool bForceInHand)
 	{
 		WEAPON::GIVE_DELAYED_WEAPON_TO_PED(ped, weaponHash, ammoCount, bForceInHand);
 	}
 
-	static void LUA_NATIVE_WEAPON_REMOVE_ALL_PED_WEAPONS( Ped ped, bool p1 )
+	static void LUA_NATIVE_WEAPON_REMOVE_ALL_PED_WEAPONS(Ped ped, bool p1)
 	{
 		WEAPON::REMOVE_ALL_PED_WEAPONS(ped, p1);
 	}
 
-	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_FROM_PED( Ped ped, Hash weaponHash )
+	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_FROM_PED(Ped ped, Hash weaponHash)
 	{
 		WEAPON::REMOVE_WEAPON_FROM_PED(ped, weaponHash);
 	}
 
-	static void LUA_NATIVE_WEAPON_HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE( Ped ped, bool toggle )
+	static void LUA_NATIVE_WEAPON_HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE(Ped ped, bool toggle)
 	{
 		WEAPON::HIDE_PED_WEAPON_FOR_SCRIPTED_CUTSCENE(ped, toggle);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_CURRENT_WEAPON_VISIBLE( Ped ped, bool visible, bool deselectWeapon, bool p3, bool p4 )
+	static void LUA_NATIVE_WEAPON_SET_PED_CURRENT_WEAPON_VISIBLE(Ped ped, bool visible, bool deselectWeapon, bool p3, bool p4)
 	{
 		WEAPON::SET_PED_CURRENT_WEAPON_VISIBLE(ped, visible, deselectWeapon, p3, p4);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_WEAPONS_WHEN_DEAD( Ped ped, bool toggle )
+	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_WEAPONS_WHEN_DEAD(Ped ped, bool toggle)
 	{
 		WEAPON::SET_PED_DROPS_WEAPONS_WHEN_DEAD(ped, toggle);
 	}
 
-	static bool LUA_NATIVE_WEAPON_HAS_PED_BEEN_DAMAGED_BY_WEAPON( Ped ped, Hash weaponHash, int weaponType )
+	static bool LUA_NATIVE_WEAPON_HAS_PED_BEEN_DAMAGED_BY_WEAPON(Ped ped, Hash weaponHash, int weaponType)
 	{
 		auto retval = (bool)WEAPON::HAS_PED_BEEN_DAMAGED_BY_WEAPON(ped, weaponHash, weaponType);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_CLEAR_PED_LAST_WEAPON_DAMAGE( Ped ped )
+	static void LUA_NATIVE_WEAPON_CLEAR_PED_LAST_WEAPON_DAMAGE(Ped ped)
 	{
 		WEAPON::CLEAR_PED_LAST_WEAPON_DAMAGE(ped);
 	}
 
-	static bool LUA_NATIVE_WEAPON_HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON( Entity entity, Hash weaponHash, int weaponType )
+	static bool LUA_NATIVE_WEAPON_HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(Entity entity, Hash weaponHash, int weaponType)
 	{
 		auto retval = (bool)WEAPON::HAS_ENTITY_BEEN_DAMAGED_BY_WEAPON(entity, weaponHash, weaponType);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_CLEAR_ENTITY_LAST_WEAPON_DAMAGE( Entity entity )
+	static void LUA_NATIVE_WEAPON_CLEAR_ENTITY_LAST_WEAPON_DAMAGE(Entity entity)
 	{
 		WEAPON::CLEAR_ENTITY_LAST_WEAPON_DAMAGE(entity);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_WEAPON( Ped ped )
+	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_WEAPON(Ped ped)
 	{
 		WEAPON::SET_PED_DROPS_WEAPON(ped);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_INVENTORY_WEAPON( Ped ped, Hash weaponHash, float xOffset, float yOffset, float zOffset, int ammoCount )
+	static void LUA_NATIVE_WEAPON_SET_PED_DROPS_INVENTORY_WEAPON(Ped ped, Hash weaponHash, float xOffset, float yOffset, float zOffset, int ammoCount)
 	{
 		WEAPON::SET_PED_DROPS_INVENTORY_WEAPON(ped, weaponHash, xOffset, yOffset, zOffset, ammoCount);
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_MAX_AMMO_IN_CLIP( Ped ped, Hash weaponHash, bool p2 )
+	static int LUA_NATIVE_WEAPON_GET_MAX_AMMO_IN_CLIP(Ped ped, Hash weaponHash, bool p2)
 	{
 		auto retval = WEAPON::GET_MAX_AMMO_IN_CLIP(ped, weaponHash, p2);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_AMMO_IN_CLIP( Ped ped, Hash weaponHash, int ammo )
+	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_AMMO_IN_CLIP(Ped ped, Hash weaponHash, int ammo)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::GET_AMMO_IN_CLIP(ped, weaponHash, &ammo);
@@ -233,13 +233,13 @@ namespace lua::native
 		return return_values;
 	}
 
-	static bool LUA_NATIVE_WEAPON_SET_AMMO_IN_CLIP( Ped ped, Hash weaponHash, int ammo )
+	static bool LUA_NATIVE_WEAPON_SET_AMMO_IN_CLIP(Ped ped, Hash weaponHash, int ammo)
 	{
 		auto retval = (bool)WEAPON::SET_AMMO_IN_CLIP(ped, weaponHash, ammo);
 		return retval;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_MAX_AMMO( Ped ped, Hash weaponHash, int ammo )
+	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_MAX_AMMO(Ped ped, Hash weaponHash, int ammo)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::GET_MAX_AMMO(ped, weaponHash, &ammo);
@@ -248,7 +248,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_MAX_AMMO_BY_TYPE( Ped ped, Hash ammoTypeHash, int ammo )
+	static std::tuple<bool, int> LUA_NATIVE_WEAPON_GET_MAX_AMMO_BY_TYPE(Ped ped, Hash ammoTypeHash, int ammo)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::GET_MAX_AMMO_BY_TYPE(ped, ammoTypeHash, &ammo);
@@ -257,45 +257,45 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_WEAPON_ADD_PED_AMMO_BY_TYPE( Ped ped, Hash ammoTypeHash, int ammo )
+	static void LUA_NATIVE_WEAPON_ADD_PED_AMMO_BY_TYPE(Ped ped, Hash ammoTypeHash, int ammo)
 	{
 		WEAPON::ADD_PED_AMMO_BY_TYPE(ped, ammoTypeHash, ammo);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_AMMO_BY_TYPE( Ped ped, Hash ammoTypeHash, int ammo )
+	static void LUA_NATIVE_WEAPON_SET_PED_AMMO_BY_TYPE(Ped ped, Hash ammoTypeHash, int ammo)
 	{
 		WEAPON::SET_PED_AMMO_BY_TYPE(ped, ammoTypeHash, ammo);
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_PED_AMMO_BY_TYPE( Ped ped, Hash ammoTypeHash )
+	static int LUA_NATIVE_WEAPON_GET_PED_AMMO_BY_TYPE(Ped ped, Hash ammoTypeHash)
 	{
 		auto retval = WEAPON::GET_PED_AMMO_BY_TYPE(ped, ammoTypeHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_AMMO_TO_DROP( Ped ped, int p1 )
+	static void LUA_NATIVE_WEAPON_SET_PED_AMMO_TO_DROP(Ped ped, int p1)
 	{
 		WEAPON::SET_PED_AMMO_TO_DROP(ped, p1);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PICKUP_AMMO_AMOUNT_SCALER( float p0 )
+	static void LUA_NATIVE_WEAPON_SET_PICKUP_AMMO_AMOUNT_SCALER(float p0)
 	{
 		WEAPON::SET_PICKUP_AMMO_AMOUNT_SCALER(p0);
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_PED_AMMO_TYPE_FROM_WEAPON( Ped ped, Hash weaponHash )
+	static Hash LUA_NATIVE_WEAPON_GET_PED_AMMO_TYPE_FROM_WEAPON(Ped ped, Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_PED_AMMO_TYPE_FROM_WEAPON(ped, weaponHash);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON( Ped ped, Hash weaponHash )
+	static Hash LUA_NATIVE_WEAPON_GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON(Ped ped, Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_PED_ORIGINAL_AMMO_TYPE_FROM_WEAPON(ped, weaponHash);
 		return retval;
 	}
 
-	static std::tuple<bool, Vector3> LUA_NATIVE_WEAPON_GET_PED_LAST_WEAPON_IMPACT_COORD( Ped ped, Vector3 coords )
+	static std::tuple<bool, Vector3> LUA_NATIVE_WEAPON_GET_PED_LAST_WEAPON_IMPACT_COORD(Ped ped, Vector3 coords)
 	{
 		std::tuple<bool, Vector3> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::GET_PED_LAST_WEAPON_IMPACT_COORD(ped, &coords);
@@ -304,207 +304,207 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_GADGET( Ped ped, Hash gadgetHash, bool p2 )
+	static void LUA_NATIVE_WEAPON_SET_PED_GADGET(Ped ped, Hash gadgetHash, bool p2)
 	{
 		WEAPON::SET_PED_GADGET(ped, gadgetHash, p2);
 	}
 
-	static bool LUA_NATIVE_WEAPON_GET_IS_PED_GADGET_EQUIPPED( Ped ped, Hash gadgetHash )
+	static bool LUA_NATIVE_WEAPON_GET_IS_PED_GADGET_EQUIPPED(Ped ped, Hash gadgetHash)
 	{
 		auto retval = (bool)WEAPON::GET_IS_PED_GADGET_EQUIPPED(ped, gadgetHash);
 		return retval;
 	}
 
-	static Hash LUA_NATIVE_WEAPON_GET_SELECTED_PED_WEAPON( Ped ped )
+	static Hash LUA_NATIVE_WEAPON_GET_SELECTED_PED_WEAPON(Ped ped)
 	{
 		auto retval = WEAPON::GET_SELECTED_PED_WEAPON(ped);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_EXPLODE_PROJECTILES( Ped ped, Hash weaponHash, bool p2 )
+	static void LUA_NATIVE_WEAPON_EXPLODE_PROJECTILES(Ped ped, Hash weaponHash, bool p2)
 	{
 		WEAPON::EXPLODE_PROJECTILES(ped, weaponHash, p2);
 	}
 
-	static void LUA_NATIVE_WEAPON_REMOVE_ALL_PROJECTILES_OF_TYPE( Hash weaponHash, bool explode )
+	static void LUA_NATIVE_WEAPON_REMOVE_ALL_PROJECTILES_OF_TYPE(Hash weaponHash, bool explode)
 	{
 		WEAPON::REMOVE_ALL_PROJECTILES_OF_TYPE(weaponHash, explode);
 	}
 
-	static float LUA_NATIVE_WEAPON_GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON( Ped ped )
+	static float LUA_NATIVE_WEAPON_GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON(Ped ped)
 	{
 		auto retval = WEAPON::GET_LOCKON_DISTANCE_OF_CURRENT_PED_WEAPON(ped);
 		return retval;
 	}
 
-	static float LUA_NATIVE_WEAPON_GET_MAX_RANGE_OF_CURRENT_PED_WEAPON( Ped ped )
+	static float LUA_NATIVE_WEAPON_GET_MAX_RANGE_OF_CURRENT_PED_WEAPON(Ped ped)
 	{
 		auto retval = WEAPON::GET_MAX_RANGE_OF_CURRENT_PED_WEAPON(ped);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_HAS_VEHICLE_GOT_PROJECTILE_ATTACHED( Ped driver, Vehicle vehicle, Hash weaponHash, Any p3 )
+	static bool LUA_NATIVE_WEAPON_HAS_VEHICLE_GOT_PROJECTILE_ATTACHED(Ped driver, Vehicle vehicle, Hash weaponHash, Any p3)
 	{
 		auto retval = (bool)WEAPON::HAS_VEHICLE_GOT_PROJECTILE_ATTACHED(driver, vehicle, weaponHash, p3);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_COMPONENT_TO_PED( Ped ped, Hash weaponHash, Hash componentHash )
+	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_COMPONENT_TO_PED(Ped ped, Hash weaponHash, Hash componentHash)
 	{
 		WEAPON::GIVE_WEAPON_COMPONENT_TO_PED(ped, weaponHash, componentHash);
 	}
 
-	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_COMPONENT_FROM_PED( Ped ped, Hash weaponHash, Hash componentHash )
+	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_COMPONENT_FROM_PED(Ped ped, Hash weaponHash, Hash componentHash)
 	{
 		WEAPON::REMOVE_WEAPON_COMPONENT_FROM_PED(ped, weaponHash, componentHash);
 	}
 
-	static bool LUA_NATIVE_WEAPON_HAS_PED_GOT_WEAPON_COMPONENT( Ped ped, Hash weaponHash, Hash componentHash )
+	static bool LUA_NATIVE_WEAPON_HAS_PED_GOT_WEAPON_COMPONENT(Ped ped, Hash weaponHash, Hash componentHash)
 	{
 		auto retval = (bool)WEAPON::HAS_PED_GOT_WEAPON_COMPONENT(ped, weaponHash, componentHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_IS_PED_WEAPON_COMPONENT_ACTIVE( Ped ped, Hash weaponHash, Hash componentHash )
+	static bool LUA_NATIVE_WEAPON_IS_PED_WEAPON_COMPONENT_ACTIVE(Ped ped, Hash weaponHash, Hash componentHash)
 	{
 		auto retval = (bool)WEAPON::IS_PED_WEAPON_COMPONENT_ACTIVE(ped, weaponHash, componentHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_REFILL_AMMO_INSTANTLY( Ped ped )
+	static bool LUA_NATIVE_WEAPON_REFILL_AMMO_INSTANTLY(Ped ped)
 	{
 		auto retval = (bool)WEAPON::REFILL_AMMO_INSTANTLY(ped);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_MAKE_PED_RELOAD( Ped ped )
+	static bool LUA_NATIVE_WEAPON_MAKE_PED_RELOAD(Ped ped)
 	{
 		auto retval = (bool)WEAPON::MAKE_PED_RELOAD(ped);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_REQUEST_WEAPON_ASSET( Hash weaponHash, int p1, int p2 )
+	static void LUA_NATIVE_WEAPON_REQUEST_WEAPON_ASSET(Hash weaponHash, int p1, int p2)
 	{
 		WEAPON::REQUEST_WEAPON_ASSET(weaponHash, p1, p2);
 	}
 
-	static bool LUA_NATIVE_WEAPON_HAS_WEAPON_ASSET_LOADED( Hash weaponHash )
+	static bool LUA_NATIVE_WEAPON_HAS_WEAPON_ASSET_LOADED(Hash weaponHash)
 	{
 		auto retval = (bool)WEAPON::HAS_WEAPON_ASSET_LOADED(weaponHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_ASSET( Hash weaponHash )
+	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_ASSET(Hash weaponHash)
 	{
 		WEAPON::REMOVE_WEAPON_ASSET(weaponHash);
 	}
 
-	static Object LUA_NATIVE_WEAPON_CREATE_WEAPON_OBJECT( Hash weaponHash, int ammoCount, float x, float y, float z, bool showWorldModel, float scale, Any p7, Any p8, Any p9 )
+	static Object LUA_NATIVE_WEAPON_CREATE_WEAPON_OBJECT(Hash weaponHash, int ammoCount, float x, float y, float z, bool showWorldModel, float scale, Any p7, Any p8, Any p9)
 	{
 		auto retval = WEAPON::CREATE_WEAPON_OBJECT(weaponHash, ammoCount, x, y, z, showWorldModel, scale, p7, p8, p9);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT( Object weaponObject, Hash componentHash )
+	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT(Object weaponObject, Hash componentHash)
 	{
 		WEAPON::GIVE_WEAPON_COMPONENT_TO_WEAPON_OBJECT(weaponObject, componentHash);
 	}
 
-	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT( Object object, Hash componentHash )
+	static void LUA_NATIVE_WEAPON_REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT(Object object, Hash componentHash)
 	{
 		WEAPON::REMOVE_WEAPON_COMPONENT_FROM_WEAPON_OBJECT(object, componentHash);
 	}
 
-	static bool LUA_NATIVE_WEAPON_HAS_WEAPON_GOT_WEAPON_COMPONENT( Object weapon, Hash componentHash )
+	static bool LUA_NATIVE_WEAPON_HAS_WEAPON_GOT_WEAPON_COMPONENT(Object weapon, Hash componentHash)
 	{
 		auto retval = (bool)WEAPON::HAS_WEAPON_GOT_WEAPON_COMPONENT(weapon, componentHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_OBJECT_TO_PED( Object weaponObject, Ped ped )
+	static void LUA_NATIVE_WEAPON_GIVE_WEAPON_OBJECT_TO_PED(Object weaponObject, Ped ped)
 	{
 		WEAPON::GIVE_WEAPON_OBJECT_TO_PED(weaponObject, ped);
 	}
 
-	static bool LUA_NATIVE_WEAPON_DOES_WEAPON_TAKE_WEAPON_COMPONENT( Hash weaponHash, Hash componentHash )
+	static bool LUA_NATIVE_WEAPON_DOES_WEAPON_TAKE_WEAPON_COMPONENT(Hash weaponHash, Hash componentHash)
 	{
 		auto retval = (bool)WEAPON::DOES_WEAPON_TAKE_WEAPON_COMPONENT(weaponHash, componentHash);
 		return retval;
 	}
 
-	static Object LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_FROM_PED( Ped ped, bool p1 )
+	static Object LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_FROM_PED(Ped ped, bool p1)
 	{
 		auto retval = WEAPON::GET_WEAPON_OBJECT_FROM_PED(ped, p1);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_GIVE_LOADOUT_TO_PED( Ped ped, Hash loadoutHash )
+	static void LUA_NATIVE_WEAPON_GIVE_LOADOUT_TO_PED(Ped ped, Hash loadoutHash)
 	{
 		WEAPON::GIVE_LOADOUT_TO_PED(ped, loadoutHash);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_WEAPON_TINT_INDEX( Ped ped, Hash weaponHash, int tintIndex )
+	static void LUA_NATIVE_WEAPON_SET_PED_WEAPON_TINT_INDEX(Ped ped, Hash weaponHash, int tintIndex)
 	{
 		WEAPON::SET_PED_WEAPON_TINT_INDEX(ped, weaponHash, tintIndex);
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_TINT_INDEX( Ped ped, Hash weaponHash )
+	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_TINT_INDEX(Ped ped, Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_PED_WEAPON_TINT_INDEX(ped, weaponHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_TINT_INDEX( Object weapon, int tintIndex )
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_TINT_INDEX(Object weapon, int tintIndex)
 	{
 		WEAPON::SET_WEAPON_OBJECT_TINT_INDEX(weapon, tintIndex);
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_TINT_INDEX( Object weapon )
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_TINT_INDEX(Object weapon)
 	{
 		auto retval = WEAPON::GET_WEAPON_OBJECT_TINT_INDEX(weapon);
 		return retval;
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_WEAPON_TINT_COUNT( Hash weaponHash )
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_TINT_COUNT(Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_WEAPON_TINT_COUNT(weaponHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_WEAPON_COMPONENT_TINT_INDEX( Ped ped, Hash weaponHash, Hash camoComponentHash, int colorIndex )
+	static void LUA_NATIVE_WEAPON_SET_PED_WEAPON_COMPONENT_TINT_INDEX(Ped ped, Hash weaponHash, Hash camoComponentHash, int colorIndex)
 	{
 		WEAPON::SET_PED_WEAPON_COMPONENT_TINT_INDEX(ped, weaponHash, camoComponentHash, colorIndex);
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_COMPONENT_TINT_INDEX( Ped ped, Hash weaponHash, Hash camoComponentHash )
+	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_COMPONENT_TINT_INDEX(Ped ped, Hash weaponHash, Hash camoComponentHash)
 	{
 		auto retval = WEAPON::GET_PED_WEAPON_COMPONENT_TINT_INDEX(ped, weaponHash, camoComponentHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX( Object weaponObject, Hash camoComponentHash, int colorIndex )
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX(Object weaponObject, Hash camoComponentHash, int colorIndex)
 	{
 		WEAPON::SET_WEAPON_OBJECT_COMPONENT_TINT_INDEX(weaponObject, camoComponentHash, colorIndex);
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX( Object weaponObject, Hash camoComponentHash )
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX(Object weaponObject, Hash camoComponentHash)
 	{
 		auto retval = WEAPON::GET_WEAPON_OBJECT_COMPONENT_TINT_INDEX(weaponObject, camoComponentHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_CAMO_INDEX( Ped ped, Hash weaponHash )
+	static int LUA_NATIVE_WEAPON_GET_PED_WEAPON_CAMO_INDEX(Ped ped, Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_PED_WEAPON_CAMO_INDEX(ped, weaponHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_CAMO_INDEX( Object weaponObject, int p1 )
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_OBJECT_CAMO_INDEX(Object weaponObject, int p1)
 	{
 		WEAPON::SET_WEAPON_OBJECT_CAMO_INDEX(weaponObject, p1);
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_WEAPON_GET_WEAPON_HUD_STATS( Hash weaponHash, Any outData )
+	static std::tuple<bool, Any> LUA_NATIVE_WEAPON_GET_WEAPON_HUD_STATS(Hash weaponHash, Any outData)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::GET_WEAPON_HUD_STATS(weaponHash, &outData);
@@ -513,7 +513,7 @@ namespace lua::native
 		return return_values;
 	}
 
-	static std::tuple<bool, Any> LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_HUD_STATS( Hash componentHash, Any outData )
+	static std::tuple<bool, Any> LUA_NATIVE_WEAPON_GET_WEAPON_COMPONENT_HUD_STATS(Hash componentHash, Any outData)
 	{
 		std::tuple<bool, Any> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::GET_WEAPON_COMPONENT_HUD_STATS(componentHash, &outData);
@@ -522,129 +522,129 @@ namespace lua::native
 		return return_values;
 	}
 
-	static float LUA_NATIVE_WEAPON_GET_WEAPON_DAMAGE( Hash weaponHash, Hash componentHash )
+	static float LUA_NATIVE_WEAPON_GET_WEAPON_DAMAGE(Hash weaponHash, Hash componentHash)
 	{
 		auto retval = WEAPON::GET_WEAPON_DAMAGE(weaponHash, componentHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_WEAPON_CLIP_SIZE( Hash weaponHash )
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_CLIP_SIZE(Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_WEAPON_CLIP_SIZE(weaponHash);
 		return retval;
 	}
 
-	static float LUA_NATIVE_WEAPON_GET_WEAPON_TIME_BETWEEN_SHOTS( Hash weaponHash )
+	static float LUA_NATIVE_WEAPON_GET_WEAPON_TIME_BETWEEN_SHOTS(Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_WEAPON_TIME_BETWEEN_SHOTS(weaponHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PED_CHANCE_OF_FIRING_BLANKS( Ped ped, float xBias, float yBias )
+	static void LUA_NATIVE_WEAPON_SET_PED_CHANCE_OF_FIRING_BLANKS(Ped ped, float xBias, float yBias)
 	{
 		WEAPON::SET_PED_CHANCE_OF_FIRING_BLANKS(ped, xBias, yBias);
 	}
 
-	static Object LUA_NATIVE_WEAPON_SET_PED_SHOOT_ORDNANCE_WEAPON( Ped ped, float p1 )
+	static Object LUA_NATIVE_WEAPON_SET_PED_SHOOT_ORDNANCE_WEAPON(Ped ped, float p1)
 	{
 		auto retval = WEAPON::SET_PED_SHOOT_ORDNANCE_WEAPON(ped, p1);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_REQUEST_WEAPON_HIGH_DETAIL_MODEL( Entity weaponObject )
+	static void LUA_NATIVE_WEAPON_REQUEST_WEAPON_HIGH_DETAIL_MODEL(Entity weaponObject)
 	{
 		WEAPON::REQUEST_WEAPON_HIGH_DETAIL_MODEL(weaponObject);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_WEAPON_DAMAGE_MODIFIER( Hash weaponHash, float damageMultiplier )
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_DAMAGE_MODIFIER(Hash weaponHash, float damageMultiplier)
 	{
 		WEAPON::SET_WEAPON_DAMAGE_MODIFIER(weaponHash, damageMultiplier);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_WEAPON_AOE_MODIFIER( Hash weaponHash, float multiplier )
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_AOE_MODIFIER(Hash weaponHash, float multiplier)
 	{
 		WEAPON::SET_WEAPON_AOE_MODIFIER(weaponHash, multiplier);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_WEAPON_EFFECT_DURATION_MODIFIER( Hash p0, float p1 )
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_EFFECT_DURATION_MODIFIER(Hash p0, float p1)
 	{
 		WEAPON::SET_WEAPON_EFFECT_DURATION_MODIFIER(p0, p1);
 	}
 
-	static bool LUA_NATIVE_WEAPON_IS_PED_CURRENT_WEAPON_SILENCED( Ped ped )
+	static bool LUA_NATIVE_WEAPON_IS_PED_CURRENT_WEAPON_SILENCED(Ped ped)
 	{
 		auto retval = (bool)WEAPON::IS_PED_CURRENT_WEAPON_SILENCED(ped);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_IS_FLASH_LIGHT_ON( Ped ped )
+	static bool LUA_NATIVE_WEAPON_IS_FLASH_LIGHT_ON(Ped ped)
 	{
 		auto retval = (bool)WEAPON::IS_FLASH_LIGHT_ON(ped);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_SET_FLASH_LIGHT_FADE_DISTANCE( float distance )
+	static bool LUA_NATIVE_WEAPON_SET_FLASH_LIGHT_FADE_DISTANCE(float distance)
 	{
 		auto retval = (bool)WEAPON::SET_FLASH_LIGHT_FADE_DISTANCE(distance);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_FLASH_LIGHT_ACTIVE_HISTORY( Ped ped, bool toggle )
+	static void LUA_NATIVE_WEAPON_SET_FLASH_LIGHT_ACTIVE_HISTORY(Ped ped, bool toggle)
 	{
 		WEAPON::SET_FLASH_LIGHT_ACTIVE_HISTORY(ped, toggle);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_WEAPON_ANIMATION_OVERRIDE( Ped ped, Hash animStyle )
+	static void LUA_NATIVE_WEAPON_SET_WEAPON_ANIMATION_OVERRIDE(Ped ped, Hash animStyle)
 	{
 		WEAPON::SET_WEAPON_ANIMATION_OVERRIDE(ped, animStyle);
 	}
 
-	static int LUA_NATIVE_WEAPON_GET_WEAPON_DAMAGE_TYPE( Hash weaponHash )
+	static int LUA_NATIVE_WEAPON_GET_WEAPON_DAMAGE_TYPE(Hash weaponHash)
 	{
 		auto retval = WEAPON::GET_WEAPON_DAMAGE_TYPE(weaponHash);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED( Ped ped )
+	static void LUA_NATIVE_WEAPON_SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED(Ped ped)
 	{
 		WEAPON::SET_EQIPPED_WEAPON_START_SPINNING_AT_FULL_SPEED(ped);
 	}
 
-	static bool LUA_NATIVE_WEAPON_CAN_USE_WEAPON_ON_PARACHUTE( Hash weaponHash )
+	static bool LUA_NATIVE_WEAPON_CAN_USE_WEAPON_ON_PARACHUTE(Hash weaponHash)
 	{
 		auto retval = (bool)WEAPON::CAN_USE_WEAPON_ON_PARACHUTE(weaponHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_WEAPON_CREATE_AIR_DEFENCE_SPHERE( float x, float y, float z, float radius, float p4, float p5, float p6, Hash weaponHash )
+	static int LUA_NATIVE_WEAPON_CREATE_AIR_DEFENCE_SPHERE(float x, float y, float z, float radius, float p4, float p5, float p6, Hash weaponHash)
 	{
 		auto retval = WEAPON::CREATE_AIR_DEFENCE_SPHERE(x, y, z, radius, p4, p5, p6, weaponHash);
 		return retval;
 	}
 
-	static int LUA_NATIVE_WEAPON_CREATE_AIR_DEFENCE_ANGLED_AREA( float p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float radius, Hash weaponHash )
+	static int LUA_NATIVE_WEAPON_CREATE_AIR_DEFENCE_ANGLED_AREA(float p0, float p1, float p2, float p3, float p4, float p5, float p6, float p7, float p8, float radius, Hash weaponHash)
 	{
 		auto retval = WEAPON::CREATE_AIR_DEFENCE_ANGLED_AREA(p0, p1, p2, p3, p4, p5, p6, p7, p8, radius, weaponHash);
 		return retval;
 	}
 
-	static bool LUA_NATIVE_WEAPON_REMOVE_AIR_DEFENCE_SPHERE( int zoneId )
+	static bool LUA_NATIVE_WEAPON_REMOVE_AIR_DEFENCE_SPHERE(int zoneId)
 	{
 		auto retval = (bool)WEAPON::REMOVE_AIR_DEFENCE_SPHERE(zoneId);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_REMOVE_ALL_AIR_DEFENCE_SPHERES(  )
+	static void LUA_NATIVE_WEAPON_REMOVE_ALL_AIR_DEFENCE_SPHERES()
 	{
 		WEAPON::REMOVE_ALL_AIR_DEFENCE_SPHERES();
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE( Player player, int zoneId, bool enable )
+	static void LUA_NATIVE_WEAPON_SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE(Player player, int zoneId, bool enable)
 	{
 		WEAPON::SET_PLAYER_TARGETTABLE_FOR_AIR_DEFENCE_SPHERE(player, zoneId, enable);
 	}
 
-	static std::tuple<bool, int> LUA_NATIVE_WEAPON_IS_AIR_DEFENCE_SPHERE_IN_AREA( float x, float y, float z, float radius, int outZoneId )
+	static std::tuple<bool, int> LUA_NATIVE_WEAPON_IS_AIR_DEFENCE_SPHERE_IN_AREA(float x, float y, float z, float radius, int outZoneId)
 	{
 		std::tuple<bool, int> return_values;
 		std::get<0>(return_values) = (bool)WEAPON::IS_AIR_DEFENCE_SPHERE_IN_AREA(x, y, z, radius, &outZoneId);
@@ -653,23 +653,23 @@ namespace lua::native
 		return return_values;
 	}
 
-	static void LUA_NATIVE_WEAPON_FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION( int zoneId, float x, float y, float z )
+	static void LUA_NATIVE_WEAPON_FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION(int zoneId, float x, float y, float z)
 	{
 		WEAPON::FIRE_AIR_DEFENCE_SPHERE_WEAPON_AT_POSITION(zoneId, x, y, z);
 	}
 
-	static bool LUA_NATIVE_WEAPON_DOES_AIR_DEFENCE_SPHERE_EXIST( int zoneId )
+	static bool LUA_NATIVE_WEAPON_DOES_AIR_DEFENCE_SPHERE_EXIST(int zoneId)
 	{
 		auto retval = (bool)WEAPON::DOES_AIR_DEFENCE_SPHERE_EXIST(zoneId);
 		return retval;
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_CAN_PED_SELECT_INVENTORY_WEAPON( Ped ped, Hash weaponHash, bool toggle )
+	static void LUA_NATIVE_WEAPON_SET_CAN_PED_SELECT_INVENTORY_WEAPON(Ped ped, Hash weaponHash, bool toggle)
 	{
 		WEAPON::SET_CAN_PED_SELECT_INVENTORY_WEAPON(ped, weaponHash, toggle);
 	}
 
-	static void LUA_NATIVE_WEAPON_SET_CAN_PED_SELECT_ALL_WEAPONS( Ped ped, bool toggle )
+	static void LUA_NATIVE_WEAPON_SET_CAN_PED_SELECT_ALL_WEAPONS(Ped ped, bool toggle)
 	{
 		WEAPON::SET_CAN_PED_SELECT_ALL_WEAPONS(ped, toggle);
 	}

src/lua/natives/lua_native_binding_ZONE.cpp

@@ -3,52 +3,52 @@
 
 namespace lua::native
 {
-	static int LUA_NATIVE_ZONE_GET_ZONE_AT_COORDS( float x, float y, float z )
+	static int LUA_NATIVE_ZONE_GET_ZONE_AT_COORDS(float x, float y, float z)
 	{
 		auto retval = ZONE::GET_ZONE_AT_COORDS(x, y, z);
 		return retval;
 	}
 
-	static int LUA_NATIVE_ZONE_GET_ZONE_FROM_NAME_ID( const char* zoneName )
+	static int LUA_NATIVE_ZONE_GET_ZONE_FROM_NAME_ID(const char* zoneName)
 	{
 		auto retval = ZONE::GET_ZONE_FROM_NAME_ID(zoneName);
 		return retval;
 	}
 
-	static int LUA_NATIVE_ZONE_GET_ZONE_POPSCHEDULE( int zoneId )
+	static int LUA_NATIVE_ZONE_GET_ZONE_POPSCHEDULE(int zoneId)
 	{
 		auto retval = ZONE::GET_ZONE_POPSCHEDULE(zoneId);
 		return retval;
 	}
 
-	static const char* LUA_NATIVE_ZONE_GET_NAME_OF_ZONE( float x, float y, float z )
+	static const char* LUA_NATIVE_ZONE_GET_NAME_OF_ZONE(float x, float y, float z)
 	{
 		auto retval = ZONE::GET_NAME_OF_ZONE(x, y, z);
 		return retval;
 	}
 
-	static void LUA_NATIVE_ZONE_SET_ZONE_ENABLED( int zoneId, bool toggle )
+	static void LUA_NATIVE_ZONE_SET_ZONE_ENABLED(int zoneId, bool toggle)
 	{
 		ZONE::SET_ZONE_ENABLED(zoneId, toggle);
 	}
 
-	static int LUA_NATIVE_ZONE_GET_ZONE_SCUMMINESS( int zoneId )
+	static int LUA_NATIVE_ZONE_GET_ZONE_SCUMMINESS(int zoneId)
 	{
 		auto retval = ZONE::GET_ZONE_SCUMMINESS(zoneId);
 		return retval;
 	}
 
-	static void LUA_NATIVE_ZONE_OVERRIDE_POPSCHEDULE_VEHICLE_MODEL( int scheduleId, Hash vehicleHash )
+	static void LUA_NATIVE_ZONE_OVERRIDE_POPSCHEDULE_VEHICLE_MODEL(int scheduleId, Hash vehicleHash)
 	{
 		ZONE::OVERRIDE_POPSCHEDULE_VEHICLE_MODEL(scheduleId, vehicleHash);
 	}
 
-	static void LUA_NATIVE_ZONE_CLEAR_POPSCHEDULE_OVERRIDE_VEHICLE_MODEL( int scheduleId )
+	static void LUA_NATIVE_ZONE_CLEAR_POPSCHEDULE_OVERRIDE_VEHICLE_MODEL(int scheduleId)
 	{
 		ZONE::CLEAR_POPSCHEDULE_OVERRIDE_VEHICLE_MODEL(scheduleId);
 	}
 
-	static Hash LUA_NATIVE_ZONE_GET_HASH_OF_MAP_AREA_AT_COORDS( float x, float y, float z )
+	static Hash LUA_NATIVE_ZONE_GET_HASH_OF_MAP_AREA_AT_COORDS(float x, float y, float z)
 	{
 		auto retval = ZONE::GET_HASH_OF_MAP_AREA_AT_COORDS(x, y, z);
 		return retval;

src/lua/natives/natives_gen.py

@@ -30,9 +30,10 @@ class Arg:
 
 
 class NativeFunc:
-    def __init__(self, namespace, name, args, return_type):
+    def __init__(self, namespace, lua_name, cpp_name, args, return_type):
         self.namespace = namespace
-        self.name = name
+        self.lua_name = lua_name
+        self.cpp_name = cpp_name
         self.args = args
         self.return_type = return_type.replace("BOOL", "bool")
 
@@ -85,10 +86,10 @@ class NativeFunc:
             + "LUA_NATIVE_"
             + self.namespace
             + "_"
-            + self.name
-            + "( "
+            + self.lua_name
+            + "("
             + fixed_params
-            + " )"
+            + ")"
         )
 
         s += "\n"
@@ -108,9 +109,9 @@ class NativeFunc:
                 if self.return_type == "bool":
                     call_native += "(bool)"
 
-            call_native += self.namespace + "::" + self.name + "("
+            call_native += self.namespace + "::" + self.cpp_name + "("
         else:
-            call_native += self.namespace + "::" + self.name + "("
+            call_native += self.namespace + "::" + self.cpp_name + "("
 
         if len(self.args) > 0:
             for arg in self.args:
@@ -177,10 +178,10 @@ def get_natives_func_from_natives_hpp_file(natives_hpp):
         if "namespace " in line:
             current_namespace = line.replace("namespace ", "").strip()
             functions_per_namespaces[current_namespace] = []
-        elif "static" in line:
+        elif "NATIVE_DECL" in line:
             words = line.split()
 
-            # remove static from the words array
+            # remove NATIVE_DECL from the words array
             words.pop(0)
 
             func_name = ""
@@ -210,10 +211,15 @@ def get_natives_func_from_natives_hpp_file(natives_hpp):
                     i += 1
 
             return_type = (
-                line[: line.find(func_name)].replace("static", "").strip()
+                line[: line.find(func_name)].replace("NATIVE_DECL", "").strip()
             )
 
-            native_func = NativeFunc(current_namespace, func_name, args, return_type)
+            lua_name = func_name
+            if lua_name.startswith('_'):
+                lua_name = lua_name.removeprefix("_")
+                lua_name = lua_name + "_"
+
+            native_func = NativeFunc(current_namespace, lua_name, func_name, args, return_type)
 
             functions_per_namespaces[current_namespace].append(native_func)
 
@@ -270,7 +276,7 @@ def generate_native_binding_cpp_and_hpp_files(functions_per_namespaces):
 
         for native_func in native_funcs:
             i += 1
-            file_buffer += "\t\t"+ namespace_name+ '.set_function("'+ native_func.name+ '", '+ "LUA_NATIVE_"+ native_func.namespace+ "_"+ native_func.name+ ");\n"
+            file_buffer += "\t\t"+ namespace_name+ '.set_function("'+ native_func.lua_name+ '", '+ "LUA_NATIVE_"+ native_func.namespace+ "_"+ native_func.lua_name+ ");\n"
 
         file_buffer+= "\t}\n" 
         file_buffer+= "}\n"

src/natives_split.py

@@ -1,48 +0,0 @@
-import os
-
-def split_natives_hpp_into_hpp_and_cpp(natives_hpp, output_hpp, output_cpp):
-    hpp_buf = ""
-    cpp_buf = '#include "natives.hpp"\n\n'
-
-    with open(natives_hpp, 'r') as natives_hpp_content:
-        cpp_start_parsing = False
-        for line in natives_hpp_content:
-            if line.startswith("namespace "):
-                hpp_buf += line
-                cpp_buf += line
-                cpp_start_parsing = True
-                continue
-            if "static" not in line:
-                hpp_buf += line
-                if cpp_start_parsing:
-                    cpp_buf += line
-                continue
-            #if "(" not in line:
-                #hpp_buf += line
-                #if cpp_start_parsing:
-                #    cpp_buf += line
-                #continue
-
-
-            line = line.replace("static ", "")
-
-            index_of_body_start = line.find("{")
-            if index_of_body_start != 1:
-                hpp_buf += line[:index_of_body_start].rstrip() + ";\n"
-
-            cpp_buf += line
-
-
-    if os.path.exists(output_hpp):
-        os.remove(output_hpp)
-    f = open(output_hpp, "a")
-    f.write(hpp_buf)
-    f.close()
-    
-    if os.path.exists(output_cpp):
-        os.remove(output_cpp)
-    f = open(output_cpp, "a")
-    f.write(cpp_buf)
-    f.close()
-
-split_natives_hpp_into_hpp_and_cpp("natives.hpp", "natives.hpp", "natives.cpp")

src/pointers.cpp

@@ -676,7 +676,7 @@ namespace big
         // Write Join Response Data
         {
             "WJRD",
-            "E8 ? ? ? ? 41 8B DF 84 C0",
+            "E8 ? ? ? ? 84 C0 74 07 40 84 FF 41 0F 95 C6",
             [](memory::handle ptr)
             {
                 g_pointers->m_gta.m_write_join_response_data = ptr.add(1).rip().as<functions::write_join_response_data>();
@@ -817,6 +817,15 @@ namespace big
                 g_pointers->m_gta.m_serialize_take_off_ped_variation_task = ptr.as<PVOID>();
             }
         },
+        // Serialize Parachute Task
+        {
+            "SPT",
+            "40 55 53 56 57 41 54 48 8B",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_serialize_parachute_task = ptr.as<PVOID>();
+            }
+        },
         // Chat Data
         {
             "CD",
@@ -844,13 +853,22 @@ namespace big
                 g_pointers->m_gta.m_invalid_decal_crash = ptr.add(1).rip().as<PVOID>();
             }
         },
-        // Task Parachute Object 0x270
+        // Task Parachute Object
         {
-            "TPO270",
+            "TPO",
             "0F 88 ? ? ? ? 75 34",
             [](memory::handle ptr)
             {
-                g_pointers->m_gta.m_task_parachute_object_0x270 = ptr.sub(6).as<PVOID>();
+                g_pointers->m_gta.m_task_parachute_object = ptr.sub(6).as<PVOID>();
+            }
+        },
+        // Task Ambient Clips
+        {
+            "TAC",
+            "48 89 5C 24 08 48 89 74 24 10 57 48 83 EC 20 80 3D ? ? ? ? ? 41 8B D8 8B F2",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_task_ambient_clips = ptr.as<PVOID>();
             }
         },
         // Encode Session Info
@@ -1299,6 +1317,118 @@ namespace big
                 g_pointers->m_gta.m_force_relay_connections = ptr.add(2).rip().as<bool*>();
             }
         },
+        // Read Bits Single
+        {
+            "RBS",
+            "48 8B C4 48 89 58 08 48 89 68 10 48 89 70 18 48 89 78 20 41 56 41 57 33 FF",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_read_bits_single = ptr.as<PVOID*>();
+            }
+        },
+        // Remove Reference
+        {
+            "RR",
+            "48 89 5C 24 08 57 48 83 EC 20 80 3D ? ? ? ? ? 48 8B FA 48 8B D9 74 13",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_remove_reference = ptr.as<functions::remove_reference>();
+            }
+        },
+        // Sync Data Reader Vtable
+        {
+            "RBS",
+            "48 8D 05 ? ? ? ? 48 8D 54 24 20 48 89 44 24 20 48 8D 44 24 40",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_sync_data_reader_vtable = ptr.add(3).rip().as<void**>();
+            }
+        },
+        // Interior Proxy Pool
+        {
+            "IPP",
+            "4C 8B 05 ? ? ? ? 4C 0F BF 0B",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_interior_proxy_pool = ptr.add(3).rip().as<GenericPool**>();
+            }
+        },
+        // Train Config Array
+        {
+            "TCA",
+            "48 8D 0D ? ? ? ? E8 ? ? ? ? 44 88 64 24 30 4C 8D 8C 24 60 02 00 00",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_train_config_array = ptr.add(3).rip().as<rage::atArray<CTrainConfig>*>();
+            }
+        },
+        // Activate Special Ability
+        {
+            "ASA",
+            "48 89 5C 24 08 48 89 74 24 10 57 48 83 EC 20 33 DB 8B F2 48 8B F9 48 39 99 D0",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_activate_special_ability = ptr.as<functions::activate_special_ability>();
+            }
+        },
+        // Set Wanted Level
+        {
+            "SWL",
+            "48 8B C4 48 89 58 08 48 89 68 10 48 89 70 18 44 88 48 20 57 41 54 41 55 41 56 41 57 48 83 EC 30 4C 8B F1 48 8B 0D ? ? ? ? 44 8B E2",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_set_wanted_level = ptr.as<functions::set_wanted_level>();
+            }
+        },
+        // Event Stuff
+        {
+            "NEM&CEQ&NEP&GNPI&QNE",
+            "48 39 99 D0 00 00 00 74 3C",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_net_event_manager = ptr.add(0xC).rip().as<rage::netEventMgr**>();
+                g_pointers->m_gta.m_check_event_queue = ptr.add(0x13).rip().as<functions::check_event_queue>();
+                g_pointers->m_gta.m_net_event_pool = ptr.add(0x1A).rip().as<GenericPool**>();
+                g_pointers->m_gta.m_get_new_pool_item = ptr.add(0x1F).rip().as<functions::get_new_pool_item>();
+                g_pointers->m_gta.m_queue_network_event = ptr.add(0x41).rip().as<functions::queue_network_event>();
+            }
+        },
+        // Construct Door Break Event
+        {
+            "CDBE",
+            "48 89 5C 24 08 57 48 83 EC 30 33 FF BA 1B",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_construct_door_break_event = ptr.as<functions::construct_door_break_event>();
+            }
+        },
+        // Delete Ped
+        {
+            "DP",
+            "48 83 EC 28 48 85 C9 74 12 48",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_delete_ped = ptr.as<functions::delete_ped>();
+            }
+        },
+        // Delete Vehicle
+        {
+            "DV",
+            "48 85 C9 74 38 53 48 83 EC 20 80",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_delete_vehicle = ptr.as<functions::delete_vehicle>();
+            }
+        },
+        // Delete Object
+        {
+            "DO",
+            "48 8B C4 48 89 58 08 48 89 68 10 48 89 70 18 48 89 78 20 41 56 48 83 EC 30 45 33 F6 40",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_delete_object = ptr.as<functions::delete_object>();
+            }
+        },
         // Max Wanted Level
         {
             "MWL",
@@ -1491,6 +1621,15 @@ namespace big
             {
                 g_pointers->m_gta.m_free_event_error = ptr.add(0x31).as<PVOID>();
             }
+        },
+        // Activate Special Ability Patch
+        {
+            "ASAP",
+            "48 89 5C 24 08 48 89 74 24 10 57 48 83 EC 20 0F B7 49 30 48 8B F2 E8 ? ? ? ? 33 DB 48 8B F8 48 85 C0 74 35",
+            [](memory::handle ptr)
+            {
+                g_pointers->m_gta.m_activate_special_ability_patch = ptr.as<PVOID>();
+            }
         }
         >(); // don't leave a trailing comma at the end
 

src/services/hotkey/hotkey_service.cpp

@@ -56,6 +56,8 @@ namespace big
 	bool hotkey_service::update_hotkey(const std::string_view name, const key_t key)
 	{
 		static auto update_hotkey_map = [](hotkey_map& hotkey_map, rage::joaat_t name_hash, key_t new_key) -> bool {
+			bool processed = false;
+
 			for (auto it = hotkey_map.begin(); it != hotkey_map.end(); ++it)
 			{
 				auto hotkey = it->second;
@@ -66,9 +68,9 @@ namespace big
 				hotkey.set_key(new_key);
 				hotkey_map.emplace(new_key, hotkey);
 
-				return true;
+				processed = true;
 			}
-			return false;
+			return processed;
 		};
 
 		const auto name_hash = rage::joaat(name);

src/services/outfit/outfit_service.cpp

@@ -1,6 +1,7 @@
-#include "util/outfit.hpp"
 #include "outfit_service.hpp"
+
 #include "natives.hpp"
+#include "util/outfit.hpp"
 
 namespace big
 {
@@ -50,15 +51,24 @@ namespace big
 		if (j.contains("blend_data") && was_components_set)
 		{
 			head_blend_data blend_data = j["blend_data"];
-			PED::SET_PED_HEAD_BLEND_DATA(self::ped, blend_data.shape_first_id, blend_data.shape_second_id,
-			    blend_data.shape_third_id, blend_data.skin_first_id, blend_data.skin_second_id, blend_data.skin_third_id,
-			    blend_data.shape_mix, blend_data.skin_mix, blend_data.third_mix, blend_data.is_parent);
+			PED::SET_PED_HEAD_BLEND_DATA(self::ped,
+			    blend_data.shape_first_id,
+			    blend_data.shape_second_id,
+			    blend_data.shape_third_id,
+			    blend_data.skin_first_id,
+			    blend_data.skin_second_id,
+			    blend_data.skin_third_id,
+			    blend_data.shape_mix,
+			    blend_data.skin_mix,
+			    blend_data.third_mix,
+			    blend_data.is_parent);
 		}
 	}
 	void outfit_service::save_outfit(std::string filename)
 	{
 		outfit::components_t components;
 		outfit::props_t props;
+		auto model = ENTITY::GET_ENTITY_MODEL(self::ped);
 
 		for (auto& item : components.items)
 		{
@@ -99,11 +109,16 @@ namespace big
 		}
 
 		head_blend_data blend_data{};
-		PED::GET_PED_HEAD_BLEND_DATA(self::ped, (Any*)&blend_data);
+
+		if (model == RAGE_JOAAT("mp_m_freemode_01") || model == RAGE_JOAAT("mp_f_freemode_01"))
+		{
+			PED::GET_PED_HEAD_BLEND_DATA(self::ped, (Any*)&blend_data);
+			j["blend_data"] = blend_data;
+		}
 
 		j["components"] = j_components;
 		j["props"]      = j_props;
-		j["blend_data"] = blend_data;
+		j["model"]      = model;
 
 		static folder saved_outfit_path = g_file_manager.get_project_folder("saved_outfits");
 		std::ofstream o(saved_outfit_path.get_file(filename).get_path());

src/services/players/player.hpp

@@ -60,6 +60,7 @@ namespace big
 		bool off_radar    = false;
 		bool never_wanted = false;
 		bool semi_godmode = false;
+		bool fix_vehicle  = false;
 
 		bool kill_loop       = false;
 		bool explosion_loop  = false;
@@ -78,12 +79,11 @@ namespace big
 
 		bool m_block_permanent_vehicles = false;
 
-		bool exposed_desync_protection = false;
-		bool is_modder                 = false;
-		bool block_join                = false;
-		int block_join_reason          = 0;
-		bool is_spammer                = false;
-		bool is_admin                  = false;
+		bool is_modder        = false;
+		bool block_join       = false;
+		int block_join_reason = 0;
+		bool is_spammer       = false;
+		bool is_admin         = false;
 		std::optional<uint32_t> player_time_value;
 		std::optional<std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds>> player_time_value_received_time;
 		std::optional<uint32_t> time_difference;

src/util/animator.hpp

@@ -1,36 +0,0 @@
-#pragma once
-
-namespace big
-{
-	class animator
-	{
-		std::chrono::time_point<std::chrono::system_clock> animation_start_time;
-		std::chrono::time_point<std::chrono::system_clock> animation_current_time;
-		float animation_curve(float t)
-		{
-			return 3 * pow(1.f - t, 2.f) * t + 3 * (1.f - t) * pow(t, 2.f) + pow(t, 3.f);
-		}
-
-	public:
-		void animate(int milliseconds, std::function<void(float&)> cb)
-		{
-			animation_current_time = std::chrono::system_clock::now();
-			float timeDiff = (float)std::chrono::duration_cast<std::chrono::milliseconds>(animation_current_time - animation_start_time)
-			                     .count();
-			float t = timeDiff / milliseconds;
-
-			if (t > 1)
-			{
-				t = 1;
-			}
-
-			float progress = animation_curve(t);
-			cb(progress);
-		}
-
-		void reset()
-		{
-			animation_start_time = std::chrono::system_clock::now();
-		}
-	};
-}