Script Conversion Request Megathread

[sebascu]

convertir a titan uno porfavor

Code: Select all

// dogzthefighter's_fortnite_script__exponential_and_linear_zen_only_includes_menu_.gpc
// ******************ZEN ONLY******************   DoGzTheFiGhTeR's FORTNITE EXPONENTIAL AND LINEAR SCRIPT    ******************ZEN ONLY****************** 
// MENU ON = HOLD L2/LT & PRESS PS/XBOX BUTTON 
// MENU 1  = PRESS R3 TO SWAP MENUS WHILE IN MENU MODE  
// (MENU 1 VALUES & TIMES) (MENU 2 MOD TOGGLES)
// WHILE IN MENUS PRESS UP OR DOWN TO CHANGE VALUE/TIME OR HOLD FOR FAST SCROLL OT TOGGLE MODS ON/OFF
// PRESS LEFT TO SWITCH TO THE PREVIOUS MOD (-) 
// PRESS RIGHT TO SWITCH TO THE NEXT MOD    (+)
// PRESS TRIANGLE OR CIRCLE TO EXIT MENUS AT ANY TIME OR IT WILL SWITCH ITSELF OFF AFTER 25 SECONDS
// MOD MENU 26 OPTIONS IN EACH MENU = 52 ( EVERYTHING CAN BE SWITCHED ON OR OFF )
// 3 DIFFERENT AIM ASSISTS ( POLAR AIM ASSIST )( PROGRESSION AIM ASSIST ) ( DoGz METHOD AIM ASSIST (VM SPEED OPTION INCLUDED ENHANCE'S ASSIST SPEED DOWN TO -9 MIN) )
// QUICK EDIT ASSIST     ( HOLD YOUR QUICK EDIT BUTTON IN AND MOVE TO SELECT TILES ZEN WILL HOLD SELECT AND CONFIRM AUTOMATICALLY )  
// INSTANT EDIT AND RESET
// FAST RESET      ( PRESS THIS BUTTON AT ANYTIME TO RESET THE PEICE YOU ARE LOOKING AT )
// EDIT SESNITIVITY CONTROL
// DOUBLE EDIT IN EDIT MODE
// DROP SHOT ON FIRE
// JUMPSHOT ON FIRE
// RAPID FIRE
// SMART FIRE
// PUMPWALL ( PUMPWALL THEN SWAP GUN OPTION )
// PUMPFLOOR WALL JUMP ( PUMPFLOOR THEN SWAP GUN OPTION )
// GHOST PEEK
// ANTIRECOIL ( USE'S RUMBLE FEEDBACK )
// INSTANT PICKAXE
// EDIT SHOT
// WALL REPLACE/WALL TAKE
// TUNNEL BOX
// TUNNELLING
// QUICK EDIT ARCH/FLOOR
// ROOFFLOOR TAP
// RAMP FLOOR WALL
// BUNNY RAMP
// WHEN ENABLED TRIGGERS HERE
// AIM ASSIST'S          = L2 (WHEN L2 & R2 ARE PRESSED IT PROVIDES A BOOST TO AIM ASSIST FOR POLAR & DoGz ONLY ( BOOST CAN BE TURNED OFF FOR POLAR ) 
// RAPID FIRE            = FIRE BUTTON
// SMART FIRE            = FIRE BUTTON OR L2 & LEFT ( 100% ACCURACY )
// JUMPSHOT              = FIRE BUTTON
// DROP SHOT             = FIRE BUTTON
// GHOST PEEK            = L2 & DOWN
// PUMP WALL             = L2 & R1 ( PUMP WALL SWAP OPTION WILL SWAP TO WEAPON BY PRESSING L1 ) 
// PUMP FLOOR            = L2 & SQUARE ( PUMP FLOOR SWAP OPTION WILL SWAP TO WEAPON BY PRESSING L1 )
// ANTI RECOIL           = L2 & R2 ( REQUIRE'S VIBRATION SET ON IN GAME BUT IT WILL BE BLOCKED TO YOUR CONTROLLER )
// DOUBLE EDIT           = R1 WHILE IN INSTANT EDIT MODE ( NOT EDIT ASSIST NOT NEEDED ) ( TAP R1 )
// TUNNEL BOX            = HOLD TRIANGLE AND TAP R1
// TUNNELLING            = PRESS OPTIONS AND REPEAT
// WALL TAKE             = HOLD R2 WHEN WALL SMASHES PRESS L1 ( WILL SWAP TO WEAPON IN COMBO )
// WINDOW EDIT SHOT   = L2 & TRIANGLE
// ROOFFLOOR TAP         = DOUBLE TAP R1 IN BUILD MODE ( HOLD R1 IN ONCE DOUBLE TAPPED TO SPAM FLOOR/PYRAMID'S )
// RAMP FLOOR WALL       = PRESS LEFT IN BUILD MODE AT THE TOP OF RAMP LOOKING SLIGHLY DOWN/STRAIGHT ON
// BUNNY RAMP            = DOUBLE TAP CROSS IN BUILD MODE
// QUICK EDIT ARCH/FLOOR = L2 & OPTIONS
// INSTANT PICKAXE       = TRIANGLE TO ACTIVATE ( RELEASE FIRE TO SWAP TO WEAPON )
// EDIT ASSIT            = L3 (HOLD)
// FAST RESET            = TOUCHPAD ( IF HOLD L2 BLOCKS FAST RESET COMBO )
// IN GAME QUICK TOGGLES ( ON/OFF IN GAME ) ( MUST BE ON IN MENU SETTINGS )
// RAPID FIRE = L2 & UP 
// SMART FIRE = L2 & RIGHT
// JUMPSHOT   = L2 & CROSS  ( R3 & BUILD TURN OFF AS WELL )
// DROP SHOT  = L2 & R3     ( CROSS & BUILD TURN OFF AS WELL )
// YOU CAN MAKE ALL ALTERATIONS BELOW INCLUDING BUTTONS, TRIGGERS AND MODS TO ENABLE/DISABLE ( FOLLOW DOWN TO main { )
// NO NEED TO ALTER BELOW HERE
const byte FONT_STATS [][] = {{ 7, 10, 18 },{ 11, 18, 11 },{ 16, 26, 7 }}; 
const byte REFERENCE [] = {48,49,50,51,52,53,54,55,56,57}; 
// NO NEED TO ALTER BELOW HERE
define SMALL = 0,MEDIUM = 1,LARGE = 2,TEXT_HORIZONTAL = 5,TEXT_VERTICAL = 8,OLED_W = 127,OLED_H = 63,START = 0,SINGLE = 1;  
define FONT_W = 0,FONT_H = 1,FONT_L = 2,FONT_VERTICAL = 25,BLACK = 0,WHITE = 1,UNFILL = 0,FILL = 1,THICKNESS = 2,NEG = 45;
// NO NEED TO ALTER BELOW HERE
define ON  = TRUE;
define OFF = FALSE;
// NO NEED TO ALTER BELOW HERE
define PS         = PS4_PS;//XBOX
define SHARE      = PS4_SHARE;//VIEW  
define OPTIONS    = PS4_OPTIONS;//MENU  
define R1         = PS4_R1;//RB  
define R2         = PS4_R2;//RT  
define R3         = PS4_R3;//RS  
define L1         = PS4_L1;//LB  
define L2         = PS4_L2;//LT  
define RX         = PS4_RX;  
define RY         = PS4_RY;  
define LX         = PS4_LX;  
define LY         = PS4_LY;     
define L3         = PS4_L3;//LS  
define UP         = PS4_UP;  
define DOWN       = PS4_DOWN;  
define LEFT       = PS4_LEFT;  
define RIGHT      = PS4_RIGHT; 
define CROSS      = PS4_CROSS;//A  
define CIRCLE     = PS4_CIRCLE;//B  
define SQUARE     = PS4_SQUARE;//X  
define TRIANGLE   = PS4_TRIANGLE;//Y  
define TOUCH      = PS4_TOUCH;//SYNC
define PRX    = POLAR_RX;
define PRY    = POLAR_RY;
define RS         = POLAR_RS;
define VIB_A      = RUMBLE_A;
// PUT YOUR BUTTONS HERE BELOW IF DIFFERENT
define AIM        = PS4_L2;//XB1_LT 
define FIRE       = PS4_R2;//XB1_RT  
define PREVWEAPON = PS4_L1;//XB1_LB 
define NEXTWEAPON = PS4_R1;//XB1_RB                                        
define BUILD      = PS4_CIRCLE;//XB1_B
define ROOF       = PS4_L1;//XB1_LB  
define STAIRS     = PS4_L2;//XB1_LT  
define FLOOR      = PS4_R1;//XB1_RB  
define WALL       = PS4_R2;//XB1_RT                                             
define CROUCH     = PS4_R3;//XB1_RS  
define JUMP       = PS4_CROSS;//XB1_A  
define PICKAXE    = PS4_TRIANGLE;//XB1_Y  
// PUT YOUR BUTTONS HERE BELOW IF DIFFERENT  
define RESET      = PS4_R3;//RESET IN GAME (EDIT MODE)   
define SELECT     = PS4_R2;//SELECT IN GAME (EDIT MODE)  
define CONFIRM    = PS4_CIRCLE;//CONFIRM IN GAME (EDIT MODE)
// PUT YOUR BUTTONS HERE BELOW IF DIFFERENT
define EDIT_BUTTON        = PS4_CIRCLE;//EDIT BUTTON IN GAME(MAY HAVE HOLD TIME ON THIS ENTER ON/OFF BELOW THIS OPTION >> define EDIT_BUTTON_HOLD   =  ON<img src="images/smilies/animated/wink_20_anim.gif" border="0" alt="" title="Wink" class="inlineimg" />
define FAST_RESET_EDIT    = PS4_L3;//EDIT BUTTON IN GAME CANNOT HAVE HOLD TIME (USED IN COMBOS)
define EDIT_ASSIST_BUTTON = PS4_L3;//EDIT BUTTON IN GAME CANNOT HAVE HOLD TIME (USED AS EDIT ASSIT BUTTON)
define FAST_RESET_BUTTON  = PS4_TOUCH;//ONE BUTTON RESET DOES MATCH IN GAME TO ANYTHING
// PUT YOUR HOLD TIME ON/OFF & HOLD TIME HERE BELOW IF DIFFERENT
define EDIT_BUTTON_HOLD   =  ON;//IF YOU HAVE HOLD TIME ON YOU EDIT BUTTON (SEPERATE FROM EDIT ASSIST BUTTON)
define EDIT_HOLD_WAIT     = 130;//IF YOU HAVE HOLD TIME ON YOU EDIT BUTTON MATCH THE TIME
// ADJUST EDIT SENSE HERE BELOW IF YOU FEEL ITS TO FAST OR SLOW (DOES NOT MATCH ANYTHING IN GAME)
define EDIT_SENSE    =  ON;//IF YOU WANT EDIT SENSITIVITY CONTROL USE THESE TWO SETTINGS (ON/OFF HERE)
define EDIT_SENSITIVITY   =  56;//SET IN GAME EDIT SENSE TO MAXIMUM SENSE 5.0X (SET 0 - 100)
define EXPO               =  11000;//IF USING EXPONENTIAL LEAVE AT 11000 (IF LINEAR SET IN GAME SET TO OFF OR 0 (ZER0))
define LINEAR             =  18000;//IF USING EXPONENTIAL OR LINEAR LEAVE AT 18000 (IF LINEAR IN GAME AND QUICK EDIT DOES NOT WORK ADJUSTMENT HERE 32767 = 100)
// PUT YOUR TIMES HERE BELOW IF YOU WISH TO (SHOULD NOT NEED ADJUSTING)
define DELAY1             =  30;//DELAY BEFORE EDIT ASSIST BUTTON TRIGGERS HOLDING OF SELECT
define WALL_REPLACE_WAIT  =  40;//WALL REPLACE TIME (WAIT TIME BETWEEN PRESSING BUILD THEN WALL) 
// PUT YOUR BUTTONS HERE BELOW IF DIFFERENT OR YOU WANT TO CHANGE
define JUMPSHOT_HOLD_TOGGLE    = AIM,     JUMPSHOT_PRESS_TOGGLE    = JUMP,   JUMPSHOT_ISOLATE  = CROUCH;
define DROPSHOT_HOLD_TOGGLE    = AIM,     DROPSHOT_PRESS_TOGGLE    = CROUCH, DROPSHOT_ISOLATE  = JUMP;
define RAPIDFIRE_HOLD_TOGGLE   = AIM,     RAPIDFIRE_PRESS_TOGGLE   = UP;
define SMARTFIRE_HOLD_TOGGLE   = AIM,     SMARTFIRE_PRESS_TOGGLE   = RIGHT;
define PUMPWALL_HOLD_TRIGGER   = AIM,     PUMPWALL_PRESS_TRIGGER   = R1;
define PUMPFLOOR_HOLD_TRIGGER  = AIM,     PUMPFLOOR_PRESS_TRIGGER  = SQUARE;
define GHOSTPEEK_HOLD_TRIGGER  = AIM,     GHOSTPEEK_PRESS_TRIGGER  = DOWN;
define SMARTFIRE_HOLD_TRIGGER  = AIM,     SMARTFIRE_PRESS_TRIGGER  = LEFT;
define WALLTAKE_HOLD_TRIGGER   = FIRE,    WALLTAKE_PRESS_TRIGGER   = PREVWEAPON;
define TUNNELBOX_HOLD_TRIGGER  = PICKAXE, TUNNELBOX_PRESS_TRIGGER  = NEXTWEAPON;
define QUICK_EDIT_HOLD_TRIGGER = AIM,     QUICK_EDIT_PRESS_TRIGGER = OPTIONS;
define RAMPFLOORWALL_PRESS_TRIGGER = LEFT;
define FLOORROOF_PRESS_TRIGGER     = FLOOR;
define BUNNYRAMP_PRESS_TRIGGER     = JUMP;
define TUNNELLING_PRESS_TRIGGER    = OPTIONS;
define DOUBLEEDIT_PRESS_TRIGGER    = NEXTWEAPON;
// PUT YOUR TIMES HERE BELOW IF YOU WISH TO (SHOULD NOT NEED ADJUSTING)(DOUBLE TAP TIME)
define FLOORROOF     = 800; 
define BUNNYRAMP     = 800; 
// PUT YOUR BUTTONS HERE BELOW IF DIFFERENT OR YOU WANT TO CHANGE
define MENU_HOLD_BUTTON  = L2;
define MENU_PRESS_BUTTON = PS;
define MENU_SWAP_BUTTON  = R3;
// NO NEED TO ALTER BELOW HERE
define MENU_TIMEOUT_  = 25000;
define SWITCH_MINIMUM = 1,SWITCH_MAXIMUM = 26;
define IDX_MIN = 1,IDX_MAX = 26;
define TIMES_VALUES = ON;
define SWITCH_MIN = 0,SWITCH_MAX = 1;
// PUT YOUR VALUES HERE BELOW WHERE LABELLED IF YOU WANT TO
define VMCR   =  0;// VIRTUAL MACHINE TIME 
define AAMIN  = -5;// PROGRESSION NEGITIVE (MINIMUM)  
define AAMAX  =  5;// PROGRESSION POSITIVE (MAXIMUM)  
define AAVAL  =  5;// PROGRESSION STEP VALUE   
define AAWMIN =  1;// PROGRESSION WAIT (MINIMUM)  
define AAWMAX =  2;// PROGRESSION WAIT (MAXIMUM)   
define AAWVAL =  1;// PROGRESSION WAIT STEP TIME 
// NO NEED TO ALTER BELOW HERE
int AS = AAMIN;  
int AW = AAWMIN;
int PROG;
int AAS = 1;   
int AAD = 1; 
// NO NEED TO ALTER BELOW HERE
int AIM_SETTINGS,TOGGLES,IDX,SWITCH,CHANGE,NO = ON,ADJUST,TAP,BUILDTRACK,RF;
int MENU,MENU_TIMEOUT,SPEED,SHUNT,SHUNT1,EDIT,EDIT1,PA,HOLD1,COUNT,WALLREPLACE;
// NO NEED TO ALTER BELOW HERE
int POLAR_RADIUS,POLAR_ANGLE,POLAR_BOOST,POLAR,A_B_S,POLAR_SHAKE,POLAR_RELEASE;
int ARC,ARC_V,ARC__VAL,ARC____VAL,ARC_VAL,ARC___VAL,DIVIDE,RECOIL_RELEASE;
int VMC,D_AS,D___AS,D_AS1,D__AS,D__AS1,POSI,NEGI,WA;
// NO NEED TO ALTER BELOW HERE
int POLAR_ASSIST,DoGz_AIM_ASSIST,PROGRESSION_ASSIST,PROGRESSION_RELEASE,VM,DASR;
int DoGz_ANTIRECOIL,GHOSTPEEK,PUMPWALL,PUMPWALLSWAP,PUMPFLOOR,PUMPFLOORSWAP;
int DROPSHOT,JUMPSHOT,RAPIDFIRE,SMARTFIRE,WALL_REPLACE,EDIT_SHOT,QUICK_EDIT;
int TUNNEL,FAST_RESET,EDIT_ASSIST,INSTANT_EDIT_RESET,INSTANT_PICKAXE;
int TUNNEL_BOX,BUNNY_RAMP,RAMP_FLOOR_WALL,FLOOR_ROOF;
int GHOST_PEEK_WAIT,RAPID_FIRE_WAIT,SMART_FIRE_WAIT;
int PUMPWALL_WAIT,PUMPFLOOR_WAIT,DROP_SHOT_WAIT,JUMPSHOT_WAIT;
// NO NEED TO ALTER BELOW HERE
const string A   = "   POLAR RADIUS";
const string B   = "   POLAR ANGLE";
const string C   = "POLAR FIRE BOOST";
const string D   = "POLAR FIRE SHAKE";
const string E   = "POL ACTUAL INPUT/";
const string F   = "  POLAR RELEASE";
const string G   = "  DoGz ASSIST +";
const string H   = "  DoGz ASSIST -";
const string I   = "DoGz ASSIST INV";
const string J   = "DoGz ASSIST OFF";
const string K   = "VM ZEN SPEED TIME";
const string L   = "PROGRESSION AIM+";
const string M   = "PROGRESSION AIM-";
const string N   = "PROGRESSION WAIT";
const string O   = "PROGRESSION OFF";
const string P   = " DROP SHOT WAIT";
const string Q   = "  JUMPSHOT WAIT";
const string R   = " RAPID FIRE WAIT";
const string S   = " SMART FIRE WAIT";
const string T   = " GHOST PEEK WAIT";
const string U   = "  PUMPWALL WAIT";
const string V   = " PUMPFLOOR WAIT";
const string W   = " DoGz ANTIRECOIL";
const string X   = "DoGz RECOIL INV";
const string Y   = "DOGZ RECOIL DIV";
const string Z   = " RECOIL RELEASE";
// NO NEED TO ALTER BELOW HERE
const string SWITCHAA   = "POLAR AIM ASSIST";
const string SWITCHBB   = " PROG AIM ASSIST";
const string SWITCHCC   = " DoGz AIM ASSIST";
const string SWITCHDD   = "VM ZEN SPEED TIME";
const string SWITCHEE   = " DoGz_ANTIRECOIL";
const string SWITCHFF   = " DROP SHOT ONFIRE";
const string SWITCHGG   = " JUMPSHOT ON FIRE";
const string SWITCHHH   = "RAPID FIRE ONFIRE";
const string SWITCHII   = "SMARTFIRE100%ACC";
const string SWITCHJJ   = " GHOST PEEK SHOT";
const string SWITCHKK   = " PUMP BUILD WALL";
const string SWITCHLL   = "PUMPWALL SWAPGUN";
const string SWITCHMM   = " PUMP FLOOR WALL";
const string SWITCHNN   = "PUMPFLOOR SWAPGUN";
const string SWITCHOO   = "QUICKWALL REPLACE";
const string SWITCHPP   = "RAMP_FLOOR_WALL";
const string SWITCHQQ   = "BUNNY RAMP FLOOR";
const string SWITCHRR   = "QUICK FLOOR_ROOF";
const string SWITCHSS   = "INSTANT FORT BOX";
const string SWITCHTT   = "QUICK TUNNELLING";
const string SWITCHUU   = "   QUICK EDIT";
const string SWITCHVV   = "    EDIT SHOT";
const string SWITCHWW   = " INSTANT PICKAXE";
const string SWITCHXX   = "    FAST RESET";
const string SWITCHYY   = "QUICKEDIT ASSIST";
const string SWITCHZZ   = "INSTANTEDITRESET";
// NO NEED TO ALTER BELOW HERE
const string MENU1      = "MENU1";
const string MENU2      = "MENU2";
const string MOD1       = "MOD1";
const string MOD2       = "MOD2";
const string MOD3       = "MOD3";
const string MOD4       = "MOD4";
const string MOD5       = "MOD5";
const string MOD6       = "MOD6";
const string MOD7       = "MOD7";
const string MOD8       = "MOD8";
const string MOD9       = "MOD9";
const string MOD10      = "MOD10";
const string MOD11      = "MOD11";
const string MOD12      = "MOD12";
const string MOD13      = "MOD13";
const string MOD14      = "MOD14";
const string MOD15      = "MOD15";
const string MOD16      = "MOD16";
const string MOD17      = "MOD17";
const string MOD18      = "MOD18";
const string MOD19      = "MOD19";
const string MOD20      = "MOD20";
const string MOD21      = "MOD21";
const string MOD22      = "MOD22";
const string MOD23      = "MOD23";
const string MOD24      = "MOD24";
const string MOD25      = "MOD25";
const string MOD26      = "MOD26";
const string TOG1       = "ON";
const string TOG0       = "OFF";
const string MODS       = " < >";
const string VALUE      = "v";
const string VALUE1     = "^";
const string MODE0      = " CIRCLE TO EXIT";
const string MODE1      = "TRIANGLE TO EXIT";
const string MODES      = " R3";
// PUT YOUR TIMES/VALUES HERE BELOW IF YOU WISH TO (SHOULD NOT NEED ADJUSTING) CAN ADJUST VIA THE MENU ALSO
// SET DEFAULT TIMES & VALUES COLUMN 1(ROW1)
// SET MINIMUM AND MAXIMUM TIMES & VALUES COLUMN 2&3(ROW2&3)
//THESE SETTINGS ARE MAINLY EXPONENTIAL IF USING LINEAR START YOUR TEST WITH THESE SETTINGS HERE BELOW
//LINEAR SETTINGS FOR AIM ASSIST AND RECOIL COPY OVER IF REQUIRED (MY LINEAR SETTINGS FOR MY SETUP)
// int TIMERA   =    4; //POLAR RADIUS
// int TIMERB   =   15; //POLAR ANGLE
// int TIMERC   =    2; //POLAR BOOST
// int TIMERE   =    3; //ACTUAL INPUT DIVIDE
// int TIMERF   =   10; //POLAR RELEASE
//RECOIL IF USING
// int TIMERX   =   25; //DOGZ RECOIL INVERT VALUE
// PUT YOUR TIMES/VALUES HERE BELOW IF YOU WISH TO (SHOULD NOT NEED ADJUSTING) CAN ADJUST VIA THE MENU ALSO
// |ROW1__________|  ROW2______________________|  ROW3_________________|_TIMER MOD REFERENCE____|
int TIMERA   =    8; define TIMERA_MIN    =    1, TIMERA_MAX    =  100;//POLAR RADIUS
int TIMERB   =   20; define TIMERB_MIN    =    1, TIMERB_MAX    =   50;//POLAR ANGLE  
int TIMERC   =    5; define TIMERC_MIN    =  -30, TIMERC_MAX    =   30;//POLAR BOOST
int TIMERD   =   20; define TIMERD_MIN    =    0, TIMERD_MAX    =   50;//POLAR SHAKE
int TIMERE   =    2; define TIMERE_MIN    =    0, TIMERE_MAX    =    5;//ACTUAL INPUT DIVIDE
int TIMERF   =   15; define TIMERF_MIN    =    5, TIMERF_MAX    =   50;//POLAR RELEASE
int TIMERG   =    5; define TIMERG_MIN    =  -35, TIMERG_MAX    =   35;//DOGZ AIMASSIST +
int TIMERH   =   -5; define TIMERH_MIN    =  -35, TIMERH_MAX    =   35;//DOGZ AIMASSIST -
int TIMERI   =    4; define TIMERI_MIN    =  -50, TIMERI_MAX    =   50;//DOGZ AIMASSIST INVERT
int TIMERJ   =   50; define TIMERJ_MIN    =    0, TIMERJ_MAX    =  100;//DOGZ AIMASSIST RELEASE
int TIMERK   =    0; define TIMERK_MIN    =   -9, TIMERK_MAX    =  100;//VIRTUAL MACHINE ZEN SPEED TIME  
int TIMERL   =    0; define TIMERL_MIN    =  -30, TIMERL_MAX    =   30;//PROGRESSION ASSIST+ 
int TIMERM   =    0; define TIMERM_MIN    =  -30, TIMERM_MAX    =   30;//PROGRESSION ASSIST- 
int TIMERN   =    0; define TIMERN_MIN    =   -2, TIMERN_MAX    =  100;//PROGRESSION WAIT  
int TIMERO   =   15; define TIMERO_MIN    =    8, TIMERO_MAX    =   90;//PROGRESSION RELEASE
int TIMERP   =   50; define TIMERP_MIN    =   10, TIMERP_MAX    =  800;//DROPSHOT
int TIMERQ   =  550; define TIMERQ_MIN    =   50, TIMERQ_MAX    =  800;//JUMPSHOT WAIT
int TIMERR   =   30; define TIMERR_MIN    =   10, TIMERR_MAX    =  800;//RAPID FIRE
int TIMERS   =  250; define TIMERS_MIN    =   10, TIMERS_MAX    =  800;//SMART FIRE
int TIMERT   =  125; define TIMERT_MIN    =   10, TIMERT_MAX    =  800;//GHOSTPEEK
int TIMERU   =   50; define TIMERU_MIN    =   10, TIMERU_MAX    =  500;//PUMP WALL
int TIMERV   =   30; define TIMERV_MIN    =   10, TIMERV_MAX    =  500;//PUMPFLOOR_WAIT
int TIMERW   =   25; define TIMERW_MIN    =    0, TIMERW_MAX    =  100;//DOGZ RECOIL VALUE
int TIMERX   =   50; define TIMERX_MIN    =    0, TIMERX_MAX    =  100;//DOGZ RECOIL INVERT VALUE
int TIMERY   =    3; define TIMERY_MIN    =  -10, TIMERY_MAX    =   20;//DOGZ RECOIL DIVIDE 
int TIMERZ   =   40; define TIMERZ_MIN    =    5, TIMERZ_MAX    =  100;//RECOIL_RELEASE
// PUT YOUR MODS ON/OFF HERE BELOW(CAN ADJUST VIA THE MENU ALSO)
int SWITCHA   =  ON;//POLAR ASSIST
int SWITCHB   = OFF;//PROGRESSION ASSIST 
int SWITCHC   = OFF;//DoGz AIM ASSIST
int SWITCHD   =  ON;//VIRTUAL MACHINE ZEN SPEED TIME
int SWITCHE   =  ON;//DoGz ANTIRECOIL
int SWITCHF   =  ON;//DROP SHOT
int SWITCHG   =  ON;//JUMPSHOT
int SWITCHH   =  ON;//RAPID FIRE
int SWITCHI   =  ON;//SMART FIRE
int SWITCHJ   =  ON;//GHOST PEEK
int SWITCHK   =  ON;//PUMP BUILD WALL
int SWITCHL   =  ON;//PUMP WALL SWAP WEAPON
int SWITCHM   =  ON;//PUMP BUILD FLOOR WALL
int SWITCHN   =  ON;//PUMP FLOOR WALL SWAP WEAPON
int SWITCHO   =  ON;//WALL REPLACE
int SWITCHP   =  ON;//RAMP FLOOR WALL
int SWITCHQ   =  ON;//BUNNY RAMP FLOOR
int SWITCHR   =  ON;//FLOOR ROOF 
int SWITCHS   =  ON;//TUNNEL BOX
int SWITCHT   =  ON;//TUNNELLING
int SWITCHU   =  ON;//QUICK EDIT HALF ARCH/STAIRS
int SWITCHV   =  ON;//WINDOW EDIT SHOT
int SWITCHW   =  ON;//INSTANT PICKAXE
int SWITCHX   =  ON;//FAST RESET
int SWITCHY   =  ON;//EDIT ASSIST
int SWITCHZ   =  ON;//INSTANT EDIT RESET
// PUT YOUR MODS ON/OFF HERE BELOW
int POLAR_BOOST_FIRE =  ON;//BOOST POLAR AIM ASSIST ON FIRE(WHEN AIMING & SHOOTING)
int POLAR_SHAKE_FIRE =  ON;//SHAKE POLAR AIM ASSIST ON FIRE(WHEN AIMING & SHOOTING)
int TOUCHPAD_SWAP    = OFF;//PS4 CONTROLLER ON PC SET TO 360 PROTOCOL(SWAPS TOUCHPAD AND SHARE BUTTONS)
int PS_OPTIONS       = OFF;//PS4 CONTROLLER ON PC SET TO 360 PROTOCOL(USE PS BUTTON AS OPTIONS BUTTON)(ALLOWS OPTIONS TO BE USED FOR A MOD TRIGGER AND PROGRAMMED TO A PADDLE)
// PUT YOUR MODS ON/OFF BY DEFAULT HERE BELOW 
int RAPID_FIRE = OFF;//RAPID FIRE ON/OFF BY DEFAULT (TOGGLE ON/OFF IN GAME)(IF ON ENSURE THIS SWITCH ABOVE IS ON == int SWITCHH = ON;//RAPID FIRE)
int SMART_FIRE = OFF;//SMART FIRE ON/OFF BY DEFAULT (TOGGLE ON/OFF IN GAME)(IF ON ENSURE THIS SWITCH ABOVE IS ON == int SWITCHI = ON;//SMART FIRE)
int DROP_SHOT  = OFF;//DROP SHOT  ON/OFF BY DEFAULT (TOGGLE ON/OFF IN GAME)(IF ON ENSURE THIS SWITCH ABOVE IS ON == int SWITCHF = ON;//DROP SHOT)
int JUMP_SHOT  = OFF;//JUMP SHOT  ON/OFF BY DEFAULT (TOGGLE ON/OFF IN GAME)(IF ON ENSURE THIS SWITCH ABOVE IS ON == int SWITCHG = ON;//JUMPSHOT)
main {
 
 block_rumble();
if (TOUCHPAD_SWAP) {
 swap (TOUCH,SHARE);
 }
if (PS_OPTIONS && !get_ival(L2) && get_ival(PS)) {
 set_val(OPTIONS,100);
 set_val(PS,0);
 }
if (TIMES_VALUES == ON) {
 POLAR_RADIUS        = TIMERA;
 POLAR_ANGLE         = TIMERB;
 POLAR_BOOST         = TIMERC;
 POLAR_SHAKE         = TIMERD;
 A_B_S               = TIMERE;
 POLAR_RELEASE       = TIMERF;
 D___AS           = TIMERG;
 D_AS1               = TIMERH;
 D__AS1              = TIMERI;
 DASR                = TIMERJ;
 VMC                 = TIMERK;
 POSI                = TIMERL;
 NEGI       = TIMERM;
 WA                  = TIMERN;
 PROGRESSION_RELEASE = TIMERO;
 DROP_SHOT_WAIT   = TIMERP;
 JUMPSHOT_WAIT       = TIMERQ;
 RAPID_FIRE_WAIT  = TIMERR;
 SMART_FIRE_WAIT  = TIMERS;
 GHOST_PEEK_WAIT  = TIMERT;
 PUMPWALL_WAIT    = TIMERU;
 PUMPFLOOR_WAIT   = TIMERV;
 ARC_VAL             = TIMERW;
 ARC___VAL         = TIMERX;
 DIVIDE             = TIMERY;
 RECOIL_RELEASE     = TIMERZ;
 
 POLAR_ASSIST        = SWITCHA;
 PROGRESSION_ASSIST = SWITCHB;
 DoGz_AIM_ASSIST     = SWITCHC;
 VM                  = SWITCHD;
 DoGz_ANTIRECOIL     = SWITCHE;
 DROPSHOT            = SWITCHF;
 JUMPSHOT      = SWITCHG;
 RAPIDFIRE   = SWITCHH;
 SMARTFIRE      = SWITCHI;
 GHOSTPEEK      = SWITCHJ;
 PUMPWALL   = SWITCHK;
 PUMPWALLSWAP        = SWITCHL;
 PUMPFLOOR      = SWITCHM;
 PUMPFLOORSWAP       = SWITCHN;
 WALL_REPLACE        = SWITCHO;
 RAMP_FLOOR_WALL     = SWITCHP;
 BUNNY_RAMP          = SWITCHQ;
 FLOOR_ROOF          = SWITCHR;
 TUNNEL_BOX          = SWITCHS;    
 TUNNEL              = SWITCHT;
 QUICK_EDIT          = SWITCHU;
 EDIT_SHOT           = SWITCHV;
 INSTANT_PICKAXE     = SWITCHW;
 FAST_RESET   = SWITCHX;
 EDIT_ASSIST   = SWITCHY;
 INSTANT_EDIT_RESET = SWITCHZ;
 }
if (get_ival(MENU_HOLD_BUTTON) && get_ival(MENU_PRESS_BUTTON)) {
 MENU = ON;
 AIM_SETTINGS = ON;
 IDX = ON;
 NAME();
 BLOCK (MENU_HOLD_BUTTON);
 BLOCK (MENU_PRESS_BUTTON);
}
if (MENU) {
if (AIM_SETTINGS || TOGGLES) {  
 MENU_TIMEOUT += get_rtime();
 }
if (get_ival(UP) || get_ival(DOWN) || get_ival(LEFT) || get_ival(RIGHT) || get_ival(MENU_SWAP_BUTTON)) {
 MENU_TIMEOUT = OFF;
 }
if (MENU_TIMEOUT >= MENU_TIMEOUT_) {
 cls_oled(BLACK);
 MENU = OFF;
 AIM_SETTINGS = OFF;
 TOGGLES = OFF;
 IDX = OFF;
 SWITCH = OFF;
 combo_stop (EXIT);
 MENU_TIMEOUT = OFF;
}
if (event_press(MENU_SWAP_BUTTON)) {
if (AIM_SETTINGS) {
 TOGGLES = ON;
 AIM_SETTINGS = OFF;
 IDX = OFF;
 SWITCH = ON;
 SWITCHES ();
}
else if (TOGGLES) {
 AIM_SETTINGS = ON;
 TOGGLES = OFF;
 SWITCH = OFF;
 IDX = ON;
 NAME();
 }
 SHUNT = MENU_SWAP_BUTTON;
}  
if (event_press(TRIANGLE) || event_press(CIRCLE)) {
 MENU = OFF;
 AIM_SETTINGS = OFF;
 TOGGLES = OFF;
 IDX = OFF;
 SWITCH = OFF;
 combo_stop (EXIT);
 cls_oled(BLACK);
 SHUNT = TRIANGLE;
 SHUNT1 = CIRCLE;
}
if (AIM_SETTINGS) {
 IDX = ADJUSTA(IDX,IDX_MIN,IDX_MAX,SINGLE,IDX);
if (IDX == 1) {
 TIMERA = ADJUST(TIMERA,TIMERA_MIN,TIMERA_MAX,SINGLE,IDX);
    }
if (IDX == 2) {
 TIMERB = ADJUST(TIMERB,TIMERB_MIN,TIMERB_MAX,SINGLE,IDX);
    }
if (IDX == 3) {
 TIMERC = ADJUST(TIMERC,TIMERC_MIN,TIMERC_MAX,SINGLE,IDX);
    }
if (IDX == 4) {
 TIMERD = ADJUST(TIMERD,TIMERD_MIN,TIMERD_MAX,SINGLE,IDX);
    }
if (IDX == 5) {
 TIMERE = ADJUST(TIMERE,TIMERE_MIN,TIMERE_MAX,SINGLE,IDX);
    }
if (IDX == 6) {
 TIMERF = ADJUST(TIMERF,TIMERF_MIN,TIMERF_MAX,SINGLE,IDX);
    }
if (IDX == 7) {
 TIMERG = ADJUST(TIMERG,TIMERG_MIN,TIMERG_MAX,SINGLE,IDX);
    }
if (IDX == 8) {
 TIMERH = ADJUST(TIMERH,TIMERH_MIN,TIMERH_MAX,SINGLE,IDX);
    }
if (IDX == 9) {
 TIMERI = ADJUST(TIMERI,TIMERI_MIN,TIMERI_MAX,SINGLE,IDX);
    }
if (IDX == 10) {
 TIMERJ = ADJUST(TIMERJ,TIMERJ_MIN,TIMERJ_MAX,SINGLE,IDX);
    }
if (IDX == 11) {
 TIMERK = ADJUST(TIMERK,TIMERK_MIN,TIMERK_MAX,SINGLE,IDX);
    }
if (IDX == 12) {
 TIMERL = ADJUST(TIMERL,TIMERL_MIN,TIMERL_MAX,SINGLE,IDX);
    }
if (IDX == 13) {
 TIMERM = ADJUST(TIMERM,TIMERM_MIN,TIMERM_MAX,SINGLE,IDX);
    }
if (IDX == 14) {
 TIMERN = ADJUST(TIMERN,TIMERN_MIN,TIMERN_MAX,SINGLE,IDX);
    }
if (IDX == 15) {
 TIMERO = ADJUST(TIMERO,TIMERO_MIN,TIMERO_MAX,SINGLE,IDX);
    }
if (IDX == 16) {
 TIMERP = ADJUST(TIMERP,TIMERP_MIN,TIMERP_MAX,SINGLE,IDX);
    }
if (IDX == 17) {
 TIMERQ = ADJUST(TIMERQ,TIMERQ_MIN,TIMERQ_MAX,SINGLE,IDX);
    }
if (IDX == 18) {
 TIMERR = ADJUST(TIMERR,TIMERR_MIN,TIMERR_MAX,SINGLE,IDX);
    }
if (IDX == 19) {
 TIMERS = ADJUST(TIMERS,TIMERS_MIN,TIMERS_MAX,SINGLE,IDX);
    }
if (IDX == 20) {
 TIMERT = ADJUST(TIMERT,TIMERT_MIN,TIMERT_MAX,SINGLE,IDX);
    }
if (IDX == 21) {
 TIMERU = ADJUST(TIMERU,TIMERU_MIN,TIMERU_MAX,SINGLE,IDX);
    }
if (IDX == 22) {
 TIMERV = ADJUST(TIMERV,TIMERV_MIN,TIMERV_MAX,SINGLE,IDX);
    }
if (IDX == 23) {
 TIMERW = ADJUST(TIMERW,TIMERW_MIN,TIMERW_MAX,SINGLE,IDX);
    }
if (IDX == 24) {
 TIMERX = ADJUST(TIMERX,TIMERX_MIN,TIMERX_MAX,SINGLE,IDX);
    }
if (IDX == 25) {
 TIMERY = ADJUST(TIMERY,TIMERY_MIN,TIMERY_MAX,SINGLE,IDX);
    }
if (IDX == 26) {
 TIMERZ = ADJUST(TIMERZ,TIMERZ_MIN,TIMERZ_MAX,SINGLE,IDX);
 }
}
if (TOGGLES) {
if (event_press(RIGHT)) {
 SWITCH += 1;
if (SWITCH > SWITCH_MAXIMUM) 
 SWITCH = SWITCH_MINIMUM; 
 SWITCHES();
}
if (event_press(LEFT)) {
 SWITCH -= 1;
if (SWITCH < SWITCH_MINIMUM) 
 SWITCH = SWITCH_MAXIMUM; 
 SWITCHES();
}
if (SWITCH == 1) {
 SWITCHA = ADJUSTA(SWITCHA,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }         
if (SWITCH == 2) {
 SWITCHB = ADJUSTA(SWITCHB,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 3) {
 SWITCHC = ADJUSTA(SWITCHC,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }          
if (SWITCH == 4) {
 SWITCHD = ADJUSTA(SWITCHD,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 5) {
 SWITCHE = ADJUSTA(SWITCHE,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }          
if (SWITCH == 6) {
 SWITCHF = ADJUSTA(SWITCHF,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 7) {
 SWITCHG = ADJUSTA(SWITCHG,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }          
if (SWITCH == 8) {
 SWITCHH = ADJUSTA(SWITCHH,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 9) {
 SWITCHI = ADJUSTA(SWITCHI,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }          
if (SWITCH == 10) {
 SWITCHJ = ADJUSTA(SWITCHJ,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 11) {
 SWITCHK = ADJUSTA(SWITCHK,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }          
if (SWITCH == 12) {
 SWITCHL = ADJUSTA(SWITCHL,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 13) {
 SWITCHM = ADJUSTA(SWITCHM,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }          
if (SWITCH == 14) {
 SWITCHN = ADJUSTA(SWITCHN,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 15) {
 SWITCHO = ADJUSTA(SWITCHO,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }         
if (SWITCH == 16) {
 SWITCHP = ADJUSTA(SWITCHP,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 17) {
 SWITCHQ = ADJUSTA(SWITCHQ,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }         
if (SWITCH == 18) {
 SWITCHR = ADJUSTA(SWITCHR,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 19) {
 SWITCHS = ADJUSTA(SWITCHS,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }         
if (SWITCH == 20) {
 SWITCHT = ADJUSTA(SWITCHT,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 21) {
 SWITCHU = ADJUSTA(SWITCHU,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }         
if (SWITCH == 22) {
 SWITCHV = ADJUSTA(SWITCHV,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 23) {
 SWITCHW = ADJUSTA(SWITCHW,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }         
if (SWITCH == 24) {
 SWITCHX = ADJUSTA(SWITCHX,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
if (SWITCH == 25) {
 SWITCHY = ADJUSTA(SWITCHY,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }          
if (SWITCH == 26) {
 SWITCHZ = ADJUSTA(SWITCHZ,SWITCH_MIN,SWITCH_MAX,SINGLE,SWITCH);
    }
}
 BLOCK(DOWN); BLOCK(UP); BLOCK(LEFT); BLOCK(RIGHT);
}
if (!MENU && EDIT_ASSIST) {
if (get_ival(EDIT_ASSIST_BUTTON)) {
 ASSIST();
 EDIT = ON;
}
if (event_release (EDIT_ASSIST_BUTTON)) {
 combo_run (CONFIRM);
 HOLD1 = OFF;
 EDIT = OFF;
 }
}
if (!MENU && FAST_RESET) {
if (!get_ival(L2) && event_press(FAST_RESET_BUTTON)) { 
if (EDIT_SENSE) { 
 stickize (RX,RY,EDIT_SENSITIVITY);
 }
    SHUNT = FAST_RESET_BUTTON;
    combo_run(RESET);
 }
}
if (!MENU && INSTANT_EDIT_RESET) {
if (EDIT_BUTTON_HOLD) {
if (get_ival(EDIT_BUTTON) && get_ptime(EDIT_BUTTON) > EDIT_HOLD_WAIT) {
 EDIT  = ON;
 EDIT1 = ON;
 }
}
else if (!EDIT_BUTTON_HOLD) {
if (get_ival(EDIT_BUTTON)) {
 EDIT  = ON;
 EDIT1 = ON;
 }
}
if (EDIT1 == ON) {
if (event_release(SELECT)) {  
    combo_run (CONFIRM);
    EDIT  = OFF;
    EDIT1 = OFF;
    }
if (event_press(DOUBLEEDIT_PRESS_TRIGGER)) {
 SHUNT = DOUBLEEDIT_PRESS_TRIGGER;
 combo_run(DOUBLE);
 EDIT = OFF;
 EDIT1 = OFF;
  }    
    }
}
if (EDIT == ON || EDIT1 == ON) {
if (EDIT_SENSE) { 
 stickize (RX,RY,EDIT_SENSITIVITY);
 }
if (event_press(RESET)) {  
    combo_run (RESETS);
    EDIT = OFF; 
}
if (event_press(PICKAXE) || event_press(BUILD) || event_press(FLOOR) || event_press(ROOF)|| event_press(STAIRS)) {
 EDIT  = OFF;
 EDIT1 = OFF;
 }
}
if (PROGRESSION_ASSIST && get_ival(AIM) >= 80) {
if (!combo_running(AAS)) {
 AS = PROGRESSION(AS,AAMIN + NEGI,AAMAX + POSI,AAVAL,AAS,1);
    AW = PROGRESSION(AW,AAWMIN,AAWMAX + WA,AAWVAL,AAD,2);
    combo_run(AAS);
     }
if (abs(get_ival(RY))> PROGRESSION_RELEASE || abs(get_ival(RX)) > PROGRESSION_RELEASE) {
 combo_stop(AAS);
 }
}
if (POLAR_ASSIST && get_ival(AIM) && abs(get_ival(RX)) <= POLAR_RELEASE && abs(get_ival(RY)) <= POLAR_RELEASE) {
if (POLAR_BOOST_FIRE && get_ival(FIRE)) {
 POLAR_RADIUS = POLAR_RADIUS + POLAR_BOOST;
 }
 else {
 POLAR_RADIUS = POLAR_RADIUS;
 }
if (POLAR_SHAKE_FIRE && get_ival(FIRE)) {
 POLAR_ANGLE = POLAR_ANGLE + POLAR_SHAKE;
 }
 else {
 POLAR_ANGLE = POLAR_ANGLE;
 }    
    set_polar(RS,SPEED = (SPEED + POLAR_ANGLE) % 360,abs(get_ival(PRX)) / A_B_S + POLAR_RADIUS * 328);
}
if (DoGz_AIM_ASSIST && abs(get_ival(RX)) < DASR && abs(get_ival(RY)) < DASR) {
if (get_ival(AIM) > 80) {
 D_AS = ON;
 AIM();
}
if(event_release(AIM) || event_release(FIRE)){
 D_AS = OFF;
 vm_tctrl(VMCR); 
 }
}
if (!MENU && INSTANT_PICKAXE) {
if (get_ival(PICKAXE)) {
 PA = ON;
 }
if(event_press(AIM)|| get_ival(NEXTWEAPON)|| get_ival(PREVWEAPON)) {
 PA = OFF;
 }                                                                                                                   
if(get_ival(PICKAXE)) {
 PA = ON;
 }
if(PA == ON) {
if(get_ival(BUILD)) { 
 PA = OFF;
 }
if(event_release(FIRE)) {
 combo_run (PICKAXE);
  }
 }
}
if (!MENU && DROPSHOT && get_ival(DROPSHOT_HOLD_TOGGLE) && event_press(DROPSHOT_PRESS_TOGGLE)) {
 DROP_SHOT = !DROP_SHOT;
 JUMP_SHOT = OFF;
}
if (!MENU && DROPSHOT && DROP_SHOT) {
if (!EDIT && !get_ival(EDIT_ASSIST_BUTTON) && get_ival(FIRE)) {
 combo_run(DROPSHOT);
 }
if (event_press(DROPSHOT_ISOLATE) || event_press(BUILD)) {
 DROP_SHOT = OFF;
 }
}
if (!MENU && PUMPWALL && get_ival(PUMPWALL_HOLD_TRIGGER) && event_press(PUMPWALL_PRESS_TRIGGER)) {
 SHUNT = PUMPWALL_PRESS_TRIGGER;
 combo_run(PUMPWALL);
}
if (PUMPFLOOR && get_ival(PUMPFLOOR_HOLD_TRIGGER) && event_press(PUMPFLOOR_PRESS_TRIGGER)) {
 SHUNT = PUMPFLOOR_PRESS_TRIGGER;
 combo_run(PUMPFLOOR);
}
if (!MENU && GHOSTPEEK && get_ival(GHOSTPEEK_HOLD_TRIGGER) && get_ival(GHOSTPEEK_PRESS_TRIGGER)) {
 BLOCK(GHOSTPEEK_PRESS_TRIGGER);
 combo_run(GHOSTPEEK);
}
if (!MENU && RAPIDFIRE && get_ival(RAPIDFIRE_HOLD_TOGGLE) && event_press(RAPIDFIRE_PRESS_TOGGLE)) { 
 SHUNT = RAPIDFIRE_PRESS_TOGGLE;
 RAPID_FIRE = !RAPID_FIRE;
 SMART_FIRE = OFF
}                                                      
if (!MENU && RAPIDFIRE && RAPID_FIRE && !EDIT && !get_ival(EDIT_ASSIST_BUTTON) && get_ival(R2)) {                                  
 combo_run(RAPID_FIRE);
}
if (!MENU && SMARTFIRE && get_ival(SMARTFIRE_HOLD_TOGGLE) && event_press(SMARTFIRE_PRESS_TOGGLE)) { 
 SHUNT = SMARTFIRE_PRESS_TOGGLE;
 SMART_FIRE = !SMART_FIRE;
 RAPID_FIRE = OFF;
}
if (!MENU && SMARTFIRE && !EDIT && !get_ival(EDIT_ASSIST_BUTTON) &&  get_ival(SMARTFIRE_HOLD_TRIGGER) && get_ival(SMARTFIRE_PRESS_TRIGGER)
 || !MENU && SMARTFIRE && SMART_FIRE && !EDIT && !get_ival(EDIT_ASSIST_BUTTON) && get_ival(R2)) { 
 BLOCK (SMARTFIRE_PRESS_TRIGGER);
 BLOCK (R2);
 combo_run(SMART_FIRE);
}
if (!MENU && JUMPSHOT && get_ival(JUMPSHOT_HOLD_TOGGLE) && event_press(JUMPSHOT_PRESS_TOGGLE)) {
 JUMP_SHOT = !JUMP_SHOT;
 DROP_SHOT = OFF;
} 
if (!MENU && JUMP_SHOT) {
if (!EDIT && !get_ival(EDIT_ASSIST_BUTTON) && get_ival(FIRE)) {
    combo_run(JUMPSHOT); 
} 
if (event_press(JUMPSHOT_ISOLATE) || event_press(BUILD)) {
 JUMP_SHOT = OFF;
  }
    }
if (!MENU && WALL_REPLACE) {
if (get_ival(WALLTAKE_HOLD_TRIGGER) && event_press(WALLTAKE_PRESS_TRIGGER)) {
 SHUNT1 = WALLTAKE_PRESS_TRIGGER;
 combo_run(WALL_REPLACE);
 WALLREPLACE = ON;
 }
if (WALLREPLACE && !combo_running(WALL_REPLACE) && event_release(WALLTAKE_HOLD_TRIGGER)) {
 combo_run(PICKAXE);
 WALLREPLACE = OFF;
 }
}
if (!MENU && TUNNEL_BOX) {
if (get_ival(TUNNELBOX_HOLD_TRIGGER) && event_press(TUNNELBOX_PRESS_TRIGGER)) {
 SHUNT = TUNNELBOX_PRESS_TRIGGER;
 BLOCK (TUNNELBOX_HOLD_TRIGGER);
 combo_run(TUNNELBOX);
 }
}
if (DoGz_ANTIRECOIL) {
if (get_ival (AIM) && get_ival (FIRE) && abs(get_ival(RY)) <= RECOIL_RELEASE && abs(get_ival(RX)) <= RECOIL_RELEASE && get_rumble(VIB_A)) {
 ARC = ON;
 DoGz_ARC();
 }
if (event_release(AIM) || event_release(FIRE)) {
 ARC = OFF;
 }
}
if(!MENU && event_press(BUILD)) {
 BUILDTRACK = !BUILDTRACK; 
}
if(event_press(PICKAXE)) {
 BUILDTRACK = OFF; 
}
if (BUILDTRACK) {
if (!MENU && FLOOR_ROOF) {
    TAP = TAP - get_rtime();
if(event_press(FLOORROOF_PRESS_TRIGGER) && TAP <= OFF) {
    TAP = FLOORROOF;
    }
else 
if(event_press(FLOORROOF_PRESS_TRIGGER) && TAP > OFF) {
    RF = ON;
    combo_run(FLOORROOF);
    }
if (RF && get_ival (FLOORROOF_PRESS_TRIGGER)) {   
     combo_run(FLOORROOF);    
    } 
    else 
    if(event_release(FLOORROOF_PRESS_TRIGGER)) {
    RF = OFF;
    }
}
if (!MENU && RAMP_FLOOR_WALL && !get_ival (AIM) && event_press(RAMPFLOORWALL_PRESS_TRIGGER)) {
 SHUNT = RAMPFLOORWALL_PRESS_TRIGGER;
    combo_run(RAMPFLOORWALL);
}
if (!MENU && BUNNY_RAMP) {
    TAP = TAP - get_rtime();
if(event_press(BUNNYRAMP_PRESS_TRIGGER) && TAP <= OFF) {
    TAP = BUNNYRAMP;}
else 
if(event_press(BUNNYRAMP_PRESS_TRIGGER) && TAP > OFF) {
    combo_run(BUNNYRAMP);
     }
 }
}
if (!MENU && TUNNEL) {
if (!BUILDTRACK || EDIT){
if (!get_ival (AIM) && event_press(TUNNELLING_PRESS_TRIGGER)) {
 SHUNT1 = TUNNELLING_PRESS_TRIGGER;
 combo_run(TUNNEL);
 BUILDTRACK = ON; 
 }
}
else if (BUILDTRACK && !get_ival (AIM) && event_press(TUNNELLING_PRESS_TRIGGER)) {
 SHUNT1 = TUNNELLING_PRESS_TRIGGER;
 combo_run(TUNNELA);
 BUILDTRACK = ON;
 }
}
if (!MENU && QUICK_EDIT) {
if (get_ival (QUICK_EDIT_HOLD_TRIGGER) && event_press(QUICK_EDIT_PRESS_TRIGGER)) {
 BLOCK (QUICK_EDIT_HOLD_TRIGGER);
 SHUNT1 = QUICK_EDIT_PRESS_TRIGGER;
 combo_run(EDIT);
 }
}
if (!MENU && EDIT_SHOT) {
if (get_ival (AIM) && event_press(PICKAXE)) {
 BLOCK (L2);
 SHUNT1 = PICKAXE;
 combo_run(EDITSHOT);
 }
}
if (SHUNT) {
if (event_release(SHUNT)) {
 SHUNT = OFF;
}
else {
 set_val (SHUNT,OFF);
 }
}
if (SHUNT1) {
if (event_release(SHUNT1)) {
 SHUNT1 = OFF;
}
else {
 set_val (SHUNT1,OFF);
  }
 } 
}
combo AAS{
 set_val(RY, 1 * - AS);
 wait(AW);
 set_val(RX, 1 * - AS);
 wait(AW);
 set_val(RY,AS);
 wait(AW);
 set_val(RX,AS);
 wait(AW);
}
combo PUMPWALL {
 set_val(FIRE,100);
 wait(PUMPWALL_WAIT);
  set_val(BUILD,100);
    wait(PUMPWALL_WAIT);
    set_val(WALL,100);
    wait(PUMPWALL_WAIT);
    set_val(BUILD,100);
 wait(50);
 wait(30);
 if (PUMPWALLSWAP == ON) {
 set_val(PREVWEAPON,100);
 }
}
combo PUMPFLOOR {    
 set_val(FIRE,100);
 wait(PUMPFLOOR_WAIT); 
    set_val(BUILD,100);
 wait(PUMPFLOOR_WAIT);
 set_val(JUMP,100);
 wait(PUMPFLOOR_WAIT);
 set_val(FLOOR,100);
 wait(PUMPFLOOR_WAIT);
 set_val(WALL,100);
 wait(PUMPFLOOR_WAIT);
 set_val(BUILD,100);
 if (PUMPFLOORSWAP == ON) {
 set_val(PREVWEAPON,100);
 }
}
combo DROPSHOT {
    wait(DROP_SHOT_WAIT)
 set_val(CROUCH,100);  
 wait(DROP_SHOT_WAIT);
 set_val(CROUCH,OFF);
}
combo GHOSTPEEK {
 set_val(CROUCH,100);
 wait(45);
 set_val(CROUCH,OFF);
 wait(65);
 set_val(FIRE,100);
 wait(15); 
 wait(10);
 set_val(CROUCH,100);
 wait(15);
 set_val(CROUCH,OFF); 
 wait(GHOST_PEEK_WAIT);
}
combo RAPID_FIRE {
 set_val(FIRE,100);
 wait(RAPID_FIRE_WAIT);
 set_val(FIRE,0);
 wait(RAPID_FIRE_WAIT);
}
combo SMART_FIRE {
 set_val(FIRE,100);
 wait(100);
 wait(SMART_FIRE_WAIT);
 set_val(FIRE,100);
}
combo JUMPSHOT {                   
    set_val(JUMP,100); 
    wait(50);  
    wait(JUMPSHOT_WAIT); 
}
combo WALL_REPLACE {
 wait(10);
 set_val (FIRE,100);
 wait(WALL_REPLACE_WAIT);
 set_val(BUILD,100);
 wait(WALL_REPLACE_WAIT);
 set_val(WALL,100);
 wait(WALL_REPLACE_WAIT);
 set_val(BUILD,100);
 wait(10);
}
combo DOUBLE {
 set_val(SELECT,100);
 wait(20);
 set_val(SELECT,OFF);
 wait(12);
 wait(100);
 set_val(EDIT_ASSIST_BUTTON,100);
 wait(20);
 set_val(SELECT,100);
 wait(12);
 set_val(SELECT,OFF);
 set_val(EDIT_ASSIST_BUTTON,OFF);
 wait(8);
}
combo CONFIRM {
 set_val(CONFIRM,100);
 wait(50);
 set_val(CONFIRM,0);
 wait(100);
}
combo PICKAXE {
 set_val(PICKAXE,100);
 wait(30);
 PA = OFF;
}
combo RESET {
 set_val(FAST_RESET_EDIT,100);
 wait(50)
 set_val(RESET,100);  
 wait(50);
 combo_run(CONFIRM);
}
combo RESETS {
 wait(20)
 combo_run(CONFIRM);
}
combo TUNNEL {
 wait(40);
 set_val(BUILD,100);
 wait(40);
 set_val(FLOOR,100);
 set_val(10,90);
 set_val(9,0);
 wait(45);
 set_val(FLOOR,100);
 set_val(10,-90);
 set_val(9,0);
 wait(100);
 set_val(FLOOR,100);
 set_val(10,90);
 set_val(9,0);
 wait(45);
 set_val(10,0);
 set_val(9,100);
 wait(70);
 set_val(WALL,100);
 wait(50);
 set_val(WALL,0);
 set_val(10,0);
 set_val(9,-100);
 wait(140);
 set_val(WALL,100);
 wait(50);
 set_val(WALL,0);
 set_val(10,0);
 set_val(9,100);
 wait(70);
 EDIT  = OFF;
 EDIT1 = OFF;
 BUILDTRACK = ON;
}
combo TUNNELA {
 wait(40);
 set_val(FLOOR,100);
 set_val(10,90);
 set_val(9,0);
 wait(45);
 set_val(FLOOR,100);
 set_val(10,-90);
 set_val(9,0);
 wait(100);
 set_val(FLOOR,100);
 set_val(10,90);
 set_val(9,0);
 wait(45);
 set_val(10,0);
 set_val(9,100);
 wait(70);
 set_val(WALL,100);
 wait(50);
 set_val(WALL,0);
 set_val(10,0);
 set_val(9,-100);
 wait(140);
 set_val(WALL,100);
 wait(50);
 set_val(WALL,0);
 set_val(10,0);
 set_val(9,100);
 wait(70); 
 EDIT  = OFF;
 EDIT1 = OFF;
}
combo EDIT {
 set_val(EDIT_ASSIST_BUTTON,100);
 wait(20);
 set_val(SELECT,100);
 set_polar(RS,90,LINEAR + EXPO);
 wait(10);
 set_val(SELECT,100);
 set_polar(RS,135,LINEAR + EXPO);
 wait(10);
 set_val(SELECT,100);
 set_polar(RS,180,LINEAR + EXPO);
 wait(10);
 set_val(SELECT,100);
 set_polar(RS,225,LINEAR + EXPO);
 wait(10);
 set_val(SELECT,100);
 set_polar(RS,270,LINEAR + EXPO);
 wait(10);
 set_val(SELECT,100);
 set_polar(RS,315,LINEAR + EXPO);
 wait(10);
 set_val(SELECT,100);
 set_polar(RS,0,LINEAR + EXPO);
 wait(10);
 set_val(SELECT,100);
 set_polar(RS,45,LINEAR + EXPO);
 wait(10);
 set_val(SELECT,100);
 set_polar(RS,90,LINEAR + EXPO);
 wait(10);
 set_val(CONFIRM,100);
 wait(70);
 BUILDTRACK = OFF;
 EDIT  = OFF;
 EDIT1 = OFF;
}
combo EDITSHOT {
    set_val(EDIT_ASSIST_BUTTON,100);
 wait(12);
 set_val(SELECT,100);
 wait(12);
 set_val(SELECT,OFF);
 set_val(EDIT_ASSIST_BUTTON,OFF);
 wait(12);
 set_val(CONFIRM,100);
 wait(12);
 set_val(CONFIRM,OFF);
    set_val(FIRE,100);
    wait(700);
    set_val(FIRE,OFF);
    set_val(CONFIRM,100);
    wait(40);
    set_val(CONFIRM,OFF);
    wait(50);
    set_val(SELECT,100);
    wait(40);
    set_val(SELECT,OFF);
    set_val(EDIT_ASSIST_BUTTON,100);
    wait(50);
    set_val(EDIT_ASSIST_BUTTON,OFF);
    wait(40);
    set_val(RESET,100);
    wait(40);
    set_val(RESET,OFF);
    set_val(CONFIRM,100);
    wait(40);
    set_val(CONFIRM,OFF);
    wait(10);
    set_val(PICKAXE,100);
    wait(40);
    set_val(PICKAXE,OFF);
    wait(40);
    set_val(PICKAXE,100);
    wait(40);
    set_val(PICKAXE,OFF);
    wait(20);
    BUILDTRACK = OFF;
 EDIT  = OFF;
 EDIT1 = OFF;
}
combo TUNNELBOX {
 wait(20);
 set_val(BUILD,100);
 wait(30);
 set_val(RY,100);
 wait(30);
 set_val(WALL,100);
 set_val(RX,100);
 wait(430);
 set_val(RY,-60);
 wait(50);
 set_val(RY, -100);
 wait(120);
 set_val(FLOOR,100);
 wait(40);
 set_val(RY, 100);
 wait(120);
 set_val(BUILD,100);
 wait(30);
 BUILDTRACK = OFF;
 EDIT  = OFF;
 EDIT1 = OFF;
}
combo RAMPFLOORWALL {                             
 set_val(STAIRS,100);
 wait(100);
 set_val(FLOOR,100);
 wait(110);
 set_val(WALL,100);
 wait(110);
}
combo BUNNYRAMP {
 set_val(JUMP,100);
 wait(50);
 set_val(FLOOR,100);
 wait(50);
 set_val(STAIRS,100);
 wait(50);
}
combo FLOORROOF {
 wait(20);
 set_val(ROOF,100);
 wait(50);
 set_val(FLOOR,0);
 if (RF) {   
    combo_run(FLOORROOF);
    }
}
combo EXIT {
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 40,SMALL,WHITE,MODE0[START]);
 wait(500);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 40,SMALL,WHITE,MODE1[START]);
}
function ASSIST () {
 HOLD1 += get_rtime();
if (get_ival(EDIT_ASSIST_BUTTON)) {
if (HOLD1 >= DELAY1)
   PRESS (SELECT);
   }
}
function PRESS (BUTTON) {
if (get_ival(BUTTON))
  return;
 set_val(BUTTON, 100);
}
function BLOCK (BUTTON) {
if (!get_ival(BUTTON)) 
  return; 
 set_val(BUTTON,OFF);
}
function AIM() {
 if (D_AS) {
 if (D_AS && VM) {
  vm_tctrl(VMC);
 }
  D__AS ++;
 if (D__AS >= D___AS)  D__AS = TIMERI;
  TIMERI --;
 if (TIMERI <= D_AS1)  TIMERI = D__AS;
  D__AS ++;
 if(get_ival(L2)) { 
 set_val (RX,get_ival(RX) + D__AS);
 set_val (RY,get_ival(RY) + D__AS);
 }
 if(get_ival(R2)) { 
 set_val (RX,get_ival(RX) + D__AS);
 set_val (RY,get_ival(RY) + D__AS);
  }
 }
}
function DoGz_ARC () {
 if (ARC){
  ARC__VAL   = ARC_VAL / DIVIDE;
  ARC____VAL = ARC_VAL / DIVIDE;
  ARC_VAL ++;
 if (ARC_VAL + ARC_V >= ARC___VAL + ARC_V)  ARC_VAL = ARC__VAL;
  ARC__VAL --;
 if (ARC__VAL <= ARC____VAL)  ARC__VAL = ARC_VAL;
  ARC_VAL ++;
  set_val (RY,get_ival(RY) + ARC_VAL + ARC_V);
 }
}
function PROGRESSION(VALUE,MIN,MAX,INCREMENT,FLOW,ID) {
    if(FLOW) {
        VALUE += INCREMENT;
    if(VALUE <= MAX)  
    return VALUE;
    if(VALUE > MAX) {
        PROG[ID] = 0;
    return VALUE - INCREMENT;}
}
 else{
        VALUE -= INCREMENT;    
    if(VALUE >= MIN)  
     return VALUE;
    if(VALUE < MIN) {
      PROG[ID] = 1;
         return VALUE + INCREMENT;}
} 
      return OFF;    
}
function NAME () {
 cls_oled(BLACK);
if (AIM_SETTINGS == ON) {
 GRID ();
 printf(TEXT_HORIZONTAL + 83,TEXT_VERTICAL + 15,SMALL,WHITE,MENU1[START]);
 CHANGE = OFF;
 combo_run (EXIT); 
if (IDX == 1) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,A[START]);
 EDITNUMBER(TIMERA,NUMBER(TIMERA));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD1[START]);
}
if (IDX == 2) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,B[START]);
 EDITNUMBER(TIMERB,NUMBER(TIMERB));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD2[START]);
}
if (IDX == 3) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,C[START]);
 EDITNUMBER(TIMERC,NUMBER(TIMERC));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD3[START]);
}
if (IDX == 4) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,D[START]);
 EDITNUMBER(TIMERD,NUMBER(TIMERD));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD4[START]);
}
if (IDX == 5) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,E[START]);
 EDITNUMBER(TIMERE,NUMBER(TIMERE));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD5[START]);
}
if (IDX == 6) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,F[START]);
 EDITNUMBER(TIMERF,NUMBER(TIMERF));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD6[START]);
}
if (IDX == 7) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,G[START]);
 EDITNUMBER(TIMERG,NUMBER(TIMERG));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD7[START]);
}
if (IDX == 8) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,H[START]);
 EDITNUMBER(TIMERH,NUMBER(TIMERH));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD8[START]);
}
if (IDX == 9) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,I[START]);
 EDITNUMBER(TIMERI,NUMBER(TIMERI));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD9[START]);
}
if (IDX == 10) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,J[START]);
 EDITNUMBER(TIMERJ,NUMBER(TIMERJ));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD10[START]);
}
if (IDX == 11) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,K[START]);
 EDITNUMBER(TIMERK,NUMBER(TIMERK));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD11[START]);
}
if (IDX == 12) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,L[START]);
 EDITNUMBER(TIMERL,NUMBER(TIMERL));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD12[START]);
}
if (IDX == 13) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,M[START]);
 EDITNUMBER(TIMERM,NUMBER(TIMERM));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD13[START]);
}
if (IDX == 14) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,N[START]);
 EDITNUMBER(TIMERN,NUMBER(TIMERN));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD14[START]);
}
if (IDX == 15) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,O[START]);
 EDITNUMBER(TIMERO,NUMBER(TIMERO));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD15[START]);
}
if (IDX == 16) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,P[START]);
 EDITNUMBER(TIMERP,NUMBER(TIMERP));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD16[START]);
}
if (IDX == 17) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,Q[START]);
 EDITNUMBER(TIMERQ,NUMBER(TIMERQ));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD17[START]);
}
if (IDX == 18) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,R[START]);
 EDITNUMBER(TIMERR,NUMBER(TIMERR));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD18[START]);
}
if (IDX == 19) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,S[START]);
 EDITNUMBER(TIMERS,NUMBER(TIMERS));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD19[START]);
}
if (IDX == 20) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,T[START]);
 EDITNUMBER(TIMERT,NUMBER(TIMERT));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD20[START]);
}
if (IDX == 21) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,U[START]);
 EDITNUMBER(TIMERU,NUMBER(TIMERU));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD21[START]);
}
if (IDX == 22) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,V[START]);
 EDITNUMBER(TIMERV,NUMBER(TIMERV));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD22[START]);
}
if (IDX == 23) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,W[START]);
 EDITNUMBER(TIMERW,NUMBER(TIMERW));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD23[START]);
}
if (IDX == 24) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,X[START]);
 EDITNUMBER(TIMERX,NUMBER(TIMERX));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD24[START]);
}
if (IDX == 25) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,Y[START]);
 EDITNUMBER(TIMERY,NUMBER(TIMERY));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD25[START]);
}
if (IDX == 26) {
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,Z[START]);
 EDITNUMBER(TIMERZ,NUMBER(TIMERZ));
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD26[START]);
  } 
 }
}
function SWITCHES () { 
 cls_oled(BLACK);
if (TOGGLES == ON) {
 GRID ();
 printf(TEXT_HORIZONTAL + 83,TEXT_VERTICAL + 15,SMALL,WHITE,MENU2[START]);
 CHANGE = OFF;
 combo_run (EXIT);
if (SWITCH == 1) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHAA[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD1[START]);
if (SWITCHA) {
 SWITCHER(SWITCHA);
 }
if (!SWITCHA)
 SWITCHER(SWITCHA);
}
if (SWITCH == 2) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHBB[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD2[START]);
if (SWITCHB) {
 SWITCHER(SWITCHB);
 }
if (!SWITCHB)
 SWITCHER(SWITCHB);
} 
if (SWITCH == 3) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHCC[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD3[START]);
if (SWITCHC){
 SWITCHER(SWITCHC);
 }
