Titan 1 Negative value change

GPC script programming for Titan One device. Code examples, how to, questions, requests.

Moderators: The_Rabid_Taco, pablosscripts, bonefisher, Baby Cham, Elvish

Titan 1 Negative value change

Postby Massacre » Thu May 16, 2019 5:32 pm

Trying to figure out how to use negative values in scripts. I change it to a T1 version and it denies it. Can someone change this for me please!! Thank you!!

Code: Select all
// GPC Online Library
// season_9_ready_ads+fire_fortnite_script_.gpc
// GPC Online Library
// season_9_ready_ads+fire_fortnite_script.gpc
// CREDITS TO SWEET EVIL USED HIS 4.65 TEST SCRIPT
// CREDITS TO WALTER MARTINEZ JUST DELETED FEW THINGS AND ADJUSTED AIM ABUSE AND AIM ASSIST
// CREDITS TO ITSNACKZ USED HIS ANTIRECOIL SETTUP
// CREDITS TO MRORION USED HIS 3LAYER RAMP RUSH
// I CLAIM NOTHING I JUST TWEAK VALUES TO MY LIKING!
///// IF YOU DNT LIKE ADS + FIRE I'LL HIGHLIGHT WAT TO DELETE AND REPLACE THAT WITH FOR THE ONES WHO DNT KNOW!!!! BE UNDER AIM ABUSE IN THE MAIN SECTION GUYS!
//Controls:                                                                               
//RAMP RUSH
// HOLD "ADS_BTN" and TAP "SWAP_BTN" for toggle ON_OFF// BEST TIMING FOR ME WAS HIT R2 RELEASE R2
//SWAP CONTROLS
// SET TO TRUE TO SHOOT WITH R1 AND AIM WITH L1
// SET TO TRUE TO JUMP WITH R3 AND CROUCH WITH X
//DROPSHOT
// HOLD L2 & SQAURE TURNS OFF AND ON
//Aim Assist -- Always on
// AIM ASSIST VALUES
//AIM ASSIST VALUES
//Aim Abuse
//How long you HOLD ADS Button
//How long you release ADS Button
//SWEET EVILS VARIABLE
// Dont't change!
//
//
//ANTI-RECOIL
// RECOIL SETTING
//Rumble
// BUTTON LAYOUT: BUILDER PRO
//XB1_RB //PS4_R2
//XB1_LB //PS4_L2
//XB1_RS //PS4_R3
//XB1_LS //PS4_L3
//XB1_A  //PS4_CROSS
//XB1_RT //PS4_R1
//XB1_LT //PS4_L1
//XB1_Y  //PS4_TRIANGLE
//XB1_B  //PS4_CIRCLE
//XB1_RB //PS4_R2
//XB1_LB //PS4_L2
//XB1_RT //PS4_R1
//XB1_LT //PS4_L1
//XB1_X //PS4_SQAURE
//XB1_RX //PS4_RX
//XB1_RY //PS4_RY
//XB1_LX //PS4_LX
//XB1_LY //PS4_LY
//XB1_UP //PS4_UP
//XB1_DOWN //PS4_DOWN
//XB1_LEFT //PS4_LEFT
//XB1_RIGHT //PS4_RIGHT
//Build Speed
//END
//vm_tctrl(-2);
//SWAP CONTROLS
//RAMP RUSH
//SWEET EVIL
//if(get_lval(PS4_RX) > NEG_Micro_MVT_Limit || get_lval(PS4_RX) < POS_Micro_MVT_Limit || get_lval(PS4_RY) > NEG_Micro_MVT_Limit || get_lval(PS4_RY) < POS_Micro_MVT_Limit
//|| get_lval(PS4_RX) > NEG_Micro_MVT_Limit || get_lval(PS4_RX) < POS_Micro_MVT_Limit || get_lval(PS4_RY) > NEG_Micro_MVT_Limit || get_lval(PS4_RY) < POS_Micro_MVT_Limit)
//RampRush
//AIM ASSIST
//AIM ABUSE
// 1.HIGHLIGHT : && get_val(FIRE_BTN)){  AND DELETE  COPY N PASTE THIS  >95 {                                                     
//Drop Shot
//ANTI-RECOIL
//COMBO SECTION
// Save the first joystick position
// Sampling frequency
// Save the second joystick position
// Sampling frequency
// Save the second joystick position
 
 
 
 
define Sampling_Time = 8;
define Aim_Boost = 7;
define Aim_Correction = 12;
define Aim_Perfection_Limit = 30;
define POS_Aim_Limit = 70;
define NEG_Aim_Limit = -70;
define POS_Micro_MVT_Limit = 16;
define NEG_Micro_MVT_Limit = -16;
define FIRE_BTN = 4;
define ADS_BTN = 7;
define CROUCH_BTN = 5;
define SPRINT_BTN = 8;
define JUMP_BTN = 19;
define NEXT_PIECE = 3;
define LEFT_BUMP = 6;
define SWAP_BTN = 17;
define BUILD_BTN = 18;
define WALL_BTN = 4;
define STAIRS_BTN = 7;
define FLOOR_BTN = 3;
define ROOF_BTN = 6;
define RELOAD_BTN = 20;
define R_X = 9;
define R_Y = 10;
define L_X = 11;
define L_Y = 12;
define UP = 13;
define DOWN = 14;
define LEFT = 15;
define RIGHT = 16;
define build_speed = 50;
define speed = 50;
 
