DIRTY SPLAT

-CONVERTED FROM TITAN TWO TO TITAN ONE -REMOVE LEFT AN RIGHT HALF SPIN TO MAKE FIT TITAN ONE MEMORY CAPACITY. -DIDNT NOT TEST SHOT TIMING VALUES -REMOVE unmap PS4_L1 near do not touch
Version2.1
AuthorN_Yo_X_Box
Publish DateSat, 27 Feb 2021 - 06:05
Last UpdateSat, 27 Feb 2021 - 06:05
Downloads313
RATE


0

0

Code: Select all
// 2K21 DIRTYSPLAT 2.1 ''convertred BY TRU-AIM LAWZ''  
//FWYB IF NOT FUCK YA
// LIKE, COMMENT, SUBSCRIBE ON YOUTUBE
//ANY WAYS AS PROMISED A NEW WORKING SCRIPT PLEASE READS BEFORE HMU ON IG ABOUT THE SCRIPT
//HAD TO REMOVE LEFT AND RIGHT HALF SPIN TO FIT TITAN ONE MEMORY CAPACITY
// INSTRUCTIONS AN CONTROLS BELOW
 
//-DO NOT TOUCH.
unmap PS4_L1;
define SQUARE = PS5_SQUARE;
define L1 = PS5_L1;
 
 
define Red      =  2;                                    //
define White      =  7;                                  //
define Blue      =  1;                                   //                                                                 
int LED_OFF       = -2;       
 
//  ___   ___  _  _ _____    ___ _  _   _   _  _  ___ ___
// |   \ / _ \| \| |_   _|  / __| || | /_\ | \| |/ __| __|
// | |) | (_) | .` | | |   | (__| __ |/ _ \| .` | (_ | _|
// |___/ \___/|_|\_|_|_|__ _\___|_||_/_/ \_\_|\_|\___|___|   __
//   /_\ | \| \ \ / /_   _| || |_ _| \| |/ __|              / __|
//  / _ \| .` |\ V /  | | | __ || || .` | (_ |            | (_ |
// /_/ \_\_|\_| |_|   |_| |_||_|___|_|\_|\___|             \___|    Tru.A.LAWZ
 
 
 
//a few have mentioned to add for donations if you choose to donate paypal.me/Dirty619
 
//______  _____ ______  _____ __   __  _____ ______  _       ___   _____   _____     __ 
//|  _  \|_   _|| ___ \|_   _|\ \ / / /  ___|| ___ \| |     / _ \ |_   _| / __  \   /  |
//| | | |  | |  | |_/ /  | |   \ V /  \ `--. | |_/ /| |    / /_\ \  | |   `' / /'   `| |
//| | | |  | |  |    /   | |    \ /    `--. \|  __/ | |    |  _  |  | |     / /      | |
//| |/ /  _| |_ | |\ \   | |    | |   /\__/ /| |    | |____| | | |  | |   ./ /___ _ _| |_
//|___/   \___/ \_| \_|  \_/    \_/   \____/ \_|    \_____/\_| |_/  \_/   \_____/(_)\___/
//                                                                                       //
// 2.1 New Features
//-You can now SAVE your values when you find them do this by PRESSING L2 + R2 then PRESS SHARE ON PS4
//-You can now RESET your values TO DEFAULT 670 and 900 to do this PRESS L2 + R2 then PRESS OPTIONS ON PS4
 
 
//-SQUARE SHOOTING IS 670 DEFAULT
//- TO INCREASE SQUARE SHOOTING VALUE BY +1  HOLD L2 and press RIGHT on DPAD
//- TO DECREASE SQUARE SHOOTING VALUE BY -1  HOLD L2 and press LEFT on DPAD
//- TO INCREASE SQUARE SHOOTING VALUE BY +10 HOLD L2 and press UP on DPAD
//- TO DECREASE SQUARE SHOOTING VALUE BY -10 HOLD L2 and press DOWN on DPAD
 
//-R2 and SQUARE SHOOTING IS 900 DEFAULT
//- TO INCREASE R2 and SQUARE SHOOTING VALUE BY +1  HOLD R2 and press RIGHT on DPAD
//- TO DECREASE R2 and SQUARE SHOOTING VALUE BY -1  HOLD R2 and press LEFT on DPAD
//- TO INCREASE R2 and SQUARE SHOOTING VALUE BY +10 HOLD R2 and press UP on DPAD
//- TO DECREASE R2 and SQUARE SHOOTING VALUE BY -10 HOLD R2 and press DOWN on DPAD
 
