Help with code error cant compile 1 error

[dany09]

Code: Select all

define ON = TRUE;
    define OFF = FALSE;
 
    //Layout
    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 L3 = PS4_L3; //LS
    define RX = PS4_RX;
    define RY = PS4_RY;
    define LX = PS4_LX;
    define LY = PS4_LY;
    define UP = PS4_UP;
    define DOWN = PS4_DOWN;
    define LEFT = PS4_LEFT;
    define RIGHT = PS4_RIGHT;
    define TRIANGLE = PS4_TRIANGLE; //Y
    define CIRCLE = PS4_CIRCLE; //B
    define CROSS = PS4_CROSS; //A
    define SQUARE = PS4_SQUARE; //X
    define TOUCHPAD = PS4_TOUCH;
 define AIM        = PS4_L2;//XB1_LT 
define FIRE       = PS4_R2;//XB1_RT  
define TACTICAL   = PS4_L1;//XB1_LB 
define LEATHAL    = PS4_R1;//XB1_RB                                        
define CROUCH     = PS4_CIRCLE;//XB1_B
define MELEE      = PS4_R3;//XB1_RS  
define SPRINT     = PS4_L3;//XB1_A  
define SWAP       = PS4_TRIANGLE;//XB1_Y  
define JUMP       = PS4_CROSS;//A
define RELOAD     = PS4_SQUARE;//X
 
 
    //MENU BUTTONS
