[Functions] source code functions

**KiLLerBoy_001** · 11-15-2015

First in introduction might be in order

I'm KiLLerboy_001 Pretty wel known in PS3's modding community for GTA 5 back in the days Memory editing

and menu creation

Now recently i achieved a PC copy of GTA 5 and went to check out the menus just to see some missing features, These will be converted to C++ type of code.
Since i cant install visual studio on my current copy of windows ( not sure why it just fails ) ill just share my code snippets hoping that somebody can include them.

Drive on water

Code:

//-----------------  Drive on water  -----------------
//Uses an extra bool called: FolowWaves, With this set to True it will Follow the waves perfectly When set on False it will Not
//
//Since both functions GET_WATER_HEIGHT_NO_WAVES & GET_WATER_HEIGHT only return a value over ocean or Alamo Sea.
//I also included a backdrop meaning if no current value is found it will always use the last found one.
//
//----------------------------------------------------
 
 
 
 
InitiateDrive()
{
   int WaterObject = CREATE_OBJECT("prop_huge_display_01",--------------------------
   SET_ENTITY_ROTATION(WaterObject,90,0,0,2,1)
   FREEZE_ENTITY_POSITION(WaterObject,1)
   SET_ENTITY_VISIBLE(WaterObject,0)
};
 
 
DriveLoop()
{
   Vector3 PlayerCoord = GET_ENTITY_COORDS(PLAYER_PED_ID(),1)
   float xPlane PlayerCoord.X
   float yPlane PlayerCoord.Y
   if (FolowWaves==true)
   {
      GET_WATER_HEIGHT(GET_ENTITY_COORDS(PLAYER_PED_ID()  ,1),float *NewZ)
      if (NewZ < -100)
      {
          float zPlane = LastZ
      }
      else
      {
         float zPlane = NewZ
         float LastZ = NewZ
      }
   }
   else
   {
      GET_WATER_HEIGHT_NO_WAVES(GET_ENTITY_COORDS(PLAYER  _PED_ID(),1),float *NewZ)
      if (NewZ < -100)
      {
          float zPlane = LastZ
      }
      else
      {
         float zPlane = NewZ
         float LastZ = NewZ
      }  
   }
   Vector3 Coord(xPlane, yPlane, zPlane)
   SET_ENTITY_COORDS(WaterObject,1,0,0,1)
};

Magic Carpet ( walk in air )

Code:

//-----------------  Magic Carpet  -----------------
//
//Nothing special Do check IS_CONTROL_PRESSED numbers though
//
//--------------------------------------------------
 
InitiateMagicCarpet()
{
   int MagicCarpetObject = CREATE_OBJECT("p_oil_slick_01",--------------------------
   FREEZE_ENTITY_POSITION(MagicCarpetObject,1)
   SET_ENTITY_VISIBLE(MagicCarpetObject,0)
};
 
MagicCarpetLoop()
{
   Vector3 PlayerCoord = GET_ENTITY_COORDS(PLAYER_PED_ID(),1)
   float xPlane PlayerCoord.X
   float yPlane PlayerCoord.Y
 
   float Normal = 1.0225
   float Down = 1.6
   float Up = 0.4
   float Vehicular 2000.0
 
   if (IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID(),0) //in Car
   {
      zPlane = PlayerCoord.Z - Vehicular
   }
   elseif (IS_CONTROL_PRESSED(2,36) == true )   //Down
   {
      zPlane = PlayerCoord.Z - Down
   }
   elseif (IS_CONTROL_PRESSED(2,26) == true )   //Up
   {
      zPlane = PlayerCoord.Z - Up
   }
   else                                         //Normal
   {
      zPlane = PlayerCoord.Z - Normal
   }
 
   Vector3 Coord(xPlane, yPlane, zPlane)
   SET_ENTITY_COORDS(MagicCarpetObject,1,0,0,1)
}

Sentry Gun (Spawns a gun that auto fires at targets and kills them in your name )

Code:

//-----------------  Sentry Gun  -----------------
//
//Includes a Variable TargetName[] that can be used to either display targeted players name or just "Vehicle"
//Configurable timeout on variable Called:Timeout
//Configurable weapon on variable Called:WeaponID  (https://www.*********.com/forums/threads/weapon-and-explosion-hashes-list.1045035/)
 
//You can switch Players as target with bool:PlayerTarget
//you can switch Vehicles as targets with bool:VehicleTarget
//Vehicles always get priority over players
//------------------------------------------------
 
 
float GetPointToPointRotation(Source,Target)
{
   return ATAN2((Target.y - Source.y),(Target.x - Source.x));
}
 
 
InitiateSentryGun()
{
   int SentryObject = CREATE_OBJECT("p_rcss_folded",--------------------------
   int Timeout = 500
   Timer = GET_GAME_TIMER() + Timeout
}
 
int GetClosestVehicle(Vector3 Coords,float Distance)
{
   Flag = 64;    
   Flag |= 65536;    
   Flag |= 2048;    
   Flag |= 1;    
   Flag |= 2;    
   Flag |= 4;  
   Flag |= 32;  
   Flag |= 16;    
   Flag |= 8;
   return GET_CLOSEST_VEHICLE(Coords,Distance,0,Flag)
}
 
SentryGunLoop()
{
   If (PlayerTarget == True )
   {
      int TargetID = GET_PLAYER_PED(GET_NEAREST_PLAYER_TO_ENTITY(Sentry  Object));
      char TargetName[] = GET_PLAYER_NAME(TargetID);
      if (TargetID == PLAYER_PED_ID())
      {
         //Dont Shoot Myself
      }
      else
      {
 
      }
   }
 
   If (VehicleTarget == True )
   {
      int TargetID = GetClosestVehicle(GET_ENTITY_COORDS(SentryObject,1  ),75);
      char TargetName[] = "Vehicle";
      if (IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID(),0) == True );
      {
         VehID = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID(),0);
         if (TargetID == VehID)
         {
            //Dont Shoot Myself
         }
         else
         {
         }
      }
      else
      {
 
      }
   }
   
   //Rotate and draw
   float Rotation = GetPointToPointRotation(SentryObject,TargetID) + 90
   SET_ENTITY_ROTATION(SentryObject,0,0,Rotation)
   DRAW_LINE(GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(S  entryObject,0,-0.2,0.57),GET_ENTITY_COORDS(TargetID,1),255,0,0,0)
 
   //Time to Kill
   if (GET_GAME_TIMER() >= Timer)
   {     SHOOT_SINGLE_BULLET_BETWEEN_COORDS(GET_OFFSET_FROM  _ENTITY_IN_WORLD_COORDS(SentryObject,0,-0.8,0.6),GET_ENTITY_COORDS(TargetID,1)250,0,Weapon  ID,PLAYER_PED_ID(),1,0,float 1.0)
        PLAY_SOUND_FROM_ENTITY(-1,"Remote_Sniper_Rifle_Fire",SentryObject,"",0,0)
   
        Timer = GET_GAME_TIMER() + Timeout  //500 Milisec between shots
   }
}

Rapid fire ( Turn anything into a minigun )

Code:

//-----------------  Rapid Fire  -----------------
 
 
#include <math.h>
 
RapidFireLoop()
{
   if ( (RapidfireActive == true) && (IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID(),1)==False) && (IS_CONTROL_PRESSED(2,199) && (GET_GAME_TIMER()>=Timeout) )
   {
      FromCoord = GET_PED_BONE_COORDS(PLAYER_PED_ID(),57005,0,0,0)
      ToCoord = GetCoordsInfrontOfCam(75)
      GET_CURRENT_PED_WEAPON(PLAYER_PED_ID,*WeaponID,0)
      SHOOT_SINGLE_BULLET_BETWEEN_COORDS(FromCoord,ToCoo  rd,250,0,WeaponID,PLAYER_PED_ID(),1,0,1)
      Timeout = GET_GAME_TIMER() + 50
   }
}
 
Vector3 GetCoordsInfrontOfCam(float distance)
{
   Vector3 GameplayCamRot = GET_GAMEPLAY_CAM_ROT(2);
   Vector3 GameplayCamCoord = GET_GAMEPLAY_CAM_COORD();
 
   float tan = Cos(GameplayCamRot.X) * distance);
   float xPlane = Sin(GameplayCamRot.Z * -1.0f) * tan) + GameplayCamCoord.X);
   float yPlane = Cos(GameplayCamRot.Z * -1.0f) * tan) + GameplayCamCoord.Y);
   float zPlane = Sin(GameplayCamRot.X) * distance) + GameplayCamCoord.Z);
 
   return new Vector3(xPlane, yPlane, zPlane);
}

Show talking players

Code:

//-----------------  Talking players  -----------------
//
// Just enable TalkingPlayers Bool and make sure that Talking[] text gets added onscreen somewhere
//-----------------------------------------------------
 
 
 
TalkingPlayerLoop()
{
   if (TalkingPlayers==true)
   {
      for (int i = 0; i < 32; ++i)
      {
         if (NETWORK_IS_PLAYER_TALKING(i) == true )
         {
            char Talking[] = GET_PLAYER_NAME(i)
            //Add code here to make the Talking[] entry be pushed to screen
         }
         i++;
      }
   }
}

Dragon mode ( Fire breather )

Code:

//-----------------  Dragon Mode  -----------------
//
// Just enable DragonMode Bool
//-----------------------------------------------------
 
 
FireManModeLoop()
{
   if ( DragonMode == true )
   {
      Vector3 Mouth = GET_PED_BONE_COORDS(PLAYER_PED_ID(), 39317, 0.1f , 0.0f, 0.0f)
      _ADD_SPECFX_EXPLOSION(Mouth.x,Mouth.y,Mouth.z, EXPLOSION_DIR_FLAME, EXPLOSION_DIR_FLAME, 1.0f, true, true, 0.0f)
   }
}

Object Removal + advanced gravity gun

Code:

// REQUiRMENTS
 
 
Vector3 GetCoordsInfrontOfCam(float distance)
{
   Vector3 GameplayCamRot = GET_GAMEPLAY_CAM_ROT(2);
   Vector3 GameplayCamCoord = GET_GAMEPLAY_CAM_COORD();
 
   float tan = Cos(GameplayCamRot.X) * distance);
   float xPlane = Sin(GameplayCamRot.Z * -1.0f) * tan) + GameplayCamCoord.X);
   float yPlane = Cos(GameplayCamRot.Z * -1.0f) * tan) + GameplayCamCoord.Y);
   float zPlane = Sin(GameplayCamRot.X) * distance) + GameplayCamCoord.Z);
 
   return new Vector3(xPlane, yPlane, zPlane);
}
 
 
 