//-TO ACTIVATE/DEACTIVATE DRIBBLES ITS R1 and UP on DPAD.
//-PERFORM DRIBBLES L3 R3 depending ball hand
//-CYCLING DRIBBLES IS  R1 and RIGHT or LEFT DPAD
//    1st Dribble is CURRY SLIDE
//    2nd Momentum to CURRYSLIDE
//    3rd Momentum Behind The Back
//    4th XPLOSIVE BEHIND THE BACK
//    5th SPINBACK
//    6th HALFSPIN FORWARD
//- TO ACTIVATE/DEACTIVATE ADVdefense ITS R1 AND THEN L2
//- PLEASE FEEL FREE TO MESSAGE ME ANY QUESTIONS OR SUGGESTIONS I WILL DROP ANOTHER VERSION OF THIS WITHOUT DRIBBLES AS ALTERNATIVE.
//-THANKS TO EVERYONE THAT HAS DONATED SINCE RELEASE OF 1.0 I APPRECIATE IT AND I HOPE THIS UPDATE CAN HELP THOSE THAT HAD ISSUES
//PRIOR VERSIONS.
//-CHECK OUT MY YOUTUBE DIRTY GAMING TIPS FOR VIDEOS EXPLAINING ANY FAQ'S ALOT OF PEOPLE HAVE
//-PLEASE REMEMBER THIS ISN'T GREEN EVERYTHING 70 PERCENT CONTESTED SCRIPT (did make a white 60 contested in rec though) BUT FROM
//PEOPLE HAVING GREAT RESULTS FROM THIS GREEN ALOT.
//- ONE FINAL TIP IF YOU NEED HELP FINDING VALUES OR TO TEST WITH DELAY ONLINE IS TO TRY AND GET A PRIVATE 3v3 PRO-AM ALOT OF PEOPLE
//IN MY DISCORD ARE DOING THAT.
 
//OK REMEMBER EXCELLENT SCRIPTS ARE BACK ") but CENTER IS STILL AVAILABLE FOR EMERGENCIES JUST TAP L1.
 
 
define MAX_RANGE = 330;
int Meter,MeterPosition,delay,R2_SQUARE_SHOT_DELAY,Dribbles,SQUARE_SHOT_DELAY,stepWait,DribbleSet,ADVdefense;
 
