Colt's Chauffeur Mod

#include <natives.h>
#include <common.h>
#include <strings.h>
#include <types.h>
#include <consts.h>

#define L1         0x4
#define L2         0x5
#define R1         0x6
#define R2         0x7
#define DPAD_UP    0x8
#define DPAD_DOWN  0x9
#define DPAD_LEFT  0xA
#define DPAD_RIGHT 0xB
#define START      0xC
#define SELECT     0xD
#define SQUARE     0xE
#define TRIANGLE   0xF
#define X          0x10
#define CIRCLE     0x11
#define STICK_L    0x12
#define STICK_R    0x13

float x, y, z;
Ped driverped;
Ped bikerped;
Vehicle maybach;
Vehicle hellfury;
bool doesgroupexist=0;
Group maybachgroup;
float speed = 50;
float speed2 = 45;
uint car = MODEL_ADMIRAL;
uint bike1 = MODEL_ZOMBIEB;
uint guard1 = MODEL_IG_JOHNNYBIKER;
uint chauf = MODEL_M_Y_PERSEUS;
float carspawn_x, carspawn_y, carspawn_z;
bool GuardSpawn = false;
bool WayPointFunction = false;
bool MaybachRadioOffFunction = false;
bool MaybachRadioOnFunction = false;
bool MaybachRadioDownFunction = false;
bool MaybachRadioUpFunction = false;
bool MaybachLockDoorsFunction = false;
bool MaybachUnlockDoorsFunction = true;
bool MaybachStopFunction = false;
bool MaybachGoFunction = false;

void ButtonSettings(void)
{
        if (IS_BUTTON_PRESSED(0, R1) && IS_BUTTON_JUST_PRESSED(0, DPAD_DOWN))
        {
                GuardSpawn = true;
        }

        if (IS_BUTTON_PRESSED(0, R1) && IS_BUTTON_JUST_PRESSED(0, DPAD_UP))
        {
                WayPointFunction = true;
        }

        if (IS_BUTTON_PRESSED(0, L1) && IS_BUTTON_JUST_PRESSED(0, DPAD_RIGHT))
        {
                MaybachRadioOnFunction = true;
        }

        if (IS_BUTTON_PRESSED(0, L1) && IS_BUTTON_JUST_PRESSED(0, DPAD_LEFT))
        {
                MaybachRadioOffFunction = true;
        }

        if (IS_BUTTON_PRESSED(0, L1) && IS_BUTTON_JUST_PRESSED(0, DPAD_DOWN))
        {
                MaybachRadioDownFunction = true;
        }

        if (IS_BUTTON_PRESSED(0, L1) && IS_BUTTON_JUST_PRESSED(0, DPAD_UP))
        {
                MaybachRadioUpFunction = true;
        }

        if (IS_BUTTON_PRESSED(0, STICK_R) && IS_BUTTON_JUST_PRESSED(0, DPAD_RIGHT))
        {
                MaybachLockDoorsFunction = true;
        }

        if (IS_BUTTON_PRESSED(0, STICK_R) && IS_BUTTON_JUST_PRESSED(0, DPAD_LEFT))
        {
                MaybachUnlockDoorsFunction = true;
        }

        if (IS_BUTTON_PRESSED(0, STICK_R) && IS_BUTTON_JUST_PRESSED(0, DPAD_DOWN))
        {
                MaybachStopFunction = true;
        }

        if (IS_BUTTON_PRESSED(0, STICK_R) && IS_BUTTON_JUST_PRESSED(0, DPAD_UP))
        {
                        MaybachGoFunction = true;
        }
}

void WayPointSupport(void)
{
        if (DOES_BLIP_EXIST(GET_FIRST_BLIP_INFO_ID(BLIP_WAYPOINT)))
        {
                if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
                {
                        Vector3 pos;
                        GET_BLIP_COORDS(GET_FIRST_BLIP_INFO_ID(BLIP_WAYPOINT),&pos);
                        GET_GROUND_Z_FOR_3D_COORD(x, y, 0, &z);
                        TASK_CAR_MISSION_COORS_TARGET(driverped, maybach, x, y, z, 1, 5.0f, 1, 1, 1);
                        print("You Are Being Driven To Your WayPoint");
                }
        }
}