if (!SWITCHC)
 SWITCHER(SWITCHC);
} 
if (SWITCH == 4) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHDD[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD4[START]);
if (SWITCHD) {
 SWITCHER(SWITCHD);
 }
if (!SWITCHD)
 SWITCHER(SWITCHD);
} 
if (SWITCH == 5) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHEE[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD5[START]);
if (SWITCHE) {
 SWITCHER(SWITCHE);
 }
if (!SWITCHE)
 SWITCHER(SWITCHE);
} 
if (SWITCH == 6) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHFF[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD6[START]);
if (SWITCHF) {
 SWITCHER(SWITCHF);
 }
if (!SWITCHF)
 SWITCHER(SWITCHF);
}
if (SWITCH == 7) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHGG[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD7[START]);
if (SWITCHG) {
 SWITCHER(SWITCHG);
 }
if (!SWITCHG)
 SWITCHER(SWITCHG);
} 
if (SWITCH == 8) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHHH[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD8[START]);
if (SWITCHH) {
 SWITCHER(SWITCHH);
 }
if (!SWITCHH)
 SWITCHER(SWITCHH);
} 
if (SWITCH == 9) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHII[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD9[START]);
if (SWITCHI)
 SWITCHER(SWITCHI);
if (!SWITCHI)
 SWITCHER(SWITCHI);
} 
if (SWITCH == 10) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHJJ[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD10[START]);
if (SWITCHJ)
 SWITCHER(SWITCHJ);