//-----------------  Remove targetted Objects  -----------------
//
// Just enable RemoveObjects Bool and shoot an object to remove it ( Client Sided )
//
//-----------------------------------------------------
 
 
RemoveObjectsLoop()
{
   if ( (RemoveObjects == true) && (IS_CONTROL_PRESSED(2,199) )
   {
      GET_ENTITY_PLAYER_IS_FREE_AIMING_AT(PLAYER_ID(),*E  ntityID)
      if (IS_ENTITY_AN_OBJECT(EntityID) == true )
      {
         DELETE_ENTITY(*EntityID)
      }
   }
}
 
 
//-----------------  Gravity gun ( Pickup and launch )  -----------------
//
// Just enable GravityGun Bool and shoot an object to pick it up shoot again to launch it
//
// When object is picked up it makes it see through and undoes this when launched ( object moves infront of you when picked up )
// ObjectHash[] can be used to display Hash of picked up object ( usefull for spawning uknown object Best display this in lower left under radar )
//
//-----------------------------------------------------
 
Bool Pickup = true
 
GravityGunLoop()
{
   if (GravityGun == true)
   {
      if ( (Pickup == true) && (IS_CONTROL_PRESSED(2,199) )
      {
         Pickup = false
         GET_ENTITY_PLAYER_IS_FREE_AIMING_AT(PLAYER_ID(),*E  ntityID)
         if (IS_ENTITY_A_PED(EntityID) == true)
         {
            if (IS_PED_IN_ANY_VEHICLE(EntityID,0))
            {
               EntityID = GET_VEHICLE_PED_IS_IN(EntityID,0)
            }
         }
         SET_ENTITY_ALPHA(EntityID,200)
      }
      elseif ( (Pickup == false) && (IS_CONTROL_PRESSED(2,199) )
      {
         Pickup = true
         if (IS_ENTITY_A_PED(EntityID) == true )
         {
            SET_ENTITY_DYNAMIC(EntityID,1)
            Vector3 Rotation = GET_ENTITY_ROTATION(EntityID,2)
            SET_ENTITY_ROTATION(EntityID,GET_GAMEPLAY_CAM_ROT(  2),2,1)
            APPLY_FORCE_TO_ENTITY(EntityID,1,0,150,0,0,0,0,0,1  ,1,1,0,1)
            SET_ENTITY_ROTATION(EntityID,Rotation,2,1)
            SET_ENTITY_ALPHA(EntityID,255)
         }
      }
      else
      {
         if (DOES_ENTITY_EXIST(EntityID)==true)
         {
            Char ObjectHash[] = GET_ENTITY_MODEL(EntityID)
            SET_ENTITY_COORDS(EntityID,GetCoordsInfrontOfCam(1  0),1,0,0,1)
         }
      }
   }
}

Advanced Flying car( Has rudder rotation like planes )

Code:

//-----------------  Flying Car  -----------------
//
// Just enable the FlyingCar Bool
//
// Double check the Numerics for IS_CONTROL_PRESSED
//-----------------------------------------------------
 
FlyingCarLoop ()
{
   if (IS_PED_IN_ANY_VEHICLE(PLAYER_PED_ID,0))
   {
      int Vehid = GET_VEHICLE_PED_IS_IN(PLAYER_PED_ID,0)
     
      if (IS_CONTROL_PRESSED(2,67) ==true ) //Forward
      {
         float Speed = GET_ENTITY_SPEED(Vehid) + 0.5
         SET_VEHICLE_FORWARD_SPEED(Vehid,Speed)
      }
 
      if ( (IS_CONTROL_PRESSED(2,196) ==true) && ( ! IS_VEHICLE_ON_ALL_WHEELS(Vehid) ) //Left
      {
         Vector3 Rot = GET_ENTITY_ROTATION(Vehid,2)
         Rot.z = Rot.z + 1.0
         newRot Vector3(Rot.x, Rot.y, Rot.z)
         SET_ENTITY_ROTATION(Vehid,newRot,2,1)
      }
 
      if ( (IS_CONTROL_PRESSED(2,197) ==true) && ( ! IS_VEHICLE_ON_ALL_WHEELS(Vehid) ) //Right
      {
         Vector3 Rot = GET_ENTITY_ROTATION(Vehid,2)
         Rot.z = Rot.z - 1.0
         newRot Vector3(Rot.x, Rot.y, Rot.z)
         SET_ENTITY_ROTATION(Vehid,newRot,2,1)
      }
   }
}

If You saw any other interesting thing in the video just asks me about it and i will supply like the Plane_crash_trench Plane object coords + rotation etc any other info youll need ill supply.

Also be sure to check out my pastebin https://pastebin.com/u/KiLLerBoy_001 has a lot of snippets / extra info there

P.S: All i asks is to be creditted for these here snippets if you chose on using them even be it partially

just some fun ( Alien egg money )

**Gaz'lam** · 11-17-2015

To Add onto this thread

Code:

void RequestControl(Entity input)
{
	NETWORK::NETWORK_REQUEST_CONTROL_OF_ENTITY(input);

	int tick = 0;
	while (tick <= 50)
	{
		if (!NETWORK::NETWORK_HAS_CONTROL_OF_ENTITY(input))
			WAIT(0);
		else
			return;
		NETWORK::NETWORK_REQUEST_CONTROL_OF_ENTITY(input);
		tick++;
	}
}

void RequestControlOfid(Entity selectedPlayer)
{
	Any netid = NETWORK::NETWORK_GET_NETWORK_ID_FROM_ENTITY(selectedPlayer);
	int tick = 0;

	while (!NETWORK::NETWORK_HAS_CONTROL_OF_NETWORK_ID(netid) && tick <= 50)
	{
		NETWORK::NETWORK_REQUEST_CONTROL_OF_NETWORK_ID(netid);
		tick++;
	}
}

void BruteForceWeaponAddons(Ped ped, Hash weaponHash, bool bSilencer)
{
	static Hash weaponAddons[] = { COMPONENT_AT_SCOPE_MACRO, COMPONENT_AT_SCOPE_MACRO_02, COMPONENT_AT_SCOPE_SMALL, COMPONENT_AT_SCOPE_SMALL_02, COMPONENT_AT_SCOPE_MEDIUM, COMPONENT_AT_SCOPE_LARGE, COMPONENT_AT_SCOPE_MAX, COMPONENT_AT_RAILCOVER_01, COMPONENT_AT_AR_AFGRIP, COMPONENT_AT_PI_FLSH, COMPONENT_AT_AR_FLSH, COMPONENT_PISTOL_CLIP_02, COMPONENT_COMBATPISTOL_CLIP_02, COMPONENT_APPISTOL_CLIP_02, COMPONENT_MICROSMG_CLIP_02, COMPONENT_SMG_CLIP_02, COMPONENT_ASSAULTRIFLE_CLIP_02, COMPONENT_CARBINERIFLE_CLIP_02, COMPONENT_ADVANCEDRIFLE_CLIP_02, COMPONENT_MG_CLIP_02, COMPONENT_COMBATMG_CLIP_02, COMPONENT_ASSAULTSHOTGUN_CLIP_02, COMPONENT_PISTOL50_CLIP_02, COMPONENT_ASSAULTSMG_CLIP_02, COMPONENT_SNSPISTOL_CLIP_02, COMPONENT_COMBATPDW_CLIP_02, COMPONENT_HEAVYPISTOL_CLIP_02, COMPONENT_SPECIALCARBINE_CLIP_02, COMPONENT_BULLPUPRIFLE_CLIP_02, COMPONENT_VINTAGEPISTOL_CLIP_02, COMPONENT_MARKSMANRIFLE_CLIP_02, COMPONENT_HEAVYSHOTGUN_CLIP_02, COMPONENT_GUSENBERG_CLIP_02 };
	for each (Hash addonHash in weaponAddons)
	{
		if (WEAPON::_CAN_WEAPON_HAVE_COMPONENT(weaponHash, addonHash))
			WEAPON::GIVE_WEAPON_COMPONENT_TO_PED(ped, weaponHash, addonHash);
	}
	if (bSilencer)
	{
		static Hash silencers[] = { COMPONENT_AT_PI_SUPP, COMPONENT_AT_PI_SUPP_02, COMPONENT_AT_AR_SUPP, COMPONENT_AT_SR_SUPP, COMPONENT_AT_AR_SUPP_02 };
		for each (Hash silencerHash in silencers)
		{
			if (WEAPON::_CAN_WEAPON_HAVE_COMPONENT(weaponHash, silencerHash)) {
				if (weaponHash != WEAPON_ADVANCEDRIFLE && WEAPON::GET_WEAPONTYPE_GROUP(weaponHash) != WEAPON_TYPE_GROUP_SHOTGUN)
					WEAPON::GIVE_WEAPON_COMPONENT_TO_PED(ped, weaponHash, silencerHash);
			}
		}
		if (weaponHash == WEAPON_SNIPERRIFLE || weaponHash == WEAPON_MICROSMG)
			WEAPON::GIVE_WEAPON_COMPONENT_TO_PED(ped, weaponHash, COMPONENT_AT_AR_SUPP_02);
	}
}

void giveWeapon(Ped selectedPed)
{
	if (ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID()))
	{
		GAMEPLAY::DISPLAY_ONSCREEN_KEYBOARD(true, "Input your weapon ID", "", "WEAPON_RAILGUN", "", "", "", 30);
		while (GAMEPLAY::UPDATE_ONSCREEN_KEYBOARD() == 0) WAIT(0);
		if (!WEAPON::IS_WEAPON_VALID(GAMEPLAY::GET_HASH_KEY(GAMEPLAY::GET_ONSCREEN_KEYBOARD_RESULT())))
		{
			notifyAboveMap("~HUD_COLOUR_BLUE~Invalid Weapon");
			return;
		}
		else
		{
			char* weapon = GAMEPLAY::GET_ONSCREEN_KEYBOARD_RESULT();
			Hash pedWeapon = GAMEPLAY::GET_HASH_KEY(weapon);
			WEAPON::GIVE_DELAYED_WEAPON_TO_PED(selectedPed, pedWeapon, 0, true);
			WEAPON::SET_PED_AMMO(selectedPed, pedWeapon, 1000);
			notifyAboveMap_Status_Text("Gave Player a %s", weapon);
		}
	}
}





void vehicleAllMods(Player selectedPlayer)
{
	if (PED::IS_PED_IN_ANY_VEHICLE(selectedPlayer, 0))
	{
		Vehicle veh = PED::GET_VEHICLE_PED_IS_USING(selectedPlayer);
		RequestControl(veh);
		VEHICLE::SET_VEHICLE_MOD_KIT(veh, 0);
		VEHICLE::SET_VEHICLE_COLOURS(veh, 120, 120);
		VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(veh, 5);
		VEHICLE::TOGGLE_VEHICLE_MOD(veh, 18, 1);
		VEHICLE::TOGGLE_VEHICLE_MOD(veh, 22, 1);
		VEHICLE::SET_VEHICLE_MOD(veh, 16, 5, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 12, 2, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 11, 3, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 14, 14, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 15, 3, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 13, 2, 0);
		VEHICLE::SET_VEHICLE_WHEEL_TYPE(veh, 6);
		VEHICLE::SET_VEHICLE_WINDOW_TINT(veh, 3);
		VEHICLE::SET_VEHICLE_MOD(veh, 23, 19, 1);
		VEHICLE::SET_VEHICLE_MOD(veh, 0, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 1, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 2, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 3, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 4, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 5, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 6, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 7, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 8, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 9, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 10, 1, 0);
		notifyAboveMap("~HUD_COLOUR_GREEN~Added all Mods to Players Vehicle");
	}
	else
	{
		notifyAboveMap("~HUD_COLOUR_RED~Player isnt in Vehicle");
	}
}


void SetOffAlarmofPlayerVehicle(Ped selectedPed)
{
	if (PED::IS_PED_IN_ANY_VEHICLE(selectedPed, FALSE))
	{
		Entity selectedVehicle = PED::GET_VEHICLE_PED_IS_USING(selectedPed);
		RequestControl(PED::GET_VEHICLE_PED_IS_USING(selectedPed));
		VEHICLE::SET_VEHICLE_ALARM(selectedVehicle, true);
		VEHICLE::START_VEHICLE_ALARM(selectedVehicle);
		notifyAboveMap("~HUD_COLOUR_GREEN~Set off alarm of Players vehicle");
	}
	else
	{
		notifyAboveMap("~HUD_COLOUR_RED~Player isnt in a Vehicle");
	}
}



void BurstSelectedPlayerTires(Ped selectedPed)
{
	if (PED::IS_PED_IN_ANY_VEHICLE(selectedPed, FALSE))
	{
		notifyAboveMap("~HUD_COLOUR_GREEN~Bursted Players Tires");
		Vehicle selectedVehicle = PED::GET_VEHICLE_PED_IS_USING(selectedPed);
		RequestControl(selectedVehicle);
		if (VEHICLE::GET_VEHICLE_TYRES_CAN_BURST(selectedVehicle))
		{
			VEHICLE::SET_VEHICLE_TYRES_CAN_BURST(selectedVehicle, TRUE);
		}
		static int tireID = 0;
		for (tireID = 0; tireID < 8; tireID++)
		{
			RequestControl(selectedVehicle);
			VEHICLE::SET_VEHICLE_TYRE_BURST(selectedVehicle, tireID, true, 1000.0);
		}
	}
	else
	{
		notifyAboveMap("~HUD_COLOUR_RED~Player isnt an any vehicle");
	}
}

void framePlayer(Ped selectedPed, char* Name)
{
	for (int i = 0; i < 32; i++)
	{
		Player playerPed = PLAYER::PLAYER_PED_ID();
		Player playerHandle = PLAYER::GET_PLAYER_PED(i);
		if (!strcmp(Name, "")) continue;
		{
			if (!strcmp(Name, "")) continue;
			{
				if (!strcmp(Name, "")) continue;
				{
					if (!strcmp(Name, "")) continue;
					{
						if (ENTITY::DOES_ENTITY_EXIST(selectedPed))
						{
							if (!PLAYER::GET_PLAYER_PED(i) == selectedPed) continue;
							notifyAboveMap_Status_Text("Framed %s", Name);
							Vector3 PlyPos1 = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(PLAYER::GET_PLAYER_PED(i), 0.0, 0.0, 0.0);
							FIRE::ADD_OWNED_EXPLOSION(selectedPed, PlyPos1.x, PlyPos1.y, PlyPos1.z, 37, 5.0, true, false, 0.1);
						}
					}
				}
			}
		}
	}
}


void beachFireEmUp()
{ // prop_beach_fire
	for (int i = 0; i < 32; i++)
	{
		Player playerHandle = PLAYER::GET_PLAYER_PED(i);
		Hash beach_fire = GAMEPLAY::GET_HASH_KEY("prop_beach_fire");
		STREAMING::REQUEST_MODEL(beach_fire);
		while (!STREAMING::HAS_MODEL_LOADED(beach_fire)) WAIT(0);
		notifyAboveMap("~HUD_COLOUR_RED~Attached Beach Fires to All Players");
		if (ENTITY::DOES_ENTITY_EXIST(playerHandle))
		{
			if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
			{
				if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
				{
					if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
					{
						if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
						{
							if (PLAYER::GET_PLAYER_PED(i) == PLAYER::PLAYER_PED_ID()) continue;
							{
								Object object = OBJECT::CREATE_OBJECT(beach_fire, 0, 0, 0, true, true, false);
								ENTITY::ATTACH_ENTITY_TO_ENTITY(object, playerHandle, PED::GET_PED_BONE_INDEX(playerHandle, SKEL_Spine_Root), 0.0, 0.0, 0.0, 0.0, 90.0, 0, false, false, false, false, 2, true);
							}
							STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(beach_fire);
						}
					}
				}
			}
		}
	}
}

void Freeze(Ped selectedPed)
{
	AI::CLEAR_PED_TASKS_IMMEDIATELY(selectedPed);
	AI::CLEAR_PED_SECONDARY_TASK(selectedPed);
}

void kickPlayerFromVeh(Ped selectedPed)
{
	if (ENTITY::DOES_ENTITY_EXIST(selectedPed))
	{
		if (PED::IS_PED_IN_ANY_VEHICLE(selectedPed, 0))
		{
			notifyAboveMap("Kicked Player from Vehicle");
			Freeze(selectedPed);
		}
		else
		{
			notifyAboveMap("Player isnt in a Vehicle");
		}
	}
	else
	{
		notifyAboveMap("Player doesnt Exist");
	}
}

void tracer()
{
	for (int i = 0; i < 32; i++)
	{
		if (PLAYER::GET_PLAYER_PED(i) == PLAYER::PLAYER_PED_ID()) continue;
		{
			if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
			{
				if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
				{
					if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
					{
						if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
						{
							if (ENTITY::DOES_ENTITY_EXIST(PLAYER::GET_PLAYER_PED(i)))
							{
								Player playerHandle = PLAYER::GET_PLAYER_PED(i);
								Player playerPed = PLAYER::PLAYER_PED_ID();
								int VehHandle = PED::GET_VEHICLE_PED_IS_IN(PLAYER::PLAYER_PED_ID(), 0);
								Vector3 getcoords1 = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(playerHandle, 0, 0, 0);
								Vector3 getcoords3 = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(playerPed, 0, 0, 0);
								GRAPHICS::DRAW_LINE(getcoords1.x, getcoords1.y, getcoords1.z, getcoords3.x, getcoords3.y, getcoords3.z, 255, 0, 0, 255);
							}
						}
					}
				}
			}
		}
	}
}


void trapPlayerInVeh(Ped selectedPed, char* Name)
{
	for (int i = 0; i < 32; i++)
	{
		if (!strcmp(Name, "")) continue;
		{
			if (!strcmp(Name, "")) continue;
			{
				if (!strcmp(Name, "")) continue;
				{
					if (!strcmp(Name, "")) continue;
					{
						Ped playerOneVeh = PED::GET_VEHICLE_PED_IS_USING(selectedPed);
						if (PED::IS_PED_IN_ANY_VEHICLE(selectedPed, FALSE))
						{
							notifyAboveMap("~HUD_COLOUR_GREEN~Kicked Player from his Vehicle");
							RequestControl(playerOneVeh);
							VEHICLE::SET_VEHICLE_DOORS_LOCKED(playerOneVeh, 4);
							VEHICLE::SET_VEHICLE_ENGINE_HEALTH(playerOneVeh, -1);
							VEHICLE::SET_VEHICLE_PETROL_TANK_HEALTH(playerOneVeh, -1);
						}
						else
						{
							notifyAboveMap("~HUD_COLOUR_GREEN~Player isnt in a Vehicle");
						}
					}
				}
			}
		}
	}
}



void massSuicide()
{
	if (ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID()))
	{
		notifyAboveMap("~HUD_COLOUR_RED~Forced Everyone to Suicide");
		for (int i = 0; i < 32; i++)
		{
			if (ENTITY::DOES_ENTITY_EXIST(PLAYER::GET_PLAYER_PED(i)))
			{
				if (PLAYER::GET_PLAYER_PED(i) == PLAYER::PLAYER_PED_ID()) continue;
				{
					if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
					{
						if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
						{
							if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
							{
								if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
								{
									if (PED::IS_PED_ON_FOOT(PLAYER::GET_PLAYER_PED(i)))
									{
										Player playerHandle = PLAYER::GET_PLAYER_PED(i);
										Vector3 PlyPos1 = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(playerHandle, 0.0, 0.0, 0.0);
										FIRE::ADD_OWNED_EXPLOSION(playerHandle, PlyPos1.x, PlyPos1.y, PlyPos1.z, 37, 5.0, false, true, 0.0);
									}
									else
									{
										Player playerHandle = PLAYER::GET_PLAYER_PED(i);
										Freeze(playerHandle);
										WAIT(0);
										Vector3 PlyPos1 = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(playerHandle, 0.0, 0.0, 0.0);
										FIRE::ADD_OWNED_EXPLOSION(playerHandle, PlyPos1.x, PlyPos1.y, PlyPos1.z, 37, 5.0, false, true, 0.0);
									}
								}
							}
						}
					}
				}
			}
		}
	}
}



Vector3 GetCoordsFromCam(int distance)
{
	Vector3 rot = CAM::GET_GAMEPLAY_CAM_ROT(2);
	Vector3 coord = CAM::GET_GAMEPLAY_CAM_COORD();

    int tZ = rot.z * 0.0174532924;
	int tX = rot.x * 0.0174532924;
	int num = std::abs(std::cos(tX));

	coord.x = coord.x + (-std::sin(tZ)) * (num + distance);
	coord.y = coord.y + (std::cos(tZ)) * (num + distance);
	coord.z = coord.z + std::sin(tX) * 8;

	return coord;
}

void BoostBaseVehicleStats(Vehicle vehicle)
{
	RequestControl(vehicle);
	VEHICLE::SET_VEHICLE_DIRT_LEVEL(vehicle, 0.0f);
	ENTITY::SET_ENTITY_INVINCIBLE(vehicle, TRUE); //That should do the trick.
	ENTITY::SET_ENTITY_PROOFS(vehicle, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE);
	VEHICLE::SET_VEHICLE_STRONG(vehicle, TRUE); //2stronk
	VEHICLE::SET_VEHICLE_CAN_BE_VISIBLY_DAMAGED(vehicle, !TRUE); //I don't think this really works, but fuck it. Call it anyway.
	VEHICLE::SET_VEHICLE_CAN_BREAK(vehicle, !FALSE); //Hopefully this fixes the car blowing up after getting hit by a train...
	VEHICLE::SET_VEHICLE_ENGINE_CAN_DEGRADE(vehicle, !FALSE);
	VEHICLE::SET_VEHICLE_IS_STOLEN(vehicle, FALSE); //What seems to be the officer, problem? *le9gagmemeface*
	VEHICLE::SET_VEHICLE_TYRES_CAN_BURST(vehicle, FALSE); //Bulletproof Tires.
	Hash vehicleModel = ENTITY::GET_ENTITY_MODEL(vehicle);
	if (VEHICLE::IS_THIS_MODEL_A_CAR(vehicleModel) || VEHICLE::IS_THIS_MODEL_A_BIKE(vehicleModel))
	{
		VEHICLE::SET_VEHICLE_MOD_KIT(vehicle, 0); //IDK what this does, but I guess it allows individual mods to be added? It's what the game does before calling SET_VEHICLE_MOD.
		VEHICLE::SET_VEHICLE_HAS_STRONG_AXLES(vehicle, TRUE); //6stronk9meme
		VEHICLE::SET_VEHICLE_MOD(vehicle, MOD_ENGINE, MOD_INDEX_FOUR, TRUE); //6fast9furious
		VEHICLE::SET_VEHICLE_MOD(vehicle, MOD_BRAKES, MOD_INDEX_THREE, TRUE); //GOTTA STOP FAST
		VEHICLE::SET_VEHICLE_MOD(vehicle, MOD_TRANSMISSION, MOD_INDEX_THREE, TRUE); //Not when I shift in to MAXIMUM OVERMEME!
		VEHICLE::SET_VEHICLE_MOD(vehicle, MOD_SUSPENSION, MOD_INDEX_FOUR, TRUE); //How low can you go?
		VEHICLE::SET_VEHICLE_MOD(vehicle, MOD_ARMOR, MOD_INDEX_FIVE, TRUE); //100% armor.
		VEHICLE::TOGGLE_VEHICLE_MOD(vehicle, MOD_TURBO, TRUE); //Forced induction huehuehue
	}
	VEHICLE::SET_VEHICLE_BODY_HEALTH(vehicle, 1000.0f); //This is what the game does
	notifyAboveMap("~HUD_COLOUR_GREEN~Boosted Base Vehicle stats");
}



void CrashPlayer(Ped selectedPed)
{
	const int maxPeds = 70;
	Ped ClonedPed[maxPeds];
	Ped playerPed = PLAYER::PLAYER_PED_ID();

	Vector3 selectedPedPosition = ENTITY::GET_ENTITY_COORDS(selectedPed, FALSE);
	Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(playerPed, FALSE);


	// check distance so i dont crash myself
	if (GAMEPLAY::GET_DISTANCE_BETWEEN_COORDS(playerPosition.x, playerPosition.y, playerPosition.z, selectedPedPosition.x, selectedPedPosition.y, selectedPedPosition.z, false) > 250.0f)
	{
		notifyAboveMap("~HUD_COLOUR_GREEN~This task will take a minute.");
		notifyAboveMap("~HUD_COLOUR_GREEN~Dont worry if the menu disappears its normal");
		//spawn peds
		for (int i = 0; i < maxPeds; i++)
		{
			ClonedPed[i] = PED::CLONE_PED(selectedPed, ENTITY::GET_ENTITY_HEADING(PLAYER::PLAYER_PED_ID()), 1, 1);
			WAIT(60);
			AI::CLEAR_PED_TASKS_IMMEDIATELY(selectedPed);
		}
		//I may need a wait function?

		//and delete the evidence
		for (int i = 0; i < maxPeds; i++)
		{
			RequestControl(ClonedPed[i]);
			PED::DELETE_PED(&ClonedPed[i]);
			AI::CLEAR_PED_TASKS_IMMEDIATELY(selectedPed);
			ENTITY::SET_PED_AS_NO_LONGER_NEEDED(&ClonedPed[i]);
		}
		notifyAboveMap("~HUD_COLOUR_GREEN~Crashed Player");
	}
	else
	{
		notifyAboveMap("~HUD_COLOUR_RED~To close to the player your trying to crash!");
		notifyAboveMap("~HUD_COLOUR_RED~Move farther away!");
	}
}


void RemoveAllPropsFromPlayer(Ped ped)
{
	Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(ped, FALSE);
	Hash modelHashes[] = { 0x2E28CA22 /*p_tram_crash_s*/, 0xA50DDDD0/*prop_bball_arcade_01*/,
		0xEFC4165A/*prop_food_van_01*/, 0x8E8C7A5B/*prop_crashed_heli*/,
		0x456AA864/*prop_dj_deck_01*/, 0xBE862050/*prop_portacabin01*/,
		0xB20E5785/*prop_sculpt_fix*/, 0x58D3B4EA/*prop_micro_01*/,
		0xC42C019A/*prop_ld_ferris_wheel*/, 0x8AF58425/*prop_lev_des_barge_01*/,
		0x3DC31836/*prop_tv_flat_01*/, 0xA9BD0D16 /*prop_coke_block_01*/,
		0x1AFA6A0A /*Prop_weed_01*/, 0x4B3D240F /*prop_wheelchair_01*/,
		0x40F52369 /*p_v_43_safe_s*/, 0xF830B63E /*prop_swiss_ball_01*/,
		0xD541462D /*p_ld_soc_ball_01*/, 0x532B1DD1 /*prop_rub_trolley01a*/,
		0x0E3BA450 /*prop_xmas_tree_int*/, 0xFB631122 /*prop_bumper_car_01*/,
		0x5571173D /*prop_beer_neon_01*/, 0x6AD326C2 /*prop_space_rifle*/,
		0x7FFBC1E2 /*prop_dummy_01*/, 0x678FC2DB /*prop_wheelchair_01_s*/,
		0x5869A8F8 /*prop_large_gold*/, 0xE6CB661E /*PROP_CS_DILDO_01*/,
		0x2AE13DFA /*prop_armchair_01*/, 0x29CB0F3C /*prop_armour_pickup*/,
		0x922C2A43 /*prop_big_shit_01*/, 0xFA686C0E /*prop_bin_04a*/,
		0x1F550C17 /*prop_chair_01a*/, 0x5B5C4263 /*prop_chip_fryer*/,
		0x39885BB5 /*prop_chickencoop_a*/, 0x16A39A90 /*prop_dog_cage_01*/,
		0xE3CE09E2 /*prop_dummy_plane*/, 0x927A5723 /*prop_fan_01*/,
		0x34D5D3FD /*prop_golf_bag_01*/, 0xB467C540 /*p_spinning_anus_s*/,
		0x745F3383 /*prop_windmill_01*/, 0x392D62AA /*prop_gold_cont_01*/,
		0x07121AC4 /*prop_xmas_ext*/, 0x0E8032E4 /*prop_weed_pallet*/,
		0xD44295DD /*p_cablecar_s*/, 0x6F9939C7 /*prop_ld_toilet_01*/,
		0x9C762726 /*prop_lev_des_barge_02*/, 0x8973A868 /*prop_air_bigradar*/,
		0xC2BC19CD /*p_cs_mp_jet_01_s*/, 651101403 /*garbage bin*/,
		1840863642 /*baskedball */ };
	for each (Hash modelHash in modelHashes)
	{
		Object obj = OBJECT::GET_CLOSEST_OBJECT_OF_TYPE(playerPosition.x, playerPosition.y, playerPosition.z, 3.0f, modelHash, TRUE, 0, 0);
		if (ENTITY::DOES_ENTITY_EXIST(obj))
		{
			RequestControl(obj);
			ENTITY::DELETE_ENTITY(&obj);
		}
	}
}


void FireLoop(Player selectedPlayer)
{
	Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(selectedPlayer, FALSE);
	Object obj = OBJECT::GET_CLOSEST_OBJECT_OF_TYPE(playerPosition.x, playerPosition.y, playerPosition.z, 3.0f, GAMEPLAY::GET_HASH_KEY("prop_beach_fire"), TRUE, 0, 0);
	if (ENTITY::DOES_ENTITY_EXIST(obj))
	{
		RequestControl(obj);
		OBJECT::DELETE_OBJECT(&obj);
		notifyAboveMap("~HUD_COLOUR_RED~Fire loop stopped!");
	}
	else
	{
		Hash beach_fire_hash = GAMEPLAY::GET_HASH_KEY("prop_beach_fire");
		STREAMING::REQUEST_MODEL(beach_fire_hash);
		while (!STREAMING::HAS_MODEL_LOADED(beach_fire_hash)) WAIT(0);
		{
			Object beach_fire = OBJECT::CREATE_OBJECT(beach_fire_hash, playerPosition.x, playerPosition.y, playerPosition.z, true, true, false);
			ENTITY::ATTACH_ENTITY_TO_ENTITY(beach_fire, selectedPlayer, PED::GET_PED_BONE_INDEX(selectedPlayer, SKEL_Spine_Root), 0.0, 0.0, 0.0, 0.0, 90.0, 0, false, false, false, false, 2, true);
			notifyAboveMap("~HUD_COLOUR_GREEN~Fire loop started!");
		}
	}
}

void teleportPlyToMe(Player selectedPlayer)
{
	Vector3 playerPedPos = ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), 0);
	if (ENTITY::DOES_ENTITY_EXIST(selectedPlayer))
	{
		if (PED::IS_PED_IN_ANY_VEHICLE(selectedPlayer, 0))
		{
			Vehicle selectedPlayerVeh = PED::GET_VEHICLE_PED_IS_IN(selectedPlayer, 0);
			RequestControl(selectedPlayerVeh);
			ENTITY::SET_ENTITY_COORDS(selectedPlayerVeh, playerPedPos.x, playerPedPos.y, playerPedPos.z, 0, 0, 0, 1);
			notifyAboveMap("~HUD_COLOUR_GREEN~Teleported Player to You");
		}
		else
		{
			notifyAboveMap("~HUD_COLOUR_RED~This function only works if a player is in a vehicle");
		}
	}
	else
	{
		notifyAboveMap("~HUD_COLOUR_RED~Player doesnt exist");
	}
}


bool IsPlayerFriend(Player player)
{
	BOOL BplayerFriend = false;
	bool bplayerFriend = false;
	int handle[76]; //var num3 = sub_34009(A_0, (A_1) + 264, (A_1) + 272);
	NETWORK::NETWORK_HANDLE_FROM_PLAYER(player, &handle[0], 13);
	if (NETWORK::NETWORK_IS_HANDLE_VALID(&handle[0], 13))
	{
		BplayerFriend = NETWORK::NETWORK_IS_FRIEND(&handle[0]);
	}
	if (BplayerFriend = 1)
		bplayerFriend = true;
	else
		bplayerFriend = false;

	return bplayerFriend;
}


void AIJackVehicle(Ped selectedPlayer)
{
	if (PED::IS_PED_IN_ANY_VEHICLE(selectedPlayer, FALSE))
	{
		Vehicle playerVeh = PED::GET_VEHICLE_PED_IS_USING(selectedPlayer);
		AI::CLEAR_PED_TASKS_IMMEDIATELY(selectedPlayer);
		WAIT(50);
		Ped Driver = PED::CLONE_PED(selectedPlayer, 0.0f, true, true);
		WAIT(50);
		PED::SET_PED_INTO_VEHICLE(Driver, playerVeh, SEAT_DRIVER);
		PED::SET_PED_DIES_WHEN_INJURED(Driver, false);
		AI::TASK_SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(Driver, true);
		WAIT(50);
		AI::TASK_VEHICLE_DRIVE_TO_COORD(Driver, playerVeh, -2000.0f, -1000.0f, 0.0f, 100.0f, 1, ENTITY::GET_ENTITY_MODEL(playerVeh), 0, 0xC00AB, -1);
		notifyAboveMap("~HUD_COLOUR_GREEN~Jacked Players Vehicle");
	}
}

void giveAllWeapons(Player selectedPlayer)
{
	static LPCSTR weaponNames[] = {
		"WEAPON_KNIFE", "WEAPON_NIGHTSTICK", "WEAPON_HAMMER", "WEAPON_BAT", "WEAPON_GOLFCLUB", "WEAPON_CROWBAR",
		"WEAPON_PISTOL", "WEAPON_COMBATPISTOL", "WEAPON_APPISTOL", "WEAPON_PISTOL50", "WEAPON_MICROSMG", "WEAPON_SMG",
		"WEAPON_ASSAULTSMG", "WEAPON_ASSAULTRIFLE", "WEAPON_CARBINERIFLE", "WEAPON_ADVANCEDRIFLE", "WEAPON_MG",
		"WEAPON_COMBATMG", "WEAPON_PUMPSHOTGUN", "WEAPON_SAWNOFFSHOTGUN", "WEAPON_ASSAULTSHOTGUN", "WEAPON_BULLPUPSHOTGUN",
		"WEAPON_STUNGUN", "WEAPON_SNIPERRIFLE", "WEAPON_HEAVYSNIPER", "WEAPON_GRENADELAUNCHER", "WEAPON_GRENADELAUNCHER_SMOKE",
		"WEAPON_RPG", "WEAPON_MINIGUN", "WEAPON_GRENADE", "WEAPON_STICKYBOMB", "WEAPON_SMOKEGRENADE", "WEAPON_BZGAS",
		"WEAPON_MOLOTOV", "WEAPON_FIREEXTINGUISHER", "WEAPON_PETROLCAN",
		"WEAPON_SNSPISTOL", "WEAPON_SPECIALCARBINE", "WEAPON_HEAVYPISTOL", "WEAPON_BULLPUPRIFLE", "WEAPON_HOMINGLAUNCHER",
		"WEAPON_PROXMINE", "WEAPON_SNOWBALL", "WEAPON_VINTAGEPISTOL", "WEAPON_DAGGER", "WEAPON_FIREWORK", "WEAPON_MUSKET",
		"WEAPON_MARKSMANRIFLE", "WEAPON_HEAVYSHOTGUN", "WEAPON_GUSENBERG", "WEAPON_HATCHET", "WEAPON_RAILGUN", "WEAPON_FLAREGUN",
		"" };
	for (int i = 0; i < sizeof(weaponNames) / sizeof(weaponNames[0]); i++)
	{
		WEAPON::GIVE_DELAYED_WEAPON_TO_PED(selectedPlayer, GAMEPLAY::GET_HASH_KEY((char *)weaponNames[i]), 1000, 0);
		BruteForceWeaponAddons(selectedPlayer, GAMEPLAY::GET_HASH_KEY((char *)weaponNames[i]), true);
		WEAPON::SET_PED_WEAPON_TINT_INDEX(selectedPlayer, GAMEPLAY::GET_HASH_KEY((char *)weaponNames[i]), WEAPONTINT_PINK);
		notifyAboveMap("All Weapons Added");
	}
}

void ClearSkiesOfBitches()
{
	if (ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID()))
	{
		notifyAboveMap("~HUD_COLOUR_RED~Cleared the Sky of Bitches");
		for (int i = 0; i < 32; i++)
		{
			if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
			{
				if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
				{
					if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
					{
						if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
						{
							if (PLAYER::GET_PLAYER_PED(i) == PLAYER::PLAYER_PED_ID()) continue;
							{
								if (ENTITY::DOES_ENTITY_EXIST(PLAYER::GET_PLAYER_PED(i)))
								{
									if (PED::IS_PED_IN_FLYING_VEHICLE(PLAYER::GET_PLAYER_PED(i)))
									{
										Vehicle playerOneVeh = PED::GET_VEHICLE_PED_IS_USING(PLAYER::GET_PLAYER_PED(i));
										VEHICLE::SET_VEHICLE_DOORS_LOCKED(playerOneVeh, 4);
										VEHICLE::SET_VEHICLE_ENGINE_HEALTH(playerOneVeh, -1);
										VEHICLE::SET_VEHICLE_PETROL_TANK_HEALTH(playerOneVeh, -1);
									}
								}
							}
						}
					}
				}
			}
		}
	}
}