init
{
                    Meter = 1;
                MeterPosition = 19;
                    delay = 21;
 
 Dribbles                   = get_pvar(SPVAR_1,    0,1,0);
 DribbleSet                 = get_pvar(SPVAR_2,    1,6,1);
 ADVdefense                 = get_pvar(SPVAR_3,    0,1,0);
 SQUARE_SHOT_DELAY          = get_pvar(SPVAR_4,    300,2400,670);
 R2_SQUARE_SHOT_DELAY         = get_pvar(SPVAR_5,    300,2400,900);
}
main
{
 
 
if(get_val(PS4_L2) && get_val(PS4_R2) && event_press(PS4_SHARE))
        {
        combo_run(SAVE);
        combo_run(RESET);
         }
 
if(get_rumble(RUMBLE_A) || get_rumble(RUMBLE_B))
        {
        combo_run(wait_time);
        }
        if(Meter)  LED_CM(Red); //Green LED means Shoot aim with R2+L1     
    else     LED_CM(Blue); //No LED means Shoot aim with L1
 
    if(get_val(PS4_L2) && get_val(PS4_R2) && event_press(PS4_OPTIONS))
     {
        SQUARE_SHOT_DELAY    = 670;
        R2_SQUARE_SHOT_DELAY = 900;
        combo_run(RESET);
        }
 
    if(get_val(PS4_R2) && event_press(PS4_SQUARE))
        {
            combo_run(SQUARE_SHOOTING);
            }
 
    if(get_val(PS4_R2) &&  event_press(PS4_SQUARE))
        {
            combo_run(R2_SQUARE_SHOOTING);
            }
 
    if(event_press(PS4_L1))
        {
            combo_run(CENTER_SHOT);
            }
////////////////////////////////////////////////////////////////////////////////////////   
 
    if(ADVdefense == 1)
        {
                if(get_val(PS4_L2))
                {
                stepWait = MAX_RANGE - (FindMax(abs(get_val(PS4_LX)),abs(get_val(PS4_LY))) * 3);
                combo_run(ALTERNATE_STEP);
                }
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////////   
//////////////////////////////////////////////////////////////////////////////////////////////////////////////   
    if(get_val(PS4_R1))
    {
 
        if(event_press(PS4_UP))
        {
            Dribbles=!Dribbles;
            set_val(PS4_UP, 0);
            }
 
        if(event_press(PS4_L2))
            {
            set_val(PS4_L2, 0);
            combo_run(RESET);
             }
 
        ADVdefense=!ADVdefense;
 
        {
        set_val(PS4_L2, 0);
        combo_run(RESET);
        }
       }     
        if(event_press(PS4_RIGHT)) //If R3 is held and (D-PAD Right is pressed, toggle Dribble sets
        {
            DribbleSet++;
            if (DribbleSet >6)
                DribbleSet = 0;
                combo_run(RESET);
                }
 
        if(event_press(PS4_LEFT)) //If R3 is held and (D-PAD Right is pressed, toggle Dribble sets
        {
            DribbleSet++;
            if (DribbleSet >0)
                DribbleSet = 6;
                combo_run(RESET);           
                }
 
////////////////////////////////////////////////////////////////////////////////////////
    if(get_val(PS4_R2) && event_press(PS4_LEFT)){
        R2_SQUARE_SHOT_DELAY -- ;
        combo_run(DECREASE1);
    }
    if(get_val(PS4_R2) && event_press(PS4_RIGHT)){
        R2_SQUARE_SHOT_DELAY ++ ;
        combo_run(INCREASE1);
    }
    if(get_val(PS4_R2) && event_press(PS4_UP)){
        R2_SQUARE_SHOT_DELAY ++ ;
        combo_run(INCREASE10);
    }
    if(get_val(PS4_R2) && event_press(PS4_DOWN)){
        R2_SQUARE_SHOT_DELAY -- ;
        combo_run(DECREASE10);   
    }
    if(get_val(PS4_L2) && event_press(PS4_LEFT)) {
        SQUARE_SHOT_DELAY -- ;
        combo_run(DECREASE1);
    }
    if(get_val(PS4_L2) && event_press(PS4_RIGHT)) {
        SQUARE_SHOT_DELAY ++ ;
        combo_run(INCREASE1);
    }
    if(get_val(PS4_L2) && event_press(PS4_UP)) {
        SQUARE_SHOT_DELAY ++ ;
        combo_run(INCREASE10);
    }
    if(get_val(PS4_L2) && event_press(PS4_DOWN)) {
        SQUARE_SHOT_DELAY -- ;
        combo_run(DECREASE10);
    }
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////       
    if(Dribbles == 1 && DribbleSet == 1)
            {
            if (event_press(PS4_L3))
            combo_run(L_CURRY_SLIDE);   
            if (event_press(PS4_R3))
            combo_run(R_CURRY_SLIDE);   
            }
}
    if(Dribbles == 1 && DribbleSet == 2)
            {
            if (event_press(PS4_L3))
            combo_run(L_MOMENTUM_CURRYSLIDE);
            if (event_press(PS4_R3))
            combo_run(R_MOMENTUM_CURRYSLIDE);       
            }
 
    if(Dribbles == 1 && DribbleSet == 3)
           {         
            if (event_press(PS4_L3))
            {
            combo_run(L_MOMENTUM_BTB);
            }
 
            if (event_press(PS4_R3))
            combo_run(R_MOMENTUM_BTB);   
            }
 
    if(Dribbles == 1 && DribbleSet == 4)
            {       
            if (event_press(PS4_L3))
            combo_run(L_HANDED_EXPLOSIVE_BTB);   
            if (event_press(PS4_R3))
            combo_run(R_HANDED_EXPLOSIVE_BTB);   
            }
 
    if(Dribbles == 1 && DribbleSet == 5)
            {       
            if (event_press(PS4_L3))
            combo_run(L_SPINBACK);
            if (event_press(PS4_R3))
            combo_run(R_SPINBACK);   
            }
 
 
}
////////////////////////////////////////////////////////////////////////////////////////   
combo SQUARE_SHOOTING
{
    wait(SQUARE_SHOT_DELAY);
    set_val(PS4_SQUARE, 0);
    wait(300);
 
}
combo R2_SQUARE_SHOOTING
{
    wait(R2_SQUARE_SHOT_DELAY);
    set_val(PS4_SQUARE, 0);
    wait(300);
}       
combo CENTER_SHOT
{
    set_val(PS4_RY, 100);
    wait(100);
    set_val(PS4_RY, 100);
    set_val(PS4_RX, 18);
    wait(650);
}
 