int RampRush = FALSE;
int R1L1_SWAP = FALSE;
int XR3_SWAP = FALSE;
int AutoDrop_onoff = TRUE;
int AimAssist = TRUE;
int aav = 19;
int aav2 =- 19;
int value = 19;
int value2 =- 19;
int delay = 20;
int AimAbuse = TRUE;
int AimAbuse_HOLD = 300;
int AimAbuse_RELEASE = 20;
int X_Last_Value = 0;
int Y_Last_Value = 0;
int X_Current_Value = 0;
int Y_Current_Value = 0;
int Sampling_Done = FALSE;
int micro_mvt = FALSE;
int spiroide_pulse = 0;
int fine_pulse = 0;
int Joystick_calibration = FALSE;
int RX_Axis_Joystick_calibrate = 0;
int RY_Axis_Joystick_calibrate = 0;
int AR = 1;
int Release = 70;
int ARS;
int rumble_type = RUMBLE_A;
 
main {
    if (R1L1_SWAP) {
        swap(3, 4);
        swap(6, 7);
    }
    if (XR3_SWAP) {
        swap(19, 5);
    }
    if (get_val(ADS_BTN)) {
        if (event_press(SWAP_BTN)) {
            RampRush =! RampRush;
            f_rumble_A_if_true(RampRush);
        }
        set_val(SWAP_BTN, 0);
    }
    if (Joystick_calibration == FALSE) {
        RX_Axis_Joystick_calibrate = get_val(PS4_RX);
        RY_Axis_Joystick_calibrate = get_val(PS4_RY);
        Joystick_calibration = TRUE;
    }
    X_Last_Value = X_Current_Value;
    Y_Last_Value = Y_Current_Value;
    X_Current_Value = get_lval(PS4_RX) - RX_Axis_Joystick_calibrate;
    Y_Current_Value = get_lval(PS4_RY) - RY_Axis_Joystick_calibrate;
    if (get_val(PS4_L2)) {
        if (abs(X_Current_Value) <= POS_Micro_MVT_Limit && abs(Y_Current_Value) <= POS_Micro_MVT_Limit) {
            if ((X_Last_Value >= 0 && X_Current_Value >= 0) || (X_Last_Value <= 0 && X_Current_Value <= 0)) {
                if (abs(abs(X_Last_Value) - abs(X_Current_Value)) < 15) {
                    micro_mvt = TRUE;
                }
                else {
                    micro_mvt = FALSE;
                }
            }
            else if ((X_Last_Value <= 0 && X_Current_Value >= 0) || (X_Last_Value >= 0 && X_Current_Value <= 0)) {
                if (abs(X_Last_Value) + abs(X_Current_Value) < 15) {
                    micro_mvt = TRUE;
                }
                else {
                    micro_mvt = FALSE;
                }
            }
            else {
                micro_mvt = FALSE;
            }
            if (micro_mvt == TRUE) {
                combo_stop(c_Aim_Assist_Perfection);
                Sampling_Done = FALSE;
            }
            if (!combo_running(c_Aim_Assist_Perfection)) {
                if (get_val(PS4_R2) > 95) {
                    combo_stop(c_Fine_Tune_Aim);
                    fine_pulse = 0;
                    combo_run(c_spiroide_Aim_Assit);
                }
                else {
                    combo_stop(c_spiroide_Aim_Assit);
                    spiroide_pulse = 0;
                    combo_run(c_Fine_Tune_Aim);
                }
            }
        }
        else if (abs(X_Current_Value) <= POS_Aim_Limit && abs(Y_Current_Value) <= POS_Aim_Limit) {
            combo_stop(c_Fine_Tune_Aim);
            combo_stop(c_spiroide_Aim_Assit);
            spiroide_pulse = 0;
            fine_pulse = 0;
            combo_run(c_Aim_Assist_Perfection);
        }
        else {
            combo_stop(c_Fine_Tune_Aim);
            combo_stop(c_spiroide_Aim_Assit);
            combo_stop(c_Aim_Assist_Perfection);
            spiroide_pulse = 0;
            fine_pulse = 0;
            Sampling_Done = FALSE;
        }
    }
    else {
        combo_stop(c_Fine_Tune_Aim);
        combo_stop(c_spiroide_Aim_Assit);
        combo_stop(c_Aim_Assist_Perfection);
        spiroide_pulse = 0;
        fine_pulse = 0;
        Sampling_Done = FALSE;
    }
    if (RampRush) {
        if (!get_val(ADS_BTN) && get_val(FIRE_BTN)) {
            combo_run(c_RampRush3L);
        }
        if (!get_val(ADS_BTN)) {
            set_val(FIRE_BTN, 0);
        }
    }
    if (AimAssist) {
        if (get_val(ADS_BTN)) {
            combo_run(c_AimAssist);
        }
    }
    if (get_val(R_X) < value2 || get_val(R_X) > value || get_val(R_Y) < value2 || get_val(R_Y) > value || get_val(R_X) < value2 || get_val(R_X) > value || get_val(R_Y) < value2 || get_val(R_Y) > value) {
        combo_stop(c_AimAssist);
    }
    if (AimAbuse) {
        if (get_val(ADS_BTN) && get_val(FIRE_BTN)) {
            combo_run(c_AimAbuse);
        }
        if (event_release(ADS_BTN)) {
            combo_stop(c_AimAbuse);
        }
    }
    if (get_val(PS4_L2)) {
        if (event_press(PS4_SQUARE)) {
            AutoDrop_onoff =! AutoDrop_onoff;
            f_rumble_A_if_true(AutoDrop_onoff);
        }
        set_val(PS4_SQUARE, 0);
    }
    if (AutoDrop_onoff) {
        if (get_val(ADS_BTN) && get_val(FIRE_BTN)) {
            combo_run(c_DROP_SHOT);
        }
    }
    if (get_val(ADS_BTN) && get_val(FIRE_BTN)) {
        combo_run(c_AR);
    }
    if (abs(get_val(10)) > Release || abs(get_val(9)) > Release) {
        combo_stop(c_AR);
    }
}
 
 
combo c_DROP_SHOT {
    set_val(CROUCH_BTN, 100);
    wait(80);
    wait(60);
    set_val(CROUCH_BTN, 100);
}
 