void killAllBounties()
{
	if (ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID()))
	{
		notifyAboveMap("~HUD_COLOUR_RED~Cleared the Sky of Bitches");
		for (int i = 0; i < 32; i++)
		{
			Player playerHandle = PLAYER::GET_PLAYER_PED(i);
			if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
			{
				if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
				{
					if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
					{
						if (!strcmp(PLAYER::GET_PLAYER_NAME(PLAYER::INT_TO_PLAYERINDEX(i)), "")) continue;
						{
							if (playerHandle == PLAYER::PLAYER_PED_ID()) continue;
							{
								if (ENTITY::DOES_ENTITY_EXIST(playerHandle))
								{
									int Blip = UI::GET_BLIP_FROM_ENTITY(playerHandle);
									if (Blip == BLIP_BOUNTY)
									{
										Freeze(playerHandle);
										Vector3 coords = ENTITY::GET_ENTITY_COORDS(playerHandle, 0);
										FIRE::ADD_OWNED_EXPLOSION(PLAYER::PLAYER_PED_ID(), coords.x, coords.y, coords.z, 37, 5.0, true, false, .1);
									}
								}
							}
						}
					}
				}
			}
		}
	}
}


void teleportToPlayer(Ped playerPed, Ped selectedPed)
{
	if (PED::IS_PED_IN_ANY_VEHICLE(selectedPed, FALSE))
	{
		Vehicle selectedVehicle = PED::GET_VEHICLE_PED_IS_USING(selectedPed);
		int numSeats = VEHICLE::GET_VEHICLE_MAX_NUMBER_OF_PASSENGERS(selectedVehicle);
		for (int i = numSeats; i >= -1; i--)
		{
			PED::SET_PED_INTO_VEHICLE(playerPed, selectedVehicle, i);
		}
	}
	else
	{
		if (PED::IS_PED_ON_FOOT(selectedPed))
		{
			Vector3 playerTwoPos = ENTITY::GET_ENTITY_COORDS(selectedPed, 0);
			Ped playerPed = PLAYER::PLAYER_PED_ID();

			if (PED::IS_PED_IN_ANY_VEHICLE(playerPed, 0))
			{
				RequestControl(PED::GET_VEHICLE_PED_IS_USING(playerPed));
				ENTITY::SET_ENTITY_COORDS_NO_OFFSET(PED::GET_VEHICLE_PED_IS_IN(playerPed, 0), playerTwoPos.x, playerTwoPos.y, playerTwoPos.z + 0.5, 0, 0, 1);
			}
			else
			{
				ENTITY::SET_ENTITY_COORDS_NO_OFFSET(playerPed, playerTwoPos.x, playerTwoPos.y, playerTwoPos.z + 0.5, 0, 0, 1);
			}
		}
	}
}