void MaybachSpawn(void)
{
        GET_CHAR_COORDINATES(GetPlayerPed(), &x, &y, &z);
        if (doesgroupexist==0)
        {
                GET_PLAYER_GROUP(GetPlayerIndex(), &maybachgroup);
                if (!DOES_GROUP_EXIST(maybachgroup))
                {
                        CREATE_GROUP(0, &maybachgroup, true);
                        SET_GROUP_LEADER(maybachgroup, GetPlayerPed());
                        SET_GROUP_SEPARATION_RANGE(maybachgroup, 9999.9);
                        SET_GROUP_FORMATION(maybachgroup, 3);
                        SET_GROUP_FORMATION_SPACING(maybachgroup, 5);
                        doesgroupexist=1;
                }
        }
        WAIT(100);
        GET_CHAR_COORDINATES(GetPlayerPed(), &carspawn_x, &carspawn_y, &carspawn_z);
        carspawn_y += 5;
        REQUEST_MODEL(car);
        while(!HAS_MODEL_LOADED(car)) WAIT(0);
        CREATE_CAR(car, carspawn_x, carspawn_y, carspawn_z, &maybach, true);
        MARK_MODEL_AS_NO_LONGER_NEEDED(car);
}

void CharInCarWarp(void)
{
        if (DOES_VEHICLE_EXIST(maybach))
        {
                WARP_CHAR_INTO_CAR_AS_PASSENGER(GetPlayerPed(), maybach, 1);
        }
}

void MaybachSettings(void)
{
        SET_CAR_AS_MISSION_CAR(maybach);
        CHANGE_CAR_COLOUR(maybach, 134, 134);
        SET_EXTRA_CAR_COLOURS(maybach, 134, 134);
        SET_VEHICLE_DIRT_LEVEL(maybach, 0);
        WASH_VEHICLE_TEXTURES(maybach, 255);
        SET_CAR_ENGINE_ON(maybach, true, false);
        SET_CAR_CAN_BE_DAMAGED(maybach, false);
        SET_CAR_CAN_BE_VISIBLY_DAMAGED(maybach, false);
        SET_CAN_BURST_CAR_TYRES(maybach, false);
}

void DriverSpawn(void)
{
        REQUEST_MODEL(chauf);
        while(!HAS_MODEL_LOADED(chauf)) WAIT(0);
        CREATE_CHAR_INSIDE_CAR(maybach, 16, chauf, &driverped);
        MARK_MODEL_AS_NO_LONGER_NEEDED(chauf);
        WAIT(100);
        print("Custom Maybach And Chauffeur Spawned. Kick Back, Relax And Enjoy The Ride!");
}

void DriverSettings(void)
{
        SET_CHAR_WILL_LEAVE_CAR_IN_COMBAT(driverped, false);
        SET_CHAR_CAN_BE_SHOT_IN_VEHICLE(driverped, false);
        SET_GROUP_CHAR_DUCKS_WHEN_AIMED_AT(driverped, false);
        SET_CHAR_NEVER_LEAVES_GROUP(driverped, true);
        SET_CHAR_CAN_BE_SHOT_IN_VEHICLE(driverped, false);
        SET_CHAR_WILL_USE_COVER(driverped, false);
        SET_CHAR_BULLETPROOF_VEST(driverped, true);
        SET_CHAR_WILL_USE_CARS_IN_COMBAT(driverped, true);
        SET_CHAR_WILL_LEAVE_CAR_IN_COMBAT(driverped, false);
        SET_PED_DONT_DO_EVASIVE_DIVES(driverped, true);
        SET_PED_DIES_WHEN_INJURED(driverped, false);
        SET_CHAR_CANT_BE_DRAGGED_OUT(driverped, true);
        SET_CHAR_INVINCIBLE(driverped, true);
        SET_CHAR_WILL_FLY_THROUGH_WINDSCREEN(driverped, false);
        SET_CHAR_CAN_SMASH_GLASS(driverped, false);
        TASK_CAR_DRIVE_WANDER(driverped, maybach, speed, 0);
        SET_GROUP_MEMBER(maybachgroup, driverped);
        SET_CHAR_RELATIONSHIP_GROUP(driverped, RELATIONSHIP_GROUP_PLAYER);
        SET_CHAR_RELATIONSHIP(driverped, RELATIONSHIP_RESPECT, RELATIONSHIP_GROUP_PLAYER);
}