define MENU_HOLD_BUTTON        = L2,      MENU_PRESS_BUTTON         = OPTIONS;// ( L2 & OPTIONS TO ENTER/EXIT MENU )(XBOX  =  LT && MENU )
define MENU_MOD_CHANGE_BUTTON  = CROSS;  //CROSS/A    ( PRESS TO CHANGE MOD/CLASS IN MENU )
define MENU_EXIT_BUTTON        = CIRCLE; //CIRCLE/B   ( PRESS TO EXIT MENU )
//RESET FUNCTION (RECOIL)                                                                  (PS4)             (XBOX1)
define RESET_HOLD_TOGGLE            = CROSS, RESET_PRESS_TOGGLE        = SHARE;  // ( CROSS/SHARE   OR    A/VIEW  )
// AIM ASSIST TOGGLES ON/OFF
define PROGRESSION_HOLD_TOGGLE       = RELOAD, PROGRESSION_PRESS_TOGGLE  = LEFT;   // ( SQUARE/LEFT   OR    X/LEFT  )
define DoGz_ASSIST_HOLD_TOGGLE       = RELOAD, DoGz_ASSIST_PRESS_TOGGLE  = RIGHT;  // ( SQUARE/RIGHT  OR    X/RIGHT )
define DONT_AT_ME_ASSIST_HOLD_TOGGLE = RELOAD,  DONT_AT_ME_PRESS_TOGGLE   = UP;     // ( SQUARE/UP     OR    X/UP    )
define SNACKS_RECOIL_HOLD_BUTTON = JUMP;// **CROSS**   RECOIL HOLD BUTTON = CROSS AND PRESS ( UP ) OR ( DOWN ) OR ( LEFT ) OR ( RIGHT ) TO ADJUST RECOIL
// DON'T TOUCH THESE BELOW
define STEP_INTERVAL =  1;
define STEPS2 = 0;
int RADIUS1,RADIUS2 = 10,RADIUS3 = 100;
int RADIUS4, RADIUS5;
int STEPS1,FIRE_RATE;
int time,angle,cos_angle,sin_angle,actual_X,actual_Y,actual_Magnitude,max_Magnitude,L;
int SHUNT,MENU,RECOIL,IDX = 1;
//MENU VALUES MIN/MAX THESE WILL BE ADDED/SUBTRACTED IN GAME VIA THE MENU
int D___AS_MIN   =   0,   D___AS_MAX =  20;
int D_AS1_MIN    = -20,   D_AS1_MAX  =   0;
int VMC_MIN      =  -5,   VMC_MAX    =  10;
int POS,POS_MIN  =   0,   POS_MAX    =  20;
int NEG,NEG_MIN  = -20,   NEG_MAX    =   1;
int WA,WA_MIN    =  -2,   WA_MAX     =  50;
int BOOST_MIN    =   1,   BOOST_MAX  =  10;
int SHAKE_MIN    =   2,   SHAKE_MAX  = 200;
//PROGRESSION ASSIST SETTINGS
define PROGRESSION_RELEASE = 15; 
define VMCR   =  0;
define AAMIN  = 0;//MINIMUM VALUE  
define AAMAX  =  6;//MAXIMUM VALUE  
define AAVAL  =  6;//STEPS   
define AAWMIN =  1;//MIN WAIT   
define AAWMAX =  2;//MAXIMUM WAIT   
define AAWVAL =  1;//STEPS
// DON'T TOUCH THESE BELOW
int AS = AAMIN;  
int AW = AAWMIN;
int PROG;
int AAS = 1;   
int AAD = 1;
//POLAR ASSIST SETTINGS
define RADIUS        =  8;// RADIUS/STRENGTH/VALUE    
define STEPS         = 20;// STEP/SPEED        
define POLAR_RELEASE = 20;// RELEASE VALUE                                   
int    POLAR_BOOST   =  7;// BOOST VALUE MUST BE 1 TO 10   ( 1 = STRONGER SHAKE __ 10 = NO SHAKE )
int    POLAR_SHAKE   = 20;// SHAKE VALUE (EXPERIMENT) 2 - 200 
//DoGz ASSIST VALUES
define DoGz_ASSIST_RELEASE = 50;
int D_AS;
int VMC    = 0;//DEFAULT VM SPEED
int D__AS  = 0;//STARTING VALUE/RETURN VALUE
int D__AS1 = 4;//INVERT DIRECTION VALUE
int D___AS = 5;//( HIGHEST VALUE )( WILL BE DOUBLED WHEN FIRING )
int D_AS1 = -5;//( LOWEST VALUE ) ( WILL BE DOUBLED WHEN FIRING )
//AUTORUN-TACTICAL SPRINT OPTIONS
define RUN_TRIGGER          = 80;//VALUE TO PUSH UP BEFORE AUTORUN STARTS
define TACTICAL_SPRINT_WAIT = 40;//TIME BETWEEN BUTTON PRESS
// ANTI RECOIL STARTING VALUES AND CONDITIONS
define INTVERTED_RECOIL   =   1;//ITzSNACK'S INVERTED RECOIL METHOD ( IF INVERTED SET TO    -1   INSTEAD OF   1 )
define DEFAULT_VERTICAL   =  21;//RECOIL  DEFAULT VERTICAL VALUE IF YOU GO BEYOND THE LIMITS WHILE ADJUSTING ( TO SAVE GOING BACK TO ZERO ) ( SET THE SAME AS VERTICAL BELOW )
define DEFAULT_HORIZONTAL =   0;//RECOIL  DEFAULT VERTICAL VALUE IF YOU GO BEYOND THE LIMITS WHILE ADJUSTING ( TO SAVE GOING BACK TO ZERO ) ( SET THE SAME AS HORIZONTAL BELOW )
int VERTICAL_RECOIL       =  21;//RECOIL VERTICAL   * STARTING VALUE * ( DEFAULT VALUE/STREGNTH )
int HORIZONTAL_RECOIL     =   0;//RECOIL HORIZONTAL * STARTING VALUE * ( DEFAULT VALUE/STREGNTH )
define SNACKS_ANTIRECOIL  =  ON;//RECOIL MASTER CONTROL ( IF YOU DON'T WANT ANTI-RECOIL RUNNING AT ALL INPUT NO HERE )
define VIBRATION_RECOIL   =  ON;//RECOIL ACTIVE ON VIBRATE OR JUST ON THE TRIGGERS ( L2 & R2 ) ( ON = VIBRATION  OR  OFF = TRIGGERS ) ( MASTER ABOVE MUST BE SET TO ON ) 
//POLAR CONDITIONS
define ACTIVE_WHEN_ADS    =  ON;//POLAR ASSSIT PRESSING AIM
define ACTIVE_WHEN_FIRING =  ON;//POLAR ASSSIT ACTIVE BY ONLY PRESSING FIRE OR AIM & FIRE                    
define POLAR_BOOST_FIRE   =  ON;//BOOST POLAR AIM ASSIST ON FIRE ( WHEN AIMING & SHOOTING )
define POLAR_SHAKE_FIRE   =  ON;//SHAKE POLAR AIM ASSIST ON FIRE ( WHEN AIMING & SHOOTING )
//AIM ASSIST MODS ON/OFF BY DEFAULT ( TOGGLE ON/OFF IN GAME )( CAN ALL RUN TOGETHER TO CREATE MORE AIM ASSISTS )( EXPERIMENT )
int DoGz_ASSIST        = ON;//DoGz AIM ASSTIST
int PROGRESSION_ASSIST = ON;//PROGRESSION AIM ASSIST
int DONT_AT_ME_ASSIST  = ON;//DON'T AT ME POLAR AIM ASSIST ( CMP VERSION )
int VM                 = ON;//VM SPEED CONTROL ( CHANGES PATTERN AND SPEED ) ( LEAVE ON ALTERED IN MENU SYSTEM )
// AUTORUN/TACTICAL SPRINT
int AUTORUN         =  ON;//ON/OFF BY DEFAULT AUTORUN  = ( PUSH FORWARD ON THE MOVEMENT STICK )
int TACTICAL_SPRINT =  ON;//ON/OFF BY DEFAULT TACTICAL = ( RUN PRESS/HOLD SPRINT )
 