void spawnPickupModel(char *propName, char *pickupName, Ped selectedPed, int value)
{
	Vector3 ENTPOS = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(selectedPed, 0, 0, 0.5);
	static Any health_pack = GAMEPLAY::GET_HASH_KEY(propName);

	STREAMING::REQUEST_MODEL(health_pack);

	while (!STREAMING::HAS_MODEL_LOADED(health_pack)) WAIT(0);

	OBJECT::CREATE_AMBIENT_PICKUP(GAMEPLAY::GET_HASH_KEY(pickupName), ENTPOS.x, ENTPOS.y, ENTPOS.z, 0, value, GAMEPLAY::GET_HASH_KEY(propName), 0, 1);

	STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(health_pack);
}



void Nuke(Ped selectedPed, char* Name)
{
	for (int i = 0; i < 32; i++)
	{
		if (!strcmp(Name, "")) continue;
		{
			if (!strcmp(Name, "")) continue;
			{
				if (!strcmp(Name, "")) continue;
				{
					if (!strcmp(Name, "")) continue;
					{
						Vector3 coords = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(selectedPed, 0.0, 0.0, 0.0);
						notifyAboveMap_Status_Text("Nuked %s", Name);
						if (PED::IS_PED_ON_FOOT(selectedPed))
						{
							FIRE::ADD_OWNED_EXPLOSION(selectedPed, coords.x, coords.y, coords.z, 37, 5.0, true, false, .1);
						}
						else
						{
							if (PED::IS_PED_IN_ANY_VEHICLE(selectedPed, 0))
							{
								Freeze(selectedPed);
								FIRE::ADD_OWNED_EXPLOSION(selectedPed, coords.x, coords.y, coords.z, 37, 5.0, true, false, .1);
							}
						}
					}
				}
			}
		}
	}
}