if (!SWITCHJ)
 SWITCHER(SWITCHJ);
} 
if (SWITCH == 11) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHKK[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD11[START]);
if (SWITCHK)
 SWITCHER(SWITCHK);
if (!SWITCHK)
 SWITCHER(SWITCHK);
}
if (SWITCH == 12) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHLL[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD12[START]);
if (SWITCHL)
 SWITCHER(SWITCHL);
if (!SWITCHL)
 SWITCHER(SWITCHL);
} 
if (SWITCH == 13) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHMM[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD13[START]);
if (SWITCHM)
 SWITCHER(SWITCHM);
if (!SWITCHM)
 SWITCHER(SWITCHM);
} 
if (SWITCH == 14) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHNN[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD14[START]);
if (SWITCHN) {
 SWITCHER(SWITCHN);
 }
if (!SWITCHN)
 SWITCHER(SWITCHN);
} 
if (SWITCH == 15) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHOO[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD15[START]);
if (SWITCHO) {
 SWITCHER(SWITCHO);
 }
if (!SWITCHO)
 SWITCHER(SWITCHO);
} 
if (SWITCH == 16) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHPP[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD16[START]);
if (SWITCHP) {
 SWITCHER(SWITCHP);
 }
if (!SWITCHP)
 SWITCHER(SWITCHP);
}
if (SWITCH == 17) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHQQ[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD17[START]);
if (SWITCHQ) {
 SWITCHER(SWITCHQ);
 }