combo c_AimAssist {
    set_val(R_Y, (aav));
    wait(delay);
    set_val(R_X, (aav));
    wait(delay);
    set_val(R_Y, (aav2));
    wait(delay);
    set_val(R_X, (aav2));
    wait(delay);
    set_val(R_Y, (aav));
    wait(delay);
    set_val(R_X, (aav));
    wait(delay);
    set_val(R_Y, (aav2));
    wait(delay);
    set_val(R_X, (aav2));
    wait(delay);
}
 
combo c_Aim_Assist_Perfection {
    X_Last_Value = X_Current_Value;
    Y_Last_Value = Y_Current_Value;
    wait(Sampling_Time);
    X_Current_Value = get_lval(PS4_RX) - RX_Axis_Joystick_calibrate;
    Y_Current_Value = get_lval(PS4_RY) - RY_Axis_Joystick_calibrate;
    if (Sampling_Done == TRUE) {
        if (X_Last_Value > 0 && X_Current_Value > 0) {
            if (X_Last_Value > X_Current_Value) {
                if (X_Last_Value - X_Current_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RX, (X_Current_Value + Aim_Boost));
                }
            }
            else {
                if (X_Current_Value - X_Last_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RX, (X_Current_Value - Aim_Boost));
                }
            }
        }
        else if (X_Last_Value > 0 && X_Current_Value < 0) {
            if (X_Last_Value + X_Current_Value < Aim_Perfection_Limit) {
                set_val(PS4_RX, (X_Current_Value + Aim_Boost));
            }
        }
        else if (X_Last_Value < 0 && X_Current_Value > 0) {
            if (X_Current_Value - X_Last_Value < Aim_Perfection_Limit) {
                set_val(PS4_RX, (X_Current_Value - Aim_Boost));
            }
        }
        else {
            if (X_Last_Value > X_Current_Value) {
                if (X_Last_Value - X_Current_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RX, (X_Current_Value - Aim_Boost));
                }
            }
            else {
                if (X_Current_Value - X_Last_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RX, (X_Current_Value + Aim_Boost));
                }
            }
        }
        if (Y_Last_Value > 0 && Y_Current_Value > 0) {
            if (Y_Last_Value > Y_Current_Value) {
                if (Y_Last_Value - Y_Current_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RY, (Y_Current_Value + Aim_Boost));
                }
            }
            else {
                if (Y_Current_Value - Y_Last_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RY, (Y_Current_Value - Aim_Boost));
                }
            }
        }
        else if (Y_Last_Value > 0 && Y_Current_Value < 0) {
            if (Y_Last_Value + Y_Current_Value < Aim_Perfection_Limit) {
                set_val(PS4_RY, (Y_Current_Value + Aim_Boost));
            }
        }
        else if (Y_Last_Value < 0 && Y_Current_Value > 0) {
            if (Y_Current_Value - Y_Last_Value < Aim_Perfection_Limit) {
                set_val(PS4_RY, (Y_Current_Value - Aim_Boost));
            }
        }
        else {
            if (Y_Last_Value > Y_Current_Value) {
                if (Y_Last_Value - Y_Current_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RY, (Y_Current_Value - Aim_Boost));
                }
            }
            else {
                if (Y_Current_Value - Y_Last_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RY, (Y_Current_Value + Aim_Boost));
                }
            }
        }
    }
    X_Last_Value = X_Current_Value;
    Y_Last_Value = Y_Current_Value;
    wait(Sampling_Time);
    X_Current_Value = get_lval(PS4_RX) - RX_Axis_Joystick_calibrate;
    Y_Current_Value = get_lval(PS4_RY) - RX_Axis_Joystick_calibrate;
    if (Sampling_Done == TRUE) {
        if (X_Last_Value > 0 && X_Current_Value > 0) {
            if (X_Last_Value > X_Current_Value) {
                if (X_Last_Value - X_Current_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RX, (X_Current_Value - Aim_Correction));
                }
            }
            else {
                if (X_Current_Value - X_Last_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RX, (X_Current_Value + Aim_Correction));
                }
            }
        }
        else if (X_Last_Value > 0 && X_Current_Value < 0) {
            if (X_Last_Value + X_Current_Value < Aim_Perfection_Limit) {
                set_val(PS4_RX, (X_Current_Value - Aim_Correction));
            }
        }
        else if (X_Last_Value < 0 && X_Current_Value > 0) {
            if (X_Current_Value - X_Last_Value < Aim_Perfection_Limit) {
                set_val(PS4_RX, (X_Current_Value + Aim_Correction));
            }
        }
        else {
            if (X_Last_Value > X_Current_Value) {
                if (X_Last_Value - X_Current_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RX, (X_Current_Value + Aim_Correction));
                }
            }
            else {
                if (X_Current_Value - X_Last_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RX, (X_Current_Value - Aim_Correction));
                }
            }
        }
        if (Y_Last_Value > 0 && Y_Current_Value > 0) {
            if (Y_Last_Value > Y_Current_Value) {
                if (Y_Last_Value - Y_Current_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RY, (Y_Current_Value - Aim_Correction));
                }
            }
            else {
                if (Y_Current_Value - Y_Last_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RY, (Y_Current_Value + Aim_Correction));
                }
            }
        }
        else if (Y_Last_Value > 0 && Y_Current_Value < 0) {
            if (Y_Last_Value + Y_Current_Value < Aim_Perfection_Limit) {
                set_val(PS4_RY, (Y_Current_Value - Aim_Correction));
            }
        }
        else if (Y_Last_Value < 0 && Y_Current_Value > 0) {
            if (Y_Current_Value - Y_Last_Value < Aim_Perfection_Limit) {
                set_val(PS4_RY, (Y_Current_Value + Aim_Correction));
            }
        }
        else {
            if (Y_Last_Value > Y_Current_Value) {
                if (Y_Last_Value - Y_Current_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RY, (Y_Current_Value + Aim_Correction));
                }
            }
            else {
                if (Y_Current_Value - Y_Last_Value < Aim_Perfection_Limit) {
                    set_val(PS4_RY, (Y_Current_Value - Aim_Correction));
                }
            }
        }
    }
    Sampling_Done = TRUE;
    wait(Sampling_Time);
}
 