bool featureVehWrapInSpawned = false;
bool featureVehSpawnedMaxMod = false;
void SpawnVehicle(Hash hash, Player selectedPlayer)
{
	if (STREAMING::IS_MODEL_IN_CDIMAGE(hash))
	{
		STREAMING::REQUEST_MODEL(hash);
		while (!STREAMING::HAS_MODEL_LOADED(hash)) WAIT(0);
		Vector3 pos = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(selectedPlayer, 0.0, 5.0, 0.0);
		Vehicle veh = VEHICLE::CREATE_VEHICLE(hash, pos.x, pos.y, pos.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), 1, 1);
		VEHICLE::SET_VEHICLE_ON_GROUND_PROPERLY(veh);
		char* plateText = ("DMZREBEL");
		VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT(veh, plateText);

		VEHICLE::SET_VEHICLE_MOD_KIT(veh, 0);
		VEHICLE::SET_VEHICLE_COLOURS(veh, 120, 120);
		VEHICLE::SET_VEHICLE_TYRE_SMOKE_COLOR(veh, rand() % 255, rand() % 255, rand() % 255);
		VEHICLE::TOGGLE_VEHICLE_MOD(veh, 18, 1);
		VEHICLE::TOGGLE_VEHICLE_MOD(veh, 22, 1);
		VEHICLE::SET_VEHICLE_MOD(veh, 16, 5, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 12, 2, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 11, 3, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 14, 14, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 15, 3, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 13, 2, 0);
		VEHICLE::SET_VEHICLE_WHEEL_TYPE(veh, 6);
		VEHICLE::SET_VEHICLE_WINDOW_TINT(veh, 5);
		VEHICLE::SET_VEHICLE_MOD(veh, 23, 14, 2);
		VEHICLE::SET_VEHICLE_MOD(veh, 0, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 1, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 2, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 3, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 4, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 5, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 6, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 7, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 8, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 9, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 10, 1, 0);
		VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(veh, 0, 1);
		VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(veh, 1, 1);
		VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(veh, 2, 1);
		VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(veh, 3, 1);
		VEHICLE::_SET_VEHICLE_NEON_LIGHTS_COLOUR(veh, rand() % 255, rand() % 255, rand() % 255);
		VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(veh, PLATE_YANKTON);

		WAIT(0);
		STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(hash);
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&veh);
	}
	else
	{
		notifyAboveMap("~HUD_COLOUR_RED~Vehicle hash doesn't exist");
	}
}


void spawnChauffer()
{
	int WaypointHandle = UI::GET_FIRST_BLIP_INFO_ID(8);
	if (UI::DOES_BLIP_EXIST(WaypointHandle))
	{
		Vector3 waypoint1 = UI::GET_BLIP_COORDS(WaypointHandle);
		STREAMING::REQUEST_MODEL(GAMEPLAY::GET_HASH_KEY("marshall"));
		while (!STREAMING::HAS_MODEL_LOADED(GAMEPLAY::GET_HASH_KEY("marshall"))) WAIT(0);
		Vector3 pos = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(PLAYER::PLAYER_PED_ID(), 0.0, 5.0, 0);
		Vehicle veh = VEHICLE::CREATE_VEHICLE(GAMEPLAY::GET_HASH_KEY("marshall"), pos.x, pos.y, pos.z, ENTITY::GET_ENTITY_HEADING(PLAYER::PLAYER_PED_ID()), 1, 1);
		if (veh != 0)
		{
			Ped Driver = PED::CREATE_RANDOM_PED_AS_DRIVER(veh, false);
			PED::SET_PED_INTO_VEHICLE(Driver, veh, -1);
			PED::SET_PED_INTO_VEHICLE(PLAYER::PLAYER_PED_ID(), veh, 0);
			AI::TASK_VEHICLE_DRIVE_TO_COORD(Driver, veh, waypoint1.x, waypoint1.y, waypoint1.z, 40, 1, ENTITY::GET_ENTITY_MODEL(veh), 7, 6, -1);
			VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(veh, PLATE_YANKTON);
			char* plateText = ("   DMZ   ");
			VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT(veh, plateText);
			notifyAboveMap("~HUD_COLOUR_GREEN~Chauffer Spawned!");
		}
	}
	else
		notifyAboveMap("~HUD_COLOUR_RED~Please choose a waypoint");
}

void Mad_Money()
{
	Ped playerPed = PLAYER::PLAYER_PED_ID();
	BOOL bPlayerExists = ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID());
	if (bPlayerExists)
	{
		ENTITY::SET_ENTITY_COORDS(playerPed, -365.425f, -131.809f, 37.873f, 0, 0, 0, 1);
		WAIT(100);
		Hash hash = GAMEPLAY::GET_HASH_KEY("buffalo2");
		STREAMING::REQUEST_MODEL(hash);
		while (!STREAMING::HAS_MODEL_LOADED(hash)) WAIT(0);
		Vector3 pos = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(PLAYER::PLAYER_PED_ID(), 0.0, 5.0, 0);
		Vehicle veh = VEHICLE::CREATE_VEHICLE(hash, pos.x, pos.y, pos.z, ENTITY::GET_ENTITY_HEADING(PLAYER::PLAYER_PED_ID()), 1, 1);
		VEHICLE::SET_VEHICLE_MOD_KIT(veh, 0);
		VEHICLE::SET_VEHICLE_COLOURS(veh, 120, 120);
		VEHICLE::SET_VEHICLE_TYRE_SMOKE_COLOR(veh, rand() % 255, rand() % 255, rand() % 255);
		VEHICLE::TOGGLE_VEHICLE_MOD(veh, 18, 1);
		VEHICLE::TOGGLE_VEHICLE_MOD(veh, 22, 1);
		VEHICLE::SET_VEHICLE_MOD(veh, 16, 5, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 12, 2, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 11, 3, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 14, 14, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 15, 3, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 13, 2, 0);
		VEHICLE::SET_VEHICLE_WHEEL_TYPE(veh, 6);
		VEHICLE::SET_VEHICLE_WINDOW_TINT(veh, 5);
		VEHICLE::SET_VEHICLE_MOD(veh, 23, 14, 2);
		VEHICLE::SET_VEHICLE_MOD(veh, 0, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 1, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 2, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 3, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 4, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 5, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 6, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 7, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 8, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 9, 1, 0);
		VEHICLE::SET_VEHICLE_MOD(veh, 10, 1, 0);
		VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(PED::GET_VEHICLE_PED_IS_IN(playerPed, 0), 0, 1);
		VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(PED::GET_VEHICLE_PED_IS_IN(playerPed, 0), 1, 1);
		VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(PED::GET_VEHICLE_PED_IS_IN(playerPed, 0), 2, 1);
		VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(PED::GET_VEHICLE_PED_IS_IN(playerPed, 0), 3, 1);
		VEHICLE::_SET_VEHICLE_NEON_LIGHTS_COLOUR(veh, rand() % 255, rand() % 255, rand() % 255);
		VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(veh, PLATE_YANKTON);
		char* plateText = ("   DMZ   ");
		VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT(veh, plateText);
		PED::SET_PED_INTO_VEHICLE(PLAYER::PLAYER_PED_ID(), veh, -1);
		WAIT(60);

		STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(hash);
		ENTITY::SET_VEHICLE_AS_NO_LONGER_NEEDED(&veh);


		notifyAboveMap("~HUD_COLOUR_GREEN~Vehicle Spawned! Sell it!");


		STATS::STAT_SET_INT(GAMEPLAY::GET_HASH_KEY("MPPLY_VEHICLE_SELL_TIME"), 0, true);
		notifyAboveMap("~HUD_COLOUR_GREEN~Sell Time Bypassed!");
		WAIT(10);

	}
}

void VectorToFloat(Vector3 unk, float *Out)
{
	Out[0] = unk.x;
	Out[1] = unk.y;
	Out[2] = unk.z;
}

void set_status_text(std::string str, DWORD time = 2500, bool isGxtEntry = false)
{
	statusText = "~HUD_COLOUR_GREEN~" + str;
	statusTextDrawTicksMax = GetTickCount() + time;
	statusTextGxtEntry = isGxtEntry;
}

void set_permstatus_text(std::string str, bool isGxtEntry = false)
{
	statusText = str;
	statusTextGxtEntry = isGxtEntry;
}



void explodeNearbyVehicles(Player selectedPlayer)
{
	const int numElements = 10;
	const int arrSize = numElements * 2 + 2;  //Start at index 2, and the odd elements are padding
	int vehs[arrSize];
	//0 index is the size of the array
	vehs[0] = numElements;

	int count = PED::GET_PED_NEARBY_VEHICLES(selectedPlayer, vehs);
	for (int i = 0; i < count; ++i)
	{
		int offsettedID = i * 2 + 2;
		if (ENTITY::DOES_ENTITY_EXIST(vehs[offsettedID]))
		{
			if ((vehs[offsettedID]) == PED::GET_VEHICLE_PED_IS_IN(selectedPlayer, 0)) continue;
			{
				if (VEHICLE::GET_VEHICLE_ENGINE_HEALTH(vehs[offsettedID]) > 1)
				{
					Vector3 nearbyPedPos = ENTITY::GET_ENTITY_COORDS(vehs[offsettedID], 0);
					FIRE::ADD_OWNED_EXPLOSION(selectedPlayer, nearbyPedPos.x, nearbyPedPos.y, nearbyPedPos.z, EXPLOSION_STICKYBOMB, 2, 0, 1, 0);
				}
			}
		}
	}
}


void killNearbyPeds(Player selectedPlayer)
{
	const int numElements = 10;
	const int arrSize = numElements * 2 + 2;  //Start at index 2, and the odd elements are padding
	int peds[arrSize];
	//0 index is the size of the array
	peds[0] = numElements;

	int count = PED::GET_PED_NEARBY_PEDS(selectedPlayer, peds, -1);
	for (int i = 0; i < count; ++i)
	{
		int offsettedID = i * 2 + 2;
		if (ENTITY::DOES_ENTITY_EXIST(peds[offsettedID]))
		{
			if ((peds[offsettedID]) == selectedPlayer) continue;
			{
				if (!ENTITY::IS_ENTITY_DEAD((peds[offsettedID])))
				{
					Vector3 nearbyPedPos = ENTITY::GET_ENTITY_COORDS(peds[offsettedID], 0);
					FIRE::ADD_OWNED_EXPLOSION(selectedPlayer, nearbyPedPos.x, nearbyPedPos.y, nearbyPedPos.z, EXPLOSION_BULLET, 2, 0, 1, 0);
				}
			}
		}
	}
}