if (!SWITCHQ)
 SWITCHER(SWITCHQ);
} 
if (SWITCH == 18) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHRR[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD18[START]);
if (SWITCHR)
 SWITCHER(SWITCHR);
if (!SWITCHR)
 SWITCHER(SWITCHR);
} 
if (SWITCH == 19) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHSS[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD19[START]);
if (SWITCHS)
 SWITCHER(SWITCHS);
if (!SWITCHS)
 SWITCHER(SWITCHS);
} 
if (SWITCH == 20) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHTT[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD20[START]);
if (SWITCHT)
 SWITCHER(SWITCHT);
if (!SWITCHT)
 SWITCHER(SWITCHT);
} 
if (SWITCH == 21) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHUU[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD21[START]);
if (SWITCHU)
 SWITCHER(SWITCHU);
if (!SWITCHU)
 SWITCHER(SWITCHU);
}
if (SWITCH == 22) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHVV[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD22[START]);
if (SWITCHV)
 SWITCHER(SWITCHV);
if (!SWITCHV)
 SWITCHER(SWITCHV);
} 
if (SWITCH == 23) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHWW[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD23[START]);
if (SWITCHW)
 SWITCHER(SWITCHW);
if (!SWITCHW)
 SWITCHER(SWITCHW);
} 
if (SWITCH == 24) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHXX[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD24[START]);
if (SWITCHX)
 SWITCHER(SWITCHX);