combo L_SPINBACK
{
    set_val(PS4_RY, -100); // 12 'o Clock
    wait(30); ////testing 30 from 60
    set_val(PS4_RX, -100); // 9 'o Clock
    wait(30);    ////same
    set_val(PS4_RY, 100);// 6 'o Clock
    wait(60)//////60 from 120
    set_val(PS4_LY, 100);
    wait(800);
}
combo R_SPINBACK
{
    set_val(PS4_RY, -100); // 12 'o Clock
    wait(30);
    set_val(PS4_RX, 100); // 3 'o Clock
    wait(30);
    set_val(PS4_RY, 100);// 6 'o Clock
    wait(60);
    set_val(PS4_LY, 100);
    wait(800);
}
combo L_MOMENTUM_BTB
{
    set_val(PS4_RX, 100);
    wait(20);
    set_val(PS4_LX, 75);
    set_val(PS4_LY, -75);
    wait(150);
    set_val(PS4_RX, -100);
    set_val(PS4_RY, 75);
    wait(80);
    set_val(PS4_LX, -75);
    set_val(PS4_LY, -75);
    wait(100);
    set_val(PS4_LX, -75);
    set_val(PS4_LY, -75);
    wait(200);
}
combo R_MOMENTUM_BTB
{     
    set_val(PS4_RX, -100);
    wait(20);   
    set_val(PS4_LX, -75);
    set_val(PS4_LY, -75);
    wait(150);
    set_val(PS4_RX, 100);
    set_val(PS4_RY, 75);
    wait(80);
    set_val(PS4_RX, 75);
    set_val(PS4_RY, 75);
    set_val(PS4_LX, 75);
    set_val(PS4_LY, -75);
    wait(100);
    set_val(PS4_LX, 75);
    set_val(PS4_LY, -75);
    wait(200);
}
combo L_MOMENTUM_CURRYSLIDE
{       
    set_val(PS4_RX, 100);
    wait(30);
    set_val(PS4_LX, 75);
    set_val(PS4_LY, -75);
    wait(150);
    set_val(PS4_RX, -100);
    set_val(PS4_RY, 75)
    wait(200);
}
combo R_MOMENTUM_CURRYSLIDE
{
    set_val(PS4_RX, -100);
    wait(30);
    set_val(PS4_LX, -75);
    set_val(PS4_LY, -75);
    wait(150);
    set_val(PS4_RX, 100);
    set_val(PS4_RY, 75);
    wait(200);
}
combo L_CURRY_SLIDE
{
    set_val(PS4_RX, 100);
    set_val(PS4_RY, 75);   
    wait(300);
}
combo R_CURRY_SLIDE
{
    set_val(PS4_RX, -100);
    set_val(PS4_RY, 75);
    wait(300);
}
combo L_HANDED_EXPLOSIVE_BTB
{
    set_val(PS4_RX, 75);
    set_val(PS4_RY, 75);
    wait(80);
    set_val(PS4_RX, 75);
    set_val(PS4_RY, 75);
    set_val(PS4_LX, 75);
    set_val(PS4_LY, -75);
    wait(100);
    set_val(PS4_LX, 75);
    set_val(PS4_LY, -70);
    wait(200);
}
combo R_HANDED_EXPLOSIVE_BTB
{   
    set_val(PS4_RX, -75);
    set_val(PS4_RY, 75);
    wait(80);
    set_val(PS4_LX, -75);
    set_val(PS4_LY, -75);
    wait(100);
    set_val(PS4_LX, -75);
    set_val(PS4_LY, -75);
    wait(200);
}
combo ALTERNATE_STEP
{
    set_val(PS4_L2,100);
        wait(60);
    set_val(PS4_L2,0);
    wait(stepWait);
}
combo INCREASE1
{
    set_rumble(RUMBLE_A, 75);
    wait(200);
    reset_rumble();
}
combo INCREASE10
{
    set_rumble(RUMBLE_B, 100);
    wait(200);
    reset_rumble();
}
combo DECREASE1
{
    set_rumble(RUMBLE_A, 25);
    wait(200);
    reset_rumble();
}
combo DECREASE10
{
    set_rumble(RUMBLE_B, 25);
    wait(200);
    reset_rumble();
}
combo RESET
{
    set_rumble(RUMBLE_A, 100);
    wait(200);
    set_rumble(RUMBLE_A, 0);
}
 
combo wait_time
{
    wait(delay);
    set_val(PS4_L2, 100);
    set_val(PS4_SQUARE, 0);
    wait(100);
    set_val(PS4_L2, 0);
    wait(300);
    }
 
combo SAVE
{
    set_pvar(SPVAR_1, Dribbles);
    set_pvar(SPVAR_2, DribbleSet);
    set_pvar(SPVAR_3, ADVdefense);
    set_pvar(SPVAR_4, SQUARE_SHOT_DELAY);   
    set_pvar(SPVAR_5, R2_SQUARE_SHOT_DELAY);
}
 
/////////////\\FUNCTIONS START\\///////////////
function FindMax(a,b) {
    if(a > b){
        return a;
    }
    return b;
}
//====================================//======================================//
//===============================//LED COLOUR//===============================//
//============================================================================//   
    function LED_CM(Colour)                                                       //
    {                                                                         //
        set_led(LED_1,dbyte(( Colour * 4)- 3  + 1));                          //
        set_led(LED_2,dbyte(((Colour * 4)- 3) + 2));                          //
        set_led(LED_3,dbyte(((Colour * 4)- 3) + 3));                          //
        set_led(LED_4,dbyte(((Colour * 4)- 3) + 4));                          //
        }                                                                     //