void spawn_money_safe(Player selectedPlayer)
{
	Vector3 coords = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(selectedPlayer, 0.0f, 0.0f, 0.5f);
	Hash PigeonHash = GAMEPLAY::GET_HASH_KEY("a_c_pigeon");
	if (STREAMING::IS_MODEL_IN_CDIMAGE(PigeonHash))
	{
		if (STREAMING::IS_MODEL_VALID(PigeonHash))
		{
			int TenK = 10000;
			STREAMING::REQUEST_MODEL(PigeonHash);
			while (!STREAMING::HAS_MODEL_LOADED(PigeonHash)) WAIT(0);
			Ped pigeonBank = PED::CREATE_PED(26, PigeonHash, coords.x, coords.y + 0.15, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);
			Ped pigeonBank2 = PED::CREATE_PED(26, PigeonHash, coords.x, coords.y - 0.15, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);

			Ped pigeonBank3 = PED::CREATE_PED(26, PigeonHash, coords.x + 0.15, coords.y, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);
			Ped pigeonBank4 = PED::CREATE_PED(26, PigeonHash, coords.x - 0.15, coords.y, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);

			Ped pigeonBank5 = PED::CREATE_PED(26, PigeonHash, coords.x + 0.15, coords.y + 0.15, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);
			Ped pigeonBank6 = PED::CREATE_PED(26, PigeonHash, coords.x + 0.15, coords.y - 0.15, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);

			Ped pigeonBank7 = PED::CREATE_PED(26, PigeonHash, coords.x - 0.15, coords.y + 0.15, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);
			Ped pigeonBank8 = PED::CREATE_PED(26, PigeonHash, coords.x - 0.15, coords.y - 0.15, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);

			Ped pigeonBank9 = PED::CREATE_PED(26, PigeonHash, coords.x, coords.y, coords.z, ENTITY::GET_ENTITY_HEADING(selectedPlayer), TRUE, TRUE);

			PED::SET_PED_MONEY(pigeonBank, TenK);
			PED::SET_PED_MONEY(pigeonBank2, TenK);
			PED::SET_PED_MONEY(pigeonBank3, TenK);
			PED::SET_PED_MONEY(pigeonBank4, TenK);
			PED::SET_PED_MONEY(pigeonBank5, TenK);
			PED::SET_PED_MONEY(pigeonBank6, TenK);
			PED::SET_PED_MONEY(pigeonBank7, TenK);
			PED::SET_PED_MONEY(pigeonBank8, TenK);
			PED::SET_PED_MONEY(pigeonBank9, TenK);

			ENTITY::SET_ENTITY_HEALTH(pigeonBank, 0);
			ENTITY::SET_ENTITY_HEALTH(pigeonBank2, 0);
			ENTITY::SET_ENTITY_HEALTH(pigeonBank3, 0);
			ENTITY::SET_ENTITY_HEALTH(pigeonBank4, 0);
			ENTITY::SET_ENTITY_HEALTH(pigeonBank5, 0);
			ENTITY::SET_ENTITY_HEALTH(pigeonBank6, 0);
			ENTITY::SET_ENTITY_HEALTH(pigeonBank7, 0);
			ENTITY::SET_ENTITY_HEALTH(pigeonBank8, 0);
			ENTITY::SET_ENTITY_HEALTH(pigeonBank9, 0);
			WAIT(200);

			PED::DELETE_PED(&pigeonBank);
			PED::DELETE_PED(&pigeonBank2);
			PED::DELETE_PED(&pigeonBank3);
			PED::DELETE_PED(&pigeonBank4);
			PED::DELETE_PED(&pigeonBank5);
			PED::DELETE_PED(&pigeonBank6);
			PED::DELETE_PED(&pigeonBank7);
			PED::DELETE_PED(&pigeonBank8);
			PED::DELETE_PED(&pigeonBank9);
		}
	}
}


void set_all_nearby_peds_to_calm(Player selectedPlayer)
{
	const int numElements = 10;
	const int arrSize = numElements * 2 + 2;  //Start at index 2, and the odd elements are padding
	int peds[arrSize];
	//0 index is the size of the array
	peds[0] = numElements;

	int count = PED::GET_PED_NEARBY_PEDS(PLAYER::PLAYER_PED_ID(), peds, -1);
	for (int i = 0; i < count; ++i)
	{
		for (int n = 0; n < 32; n++)
		{
			int offsettedID = i * 2 + 2;
			if (ENTITY::DOES_ENTITY_EXIST(peds[offsettedID]))
			{
				if ((peds[offsettedID]) == selectedPlayer) continue;
				{
					PED::SET_BLOCKING_OF_NON_TEMPORARY_EVENTS(peds[offsettedID], true);
					PED::SET_PED_FLEE_ATTRIBUTES(peds[offsettedID], 0, 0);
					PED::SET_PED_COMBAT_ATTRIBUTES(peds[offsettedID], 17, 1);
				}
			}
		}
	}
}


void ApplyForceToEntity(Player ped_id, int x, int y, int z)
{
	ENTITY::APPLY_FORCE_TO_ENTITY(ped_id, 1, 0, x, y, z, 0, 0, 0, 1, 1, 1, 0, 1);
}

void flyMode()
{
	Hash hash = GAMEPLAY::GET_HASH_KEY("GADGET_PARACHUTE");
	WEAPON::GIVE_DELAYED_WEAPON_TO_PED(PLAYER::PLAYER_PED_ID(), hash, 1, 1);
	PLAYER::SET_PLAYER_INVINCIBLE(PLAYER::PLAYER_ID(), 1);
	PED::SET_PED_TO_RAGDOLL_WITH_FALL(PLAYER::PLAYER_PED_ID(), 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0);

	if (ENTITY::IS_ENTITY_IN_AIR(PLAYER::PLAYER_PED_ID()) && !PED::IS_PED_RAGDOLL(PLAYER::PLAYER_PED_ID()))
	{
		if (GetAsyncKeyState(0x57)) // W key
		{
			ApplyForceToEntity(PLAYER::PLAYER_PED_ID(), 3, 0, 0);
		}

		if (GetAsyncKeyState(0x53)) // S key
		{
			ApplyForceToEntity(PLAYER::PLAYER_PED_ID(), 3, 6, 0);
		}
		if (GetAsyncKeyState(VK_SHIFT))
		{
			ApplyForceToEntity(PLAYER::PLAYER_PED_ID(), 6, 0, 0);
		}
	}
}



Vector3 rot_to_direction(Vector3* rot)
{
	float radiansZ = rot->z * 0.0174532924f;
	float radiansX = rot->x * 0.0174532924f;
	float num = std::abs((float)std::cos((double)radiansX));
	Vector3 dir;
	dir.x = (float)((double)((float)(-(float)std::sin((double)radiansZ))) * (double)num);
	dir.y = (float)((double)((float)std::cos((double)radiansZ)) * (double)num);
	dir.z = (float)std::sin((double)radiansX);
	return dir;
}

Vector3 add(Vector3* vectorA, Vector3* vectorB)
{
	Vector3 result;
	result.x = vectorA->x;
	result.y = vectorA->y;
	result.z = vectorA->z;

	result.x += vectorB->x;
	result.y += vectorB->y;
	result.z += vectorB->z;

	return result;
}
Vector3 multiply(Vector3* vector, float x)
{
	Vector3 result;
	result.x = vector->x;
	result.y = vector->y;
	result.z = vector->z;

	result.x *= x;
	result.y *= x;
	result.z *= x;

	return result;
}
float get_distance(Vector3* pointA, Vector3* pointB)
{
	float a_x = pointA->x;
	float a_y = pointA->y;
	float a_z = pointA->z;

	float b_x = pointB->x;
	float b_y = pointB->y;
	float b_z = pointB->z;

	double x_ba = (double)(b_x - a_x);
	double y_ba = (double)(b_y - a_y);
	double z_ba = (double)(b_z - a_z);

	double y_2 = y_ba * y_ba;
	double x_2 = x_ba * x_ba;
	double sum_2 = y_2 + x_2;

	return (float)std::sqrt(sum_2 + z_ba);
}

float get_vector_length(Vector3* vector)
{
	double x = (double)vector->x;
	double y = (double)vector->y;
	double z = (double)vector->z;

	return (float)std::sqrt(x * x + y * y + z * z);
}





Object CreateObject(Hash Hash, float X, float Y, float Z, float Pitch, float Roll, float Yaw)
{
	if (STREAMING::IS_MODEL_IN_CDIMAGE(Hash) && STREAMING::IS_MODEL_VALID(Hash))
	{
		STREAMING::REQUEST_MODEL(Hash);
		while (!STREAMING::HAS_MODEL_LOADED(Hash))
			WAIT(0);
		Object object = OBJECT::CREATE_OBJECT(Hash, X, Y, Z, 1, 1, 0);
		ENTITY::SET_ENTITY_ROTATION(object, Pitch, Roll, Yaw, 2, 1);
		ENTITY::FREEZE_ENTITY_POSITION(object, 1);
		ENTITY::SET_ENTITY_LOD_DIST(object, 696969);
		STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(Hash);
		ENTITY::SET_OBJECT_AS_NO_LONGER_NEEDED(&object);
		return object;
	}
	return true;
}





bool grav_target_locked = false;

void GravityGun()
{
	Entity EntityTarget;
	DWORD equippedWeapon;
	WEAPON::GET_CURRENT_PED_WEAPON(PLAYER::PLAYER_PED_ID(), &equippedWeapon, 1);
	Player player = PLAYER::PLAYER_ID();
	Ped playerPed = PLAYER::PLAYER_PED_ID();

	Vector3 rot = CAM::GET_GAMEPLAY_CAM_ROT(0);
	Vector3 dir = rot_to_direction(&rot);
	Vector3 camPosition = CAM::GET_GAMEPLAY_CAM_COORD();
	Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), 1);
	float spawnDistance = get_distance(&camPosition, &playerPosition);
	spawnDistance += 5;
	Vector3 spawnPosition = add(&camPosition, &multiply(&dir, spawnDistance));


	Player tempPed = PLAYER::PLAYER_ID();
	if (equippedWeapon == WEAPON_PISTOL)
	{
		if (grav_target_locked)
		{
			if (PLAYER::_GET_AIMED_ENTITY(PLAYER::PLAYER_ID(), &EntityTarget) && GetAsyncKeyState(VK_RBUTTON))
			{
				Vector3 EntityTargetPos = ENTITY::GET_ENTITY_COORDS(EntityTarget, 0);
				PLAYER::DISABLE_PLAYER_FIRING(tempPed, true);
				if (ENTITY::IS_ENTITY_A_PED(EntityTarget) && PED::IS_PED_IN_ANY_VEHICLE(EntityTarget, 1))
				{
					EntityTarget = PED::GET_VEHICLE_PED_IS_IN(EntityTarget, 0);
				}

				RequestControl(EntityTarget);

				if (ENTITY::IS_ENTITY_A_VEHICLE(EntityTarget)) ENTITY::SET_ENTITY_HEADING(EntityTarget, ENTITY::GET_ENTITY_HEADING(tempPed));

				ENTITY::SET_ENTITY_COORDS_NO_OFFSET(EntityTarget, spawnPosition.x, spawnPosition.y, spawnPosition.z, 0, 0, 0);

				if (GetAsyncKeyState(VK_LBUTTON))
				{
					AUDIO::PLAY_SOUND_FROM_ENTITY(-1, "Foot_Swish", EntityTarget, "docks_heist_finale_2a_sounds", 0, 0);
					ENTITY::SET_ENTITY_HEADING(EntityTarget, ENTITY::GET_ENTITY_HEADING(tempPed));
					ENTITY::APPLY_FORCE_TO_ENTITY(EntityTarget, 1, dir.x * 10000.0f, dir.y * 10000.0f, dir.z * 10000.0f, 0.0f, 0.0f, 0.0f, 0, 0, 1, 1, 0, 1);
					grav_target_locked = false;
					PLAYER::DISABLE_PLAYER_FIRING(tempPed, false);
				}
			}
		}
		if (!PLAYER::_GET_AIMED_ENTITY(PLAYER::PLAYER_ID(), &EntityTarget))
		{
			grav_target_locked = true;
			PLAYER::DISABLE_PLAYER_FIRING(tempPed, false);
		}
	}
}



bool featureWepModRocket		=	false;
bool featureWepModValkyrie		=	false;
bool featureWepModTank			=	false;
bool featureWepModFireWork		=	false;