void Bike1Spawn(void)
{
        GET_CHAR_COORDINATES(GetPlayerPed(), &carspawn_x, &carspawn_y, &carspawn_z);
        carspawn_y += 5;
        REQUEST_MODEL(bike1);
        while(!HAS_MODEL_LOADED(bike1)) WAIT(0);
        CREATE_CAR(bike1, carspawn_x, carspawn_y, carspawn_z, &hellfury, true);
        MARK_MODEL_AS_NO_LONGER_NEEDED(bike1);
}

void Bike1Settings(void)
{
        CHANGE_CAR_COLOUR(hellfury, 1, 1);
        SET_EXTRA_CAR_COLOURS(hellfury, 1, 1);
        SET_VEHICLE_DIRT_LEVEL(hellfury, 0);
        WASH_VEHICLE_TEXTURES(hellfury, 255);
        SET_CAR_ENGINE_ON(hellfury, true, false);
        SET_CAR_CAN_BE_DAMAGED(hellfury, false);
        SET_CAR_CAN_BE_VISIBLY_DAMAGED(hellfury, false);
        SET_CAN_BURST_CAR_TYRES(hellfury, false);
}

void Guard1Spawn(void)
{
        REQUEST_MODEL(guard1);
        while(!HAS_MODEL_LOADED(guard1)) WAIT(0);
        CREATE_CHAR_INSIDE_CAR(hellfury, 16, guard1, &bikerped);
        MARK_MODEL_AS_NO_LONGER_NEEDED(guard1);
}

void GuardSettings(void)
{
        SET_CHAR_WILL_LEAVE_CAR_IN_COMBAT(bikerped, false);
        SET_CHAR_CAN_BE_SHOT_IN_VEHICLE(bikerped, false);
        SET_GROUP_CHAR_DUCKS_WHEN_AIMED_AT(bikerped, false);
        SET_CHAR_NEVER_LEAVES_GROUP(bikerped, true);
        SET_CHAR_CAN_BE_SHOT_IN_VEHICLE(bikerped, false);
        SET_CHAR_WILL_USE_COVER(bikerped, false);
        SET_CHAR_BULLETPROOF_VEST(bikerped, true);
        SET_CHAR_WILL_USE_CARS_IN_COMBAT(bikerped, true);
        SET_CHAR_WILL_LEAVE_CAR_IN_COMBAT(bikerped, false);
        SET_PED_DONT_DO_EVASIVE_DIVES(bikerped, true);
        SET_PED_DIES_WHEN_INJURED(bikerped, false);
        SET_CHAR_CANT_BE_DRAGGED_OUT(bikerped, true);
        SET_CHAR_INVINCIBLE(bikerped, true);
        SET_CHAR_WILL_FLY_THROUGH_WINDSCREEN(bikerped, false);
        SET_CHAR_CAN_SMASH_GLASS(bikerped, false);
        TASK_CAR_MISSION_PED_TARGET(bikerped, maybach, GetPlayerPed(), 2, 40.0, 2, 0, 10);
        SET_GROUP_MEMBER(maybachgroup, bikerped);
        SET_CHAR_RELATIONSHIP_GROUP(bikerped, RELATIONSHIP_GROUP_PLAYER);
        SET_CHAR_RELATIONSHIP(bikerped, RELATIONSHIP_RESPECT, RELATIONSHIP_GROUP_PLAYER);
}

void MaybachRadioOn(void)
{
        if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
        {
                ENABLE_FRONTEND_RADIO();
                SET_MOBILE_RADIO_ENABLED_DURING_GAMEPLAY(1);
                SET_MOBILE_PHONE_RADIO_STATE(1);
                RETUNE_RADIO_UP();
                WAIT(1);
                print(GET_PLAYER_RADIO_STATION_NAME());
        }
        else
        {
                print("You Need To Be In The Maybach To Use This Function");
        }
}

void MaybachRadioOff(void)
{
        if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
        {
                RETUNE_RADIO_TO_STATION_INDEX(255);
                SET_MOBILE_RADIO_ENABLED_DURING_GAMEPLAY(0);
                SET_MOBILE_PHONE_RADIO_STATE(0);
                print("Radio Turned Off");
        }
        else
        {
                print("You Need To Be In The Maybach To Use This Function");
        }
}

void MaybachRadioDown(void)
{
        if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
        {
                ENABLE_FRONTEND_RADIO();
                SET_MOBILE_RADIO_ENABLED_DURING_GAMEPLAY(1);
                SET_MOBILE_PHONE_RADIO_STATE(1);
                RETUNE_RADIO_DOWN();
                WAIT(1);
                print(GET_PLAYER_RADIO_STATION_NAME());
        }
        else
        {
                print("You Need To Be In The Maybach To Use This Function");
        }
}

