Script Converting

GPC2 script programming for Titan Two. Code examples, questions, requests.

Script Converting

Postby Candidutee » Wed Jan 04, 2023 4:37 pm

Hey everyone i need help to convert this Script from device Zen to a Titan compatible. I tried to convert it with the Gpc converter and Script Manipulator of device and manually by myself. It doesnt work. I hope really somoene can help me with this. :)

Code: Select all
define AdsBtn          = PS4_L2;
define FireBtn          = PS4_R2;
define CrouchBtn       = PS4_R3
define JumpBtn        = PS4_CROSS;
define LX             = PS4_LX;
define LY             = PS4_LY;
define RX             = PS4_RX;
define RY             = PS4_RY;
define On             = TRUE;
define Off            = FALSE;
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
           Crouch Shot Desactive ON/OFF             
 -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

define CrouchShotHold  = PS4_L2;   // CROUCH SHOT HOLD TOGGLE
define CrouchShotPress = PS4_LEFT; // CROUCH SHOT PRESS TOGGLE
 
 
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
           Slide Shot Desactive ON/OFF             
 -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

define SlideHold  = PS4_L2;    // SLIDE SHOT HOLD TOGGLE
define SlidePress = PS4_RIGHT; // SLIDE SHOT HOLD TOGGLE
 
 
 
// AIM ASSIST EXPLOIT EXPONENTIAL
int Aim_Exploit_Expo  = On; // [(On) or (Off)] = {Aim Assist Exponential Toggle On/Off By Default}
int Strength_Expo     = 30; // FORCA AIM ASSIST
int Wait_Expo         = 9// ESPERA DO AIM ASSIST
 
 
// AIM ASSIST EXPLOIT LINEAR
int Aim_Exploit_Linear = Off; // [(On) or (Off)] = {Aim Assist Linear Toggle On/Off By Default}
int Strength_Linear    = 150; // FORCA AIM ASSIST  // O VALOR MAXIMO 150
int Wait_Linear        = 20// ESPERA DO AIM ASSIST     //CASO SEU PERSONAGEM ESTEJA SE MEXENDO MUITO PARA OS LADOS DIMINUIR
 
 
// FIRE ASSIST EXPLOIT
int Assist_Fire_Exploit  = On; // [(On) or (Off)] = {Fire Assist Exploit Toggle On/Off By Default}
int Fire_Assist_Strength = 120; // FORCA FIRE ASSIST
 
 
// 100% ACCURACY EXPLOIT (1 BUTTON)
int Accuracy_Exploit   = On;  // [(On) or (Off)] = {Accuracy 100% 1 Button Toggle On/Off By Default} [!!define StopAC = PS4_R3 ; ]
int Spam_Accuracy      = 100;
define HoldButtonStop  = PS4_R3;
 
 
// ANTI RECOIL
int Anti_Recoil  = Off; // [(On) or (Off)] = {Anti-Recoil Toggle On/Off By Default}
int AR_Ver       = 10; // ANTI RECOIL VERTICAL
int AR_Horiz     = 0// ANTI RECOIL HORIZONTAL
 
 
// HEAD SHOT
int Head_Shot      = On; // [(On) or (Off)] = {Head Assist Exploit Toggle On/Off By Default}
int HeadStep       = 30// [1 - 30] = Step Increment Increasing Until Its Reached HeadMax   
int HeadMax        = 70; // [1 - 70] = Max Head Assist Value     
int HipAssistHead  = On; // [(On) or (Off)] = Operate on Fire Only [If FALSE It Will Only Run On ADS & FIRE]
 
 
// RAPID CROUCH
int Drop_Shot      = Off; // [(On) or (Off)] = {Rapid Crouch Toggle On/Off By Default}
int DropShotWait   = 50; // COM MENOS VALOR, NOSSO PERSONAGEM VAI BAIXAR E LEVANTAR MAIS R?PIDO
 
 
// SLIDE SHOT
int Slide_Shot     = Off; // [(On) or (Off)] = {Slide Shot Toggle On/Off By Default}
int SlideShotWait  = 150;
 
 
// BLOCK RUMBLE
int Block_Rumble  = On; // [(On) or (Off)] = Block Controller Rumble
 
 
 
 
 