if (!SWITCHX)
 SWITCHER(SWITCHX);
} 
if (SWITCH == 25) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHYY[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD25[START]);
if (SWITCHY) {
 SWITCHER(SWITCHY);
 }
if (!SWITCHY)
 SWITCHER(SWITCHY);
} 
if (SWITCH == 26) { 
 printf(TEXT_HORIZONTAL,TEXT_VERTICAL,SMALL,WHITE,SWITCHZZ[START]);
 printf(TEXT_HORIZONTAL + 3,TEXT_VERTICAL + 15,SMALL,WHITE,MOD26[START]);
if (SWITCHZ) {
 SWITCHER(SWITCHZ);
 }
if (!SWITCHZ)
 SWITCHER(SWITCHZ);
  }
 }
}
function GRID () {
 line_oled(OLED_W - 3,START + 20,START + 4,START + 20,THICKNESS,WHITE);
 rect_oled(START + 1,START + 1,OLED_W,OLED_H,UNFILL,WHITE);
 rect_oled(START + 4,START + 3,OLED_W - 6,OLED_H - 4,UNFILL,WHITE);
 rect_oled(START + 7,OLED_H - 17,OLED_W - 12,START + 13,UNFILL,WHITE);
 rect_oled(START + 5,START + 20,OLED_H - 23,START + 22,UNFILL,WHITE);
 rect_oled(OLED_W - 40,START + 23,OLED_H - 25,START + 22,UNFILL,WHITE);
 printf(TEXT_HORIZONTAL + 2 ,TEXT_VERTICAL + 23,SMALL,WHITE,MODS[START]);
 printf(TEXT_HORIZONTAL + 74,TEXT_VERTICAL + 18,SMALL,WHITE,VALUE1[START]);
 printf(TEXT_HORIZONTAL + 74,TEXT_VERTICAL + 24,SMALL,WHITE,VALUE[START]);
 printf(TEXT_HORIZONTAL + 87,TEXT_VERTICAL + 25,SMALL,WHITE,MODES[START]);
}
function ADJUST (VALUE,MIN,MAX,AMOUNT,INDEX) {
if (event_press(UP) || get_ival (UP) && get_ptime (UP) >= 150) {
 CHANGE = ON;
 VALUE += AMOUNT;
 return VALUE;
    }
if (VALUE > MAX) { 
 return MIN;
 }
if (event_press(DOWN) || get_ival (DOWN) && get_ptime (DOWN) >= 150) {
 CHANGE = ON;
 VALUE -= AMOUNT;
 return VALUE;
 }
if (VALUE < MIN) {
 return MAX;
 }
if (CHANGE == ON && INDEX == IDX) {
 NAME();
 }
 return VALUE;
}
function ADJUSTA (VALUE,MIN,MAX,AMOUNT,INDEX) {
if (INDEX == SWITCH && event_press(UP) || INDEX == IDX && event_press(RIGHT)) {
 CHANGE = ON;
 VALUE += AMOUNT;
    return VALUE;
 }
if (VALUE > MAX) { 
 return MIN;}
if (INDEX == SWITCH && event_press(DOWN) || INDEX == IDX && event_press(LEFT)) {
 CHANGE = ON;
 VALUE -= AMOUNT;
 return VALUE;
 }
if (VALUE < MIN) {
 return MAX;
 }
if (CHANGE == ON && INDEX == SWITCH) {
 SWITCHES();
 
 }
else if (CHANGE == ON && INDEX == IDX) {
 NAME();
 }
return VALUE;
}
function SWITCHER (ID) {
if (ID) {
 printf(TEXT_HORIZONTAL + 46,TEXT_VERTICAL + 16,1,MEDIUM,TOG1[START]);
 }
if (!ID) {
 printf(TEXT_HORIZONTAL + 41,TEXT_VERTICAL + 16,MEDIUM,WHITE,TOG0[START]);
 }
}
function EDITNUMBER (DIGIT,FDIGIT) {
if (DIGIT < START) {
 putc_oled(NO,NEG);
 NO += 1;
 DIGIT = abs(DIGIT);
 COUNT = ON;
 }
else 
 COUNT = START;
if (FDIGIT >= 3) {
 putc_oled(NO,REFERENCE[DIGIT / 100]);
 DIGIT = DIGIT % 100;
 NO +=  1;
 }
if (FDIGIT >= 2) {
 putc_oled(NO,REFERENCE[DIGIT / 10]);
 DIGIT = DIGIT % 10;
 NO += 1;
 }
 putc_oled(NO,REFERENCE[DIGIT]);
 puts_oled(CENTER(FDIGIT + COUNT,FONT_H),FONT_VERTICAL,MEDIUM,NO,WHITE);    
 NO = ON;
} 
function NUMBER (NUM) {
    NUM = abs(NUM);
if (NUM /  100 > START) 
 return 3;
if (NUM /   10 > START) 
 return 2;
  return 1;
}    
function CENTER (CHAR,SIZE) {
    ADJUST = CHAR * FONT_STATS[SIZE][FONT_W];
    ADJUST = (OLED_W - ADJUST) / FONT_L;
  return ADJUST;
}