combo c_Fine_Tune_Aim {
    set_val(PS4_RX, (4 + fine_pulse));
    wait(Sampling_Time);
    wait(Sampling_Time);
    wait(Sampling_Time);
    set_val(PS4_RX, ( - 4 - fine_pulse));
    wait(Sampling_Time);
    wait(Sampling_Time);
    wait(Sampling_Time);
    fine_pulse = fine_pulse + 2;
    if (fine_pulse > 10) {
        fine_pulse = 0;
    }
}
 
combo c_spiroide_Aim_Assit {
    set_val(PS4_RY, (5 + spiroide_pulse));
    wait(Sampling_Time);
    wait(Sampling_Time);
    set_val(PS4_RX, (4 + spiroide_pulse));
    wait(Sampling_Time);
    wait(Sampling_Time);
    set_val(PS4_RY, (5 + spiroide_pulse));
    wait(Sampling_Time);
    wait(Sampling_Time);
    wait(Sampling_Time);
    wait(Sampling_Time);
    set_val(PS4_RY, (5 + spiroide_pulse));
    wait(Sampling_Time);
    wait(Sampling_Time);
    set_val(PS4_RX, ( - 4 - spiroide_pulse));
    wait(Sampling_Time);
    wait(Sampling_Time);
    set_val(PS4_RY, (5 + spiroide_pulse));
    wait(Sampling_Time);
    wait(Sampling_Time);
    wait(Sampling_Time);
    wait(Sampling_Time);
    spiroide_pulse = spiroide_pulse + 2;
    if (spiroide_pulse > 10) {
        spiroide_pulse = 0;
    }
}
 