void MaybachRadioUp(void)
{
        if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
        {
                ENABLE_FRONTEND_RADIO();
                SET_MOBILE_RADIO_ENABLED_DURING_GAMEPLAY(1);
                SET_MOBILE_PHONE_RADIO_STATE(1);
                RETUNE_RADIO_UP();
                WAIT(1);
                print(GET_PLAYER_RADIO_STATION_NAME());
        }
        else
        {
                print("You Need To Be In The Maybach To Use This Function");
        }
}

void MaybachLockDoors(void)
{
        if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
        {
                LOCK_CAR_DOORS(maybach,VEHICLE_DOOR_LOCKED_BOTH_SIDES);
                print("Maybach Doors Locked");
        }
        else
        {
                print("You Need To Be In The Maybach To Use This Function");
        }
}

void MaybachUnlockDoors(void)
{
        if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
        {
                LOCK_CAR_DOORS(maybach,VEHICLE_DOOR_UNLOCKED);
                print("Maybach Doors Unlocked");
        }
        else
        {
                print("You Need To Be In The Maybach To Use This Function");
        }
}

void MaybachStop(void)
{
        if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
        {
                FREEZE_CAR_POSITION(maybach, true);
                print("Maybach Stopped");
        }
        else
        {
                print("You Need To Be In The Maybach To Use This Function");
        }
}

void MaybachGo(void)
{
        if (IS_CHAR_IN_CAR(GetPlayerPed(), maybach))
        {
                FREEZE_CAR_POSITION(maybach, false);
                print("Maybach Started");
        }
        else
        {
                print("You Need To Be In The Maybach To Use This Function");
        }
}
void MyGuardSpawn(void)
{
        if (GuardSpawn)
        {
                GuardSpawn = false;
                Bike1Spawn();
                Bike1Settings();
                Guard1Spawn();
                GuardSettings();
                print("Personal Protection Spawned");
        }
}
void MyWayPointFunction(void)
{
        if (WayPointFunction)
        {
                WayPointFunction = false;
                WayPointSupport();
        }
}

void MyMaybachRadioOff(void)
{
        if (MaybachRadioOffFunction)
        {
                MaybachRadioOffFunction = false;
                MaybachRadioOff();
        }
}

void MyMaybachRadioOn(void)
{
        if (MaybachRadioOnFunction)
        {
                MaybachRadioOnFunction = false;
                MaybachRadioOn();
        }
}

void MyMaybachRadioDown(void)
{
        if (MaybachRadioDownFunction)
        {
                MaybachRadioDownFunction = false;
                MaybachRadioDown();
        }
}

void MyMaybachRadioUp(void)
{
        if (MaybachRadioUpFunction)
        {
                MaybachRadioUpFunction = false;
                MaybachRadioUp();
        }
}

void MyMaybachLockDoors(void)
{
        if (MaybachLockDoorsFunction)
        {
                MaybachLockDoorsFunction = false;
                MaybachLockDoors();
        }
}

void MyMaybachUnlockDoors(void)
{
        if (MaybachUnlockDoorsFunction)
        {
                MaybachUnlockDoorsFunction = false;
                MaybachUnlockDoors();
        }
}

void MyMaybachStop(void)
{
        if (MaybachStopFunction)
        {
                MaybachStopFunction = false;
                MaybachStop();
        }
}

void MyMaybachGo(void)
{
        if (MaybachGoFunction)
        {
                MaybachGoFunction = false;
                MaybachGo();
        }
}

void main(void)
{
        THIS_SCRIPT_IS_SAFE_FOR_NETWORK_GAME();
        print("Maybach Mod v2 Made By ~b~Colt From PSX-Scene.Com");

        MaybachSpawn();
        MaybachSettings();

        //Bike1Spawn();
        //Bike1Settings();

        DriverSpawn();
        DriverSettings();

        //Guard1Spawn();
        //GuardSettings();

        CharInCarWarp();
        while(true)
        {
                WAIT(0);
                ButtonSettings();
                MyGuardSpawn();
                MyWayPointFunction();
                MyMaybachRadioOn();
                MyMaybachRadioOff();
                MyMaybachRadioUp();
                MyMaybachRadioDown();
                MyMaybachLockDoors();
                MyMaybachUnlockDoors();
                MyMaybachStop();
                MyMaybachGo();
        }
}