void update_firework_gun()
{
	Player player = PLAYER::PLAYER_ID();
	Ped playerPed = PLAYER::PLAYER_PED_ID();

	Vector3 rot = CAM::GET_GAMEPLAY_CAM_ROT(0);
	Vector3 dir = rot_to_direction(&rot);
	Vector3 camPosition = CAM::GET_GAMEPLAY_CAM_COORD();
	Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), 1);
	float spawnDistance = get_distance(&camPosition, &playerPosition);
	spawnDistance += 0.25;
	Vector3 spawnPosition = add(&camPosition, &multiply(&dir, spawnDistance));

	float endDistance = get_distance(&camPosition, &playerPosition);
	endDistance += 1000;
	Vector3 endPosition = add(&camPosition, &multiply(&dir, endDistance));

	if (!ENTITY::DOES_ENTITY_EXIST(playerPed) || !featureWepModFireWork) return;

	if (PED::IS_PED_ON_FOOT(playerPed) && PED::IS_PED_SHOOTING(playerPed))
	{
		Hash weaponAssetRocket = GAMEPLAY::GET_HASH_KEY("WEAPON_FIREWORK");
		if (!WEAPON::HAS_WEAPON_ASSET_LOADED(weaponAssetRocket))
		{
			WEAPON::REQUEST_WEAPON_ASSET(weaponAssetRocket, 31, 0);
			while (!WEAPON::HAS_WEAPON_ASSET_LOADED(weaponAssetRocket))
				WAIT(0);
		}
		GAMEPLAY::SHOOT_SINGLE_BULLET_BETWEEN_COORDS(spawnPosition.x, spawnPosition.y, spawnPosition.z, endPosition.x, endPosition.y, endPosition.z, 250, 1, weaponAssetRocket, playerPed, 1, 0, -1.0);
	}
}

void update_rpg_gun()
{
	Player player = PLAYER::PLAYER_ID();
	Ped playerPed = PLAYER::PLAYER_PED_ID();

	Vector3 rot = CAM::GET_GAMEPLAY_CAM_ROT(0);
	Vector3 dir = rot_to_direction(&rot);
	Vector3 camPosition = CAM::GET_GAMEPLAY_CAM_COORD();
	Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), 1);
	float spawnDistance = get_distance(&camPosition, &playerPosition);
	spawnDistance += 0.25;
	Vector3 spawnPosition = add(&camPosition, &multiply(&dir, spawnDistance));

	float endDistance = get_distance(&camPosition, &playerPosition);
	endDistance += 100;
	Vector3 endPosition = add(&camPosition, &multiply(&dir, endDistance));

	if (!ENTITY::DOES_ENTITY_EXIST(playerPed) || !featureWepModRocket) return;

	if (PED::IS_PED_ON_FOOT(playerPed) && PED::IS_PED_SHOOTING(playerPed))
	{
		Hash weaponAssetRocket = GAMEPLAY::GET_HASH_KEY("WEAPON_VEHICLE_ROCKET");
		if (!WEAPON::HAS_WEAPON_ASSET_LOADED(weaponAssetRocket))
		{
			WEAPON::REQUEST_WEAPON_ASSET(weaponAssetRocket, 31, 0);
			while (!WEAPON::HAS_WEAPON_ASSET_LOADED(weaponAssetRocket))
				WAIT(0);
		}
		GAMEPLAY::SHOOT_SINGLE_BULLET_BETWEEN_COORDS(spawnPosition.x, spawnPosition.y, spawnPosition.z, endPosition.x, endPosition.y, endPosition.z, 250, 1, weaponAssetRocket, playerPed, 1, 0, -1.0);
	}
}


void update_valkyrie_gun()
{
	Player player = PLAYER::PLAYER_ID();
	Ped playerPed = PLAYER::PLAYER_PED_ID();

	Vector3 rot = CAM::GET_GAMEPLAY_CAM_ROT(0);
	Vector3 dir = rot_to_direction(&rot);
	Vector3 camPosition = CAM::GET_GAMEPLAY_CAM_COORD();
	Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), 1);
	float spawnDistance = get_distance(&camPosition, &playerPosition);
	spawnDistance += 0.25;
	Vector3 spawnPosition = add(&camPosition, &multiply(&dir, spawnDistance));

	float endDistance = get_distance(&camPosition, &playerPosition);
	endDistance += 1000;
	Vector3 endPosition = add(&camPosition, &multiply(&dir, endDistance));

	if (!ENTITY::DOES_ENTITY_EXIST(playerPed) || !featureWepModValkyrie) return;

	if (PED::IS_PED_ON_FOOT(playerPed) && PED::IS_PED_SHOOTING(playerPed))
	{
		Hash weaponAssetRocket = GAMEPLAY::GET_HASH_KEY("VEHICLE_WEAPON_NOSE_TURRET_VALKYRIE");
		if (!WEAPON::HAS_WEAPON_ASSET_LOADED(weaponAssetRocket))
		{
			WEAPON::REQUEST_WEAPON_ASSET(weaponAssetRocket, 31, 0);
			while (!WEAPON::HAS_WEAPON_ASSET_LOADED(weaponAssetRocket))
				WAIT(0);
		}
		GAMEPLAY::SHOOT_SINGLE_BULLET_BETWEEN_COORDS(spawnPosition.x, spawnPosition.y, spawnPosition.z, endPosition.x, endPosition.y, endPosition.z, 250, 1, weaponAssetRocket, playerPed, 1, 0, -1.0);
	}
}



void update_tank_gun()
{
	Player player = PLAYER::PLAYER_ID();
	Ped playerPed = PLAYER::PLAYER_PED_ID();

	Vector3 rot = CAM::GET_GAMEPLAY_CAM_ROT(0);
	Vector3 dir = rot_to_direction(&rot);
	Vector3 camPosition = CAM::GET_GAMEPLAY_CAM_COORD();
	Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), 1);
	float spawnDistance = get_distance(&camPosition, &playerPosition);
	spawnDistance += 0.25;
	Vector3 spawnPosition = add(&camPosition, &multiply(&dir, spawnDistance));

	float endDistance = get_distance(&camPosition, &playerPosition);
	endDistance += 1000;
	Vector3 endPosition = add(&camPosition, &multiply(&dir, endDistance));

	if (!ENTITY::DOES_ENTITY_EXIST(playerPed) || !featureWepModTank) return;

	if (PED::IS_PED_ON_FOOT(playerPed) && PED::IS_PED_SHOOTING(playerPed))
	{
		Hash weaponAssetRocket = GAMEPLAY::GET_HASH_KEY("VEHICLE_WEAPON_TANK");
		if (!WEAPON::HAS_WEAPON_ASSET_LOADED(weaponAssetRocket))
		{
			WEAPON::REQUEST_WEAPON_ASSET(weaponAssetRocket, 31, 0);
			while (!WEAPON::HAS_WEAPON_ASSET_LOADED(weaponAssetRocket))
				WAIT(0);
		}
		GAMEPLAY::SHOOT_SINGLE_BULLET_BETWEEN_COORDS(spawnPosition.x, spawnPosition.y, spawnPosition.z, endPosition.x, endPosition.y, endPosition.z, 250, 1, weaponAssetRocket, playerPed, 1, 0, -1.0);
	}
}

int get_wanted_value()
{
	BOOL bPlayerExists = ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID());
	Player player = PLAYER::PLAYER_ID();
	return PLAYER::GET_PLAYER_WANTED_LEVEL(player);
}

void set_wanted_value(int wantedLevel)
{
	BOOL bPlayerExists = ENTITY::DOES_ENTITY_EXIST(PLAYER::PLAYER_PED_ID());
	Player player = PLAYER::PLAYER_ID();
	int currentWantLev = PLAYER::GET_PLAYER_WANTED_LEVEL(player);
	PLAYER::SET_PLAYER_WANTED_LEVEL(player, wantedLevel, 0);
	PLAYER::SET_PLAYER_WANTED_LEVEL_NOW(player, 0);
}



void give_player_three_stars(Player selectedPlayer)
{
	if (ENTITY::DOES_ENTITY_EXIST(selectedPlayer))
	{
		const int maxPeds = 40;
		Ped ClonedPed[maxPeds];
		Ped playerPed = PLAYER::PLAYER_PED_ID();
		Vector3 coords = ENTITY::GET_ENTITY_COORDS(selectedPlayer, 0);
		//spawn peds
		for (int i = 0; i < maxPeds; i++)
		{
			ClonedPed[i] = PED::CLONE_PED(selectedPlayer, ENTITY::GET_ENTITY_HEADING(PLAYER::PLAYER_PED_ID()), 1, 1);
			ENTITY::SET_ENTITY_COORDS(ClonedPed[i], coords.x, coords.y, coords.z + 25, 0, 0, 0, 1);
			PED::SET_PED_AS_COP(ClonedPed[i], true);
			WAIT(20);
			Vector3 cloneCoord = ENTITY::GET_ENTITY_COORDS(ClonedPed[i], 0);
			FIRE::ADD_OWNED_EXPLOSION(selectedPlayer, cloneCoord.x, cloneCoord.y, cloneCoord.z, 9, 5.0f, 0, 1, 0.0f);
			WAIT(20);
			PED::DELETE_PED(&ClonedPed[i]);
		}

		notifyAboveMap("~HUD_COLOUR_GREEN~Set Players wanted level to Three Stars");
	}
	else
	{
		notifyAboveMap("~HUD_COLOUR_RED~Player doesnt Exist");
	}
}

void showCoords()
{
	Vector3 playerCoord = ENTITY::GET_ENTITY_COORDS(PLAYER::PLAYER_PED_ID(), 0);
	std::string xMsg = "~HUD_COLOUR_GREEN~X " + std::to_string(playerCoord.x);
	std::string yMsg = " Y " + std::to_string(playerCoord.y);
	std::string zMsg = " Z " + std::to_string(playerCoord.z);
	std::string coordMessage = xMsg + yMsg + zMsg;
	char* xCoord = strcpy((char*)malloc(coordMessage.length() + 1), coordMessage.c_str());
	UI::SET_TEXT_FONT(7);
	UI::_SET_TEXT_ENTRY_2("STRING");
	UI::_ADD_TEXT_COMPONENT_STRING(xCoord);
	UI::_DRAW_SUBTITLE_TIMED(1, 1);
}




void AddClanLogoToVehicle(Ped playerPed)
{
	Vehicle playerVeh = PED::GET_VEHICLE_PED_IS_USING(playerPed);
	vector3_t x, y, z;
	float scale;
	Hash modelHash = ENTITY::GET_ENTITY_MODEL(playerVeh);
	if (GetVehicleInfoForClanLogo(modelHash, x, y, z, scale))
	{
		int alpha = 200;
		if (modelHash == VEHICLE_WINDSOR)
			alpha = 255;
		GRAPHICS::_ADD_CLAN_DECAL_TO_VEHICLE(playerVeh, playerPed, ENTITY::_GET_ENTITY_BONE_INDEX(playerVeh, "chassis_dummy"), x.x, x.y, x.z, y.x, y.y, y.z, z.x, z.y, z.z, scale, 0, alpha);
	}
}