combo c_AimAbuse {
    set_val(ADS_BTN, 100);
    wait(AimAbuse_HOLD);
    set_val(ADS_BTN, 0);
    wait(AimAbuse_RELEASE);
}
 
combo c_RampRush3L {
    set_val(PS4_R1, 100);
    wait(110);
    set_val(PS4_R1, 0);
    wait(60);
    set_val(PS4_R2, 100);
    wait(40);
    set_val(PS4_R2, 100);
    wait(100);
    set_val(PS4_R2, 0);
    wait(40);
    set_val(PS4_L2, 100);
    wait(100);
    set_val(PS4_L2, 0);
    wait(500);
}
 
combo c_Vibrate {
    set_rumble(rumble_type, 100);
    wait(300);
    reset_rumble();
}
 
combo c_AR {
    ARS = get_val(10) + AR;
    if (ARS > 100) ARS = 100;
    set_val(10, ARS);
}
 
 
function f_rumble_A_if_true(var) {
    if (var) rumble_type = RUMBLE_A;
    else  rumble_type = RUMBLE_B;
    combo_run(c_Vibrate);
}
 
 
 
User avatar
Massacre
Sergeant Major
Sergeant Major
 
Posts: 95
Joined: Wed Jul 06, 2016 1:55 am
Location: Oklahoma

Re: Titan 1 Negative value change

Postby Scachi » Thu May 16, 2019 6:17 pm

Change the "define" word to "int" for the ones with negative values
User avatar
Scachi
Brigadier General
Brigadier General
 
Posts: 1987
Joined: Wed May 11, 2016 6:25 am
Location: Germany


Return to GPC Script Programming (Titan One)

Who is online

Users browsing this forum: No registered users and 5 guests