[Mad]

convertir a titan uno porfavor

Only CM scripts can be converted.

[Dylan7762]

call_of_duty_black_ops_cold_war.gpc

(44.5 KiB) Downloaded 133 times

NBA 2K21 next gen.gpc

(5.88 KiB) Downloaded 100 times

nba2k21_next_gen_jefe_x_2k.gpc

(12.29 KiB) Downloaded 86 times

need scripts converted/fixed for T1 Thanks

[whiteindian]

Hi,

I've written a script for NBA 2k21 auto green jumpshot using PS4_Square button for shooting. It also includes, on the fly adjustment for early and late releases and SAVE Jumpshot setting function.

SYNTAX seems to be correct as compiler was successful with 0 errors/warnings.

However, I am unsure I have captured the save function correctly and wasnt able to determine if it was working as intended.

My concerns in the script are highlighted in purple and have attached script as GPC file for amendendment if required.

Essentially I am trying to get the save function to store "ON THE FLY JUMPSHOT TIMING ADJUSTMENTS" within the script itself/T1 device. This way would mean that jumpshot timing adjustments dont need to be done everytime you switch to T1 slot to use the script.

Hope this makes sense and hope someone can help

Code: Select all

/* *
// GPC Online Library
// Author : whiteindian 
// GPC SCRIPT - (DRAFT v0.1) T1 NBA 2k21 Perfect Jumpshot - PS4_SQUARE BUTTON w/ SHOT METER OFF
///////////////////////////////////////////////////////
///////////////////////////////////////////////////////
 
This script will online work in NBA2k21 online game modes for Park/Rec/Pro-Am 
NOTE: (SCRIPT DOES NOT WORK IN OFFLINE MODES for NBA 2K21)
 
///////////////////////////////////////////////////////
///////////////////////////////////////////////////////
 
STEP 1. NBA 2K21 Controller Settings
 
a) Select "CONTROLLER SETTINGS" within NBA 2K21 game menus
b) In "CONTROLLER SETTINGS" set VIBRATION = ON
c) In "CONTROLLER SETTINGS" set SHOT METER = OFF
d) In "CONTROLLER SETTINGS" set SHOT TIMING = Shots and Layup
e) In "CONTROLLER SETTINGS" set SHOT AIMING & FREETHROW AIMING = OFF
f) In "CONTROLLER SETTINGS" set SHOTFEEDBACK = ALL USERS (This shows if jumpshot is late or early) 
 
///////////////////////////////////////////////////////
STEP 2. SHOOTING WITH PS4_4 SQUARE BUTTON
 
a) PRESS and HOLD PS4 Square until Jumpshot releases on it's own
 
///////////////////////////////////////////////////////
STEP 3. ADJUST & SAVE YOUR JUMPSHOT RELEASE ON THE FLY
 
a) If you are getting lates - Decrease delay in increments of 1 (Press and hold PS4 L1 + PS4 LEFT) 
b) If you are getting earlies - Increase delay in increments of 1 (Press and hold PS4 L1 + PS4 RIGHT) 
c) SAVE jumpshot settings on the fly - (Press and Hold PS4_L1 + PS4_OPTIONS)
///////////////////////////////////////////////////////
*/
 