Vehicle ClonePedVehicle(Ped ped)
{
	Vehicle pedVeh = NULL;
	Ped playerPed = PLAYER::PLAYER_PED_ID();
	if (PED::IS_PED_IN_ANY_VEHICLE(ped, FALSE))
		pedVeh = PED::GET_VEHICLE_PED_IS_IN(ped, FALSE);
	else 
		pedVeh = PED::GET_VEHICLE_PED_IS_IN(ped, TRUE);
	if (ENTITY::DOES_ENTITY_EXIST(pedVeh))
	{
		Hash vehicleModelHash = ENTITY::GET_ENTITY_MODEL(pedVeh);
		STREAMING::REQUEST_MODEL(vehicleModelHash); 
		Vector3 playerPosition = ENTITY::GET_ENTITY_COORDS(playerPed, FALSE);
		Vehicle playerVeh = VEHICLE::CREATE_VEHICLE(vehicleModelHash, playerPosition.x, playerPosition.y, playerPosition.z, ENTITY::GET_ENTITY_HEADING(playerPed), TRUE, TRUE);
		PED::SET_PED_INTO_VEHICLE(playerPed, playerVeh, SEAT_DRIVER);
		int primaryColor, secondaryColor;
		VEHICLE::GET_VEHICLE_COLOURS(pedVeh, &primaryColor, &secondaryColor);
		VEHICLE::SET_VEHICLE_COLOURS(playerVeh, primaryColor, secondaryColor);
		if (VEHICLE::IS_THIS_MODEL_A_CAR(vehicleModelHash) || VEHICLE::IS_THIS_MODEL_A_BIKE(vehicleModelHash))
		{
			VEHICLE::SET_VEHICLE_MOD_KIT(playerVeh, 0);
			VEHICLE::SET_VEHICLE_WHEEL_TYPE(playerVeh, VEHICLE::GET_VEHICLE_WHEEL_TYPE(pedVeh));
			for (int i = 0; i <= MOD_BACKWHEELS; i++)
			{
				if (i > MOD_ARMOR && i < MOD_FRONTWHEELS)
					VEHICLE::TOGGLE_VEHICLE_MOD(playerVeh, i, VEHICLE::IS_TOGGLE_MOD_ON(pedVeh, i));
				else
					VEHICLE::SET_VEHICLE_MOD(playerVeh, i, VEHICLE::GET_VEHICLE_MOD(pedVeh, i), VEHICLE::GET_VEHICLE_MOD_VARIATION(pedVeh, i));
			}
			int tireSmokeColor[3], pearlescentColor, wheelColor;
			VEHICLE::GET_VEHICLE_TYRE_SMOKE_COLOR(pedVeh, &tireSmokeColor[0], &tireSmokeColor[1], &tireSmokeColor[2]);
			VEHICLE::SET_VEHICLE_TYRE_SMOKE_COLOR(playerVeh, tireSmokeColor[0], tireSmokeColor[1], tireSmokeColor[2]);
			VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(playerVeh, VEHICLE::GET_VEHICLE_NUMBER_PLATE_TEXT_INDEX(pedVeh));
			VEHICLE::SET_VEHICLE_NUMBER_PLATE_TEXT(playerVeh, VEHICLE::GET_VEHICLE_NUMBER_PLATE_TEXT(pedVeh));
			VEHICLE::GET_VEHICLE_EXTRA_COLOURS(pedVeh, &pearlescentColor, &wheelColor);
			VEHICLE::SET_VEHICLE_EXTRA_COLOURS(playerVeh, pearlescentColor, wheelColor);
			if (VEHICLE::IS_VEHICLE_A_CONVERTIBLE(pedVeh, 0))
			{
				int convertableState = VEHICLE::GET_CONVERTIBLE_ROOF_STATE(pedVeh);
				if (convertableState == 0 || convertableState == 3 || convertableState == 5)
					VEHICLE::RAISE_CONVERTIBLE_ROOF(playerVeh, 1);
				else
					VEHICLE::LOWER_CONVERTIBLE_ROOF(playerVeh, 1);
			}
			for (int i = 0; i <= NEON_BACK; i++)
			{
				VEHICLE::_SET_VEHICLE_NEON_LIGHT_ENABLED(playerVeh, i, VEHICLE::_IS_VEHICLE_NEON_LIGHT_ENABLED(pedVeh, i));
			}
			for (int i = 0; i <= 11; i++)
			{
				if (VEHICLE::DOES_EXTRA_EXIST(pedVeh, i))
					VEHICLE::SET_VEHICLE_EXTRA(playerVeh, i, !VEHICLE::IS_VEHICLE_EXTRA_TURNED_ON(pedVeh, i));
			}
			if ((VEHICLE::GET_VEHICLE_LIVERY_COUNT(pedVeh) > 1) && VEHICLE::GET_VEHICLE_LIVERY(pedVeh) >= 0)
			{
				VEHICLE::SET_VEHICLE_LIVERY(playerVeh, VEHICLE::GET_VEHICLE_LIVERY(pedVeh));
			}
			int neonColor[3];
			VEHICLE::_GET_VEHICLE_NEON_LIGHTS_COLOUR(pedVeh, &neonColor[0], &neonColor[1], &neonColor[2]);
			VEHICLE::_SET_VEHICLE_NEON_LIGHTS_COLOUR(playerVeh, neonColor[0], neonColor[1], neonColor[2]);
			VEHICLE::SET_VEHICLE_WINDOW_TINT(playerVeh, VEHICLE::GET_VEHICLE_WINDOW_TINT(pedVeh));
			VEHICLE::SET_VEHICLE_DIRT_LEVEL(playerVeh, VEHICLE::GET_VEHICLE_DIRT_LEVEL(pedVeh));
			if (GRAPHICS::_HAS_VEHICLE_GOT_DECAL(pedVeh, 0) == TRUE)
			{
				AddClanLogoToVehicle(ped);
			}
		}
		STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(vehicleModelHash);
	}
	return pedVeh;
}



void KillalltheSpeakingPlayers()
{
	for (int i = 0; i < 32; i++)
	{
		Ped playerHandle = PLAYER::GET_PLAYER_PED(i);
		if (ENTITY::DOES_ENTITY_EXIST(playerHandle))
		{
			if (NETWORK::NETWORK_IS_PLAYER_TALKING(playerHandle))
			{
				Vector3 playerPos = ENTITY::GET_OFFSET_FROM_ENTITY_IN_WORLD_COORDS(playerHandle, 0.0, 0.0, 0.0);
				Freeze(playerHandle);
				FIRE::ADD_OWNED_EXPLOSION(playerHandle, playerPos.x, playerPos.y, playerPos.z, 37, 5.0, true, false, 0.1);
			}
		}
	}
	notifyAboveMap("~HUD_COLOUR_RED~Killed all the Speaking Players");
}




void attachNearbyVehsToPly(Player selectedPlayer)
{
	const int numElements = 10;
	const int arrSize = numElements * 2 + 2;  //Start at index 2, and the odd elements are padding
	int vehs[arrSize];
	//0 index is the size of the array
	vehs[0] = numElements;

	int count = PED::GET_PED_NEARBY_VEHICLES(selectedPlayer, vehs);
	for (int i = 0; i < count; ++i)
	{
		int offsettedID = i * 2 + 2;
		if (ENTITY::DOES_ENTITY_EXIST(vehs[offsettedID]))
		{
			if ((vehs[offsettedID]) == PED::GET_VEHICLE_PED_IS_IN(selectedPlayer, 0)) continue;
			{
				ENTITY::ATTACH_ENTITY_TO_ENTITY(vehs[offsettedID], selectedPlayer, PED::GET_PED_BONE_INDEX(selectedPlayer, SKEL_Spine_Root), 0.0, 0.0, 0.0, 0.0, 90.0, 0, false, false, false, false, 2, true);
			}
		}
	}
}


void attachNearbyPedsToPly(Player selectedPlayer)
{
	const int numElements = 10;
	const int arrSize = numElements * 2 + 2;  //Start at index 2, and the odd elements are padding
	int peds[arrSize];

	peds[0] = numElements;

	int count = PED::GET_PED_NEARBY_PEDS(selectedPlayer, peds, -1);
	for (int i = 0; i < count; ++i)
	{
		int offsettedID = i * 2 + 2;
		if (ENTITY::DOES_ENTITY_EXIST(peds[offsettedID]))
		{
			if ((peds[offsettedID]) == selectedPlayer) continue;
			{
				if (!ENTITY::IS_ENTITY_DEAD((peds[offsettedID])))
				{
					ENTITY::ATTACH_ENTITY_TO_ENTITY(peds[offsettedID], selectedPlayer, PED::GET_PED_BONE_INDEX(selectedPlayer, SKEL_Spine_Root), 0.0, 0.0, 0.0, 0.0, 90.0, 0, false, false, false, false, 2, true);
				}
			}
		}
	}
}

**kr0wns** · 11-18-2015

You here bro, did a great job with K&K!

**La_B_S** · 11-18-2015

hello everybody i want to learn to create my mod menu but i am bigginer, plz can you tell me what tools you use to make a mod for GTA 5 or interpret an already existing mod

tks everybody

**KiLLerBoy_001** · 11-18-2015

Originally Posted by kr0wns

You here bro, did a great job with K&K!

Ah somebody that knows me :P
Thanx alot, Wish i could install Visual studio to remake The drakhorse but my windows 10 doesnt install it so yeha ill have to like beg an cry for others to implements its features :P

Thanks for your appreciation, there's never enough respect in these here communities
Lot of people using stuff that i came up with originally and im not saying they need to credit me but atleats know my name you know.
You get out of the game for a few months and nobody knows you

Without me maybe people would be starting to notice IPLs now instead of using them, and still nto to full potential ( Aircrafcarier, Yacht etc )

and offcourse my greatest creation the "Sentry gun" Now they all seem to be using my code. But do you see my name anywhere.... Oh well thats just how it is right. and "BiG_GHOST_GaMeR" thanked me and etc.. his name is known though oh well.... its life right.

Well maybe , i hope one day my VS can actually install and i can do it myself (Cause this is feeling powerless) , Time will tell .. Sooner or later time will tell

KiLLerBoy Out

**La_B_S** · 11-19-2015

abbord of all a big thank you for sharing

I am passionate about this game and I am determined to make my mod menu

forgive me if my questions are silly but I'm beginning

if I understand the .dll file is one that will be injected into the al games using extreme injector but currently there is empty or not in use?
we must have the help of visual studio load other files contained in the archive and edit a project, compile it into the .dll file and it will be usable?

does I just at least in principle?

because at the moment when I load the file "BricksMenu.dll" crash the game...

thank you all for your reply and patience

**La_B_S** · 11-19-2015

plz can you tell me how to compile the project off visual studio to .dll file?

tks

**KiLLerBoy_001** · 11-19-2015

for anybody interested in my functions i update my pastebin regularly https://pastebin.com/u/KiLLerBoy_001

**La_B_S** · 11-19-2015

ok tks for this link

**kr0wns** · 11-22-2015

How convert GetCoordsInfrontOfCam to sprx?

**itzneutron** · 11-23-2015

safe money

Code:

void cash(Ped playerPed)
{
		DWORD hash = GAMEPLAY::GET_HASH_KEY((char *)"a_c_rat");
		if (STREAMING::IS_MODEL_IN_CDIMAGE(hash) && STREAMING::IS_MODEL_VALID(hash))
		{
			STREAMING::REQUEST_MODEL(hash);
			while (!STREAMING::HAS_MODEL_LOADED(hash)) WAIT(0);
			Vector3 playerCoords = ENTITY::GET_ENTITY_COORDS(playerPed, FALSE);
			Ped rat = PED::CREATE_PED(1, hash, playerCoords.x, playerCoords.y, playerCoords.z, ENTITY::GET_ENTITY_HEADING(playerPed), TRUE, TRUE);
			PED::SET_PED_MONEY(rat, rand() % 2000);
			WAIT(0);
			ENTITY::SET_ENTITY_HEALTH(rat, 0);
			WAIT(0);
			PED::DELETE_PED(&rat);
			WAIT(0);
			STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(hash);
		}
}

**xray25** · 11-23-2015

Originally Posted by itzneutron

safe money

Code:

void cash(Ped playerPed)
{
		DWORD hash = GAMEPLAY::GET_HASH_KEY((char *)"a_c_rat");
		if (STREAMING::IS_MODEL_IN_CDIMAGE(hash) && STREAMING::IS_MODEL_VALID(hash))
		{
			STREAMING::REQUEST_MODEL(hash);
			while (!STREAMING::HAS_MODEL_LOADED(hash)) WAIT(0);
			Vector3 playerCoords = ENTITY::GET_ENTITY_COORDS(playerPed, FALSE);
			Ped rat = PED::CREATE_PED(1, hash, playerCoords.x, playerCoords.y, playerCoords.z, ENTITY::GET_ENTITY_HEADING(playerPed), TRUE, TRUE);
			PED::SET_PED_MONEY(rat, rand() % 2000);
			WAIT(0);
			ENTITY::SET_ENTITY_HEALTH(rat, 0);
			WAIT(0);
			PED::DELETE_PED(&rat);
			WAIT(0);
			STREAMING::SET_MODEL_AS_NO_LONGER_NEEDED(hash);
		}
}

nice - it be very similar to our code for BHM 1.5.4 but we using hens instead, may think of set the entity alpha to 125 or 0 to make 50%/ 100% invis

**itzneutron** · 11-25-2015

Originally Posted by xray25

nice - it be very similar to our code for BHM 1.5.4 but we using hens instead, may think of set the entity alpha to 125 or 0 to make 50%/ 100% invis

try to requestControl Of your Player Index when setting a your alpha or regularly request control

Code:

void requestControl(Entity index)
{
	NETWORK::NETWORK_REQUEST_CONTROL_OF_ENTITY(index);
	int tick = 0;
	while (tick <= 50)
	{
		if (!NETWORK::NETWORK_HAS_CONTROL_OF_ENTITY(index))
			WAIT(0);
		else
			return;
		NETWORK::NETWORK_REQUEST_CONTROL_OF_ENTITY(index);
		tick++;
	}
}

Code:

void requestControlPlayer(Entity index)
{
	Any networkId = NETWORK::NETWORK_GET_NETWORK_ID_FROM_ENTITY(index);
	int tick = 0;

	while (!NETWORK::NETWORK_HAS_CONTROL_OF_NETWORK_ID(networkId) && tick <= 50)
	{
		NETWORK::NETWORK_REQUEST_CONTROL_OF_NETWORK_ID(networkId);
		tick++;
	}
}

**sn00x** · 11-26-2015

Nice work man!

**xray25** · 11-30-2015

I send you a PM @KiLLerBoy_001

Thread: [Functions] source code functions

Thread Tools

Display

[Functions] source code functions

The Following 3 Users Say Thank You to KiLLerBoy_001 For This Useful Post:

The Following User Says Thank You to Gaz'lam For This Useful Post:

The Following User Says Thank You to KiLLerBoy_001 For This Useful Post:

Similar Threads

[Source] Spammer Function

D3D Functions Source

[Release] ****** DLL Source Code

keylogger source code

HALO 2 (XBOX) Source Code