main {
if (get_val(RESET_HOLD_TOGGLE) && event_press(RESET_PRESS_TOGGLE)) {
 SHUNT = RESET_PRESS_TOGGLE;
 VERTICAL_RECOIL   = DEFAULT_VERTICAL;
 HORIZONTAL_RECOIL = DEFAULT_HORIZONTAL;
}
if (AUTORUN && get_val(LY) < -RUN_TRIGGER) { 
    combo_run(RUN);
}
if (TACTICAL_SPRINT && get_val(L3)) { 
 set_val(L3,0);
 combo_stop(RUN);
 combo_run(TACTICAL1);
}
if (get_val(MENU_HOLD_BUTTON) && event_press(MENU_PRESS_BUTTON)) {
 SHUNT = MENU_PRESS_BUTTON;
 MENU = !MENU;
 IDX = 1;
 combo_run(VIBRATE);
}
if (MENU) {
if (event_press(MENU_EXIT_BUTTON)) {
    MENU = OFF;
    }
if (event_press(MENU_MOD_CHANGE_BUTTON)) {
    IDX += 1;
if (IDX > 8) IDX = 1; 
    }
if (IDX == 1) {
    LED(0,2,0,0);//RED =  = DOGZ ASSIST POSITIVE VALUE
    D___AS = ADJUST(D___AS,D___AS_MIN,D___AS_MAX,1);
}
if (IDX == 2) {
    LED(0,0,2,0);//GREEN = DOGZ ASSIST NEGITIVE VALUE
    D_AS1 = ADJUST(D_AS1,D_AS1_MIN,D_AS1_MAX,1); 
}
if (IDX == 3) {
    LED(0,0,0,2);//PINK/PURPLE =  VIRTUAL MACHINE RUN TIME WHILE HOLDING L2 (INTENDED FOR DOGZ ASSIST)
 VMC = ADJUST(VMC,VMC_MIN,VMC_MAX,1);
}
if (IDX == 4) {
    LED(0,2,2,0);//YELLOW = PROGRESSION POSITIVE
 POS = ADJUST(POS,POS_MIN,POS_MAX,1);
}
if (IDX == 5) {
    LED(2,2,2,2);//WHITE = PROGRESSION NEGITIVE
 NEG = ADJUST(NEG,NEG_MIN,NEG_MAX,1);
}
if (IDX == 6) {
    LED(3,0,0,0);//BRIGHT BLUE = PROGRESSION WAIT
 WA = ADJUST(WA,WA_MIN,WA_MAX,1);
}
if (IDX == 7) {
    LED(0,0,0,L/3);///BRIGHT PINK/PURPLE PULSING = POLAR SHAKE
 POLAR_BOOST = ADJUST(POLAR_BOOST,BOOST_MIN,BOOST_MAX,1);
 L++;
if (L > 3) {
 L = OFF;
 }
}
if (IDX == 8) {
    LED(L/3,0,0,0);//BRIGHT BLUE PULSING = POLAR SHAKE
 POLAR_SHAKE = ADJUST(POLAR_SHAKE,SHAKE_MIN,SHAKE_MAX,1);
 L++;
if (L > 3) {
 L = OFF;
 }
}
 set_val(MENU_MOD_CHANGE_BUTTON,0); set_val(MENU_EXIT_BUTTON,0); set_val(UP,0); set_val(DOWN,0); 
}
else {
reset_leds ();
}
if (get_val(DONT_AT_ME_ASSIST_HOLD_TOGGLE) && event_press(DONT_AT_ME_PRESS_TOGGLE)) {
 SHUNT = DONT_AT_ME_PRESS_TOGGLE;
 DONT_AT_ME_ASSIST = !DONT_AT_ME_ASSIST;
}
if (DONT_AT_ME_ASSIST) {
 actual_X = get_val(X);   
    actual_Y = get_val(Y);           
    actual_Magnitude = isqrt(pow(actual_X, 2) + pow(actual_Y, 2));  
    max_Magnitude = (actual_Magnitude < 100);                      
if (POLAR_BOOST_FIRE) {
if (get_val(FIRE)) { 
    RADIUS1 =  POLAR_BOOST * RADIUS2;
    }
else
    RADIUS1 =  RADIUS3;
    }
if (POLAR_SHAKE_FIRE) {
if (POLAR_SHAKE_FIRE && get_val(FIRE)) {
 STEPS1 = POLAR_SHAKE;
 }
else
 STEPS1 = STEPS2;
}      
if (!(time++ % STEP_INTERVAL)){                                  
 angle += STEPS + STEPS1;                                                 
    }                                                               
    angle = angle % 360;                                            
    sin_angle = Polar_Array[angle % 360];                           
    cos_angle = Polar_Array[(angle + 270) % 360];                  
    cos_angle = (cos_angle * RADIUS) / RADIUS1;                         
    sin_angle = (sin_angle * RADIUS) / RADIUS1;                          
if ((ACTIVE_WHEN_ADS && get_val(AIM) && abs(get_val(RY)) < POLAR_RELEASE && abs(get_val(RX)) < POLAR_RELEASE) 
    || (ACTIVE_WHEN_FIRING && get_val(FIRE) && abs(get_val(RY))< POLAR_RELEASE && abs(get_val(RX)) < POLAR_RELEASE)) { 
if(actual_Magnitude <= RADIUS){                                                      
    sin_angle -= actual_Y;                                                              
    cos_angle -= actual_X;                                                                 
    }
else {                                                                                       
    sin_angle = (sin_angle * (200 - ((abs(actual_Y) + actual_Magnitude) / 10) * 10) / 200) * max_Magnitude; 
    cos_angle = (cos_angle * (200 - ((abs(actual_X) + actual_Magnitude) / 10) * 10) / 200) * max_Magnitude; 
 }                                                  
    set_val(X, clamp(actual_X + cos_angle, -100, 100));
    set_val(Y, clamp(actual_Y + sin_angle, -100, 100)); 
    }
}
if (get_val(PROGRESSION_HOLD_TOGGLE) && event_press(PROGRESSION_PRESS_TOGGLE)) {
 SHUNT = PROGRESSION_PRESS_TOGGLE;
 PROGRESSION_ASSIST = !PROGRESSION_ASSIST;
}
if (PROGRESSION_ASSIST && get_val(AIM) >= 80) {
if (!combo_running(AAS1)) {
 AS = PROGRESSION(AS,AAMIN + NEG,AAMAX + POS,AAVAL,AAS,1);
    AW = PROGRESSION(AW,AAWMIN,AAWMAX + WA,AAWVAL,AAD,2);
    combo_run(AAS1);
     }
if (abs(get_val(RY))> PROGRESSION_RELEASE || abs(get_val(RX)) > PROGRESSION_RELEASE) {
 combo_stop(AAS1);
 }
}
if (get_val(DoGz_ASSIST_HOLD_TOGGLE) && event_press(DoGz_ASSIST_PRESS_TOGGLE)) {
 SHUNT = DoGz_ASSIST_PRESS_TOGGLE;
 DoGz_ASSIST = !DoGz_ASSIST;
}
if (DoGz_ASSIST && abs(get_val(RX)) < DoGz_ASSIST_RELEASE && abs(get_val(RY)) < DoGz_ASSIST_RELEASE) {
if (get_val(AIM) > 80) {
 D_AS = ON;
 AIM();
}
if(event_release(AIM) || event_release(FIRE)){
 D_AS = OFF;
 vm_tctrl(VMCR); 
 }
}
if (SNACKS_ANTIRECOIL) {
if (VIBRATION_RECOIL) {
if (get_val(AIM) && get_val(FIRE) && get_rumble(VIB_A)) {
    combo_run(RECOIL1);
    }
}
else 
if (!VIBRATION_RECOIL && get_val(AIM) && get_val(FIRE)) {
    combo_run(RECOIL1);
}
if (get_val(SNACKS_RECOIL_HOLD_BUTTON)) { 
if (event_press(UP)) {
    VERTICAL_RECOIL = VERTICAL_RECOIL + 1;
    combo_run(VIBRATE);
    }
if (event_press(DOWN)) {
    VERTICAL_RECOIL = VERTICAL_RECOIL - 1;
    combo_run(VIBRATE);
    }
if (event_press(RIGHT)) {
    HORIZONTAL_RECOIL = HORIZONTAL_RECOIL + 1;
    combo_run(VIBRATE);
    }
if (event_press(LEFT)) {
    HORIZONTAL_RECOIL = HORIZONTAL_RECOIL - 1;
    combo_run(VIBRATE);
    }
if (VERTICAL_RECOIL < 0 || VERTICAL_RECOIL > 100) {
 VERTICAL_RECOIL = DEFAULT_VERTICAL;
}
if (HORIZONTAL_RECOIL < 0 || HORIZONTAL_RECOIL > 100) {
 HORIZONTAL_RECOIL = DEFAULT_HORIZONTAL;
}
 set_val(UP,0); set_val(DOWN,0); set_val(RIGHT,0); set_val(LEFT,0);
}
if (abs(get_val(RY)) > VERTICAL_RECOIL + 2 || abs(get_val(RX)) > VERTICAL_RECOIL + 2) {
    combo_stop(RECOIL);
 }  
}
if (SHUNT) {
if (event_release(SHUNT)) {
 SHUNT = OFF;
 }
else {
 set_val (SHUNT,OFF);
  }
 }
}
combo RUN {
   set_val(SPRINT,100);
}
combo TACTICAL1 {
   wait(TACTICAL_SPRINT_WAIT); 
   set_val(SPRINT, 100);
   wait(TACTICAL_SPRINT_WAIT);         
}
combo AAS1{
 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 RECOIL1 {
    RECOIL = get_val(RY) + VERTICAL_RECOIL;
if(RECOIL > 100) RECOIL = 100;
    set_val(PS4_RY,RECOIL * INTVERTED_RECOIL);
    RECOIL = get_val(RX) + HORIZONTAL_RECOIL;
if(RECOIL > 100) RECOIL = 100;
    set_val(PS4_RX,RECOIL);
}
combo VIBRATE {
    set_rumble(VIB_A,60);
    wait(350);
 reset_rumble ();
} 
function AIM1() {
 if (D_AS) {
 if (D_AS && VM) {
  vm_tctrl(VMC);
 }
  D__AS ++;
 if (D__AS >= D___AS)  D__AS = D__AS1;
  D__AS1 --;
 if (D__AS1 <= D_AS1)  D__AS1 = D__AS;
  D__AS ++;
 if(get_val(AIM)) { 
 set_val (RX,get_val(RX) + D__AS);
 set_val (RY,get_val(RY) + D__AS);
 }
 if(get_val(FIRE)) { 
 set_val (RX,get_val(RX) + D__AS);
 set_val (RY,get_val(RY) + D__AS);
  }
 }
}
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 ADJUST (VALUE,MIN,MAX,AMOUNT) {
if (event_press(UP)) {
 VALUE += AMOUNT;
 return VALUE;
    }
if (VALUE > MAX) { 
 return MIN;
 }
if (event_press(DOWN)) {
 VALUE -= AMOUNT;
 return VALUE;
 }
if (VALUE < MIN) {
 return MAX;
 }
if (VALUE == MAX) {
 combo_run(VIBRATE);
 }
return VALUE;
}
function LED(a,b,c,d) {
    set_led(LED_1,a);
    set_led(LED_2,b);
    set_led(LED_3,c);
    set_led(LED_4,d);
}
function clamp( v, lo, hi) { 
if(v < lo) 
   return lo;               
if(v > hi) 
   return hi;        
    return v;     
}

[Mad]

This is not a T2 script so you'll need to convert it first: viewtopic.php?f=3&t=12027