[color=#8000FF]int delay = 21;  
///////////////////////////////////////////////////////
init 
{
     delay = get_pvar(SPVAR_1,    1,100,21);
}[/color]
///////////////////////////////////////////////////////
main 
{
///////////////////////////////////////////////////////
    //PS4_Square button Shooting//
///////////////////////////////////////////////////////
 
    if(get_rumble(RUMBLE_A) || get_rumble(RUMBLE_B)) 
    {
        combo_run(wait_time);
    }
 
///////////////////////////////////////////////////////
      //Adjusting shot timing on the fly//  
///////////////////////////////////////////////////////
 
      // decrease delay if you're getting lates
    if(get_val(PS4_L1) && event_press(PS4_LEFT)) {
        delay--;
            combo_run(RUMBLE);
    }
 
    // increase delay if you're getting earlies
    if(get_val(PS4_L1) && event_press(PS4_RIGHT)) {
        delay++;
            combo_run(RUMBLE);
    }
 
    //reset delay
    if(get_val(PS4_L1) && event_press(PS4_UP)) {
        delay = 21;
        combo_run(reset_noti);
    }
///////////////////////////////////////////////////////
      //Save Jumpshot Settings //  
///////////////////////////////////////////////////////
 
 [color=#8000FF]       //SAVE SETTINGS
      if(get_val(PS4_L1))
    {
        if(get_val(PS4_OPTIONS)) 
        {
            combo_run(Save);
            combo_run(RUMBLE);
        }
    }
 
}
 [/color]
combo wait_time
{
    wait(delay);
    set_val(PS4_L2, 100);
    set_val(PS4_SQUARE, 0):
    wait(100);
    set_val(PS4_L2, 0);
    wait(200):
}
 
combo RUMBLE
{
    set_rumble(RUMBLE_A, 50);
    wait(200);
    set_rumble(RUMBLE_A, 0);
}
[color=#8000FF]combo Save
{
    set_pvar(SPVAR_1, delay);
}[/color]
combo reset_noti{
    set_rumble(RUMBLE_A, 100);
    set_rumble(RUMBLE_B, 100);
    wait(225);
    set_rumble(RUMBLE_A, 0);
    set_rumble(RUMBLE_B, 0):
    wait(300);
    set_rumble(RUMBLE_A, 100);
    set_rumble(RUMBLE_B, 100);
    wait(225);
    reset_rumble();    
}
 
 
 

[Mad]

need scripts converted/fixed for T1 Thanks

T1 NBA 2K21 next gen.gpc

(5.89 KiB) Downloaded 124 times

T1 nba2k21_next_gen_jefe_x_2k.gpc

(12.3 KiB) Downloaded 105 times

T1 call_of_duty_black_ops_cold_war.gpc

(37.88 KiB) Downloaded 338 times

[coolfedorabro]

please help covert this to T1 thank you!

Code: Select all

DO NOT CHANGE ORDER */
 
int adjustables;
/*
============================================================================================================================
   Default Values
============================================================================================================================
*/
int meterposition  = 19;
int buttonShotTiming  = 21;
int careershooting;
int dribbleSet;
int QS;
 
 
/*
============================================================================================================================
   DO NOT CHANGE BELOW HERE
============================================================================================================================
*/
define BLUE      =   0;
define RED       =   1;
define GREEN     =   2;
define PINK      =   3;
define MAX_RANGE = 330;
 
int defenseOnOff = TRUE,dribbleOnOff = TRUE;
 
int blockButton,timeBetweenTriggers;
/*
============================================================================================================================
   INIT
============================================================================================================================
*/
init {
    careershooting    = get_pvar(SPVAR_1,0, 1, 0);
    dribbleSet        = get_pvar(SPVAR_2,0, 6, 0);
    dribbleOnOff      = get_pvar(SPVAR_3,0, 1, 0);
    defenseOnOff      = get_pvar(SPVAR_4,0, 1, 0);
    QS                = get_pvar(SPVAR_5,0, 1, 0);
}
 
/*
============================================================================================================================
   MAIN
============================================================================================================================
*/
main{
 
     Toggles();
 
      Adjustables();
 
      if(careershooting)  set_led(GREEN,1); //Green LED means Shoot aim with R2+L1     
    else     reset_leds(); //No LED means Shoot aim with L1 
 
    if(i > -1) {
        if(!combo_running(SET_BUTTON_VALUES)) {    
            if(ButtonsVals()) {
                combo_run(SET_BUTTON_VALUES);
            }
        }
    }else{  
        //--dribble activaton
        if(dribbleOnOff && !get_val(PS4_OPTIONS)) {
            if(event_press(PS4_L3)) {
                i = FindID(D_SETS[0][dribbleSet]); 
                blockButton = PS4_L3;
            }
            if(event_press(PS4_R3)) {
                i = FindID(D_SETS[1][dribbleSet]);
            }
        }
     }//--end activation
 
 
 
    //--stick shot
        if(careershooting == 1 && get_val(PS4_R2) && event_press(PS4_L1)){
            combo_run(SHOOT);
            blockButton = PS4_L1;}
 
        if(careershooting == 0 && event_press(PS4_L1)){
            combo_run(SHOOT);
            blockButton = PS4_L1;}
 
        //--QS
        if(QS == 1)
        {
            if((get_val(PS4_LX))<0 && event_press(PS4_DOWN)) 
            {
                i = FindID(QSLH); 
                blockButton = PS4_DOWN;
            }
            if((get_val(PS4_LX))>0 && event_press(PS4_DOWN)) 
            {
                i = FindID(QSRH);
                blockButton = PS4_DOWN;
            }
        }
 
 
 
    //--stick shot/ button shot end
    if(get_rumble(RUMBLE_A) || get_rumble(RUMBLE_B)) {
        combo_run(END_SHOT);
    }
    //--intense d+
    if(defenseOnOff) {
        if(get_val(PS4_L2) && get_val(PS4_R2)) {
            if(FindMax(abs(get_val(PS4_LX)),abs(get_val(PS4_LY))) > 15) {
                timeBetweenTriggers =  MAX_RANGE - (FindMax(abs(get_val(XB1_LX)),abs(get_val(XB1_LY))) * 3);
                combo_run(ALTERNATE_TRIGGERS);                    
                }
                set_ledx(RED,3);
            }
        if(event_release(PS4_R2)){
        set_led(BLUE,1);
        }
    }
    //--save data
    if((get_val(PS4_OPTIONS) && event_press(PS4_SHARE)) || (get_val(PS4_SHARE) && event_press(PS4_OPTIONS))) {
        SaveData();
        Rumble(TRUE);
    }
    //--reset to defautls
    if(get_val(PS4_L1) && get_val(PS4_R1) && event_press(PS4_OPTIONS)) {
        ResetDefaults();
    }
    //--block output
    if(blockButton) {
        if(event_release(blockButton)) {
            blockButton = 0;
        }else{
            set_val(blockButton,0);
        }
    }
    //--rumbles
    if(rumble) {
        combo_run(RUMBLE);
    }
}
/*
============================================================================================================================
   Toggles
============================================================================================================================
*/
function Toggles() {
    if(get_val(PS4_OPTIONS)) {
        if(event_press(PS4_L2)) {
            defenseOnOff = !defenseOnOff;
            Rumble(defenseOnOff);
            blockButton = PS4_L2;
        }
        if(event_press(PS4_L1)) {
                 careershooting=!careershooting; 
                Rumble(TRUE);
                blockButton = PS4_L1;
        }
        if(event_press(PS4_L3)) {
            dribbleOnOff = !dribbleOnOff;
            Rumble(dribbleOnOff);
            blockButton = PS4_L3;
        }
        if(event_press(PS4_DOWN)) {
            QS = !QS;
            Rumble(QS);
            blockButton = PS4_DOWN;
        }
    }
}
/*
============================================================================================================================
   Adjustables
============================================================================================================================
*/
define ADD =  1;
define SUB = -1;
define MIN =  0;
 
int offset;
 
function Adjustables() {
    if(get_val(PS4_L1)) {
        CheckDpad(PS4_LEFT,SUB,offset,MIN,50);
        CheckDpad(PS4_RIGHT,ADD,offset,MIN,50);
    }
    if(get_val(PS4_SQUARE)) {
        CheckDpad(PS4_LEFT,SUB,3,MIN,50);
        CheckDpad(PS4_RIGHT,ADD,3,MIN,50);
    }    
    if(get_val(PS4_R2)) {
        CheckDpad(PS4_LEFT,SUB,4,MIN,6); 
        CheckDpad(PS4_RIGHT,ADD,4,MIN,6); 
    }
}
/*
============================================================================================================================
   Check D-PAD
============================================================================================================================
*/
function CheckDpad(btn,val,offset,minV,maxV) {
    if(event_press(btn)) {
        adjustables[offset] += val;
        if(adjustables[offset] < minV) {
            adjustables[offset] = maxV;
        }
        if(adjustables[offset] > maxV) {
            adjustables[offset] = minV;
        }
        rumble = 1;
    }
}
/*
============================================================================================================================
   Combo Labels
============================================================================================================================
*/
define LHHS              = 100;
define RHHS              = 101;
define LH_MOMENTUM       = 102;
define RH_MOMENTUM       = 103;
define LH_MOMENTUM_BTB      = 104;
define RH_MOMENTUM_BTB      = 105;
define LH_MOMENTUM_SLIDE = 106;
define RH_MOMENTUM_SLIDE = 107;
define LH_SLIDE          = 108;
define RH_SLIDE          = 109;
define LH_EXPLOSIVE_BB   = 110;
define RH_EXPLOSIVE_BB   = 111;
define BOOST_LH          = 112;
define BOOST_RH          = 113;
define QSLH              = 114;
define QSRH              = 115;
define EOC               = 255;
/*
============================================================================================================================
   DRIBBLE SETS[]
============================================================================================================================
*/
const int D_SETS[][] = {
    {LH_SLIDE,LH_EXPLOSIVE_BB,LH_MOMENTUM,LH_MOMENTUM_BTB,LH_MOMENTUM_SLIDE,LHHS,BOOST_LH},
    {RH_SLIDE,RH_EXPLOSIVE_BB,RH_MOMENTUM,RH_MOMENTUM_BTB,RH_MOMENTUM_SLIDE,RHHS,BOOST_RH}
};
/*
============================================================================================================================
   C_DATA[]
============================================================================================================================
*/
const int C_DATA[] = {
    //--Left Hand Half Spin
    LHHS,1,9,-100,1, 2,9,-100,10,-30,1,2,9,-20,10,-100,1,1,10,-100,1,EOC,    
 
    //--Right Hand Half Spin
    RHHS,1,9,100,1, 2,9,100,10,-30,1,2,9,20,10,-100,1,1,10,-100,1,EOC,  
 
    //--Left Hand Momentum
    LH_MOMENTUM,1,9,100,4,2,11,75,12,-75,10,EOC,   
 
    //--Right Hand Momentum
    RH_MOMENTUM,1,9,-100,4,2,11,-75,12,-75,10,EOC,    
 
    //--Left Hand Momentum Behind the Back + Right Hand Explosive Behind the Back
    LH_MOMENTUM_BTB,1,9,100,4,2,11,75,12,-75,30,2,9,-75,10,75,8,2,11,-75,12,-75,10,2,11,-75,12,-75,20,EOC,   
 
    //--Right Hand Momentum Behind the Back + Left Hand Explosive Behind the Back
    RH_MOMENTUM_BTB,1,9,-100,4,2,11,-75,12,-75,30,2,9,75,10,75,8,4,9,75,10,75,11,75,12,-75,10, 2,11,75,12,-70,20,EOC,
 
    //-Left Hand Momentum Curry Slide + Right Hand Curry Slide
    LH_MOMENTUM_SLIDE,1,9,100,4,2,11,75,12,-75,30,2,9,-100,10,50,40,EOC,
 
    //-Right Hand Momentum Curry Slide + Left Hand Curry Slide
    RH_MOMENTUM_SLIDE,1,9,-100,4,2,11,-75,12,-75,30,2,9,100,10,50,40,EOC,
 
    //--Left Hand Curry Slide
    LH_SLIDE,2,9,100,10,50,40,EOC,
 
    //--Right Hand Curry Slide
    RH_SLIDE,2,9,-100,10,50,40,EOC,
 
    //--Left Hand Explosive Behind the Back
    LH_EXPLOSIVE_BB,2,9,75,10,75,8,4,9,75,10,75,11,75,12,-75,10,2,11,75,12,-70,20,EOC,
 
    //--Right Hand Explosive Behind the Back
    RH_EXPLOSIVE_BB,2,9,-75,10,75,8,2,11,-75,12,-75,10,2,11,-75,12,-75,20,EOC,
 
    //--Left Hand Boost
    BOOST_LH,1,9,100,6,1,9,0,35,1,11,100,6, 2,11,100,4,100,40,EOC,
 
    //--RightHand Boost
    BOOST_RH,1,9,-100,6,1,9,0,35,1,11,-100,6,2,11,-100,4,100,40,EOC, 
 
    //--Left Hand Quick Stop
    QSLH,1,9,100,3,EOC,    
 
    //--Right Hand Quick Stop
    QSRH,1,9,-100,3,EOC 
};    
/*
============================================================================================================================
   Find Stick Position Name 
============================================================================================================================
*/
int i = -1,v;
 
function FindID(arrayID) { 
    i = 0; 
    while(i < (sizeof(C_DATA) / sizeof(C_DATA[0]))) { 
        v = C_DATA[i]; 
        if(v == arrayID) { 
            return(i + 1); 
        } 
        while(v != EOC) {  
            i++; 
            v = C_DATA[i]; 
        }
        i++; 
    }
    return(-1); 
}
/*
============================================================================================================================
   Buttons & Valuse 
============================================================================================================================
*/
int bvCount,idx;
int button[4],value[4];
int bvWait; 
 
function ButtonsVals() {
    InitializeButtons();
     if(C_DATA[i] == EOC) {
        i = -1;
        return FALSE;
    }
    bvCount = C_DATA[i]; 
    i++;
    for(idx = 0;idx <= 3;idx++) {
        if(idx < bvCount) {
            button[idx] = C_DATA[i];  
            value[idx] = C_DATA[i + 1]; 
            i += 2;
        } 
    }
    bvWait = C_DATA[i] * 10;
    i++;
    return TRUE;
}    
/*
============================================================================================================================
   SET BUTTON VALS
============================================================================================================================
*/
combo SET_BUTTON_VALUES {
   for(idx = 0; idx <= 3; idx++) {
        if(button[idx] > -1) {
            set_val(button[idx],value[idx]) 
        }
    } 
    wait(bvWait);
} 
/*
============================================================================================================================
   Initialize Buttons
============================================================================================================================
*/
function InitializeButtons() {
    for(idx = 0; idx <= 3; idx++) {
        button[idx] = -1;
    }
}
/*
============================================================================================================================
   Defense
============================================================================================================================
*/
combo ALTERNATE_TRIGGERS {
    set_val(XB1_LT,100);
    set_val(XB1_RT,0);
    wait(30);
    set_val(XB1_LT,0);
    set_val(XB1_RT,0);
    wait(timeBetweenTriggers);
    set_val(XB1_RT,100);
    set_val(XB1_LT,0);
    wait(30);
    set_val(XB1_LT,0);
    set_val(XB1_RT,0);
    wait(timeBetweenTriggers);
}
/*
============================================================================================================================
   FindMax
============================================================================================================================
*/
function FindMax(a,b) {
    if(a > b){
        return a;
    }
    return b;
}
/*
============================================================================================================================
   Rumble
============================================================================================================================
*/
int rumble;
 
function Rumble(rTimes) {
    if(!rTimes) {
        rumble = 2;
    }else{
        rumble = rTimes;
    }
}
/*
============================================================================================================================
   Rumble
============================================================================================================================
*/
combo RUMBLE {
    set_rumble(RUMBLE_B,50);
    wait(200);
    reset_rumble();
    wait(150);
    rumble -= 1;
}
 
/*
============================================================================================================================
   Button Shot
============================================================================================================================
*/
combo END_SHOT {
    wait(buttonShotTiming);
    combo_stop(SHOOT);
    set_val(PS4_L2,100);
    set_val(PS4_SQUARE,0);
    wait(100);
    set_val(PS4_L2, 0);
    wait(200):
}
/*
============================================================================================================================
   Save Data
============================================================================================================================
*/
function SaveData() {
    set_pvar(SPVAR_1,careershooting);
    set_pvar(SPVAR_2,dribbleSet);
    set_pvar(SPVAR_3,dribbleOnOff);
    set_pvar(SPVAR_4,defenseOnOff);
    set_pvar(SPVAR_5,QS);
}
 
combo SHOOT {
    set_val(PS4_RX,meterposition);
    set_val(PS4_RY,100);
    wait(1500);
}
function ResetDefaults() {
    careershooting = 0;
    dribbleSet = 0;
    dribbleOnOff = FALSE;
    defenseOnOff = FALSE;
    dribbleSet = 0;
    SaveData();
}

[sebascu]

Ayuda para convertir a titan 1

[J2Kbr]

please help covert this to T1 thank you!

Just converted this one here:
viewtopic.php?p=106451#p106451

[Alfagamer]

Conversione per t1

[whiteindian]

I have attempted to convert a T1 script to T2. But have not been able to compile it successfully nor use the converter tool with having issue with a macro being redefined. tested it and it loops at first command.

I have attached the original T1 script which is working , fully compliled without error.

I have also attached the attempt i have made to convert to T2 script.

can someone please help convert the original T1 script so it works as T2 script and compiles without error or macro redefine errors?

Thanks