int DisplayTitle = TRUE;
int ScreenSaver,BlankScreen,ModMenu,DisplayMenu,ModNameIdx,Toggle,EditMenu,ValNameIdx,KillSwitch;
int AntirecoilVertical,AntirecoilHorizontal,Head;
define AmountOfEditableValues = 10;
 
 
 
 
main {
 
 
 
    if(get_ival(PS4_L2)) {
 
        if(event_press(PS4_OPTIONS)) {
 
            ModMenu     = TRUE;   
            DisplayMenu = TRUE;       
            EditMenu    = FALSE;     
 
        if(!ModMenu)           
 
            DisplayTitle = TRUE;
        }
 
        if(event_press(PS4_SHARE)) {
 
            KillSwitch =! KillSwitch;
            combo_run(KillSwitch)
        }     
            set_val(PS4_OPTIONS,0); set_val(PS4_SHARE,0);
        }
        if(!DisplayTitle) {
 
        if(ModMenu) {
 
            ModNameIdx        = MenuNavigation(ModNameIdx,0,8);   
 
                Aim_Exploit_Expo               = ToggleSwitch(ModNameIdx == 0, Aim_Exploit_Expo);
                Aim_Exploit_Linear             = ToggleSwitch(ModNameIdx == 1, Aim_Exploit_Linear);
                Assist_Fire_Exploit            = ToggleSwitch(ModNameIdx == 2, Assist_Fire_Exploit);
                Accuracy_Exploit               = ToggleSwitch(ModNameIdx == 3, Accuracy_Exploit);
                Anti_Recoil                    = ToggleSwitch(ModNameIdx == 4, Anti_Recoil);
                Head_Shot                      = ToggleSwitch(ModNameIdx == 5, Head_Shot);
                Drop_Shot                      = ToggleSwitch(ModNameIdx == 6, Drop_Shot);
                Slide_Shot                      = ToggleSwitch(ModNameIdx == 7, Slide_Shot);
                Block_Rumble                   = ToggleSwitch(ModNameIdx == 8, Block_Rumble);
            }
 
        if(EditMenu) {
 
            ValNameIdx        = MenuNavigation(ValNameIdx,0,11);
 
                Strength_Expo              = EditValues(ValNameIdx , 0, Strength_Expo        , 0, 99);
                Wait_Expo                  = EditValues(ValNameIdx , 1, Wait_Expo            , 0, 99);
                Strength_Linear            = EditValues(ValNameIdx , 2, Strength_Linear      , 0, 150);
                Wait_Linear                = EditValues(ValNameIdx , 3, Wait_Linear          , 0, 50);
                Fire_Assist_Strength       = EditValues(ValNameIdx , 4, Fire_Assist_Strength , 0, 500);
                Spam_Accuracy              = EditValues(ValNameIdx , 5, Spam_Accuracy        , 0, 100);
                AR_Ver                     = EditValues(ValNameIdx , 6, AR_Ver               , 0, 99);
                AR_Horiz                   = EditValues(ValNameIdx , 7, AR_Horiz             , 0, 99);
                HeadStep                   = EditValues(ValNameIdx , 8, HeadStep             , 0, 30);
                HeadMax                    = EditValues(ValNameIdx , 9, HeadMax              , 0, 70);
                DropShotWait               = EditValues(ValNameIdx , 10, DropShotWait        , 0, 200);
                SlideShotWait              = EditValues(ValNameIdx , 11, SlideShotWait       , 0, 400);
 
               if(ModNameIdx == 0) ValNameIdx = cycle(ValNameIdx,0,1);
               if(ModNameIdx == 1) ValNameIdx = cycle(ValNameIdx,2,3);
               if(ModNameIdx == 2) ValNameIdx = cycle(ValNameIdx,4,4);
               if(ModNameIdx == 3) ValNameIdx = cycle(ValNameIdx,5,5);
               if(ModNameIdx == 4) ValNameIdx = cycle(ValNameIdx,6,7);
               if(ModNameIdx == 5) ValNameIdx = cycle(ValNameIdx,8,9);
               if(ModNameIdx == 6) ValNameIdx = cycle(ValNameIdx,10,10);
               if(ModNameIdx == 7) ValNameIdx = cycle(ValNameIdx,11,11);
 
            }
        }
        if(DisplayMenu) {
 
                cls_oled(OLED_BLACK);   
                rect_oled(0, 0, OLED_WIDTH, OLED_HEIGHT, OLED_BLACK, OLED_WHITE);
                line_oled(0, 27, OLED_WIDTH - 1, 27, 1, OLED_WHITE);
 
        if(EditMenu) {
 
                printf(center_x(get_valName_chars(ValNameIdx), OLED_FONT_MEDIUM_WIDTH),7,OLED_FONT_MEDIUM,OLED_WHITE,ValNames[ValNameIdx]);
            }
            else if (ModMenu) {
 
                    printf(center_x(get_modName_chars(ModNameIdx), OLED_FONT_MEDIUM_WIDTH),7,OLED_FONT_MEDIUM,OLED_WHITE,ModNames[ModNameIdx])
 
                if(Toggle == 1)
 
                     printf(center_x(get_misc_chars(1), OLED_FONT_SMALL_WIDTH), 40,OLED_FONT_SMALL,OLED_WHITE,Misc[1]);   
 
                   else if(Toggle == 0) 
 
                        printf(center_x(get_misc_chars(2), OLED_FONT_MEDIUM_WIDTH), 40,OLED_FONT_MEDIUM,OLED_WHITE,Misc[2])
            }
            Toggle = FALSE;
            DisplayMenu = FALSE;
        }
 
        if(!ModMenu && !EditMenu) {
 
            if(DisplayTitle) {
 
                cls_oled(OLED_BLACK)
                rect_oled(0, 0, OLED_WIDTH, OLED_HEIGHT, OLED_BLACK, OLED_WHITE)
                printf(center_x(get_misc_chars(0), OLED_FONT_SMALL_WIDTH),7,OLED_FONT_SMALL,OLED_WHITE,Misc[0])
                printf(center_x(get_misc_chars(3), OLED_FONT_SMALL_WIDTH),22,OLED_FONT_SMALL,OLED_WHITE,Misc[3]);
                printf(center_x(get_misc_chars(4), OLED_FONT_SMALL_WIDTH),37,OLED_FONT_SMALL,OLED_WHITE,Misc[4]);
                printf(center_x(get_misc_chars(5), OLED_FONT_SMALL_WIDTH),50,OLED_FONT_SMALL,OLED_WHITE,Misc[5]);
 
                DisplayTitle = FALSE;
                ScreenSaver  = TRUE;
            }
            if(ScreenSaver) 
            {
                   BlankScreen += get_rtime();
 
                if(BlankScreen >= 10000)
                {
                    cls_oled(OLED_BLACK);
                    BlankScreen = 0;
                    ScreenSaver = TRUE;
 
                }
            }
        }
 
        if(!KillSwitch) {
 
    //===========================================
    //   BLOCK RUMBLE
    //===========================================
    if (Block_Rumble) {
        block_rumble();
    }
 
    //===========================================
    //        AIM ASSIST EXPLOIT EXPO V3
    //===========================================     
    if (Aim_Exploit_Expo) {
 
        if (get_ival(AdsBtn)) {
 
            combo_run(Aim_Expo);
 
        } else {
 
            combo_stop(Aim_Expo);
 
    }
}
    //===========================================
    //        AIM ASSIST EXPLOIT LINEAR V3
    //===========================================   
    if (Aim_Exploit_Linear) {
 
        if (get_ival(AdsBtn)) {
 
            combo_run(Aim_Linear);
    }
}
    //===========================================
    //          FIRE ASSIST EXPLOIT V3
    //=========================================== 
    if (Assist_Fire_Exploit) {
 
        if (get_ival(FireBtn) && !get_ival(AdsBtn)) {
 
            if (abs(get_ival(LX)) <= 40 && abs(get_ival(LY)) <= 35) {
 
                combo_run(FireAssist);
 
            } else {
 
                combo_stop(FireAssist);
        }
    }
}
    //===========================================
    //          100% ACCUARCY EXPLOIT V3
    //===========================================   
    if (Accuracy_Exploit) {
 
        if (event_press(FireBtn) && !get_ival(HoldButtonStop)) {
 
            combo_run(Accuracy100);
    }
}
 
    //===========================================
    //               ANTI RECOIL
    //===========================================     
    if (Anti_Recoil) {
 
        if (get_ival(AdsBtn) && get_ival(FireBtn)) {
 
            combo_run(AntiRecoil);
    }
}
 
    //===========================================
    //            HEAD SHOT ASSIST
    //===========================================   
    if (Head_Shot) {
 
        if (get_ival(AdsBtn) && get_ival(FireBtn) || HipAssistHead && get_ival(FireBtn)) {
 
            if (abs(get_ival(RY)) < HeadMax) {
 
                Head += HeadStep;
                combo_run(HeadShotAssist);
        }
    }
            if (!get_ival(FireBtn)) Head = 0;
            if (Head >= HeadMax) combo_stop(HeadShotAssist)
    }
}
 
    //===========================================
    //            RAPID CROUCH
    //===========================================         
    if (get_val(CrouchShotHold) && event_press(CrouchShotPress)) {
 
          Drop_Shot = !Drop_Shot;
      }
 
        if (Drop_Shot && get_ival(FireBtn)) {
 
            combo_run(DropShot);
        }   
            else {
 
            combo_stop(DropShot);
}
 
 
    //===========================================
    //               SLIDE SHOT
    //===========================================       
 
    if (get_val(SlideHold) && event_press(SlidePress)) {
 
          Slide_Shot = !Slide_Shot;
      }
 
        if (Slide_Shot) {
 
        if (!get_ival(AdsBtn) && event_press(FireBtn)) {
 
                combo_run(SlideShot);
            }
 
         if (event_release(FireBtn)) {
 
                combo_run(SlideShot);
            }
 
          if (combo_running(SlideShot)) {
 
                set_val(FireBtn,0);
        }
    }
}
//========================================================================//
//                              COMBOS                                    //
//========================================================================//   
combo ToggleVibrate {
 
    if(Toggle)
    set_ledx(2, 2);
    set_rumble(RUMBLE_B, 50);
    wait(150);
    reset_rumble();
    wait(100);
    set_rumble(RUMBLE_B, 50);
    wait(150);
    reset_rumble();
    reset_leds();
    if(!Toggle)
    set_ledx(1, 1);
    set_rumble(RUMBLE_A, 50);
    wait(300);
    reset_rumble();
    wait(400);
    reset_leds();
}
combo RumbleOff {                       
 
    set_ledx(1, 1);
    set_rumble(RUMBLE_A, 50);
    wait(300);
    reset_rumble();
    wait(400);
    reset_leds();
}
combo Aim_Expo {
 
    set_val(RY,AxisRelease(RY,Strength_Expo));
    wait(Wait_Expo);
    set_val(RX,AxisRelease(RX,Strength_Expo));
    set_val(LX,AxisRelease(LX,Strength_Expo));
    wait(Wait_Expo);
    set_val(RY,AxisRelease(RY,Strength_Expo));
    wait(Wait_Expo);
    set_val(RX,AxisRelease(RX,inv(Strength_Expo)));
    wait(Wait_Expo);
    set_val(RX,AxisRelease(RX,inv(Strength_Expo)));
    set_val(LX,AxisRelease(LX,inv(Strength_Expo)));
    wait(Wait_Expo);
}
combo Aim_Linear {
 
    set_val(LX,inv(Strength_Linear));
    wait(Wait_Linear);
    set_val(LX,Strength_Linear);
    wait(Wait_Linear);
}
combo FireAssist {
 
    set_val(LX,-100);
    wait(Fire_Assist_Strength);
    set_val(LX,100);
    wait(Fire_Assist_Strength);
}
combo Accuracy100 {
 
    set_val(AdsBtn,100);
    wait(Spam_Accuracy);
}
combo AntiRecoil {
 
    AntirecoilVertical = get_val(PS4_RY) + AR_Ver; 
    if(AntirecoilVertical > 100) AntirecoilVertical = 100;
    if(abs(get_val(PS4_RY)) < abs(AR_Ver)5)
    set_val(PS4_RY, (AntirecoilVertical));
    AntirecoilHorizontal = get_val(PS4_RX) + AR_Horiz;
    if(AntirecoilHorizontal > 100) AntirecoilHorizontal = 100;
    if(abs(get_val(PS4_RX)) < abs(AR_Horiz)  + 5)
    set_val(PS4_RX, AntirecoilHorizontal);
}
combo HeadShotAssist {
 
    set_val(RY,inv(Head) + get_val(RY));
}
combo DropShot {
 
    set_val(CrouchBtn,100);
    wait(50);
    set_val(CrouchBtn,0);
    wait(20);
    wait(DropShotWait);
}
combo SlideShot {
 
    set_val(CrouchBtn,100);
    wait(SlideShotWait);
}
 
 
//========================================================================//
//                              FUNCTIONS                                 //
//========================================================================//
function MenuNavigation(f_modorval,f_min,f_max) {
 
    if(!get_val(PS4_L2)) {
 
        if(event_press(PS4_RIGHT)) {     
 
            f_modorval = cycle(f_modorval + 1, f_min , f_max  );
            DisplayMenu = TRUE;   
           }     
        if(event_press(PS4_LEFT)) { 
 
            f_modorval = cycle(f_modorval - 1, f_min , f_max  );
            DisplayMenu = TRUE;
        }
 
        set_val(PS4_RIGHT,0); set_val(PS4_LEFT,0);
    }
 
    if(f_modorval <= AmountOfEditableValues) {
 
        if(event_press(PS4_CROSS)) {
 
            ValNameIdx  = AmountOfEditableValues + 1;
            EditMenu    = TRUE;
            ModMenu     = FALSE;
            DisplayMenu = TRUE;
        }
        set_val(PS4_CROSS,0);
    }
    if(ModMenu) {
 
        if(event_press(PS4_CIRCLE)) {   
 
            DisplayTitle = TRUE;
            ModMenu      = FALSE;
            DisplayMenu  = FALSE;
            combo_run(RumbleOff);     
        }
        set_val(PS4_CIRCLE,0);
    }
    if(EditMenu) {
 
        if(event_press(PS4_CIRCLE)) {       
 
            EditMenu     = FALSE;
               ModMenu      = TRUE;
            DisplayMenu  = TRUE;       
        }
        set_val(PS4_CIRCLE,0);
    }
    return f_modorval;
}
function ToggleSwitch(f_name,f_val) {
 
    if(f_name) {       
 
        if(event_press(PS4_UP) || event_press(PS4_DOWN)) {
            f_val =! f_val;
            DisplayMenu = TRUE;       
            combo_run(ToggleVibrate);
        }
        Toggle = f_val
        set_val(PS4_UP,0); set_val(PS4_DOWN,0);
    }
    return f_val;
}
function AxisRelease(AxisXY,AxisVal) {
 
    if (abs(get_ival(AxisXY)) <= Strength_Expo)
 
        return AxisVal;
        return get_ival(AxisXY);
}
function cycle(f_val, f_lo, f_hi) {
    if(f_val > f_hi) return f_lo;
    if(f_val < f_lo) return f_hi;
    return f_val;
}
function get_misc_chars(f_idx){
    if (Misc[f_idx + 1] != -1)
        return Misc[f_idx + 1] - Misc[f_idx] - 1;
    return sizeof(Misc) - Misc[f_idx];       
}
function get_modName_chars(f_idx) {
    if (ModNames[f_idx + 1] != -1)
        return ModNames[f_idx + 1] - ModNames[f_idx] - 1;
    return sizeof(ModNames) - ModNames[f_idx];       
}
function get_valName_chars(f_idx) {
    if (ValNames[f_idx + 1] != -1)
        return ValNames[f_idx + 1] - ValNames[f_idx] - 1;
    return sizeof(ValNames) - ValNames[f_idx];       
}
User avatar
Candidutee
Private
Private
 
Posts: 1
Joined: Mon Nov 15, 2021 2:15 pm
Location: Germany

Return to GPC2 Script Programming

Who is online

Users browsing this forum: No registered users and 120 guests