Script Conversion Request Megathread

GPC1 script programming for Titan One. Code examples, questions, requests.

Re: Script Conversion Request Megathread

Postby Chase1015 » Tue Nov 24, 2020 8:16 pm

Please convert this to T1
Attachments
JEFE NEXT GEN RT + LB Perfect Shot Updated.gpc
(4.98 KiB) Downloaded 91 times
User avatar
Chase1015
Private First Class
Private First Class
 
Posts: 3
Joined: Wed Oct 14, 2020 5:45 pm

Re: Script Conversion Request Megathread

Postby Mad » Tue Nov 24, 2020 9:23 pm

Chase1015 wrote:Please convert this to T1

T1 RT + LB Perfect Shot Updated.gpc
(4.97 KiB) Downloaded 98 times
ConsoleTuner Support Team || ConsoleTuner Discord || InputSense Discord (2K / FPS)
Mad
Major General
Major General
 
Posts: 4533
Joined: Wed May 22, 2019 5:39 am

Re: Script Conversion Request Megathread

Postby Tomhug » Wed Nov 25, 2020 10:31 pm

Code: Select all
Code:
*/
 
define Blue          =  1;             
define Green         =  3;   
define LED_OFF       = -2;
define Red           =  2;
 
data( 1,                 
  2,0,0,0 , //1. Blue                 
  0,2,0,0 , //2. Red                   
  0,0,2,0 , //3. Green                 
  0,0,0,2 , //4. Pink                 
  2,0,2,0 , //5. SkyBlue               
  0,2,2,0 , //6. Yellow               
  2,2,2,2   //7. White                 
)
 
 
int MeterPosition = 18;
int CareerShooting = 0;
int release = 21;
int defenseOnOff = TRUE;
int blockButton;
int timeBetweenTriggers;
 
 
define MAX_RANGE = 330;
 
 
main
{
    if(get_rumble(RUMBLE_A) || get_rumble(RUMBLE_B)) {combo_run(wait_time);}
 
 
    // -- Advanced Defense
    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);   
        }
            LED_CM(Red);
        }
 
           if(event_release(PS4_R2) || event_release(PS4_L2))
        {
            LED_CM(Blue);
        }
 
 
 
      // -- Toggles
    if(get_val(PS4_OPTIONS))
    {
        if(event_press(PS4_L1))
        {
            CareerShooting=!CareerShooting;
            set_val(PS4_L1, 0);
        }
    }
 
    // -- Shooting
    if (CareerShooting == 1)
    { 
        if(get_val(PS4_R2))
        {   
            if(get_val(PS4_L1))
            {
                set_val(PS4_RX, MeterPosition);
                set_val(PS4_RY, 100);
            }
        }
    }
 
    if (CareerShooting == 0)
    { 
        if(get_val(PS4_L1))
        {
            set_val(PS4_RX, MeterPosition);
            set_val(PS4_RY, 100);
        }
    }
 
       // -- Dribbles
    if(get_val(PS4_R2))
    {       
        if (event_press(PS4_L3))
        {
            combo_run(LHSpinBack);
        }
 
        if (event_press(PS4_R3))
        {
            combo_run(Takeover);
            combo_run(RHSpinBack);
        }
 
        if (event_press(PS4_LEFT))
        {
            combo_run(LHDribbleFreeze);
            blockButton = PS4_LEFT;
        }
 
        if (event_press(PS4_RIGHT))
        {
            combo_run(RHDribbleFreeze);
            blockButton = PS4_RIGHT;
        }
    }
 
        if(get_val(PS4_L3))
        {
            combo_run(LHSLIDE);
            set_val(PS4_L3, 0);
        }
 
        if(get_val(PS4_R3))
        {
            combo_run(Takeover);
            combo_run(RHSLIDE);
            set_val(PS4_R3, 0);
        }
 
         if(combo_running(RHSpinBack) || combo_running(LHSpinBack))
         {
          combo_stop(LHSLIDE);
          combo_stop(RHSLIDE);
          set_val(PS4_R2, 0);
         }
 
 
 
        //--block output
        if(blockButton)
        {
            if(event_release(blockButton))
            {
                blockButton = 0;
            }
                else
                {
                    set_val(blockButton,0);
                }
        }
}
 
 
 
 
//=======================================
// Dribble Moves//=======================
//=======================================
 
 
combo LHSLIDE
{
    set_val(PS4_RX, 75);
    set_val(PS4_RY, 75);
    wait(400);
}
 
 
 
 
combo RHSLIDE
{
    set_val(PS4_RX, -75);
    set_val(PS4_RY, 75);
    wait(400);
}
/*
combo RHExplosiveBB
{
    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 LHExplosiveBB
{
    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 LHDribbleFreeze
{
    set_val(PS4_RX, 100);
    wait(100);
    wait(150);
    set_val(PS4_R2, 100);
    set_val(PS4_LY, 100);
    wait(500);
    set_val(PS4_LX, -75);
    set_val(PS4_LY, -75);
    wait(700);
    set_val(PS4_L2, 100);
    set_val(PS4_L3, 100);
    wait(1500);
}
 
 
combo RHDribbleFreeze
{
    set_val(PS4_RX, -100);
    wait(100);
    wait(150);
    set_val(PS4_R2, 100);
    set_val(PS4_LY, 100);
    wait(500);
    set_val(PS4_LX, 75);
    set_val(PS4_LY, -75);
    wait(700);
    set_val(PS4_L2, 100);
    set_val(PS4_L3, 100);
    wait(1500);
}
 
 
 
 
combo RHSpinBack
{   
    set_val(PS4_RY, -100); // 12 'o Clock
    wait(60);
    set_val(PS4_RX, 100); // 3 'o Clock
    wait(60);
    set_val(PS4_RY, 100);// 6 'o Clock
    wait(120);
    set_val(PS4_LY, 100);
    wait(800);
}
 
 
combo LHSpinBack
{
    set_val(PS4_RY, -100); // 12 'o Clock
    wait(60);
    set_val(PS4_RX, -100); // 9 'o Clock
    wait(60);   
    set_val(PS4_RY, 100);// 6 'o Clock
    wait(120);
    set_val(PS4_LY, 100);
    wait(800);
}
 
 
combo QuickStopLeftHand
{
    set_val(PS4_RX, 100);
    wait(100);
}
 
 
combo QuickStopRightHand
{
    set_val(PS4_RX, -100);
    wait(100);
}
 
 
 
 
//=======================================
// Stick Shooting//======================
//=======================================
 
 
combo wait_time
{
    wait(release);
    set_val(PS4_L2, 100);
    set_val(PS4_SQUARE, 0):
    wait(100);
    set_val(PS4_L2, 0);
    wait(200):
}
 
 
combo Takeover
{
    set_val(PS4_R3, 100);
    wait(100);
    set_val(PS4_R3, 0);
}
 
 
combo RUMBLE
{
    set_rumble(RUMBLE_A, 50);
    wait(200);
    set_rumble(RUMBLE_A, 0);
}
/*
============================================================================================================================
   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;
}
 
 
//=========================================================
//LED COLOURS//============================================
//=========================================================
function LED_CM(Colour)
{           
    set_led(LED_1,dbyte(( Colour * 4)- 3     ));
    set_led(LED_2,dbyte(((Colour * 4)- 3) + 1));
    set_led(LED_3,dbyte(((Colour * 4)- 3) + 2));
    set_led(LED_4,dbyte(((Colour * 4)- 3) + 3));
}
 


T1 please.
User avatar
Tomhug
Sergeant
Sergeant
 
Posts: 6
Joined: Sun Oct 25, 2020 9:08 am

Re: Script Conversion Request Megathread

Postby Mad » Thu Nov 26, 2020 12:24 am

Tomhug wrote:T1 please.
T1 2K21.gpc
(6.69 KiB) Downloaded 99 times
ConsoleTuner Support Team || ConsoleTuner Discord || InputSense Discord (2K / FPS)
Mad
Major General
Major General
 
Posts: 4533
Joined: Wed May 22, 2019 5:39 am

Re: Script Conversion Request Megathread

Postby gohun9008 » Sat Nov 28, 2020 1:33 pm

Can anyone change this too t1? If possible
Attachments
Dri_Cloud_v1.gpc
(9.93 KiB) Downloaded 83 times
User avatar
gohun9008
First Sergeant
First Sergeant
 
Posts: 63
Joined: Sun Sep 13, 2015 2:37 pm

Re: Script Conversion Request Megathread

Postby sebascu » Sun Nov 29, 2020 1:04 pm

dogzthefighters_fortnite_script_exponential_and_linear_v2_zen_only_includes_menu_v3.gpc
ayuda para convertir a titan one
(65.44 KiB) Downloaded 95 times
User avatar
sebascu
Sergeant Major
Sergeant Major
 
Posts: 68
Joined: Sat Aug 03, 2019 5:32 pm

Re: Script Conversion Request Megathread

Postby sebascu » Sun Nov 29, 2020 1:07 pm

ayuda para comvertir a titan one
Code: Select all
// GPC Online Library
// fortnite_aim_with_polar_(zen_+_max)_[perfect_accuracy_only].gpc
 
                                                                                                                                                             /*
   ___         _  __      __   ___   __   __  ___   
  / _ \ ___   / |/ /___  / /_ / _ | / /_ /  |/  /___
 / // // _ \ /    // _ \/ __// __ |/ __// /|_/ // -_)
/____/ \___//_/|_/ \___/\__//_/ |_|\__//_/  /_/ \__/  For Polar Aim Assist That Works With device
 
   ___        _____    ______ __        ____ _  _____ __  ______      ___
  / _ \ ___  / ___/___/_  __// /  ___  / __/(_)/ ___// / /_  __/___  / _ \
 / // // _ \/ (_ //_ / / /  / _ \/ -_)/ _/ / // (_ // _ \ / /  / -_)/ , _/
/____/ \___/\___/ /__//_/  /_//_/\__//_/  /_/ \___//_//_//_/   \__//_/|_|  For Enhancing DoNotAtMe's Polar Aim Assist
                                                                           Code For device
   ____ __        ____                 __ 
  /  _// /_ ___  / __/___  ___ _ ____ / /__
 _/ / / __//_ / _\ \ / _ \/ _ `// __//  '_/
/___/ \__/ /__//___//_//_/\_,_/ \__//_/\_\  For Most Of The Other Aim Assist Codes
 
   ____ ____     _  __ _  __          __       _
  / __// __/    / |/ /(_)/ /__ ___   / /___ _ (_)
 _\ \ _\ \     /    // //  '_// _ \ / // _ `// /
/___//___/____/_/|_//_//_/\_\ \___//_/ \_,_//_/  For Putting All This Together
         /___/                                   
                                                                                                                                                             */

//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 X = RX;                                   
define Y = RY;
 
//DON'T AT ME POLAR AIM ASSIST (CMP VERSION)
int DONT_AT_ME_ASSIST = TRUE
 
//100% Perfect Accuracy (L2 + R1)
int PerfectAccuracy = TRUE;
 
//Aim assist ADS
int Aim1  = 21;// Decrease if shake
int Aim1_delay= 20;// Increase if game lag
 
//Aim Assist Hip Fire
int Aim2  = 21;// Decrease if shake
int Aim2_delay= 20;// Increase if game lag
 
//2nd Aim Assist ADS
int AP = 20; //Decrease if shake
int AM = -20; //Decrease if shake
int Delay = 21; //How fast Aim Assist Run
int Reelease = 21; //Must be 1 higher than AP & AM
 
//2nd Aim Assist Hip Fire
int APP = 19; //Decrease if shake
int AMM = -19; //Decrease if shake
int Delayyyy = 21; //How fast Aim Assist Run
int Reeleasee = 20; //Must be 1 higher than APP & AMM
 
//Aim Assist
int AimmAsssist = TRUE;
int aav  = 10;//
int delay  = 5;
 
//Aim Abuse
int AimAbuse = TRUE;
int AimAbuse_HOLD = 460;
int AimAbuse_RELEASE = 20;
 
//Anti Recoil
int AntiRecoil = TRUE;
int arv = 3;
 
// 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
 
// POLAR CONDITIONS
define ACTIVE_WHEN_ADS    = TRUE;//POLAR ASSSIT PRESSING AIM
define ACTIVE_WHEN_FIRING = TRUE;//POLAR ASSSIT ACTIVE BY ONLY PRESSING FIRE OR AIM & FIRE                   
define POLAR_BOOST_FIRE   = TRUE;//BOOST POLAR AIM ASSIST ON FIRE ( WHEN AIMING & SHOOTING )
define POLAR_SHAKE_FIRE   = TRUE//SHAKE POLAR AIM ASSIST ON FIRE ( WHEN AIMING & SHOOTING )
 
// DON'T TOUCH THESE BELOW
define STEP_INTERVAL =  1;
define STEPS2 = 0;
int RADIUS1,RADIUS2 = 10,RADIUS3 = 100;
int time,angle,cos_angle,sin_angle,actual_X,actual_Y,actual_Magnitude,max_Magnitude,STEPS1;
 
const char Polar_Array[]={100,100,100,100,100,100,100,100,99,99,99,99,98,98,97,97,97,96,95,95,94,94,93,92,92,91,90,89,89,88,87,86,85,84,83,82,81,   
80,79,78,77,75,74,73,72,71,70,69,67,66,65,63,62,61,59,58,56,55,53,52,50,49,47,46,44,43,41,40,38,36,35,33,31,30,28,26,25,23,21,20,18,16,14,13,11,9,7,
6,4,2,0,-1,-3,-5,-7,-8,-10,-12,-13,-15,-17,-19,-20,-22,-24,-25,-27,-29,-30,-32,-34,-35,-37,-39,-40,-42,-43,-45,-46,-48,-50,-51,-53,-54,-55,-57,-58
-60,-61,-62,-64,-65,-66,-68,-69,-70,-71,-73,-74,-75,-76,-77,-78,-79,-80,-81,-82,-83,-84,-85,-86,-87,-88,-89,-89,-90,-91,-92,-92,-93,-93,-94,-95,-95,
-96,-96,-97,-97,-97,-98,-98,-99,-99,-99,-99,-100,-100,-100,-100,-100,-100,-100,-100,-100,-100,-100,-100,-100,-100,-99,-99,-99,-98,-98,-98,-97,-97,   
-96,-96,-95,-94,-94,-93,-93,-92,-91,-90,-90,-89,-88,-87,-86,-85,-84,-83,-82,-81,-80,-79,-78,-77,-76,-75,-74,-72,-71,-70,-69,-67,-66,-65,-63,-62,-61,
-59,-58,-56,-55,-53,-52,-50,-49,-47,-46,-44,-43,-41,-40,-38,-36,-35,-33,-31,-30,-28,-26,-25,-23,-21,-20,-18,-16,-14,-13,-11,-9,-7,-6,-4,-2,0,2,4,6,7,
9,11,13,14,16,18,20,21,23,25,26,28,30,31,33,35,36,38,40,41,43,44,46,47,49,51,52,54,55,56,58,59,61,62,63,65,66,67,69,70,70,72,73,74,75,77,78,79,80,81,
82,83,84,85,86,87,88,89,89,90,91,92,92,93,94,94,95,95,96,97,97,97,98,98,99,99,99,99,100,100,100,100,100,100,100};
/*-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 | | | | | | | | |M|A|I|N| | |S|E|C|T|I|O|N| | | | | | | | | | | | | | | | | | | | | | |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+*/
      
main {
if(get_val(PS4_L2) && event_press(PS4_L2))
combo_run(AimAssist1);
else
combo_stop(AimAssist1);
 
if(get_val(PS4_R2)) combo_run(AimAssist2);
else
combo_stop(AimAssist2);
 
if(get_val(PS4_L2) && event_press(PS4_R2))
combo_run(Aim1_XY);
else
combo_stop(Aim1_XY);
 
if(get_val(PS4_R2))
combo_run(Aim2_XY);
else
combo_stop(Aim2_XY);
 
if(AntiRecoil){
if(get_val(PS4_L2) && !get_val(PS4_R2)){
arv =  -3;}
if(get_val(PS4_R2) && !get_val(PS4_L2)){       
arv =  3;}
if(get_val(PS4_R2) && get_val(PS4_L2)){       
arv =  3;}
}
 
if (AimmAsssist) {
if (get_val(PS4_L2)> 105/1/1<9999){ combo_run(AimmAsssist);}
}
if (abs(get_val(PS4_RX)) > 19 || abs(get_val(PS4_RY)) > 19){
combo_stop(AimmAsssist);}
if(AimAbuse){
if(get_val(PS4_L2)> 95){
combo_run(AimAbuse);}
if(event_release(PS4_L2)){ combo_stop(AimAbuse);}
}
 
if (get_val(PS4_L2) && get_val(PS4_R1)) {
PerfectAccuracy = !PerfectAccuracy;
combo_run(cPerfectAccuracy);
set_val(PS4_R1, 0);
} else {
combo_stop(cPerfectAccuracy);
}
    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(PS4_R2)) {   
       RADIUS1 =  POLAR_BOOST * RADIUS2;
       }
else
    RADIUS1 =  RADIUS3;
       }
if (POLAR_SHAKE_FIRE) {
if (POLAR_SHAKE_FIRE && get_val(PS4_R2)) {
    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(PS4_L2) && abs(get_val(PS4_RY)) < POLAR_RELEASE && abs(get_val(PS4_RX)) < POLAR_RELEASE)
       || (ACTIVE_WHEN_FIRING && get_val(PS4_R2) && abs(get_val(PS4_RY))< POLAR_RELEASE && abs(get_val(PS4_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));
    }
}
  }
/*-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 | | | | | | | | |C|O|M|B|O| |S|E|C|T|I|O|N| | | | | | | | | | | | | | | | | | | | | | |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+*/

combo cPerfectAccuracy {
set_val(PS4_R2,100);
wait(100);
wait(250);
set_val(PS4_R2,100);
}
combo Aim1_XY {
set_val(PS4_RY,xy_val(PS4_RY,Aim1));
wait(Aim1_delay)
set_val(PS4_RX,xy_val(PS4_RX,Aim1));
set_val(PS4_LX,xy_val(PS4_LX,Aim1));
wait(Aim1_delay)
set_val(PS4_RY,xy_val(PS4_RY,inv(Aim1)));
wait(Aim1_delay)
set_val(PS4_RX,xy_val(PS4_RX,inv(Aim1)));
set_val(PS4_LX,xy_val(PS4_LX,inv(Aim1)));
wait(Aim1_delay)
}
combo Aim2_XY {
set_val(PS4_RY,xxyy_val(PS4_RY,Aim2));
wait(Aim2_delay)
set_val(PS4_RX,xxyy_val(PS4_RX,Aim2));
set_val(PS4_LX,xxyy_val(PS4_LX,Aim2));
wait(Aim2_delay)
set_val(PS4_RY,xxyy_val(PS4_RY,inv(Aim2)));
wait(Aim2_delay)
set_val(PS4_RX,xxyy_val(PS4_RX,inv(Aim2)));
set_val(PS4_LX,xxyy_val(PS4_LX,inv(Aim2)));
wait(Aim2_delay)
}
combo AimAssist1 {
set_val(PS4_RY,a_f(PS4_RY,AP));
wait(Delay)
set_val(PS4_RX,a_f(PS4_RX,AP));
wait(Delay)
set_val(PS4_RY,a_f(PS4_RY,AM));
wait(Delay)
set_val(PS4_RX,a_f(PS4_RX,AM));
wait(Delay)
}
combo AimAssist2 {
set_val(PS4_RY,aa_ff(PS4_RY,APP));
wait(Delayyyy)
set_val(PS4_RX,aa_ff(PS4_RX,APP));
wait(Delayyyy)
set_val(PS4_RY,aa_ff(PS4_RY,AMM));
wait(Delayyyy)
set_val(PS4_RX,aa_ff(PS4_RX,AMM));
wait(Delayyyy)
}
combo AimmAsssist  {
set_val(PS4_RY, (aav)); wait(delay)
set_val(PS4_RX, (aav)); wait(delay)
set_val(PS4_RY, aav * -1); wait(delay)
set_val(PS4_RX, aav * -1); wait(delay)
}
combo AimAbuse {
set_val(PS4_L2, 100);
wait(AimAbuse_HOLD);
set_val(PS4_L2, 0);
wait(AimAbuse_RELEASE);
}
/*-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 | | | | | | | | |F |U | N | C | T | I | O | N | S | | | | | | | | | | | | | | | | | | |
 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+*/

function clamp(int v,int lo,int hi) {
if(v < lo)
      return lo;               
if(v > hi)
      return hi;       
          return v;     
}
function a_f(p,m) {
if(abs(get_val(p)) < Reelease)
return m;
return get_val(p);
}
function aa_ff(p,m) {
if(abs(get_val(p)) < Reeleasee)
return m;
return get_val(p);
}
function xy_val(f_axis,f_val) {
if(abs(get_val(f_axis)) < Aim1 + 1)
return f_val;
return get_val(f_axis);
}
function xxyy_val(f_axis,f_val) {
if(abs(get_val(f_axis)) < Aim2 + 1)
return f_val;
return get_val(f_axis);
}
User avatar
sebascu
Sergeant Major
Sergeant Major
 
Posts: 68
Joined: Sat Aug 03, 2019 5:32 pm

Re: Script Conversion Request Megathread

Postby Mad » Sun Nov 29, 2020 8:07 pm

sebascu wrote:ayuda para comvertir a titan one

converted here: viewtopic.php?f=6&t=14428&hilit=fortnite&start=270#p99551
ConsoleTuner Support Team || ConsoleTuner Discord || InputSense Discord (2K / FPS)
Mad
Major General
Major General
 
Posts: 4533
Joined: Wed May 22, 2019 5:39 am

Re: Script Conversion Request Megathread

Postby gohun9008 » Mon Nov 30, 2020 3:35 am

Mad wrote:
sebascu wrote:ayuda para comvertir a titan one

converted here: viewtopic.php?f=6&t=14428&hilit=fortnite&start=270#p99551

Think u can do mine?
User avatar
gohun9008
First Sergeant
First Sergeant
 
Posts: 63
Joined: Sun Sep 13, 2015 2:37 pm

Re: Script Conversion Request Megathread

Postby sebascu » Mon Nov 30, 2020 9:51 pm

comvertir a titan one porfavor

Code: Select all
//Posted : Monday 30th of November, 2020 21:46 UTC  
 
 
//#################################################################################################
//######################################### Sweet_EviL_14 #########################################
//#################################################################################################
//#     _________                      __    ___________     .__.____       ____   _____          #
//#    /   _____/_  _  __ ____   _____/  |_  \_   _____/__  _|__|    |     /_   | /  |  |         #
//#    \_____  \\ \/ \/ // __ \_/ __ \   __\  |    __)_\  \/ /  |    |      |   |/   |  |_        #
//#    /        \\     /\  ___/\  ___/|  |    |        \\   /|  |    |___   |   /    ^   /        #
//#   /_______  / \/\_/  \___  >\___  >__|   /_______  / \_/ |__|_______ \  |___\____   |         #
//#           \/             \/     \/               \/                 \/           |__|         #
//#                                                                                               #
//#################################################################################################
//############################## Sweet_EviL_14 SE_PRO_AIM_V2.9.5 ##################################
//#################################################################################################
//
 
// don't change
/*
const int Lookup_Table[] =
{
    0,     1,  3,  5,  6,  8,  10, 12, 13, 15,
    17, 19, 20, 22, 24, 25, 27, 29, 30, 32,
    34, 35, 37, 39, 40, 42, 43, 45, 46, 48,
    50, 51, 52, 54, 55, 57, 58, 60, 61, 62,
    64, 65, 66, 68, 69, 70, 71, 73, 74, 75,
    76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
    86, 87, 88, 89, 89, 90, 91, 92, 92, 93,
    93, 94, 95, 95, 96, 96, 97, 97, 98, 98,
    98, 98, 99, 99, 99, 99, 99, 99, 99, 99,
    100
}
/*/

 
 
const int16 Lookup_Table[] =
{
    0,      1734526987104, 121, 139, 156,
    173, 190, 207, 224, 241, 258, 275, 292, 309, 325,
    342, 358, 374, 390, 406, 422, 438, 453, 469, 484,
    500, 515, 529, 544, 559, 573, 587, 601, 615, 629,
    642, 656, 669, 682, 694, 707, 719, 731, 743, 754,
    766, 777, 788, 798, 809, 819, 829, 838, 848, 857,
    866, 874, 882, 891, 898, 906, 913, 920, 927, 933,
    939, 945, 951, 956, 961, 965, 970, 974, 978, 981,
    984, 987, 990, 992, 994, 996, 997, 998, 999, 999,
    1000
}
 
 
//#################################################################################################
 
 
//Don't change these value!!!!!!!
 
 
define PROCESS_SE_AIM_PRO        = 0;
define PROCESS_SMOOTHING        = 1;
 
 
//#################################################################################################
 
 
//Don't change these value!!!!!!!
 
 
define REGULAR_AIM_ASSIST        = 0;
define DYNAMIC_AIM_ASSIST        = 1;
define SPIROIDE_AIM_ASSIST        = 2;
define DYSPIROIDE_AIM_ASSIST    = 3;   // DYNAMIC_AIM_ASSIST + SPIROIDE_AIM_ASSIST
 
 
//Choose Type
define AIM_ASSIST_TYPE            = DYSPIROIDE_AIM_ASSIST; // select your aim assist type choose:
 
 
 
 
//#################################################################################################
 
 
define CIRCULAR_SHAPES            = 0;
define LINEAR_SHAPES            = 1;
define ELLIPSOID_SHAPES            = 2;
 
 
//Choose Pattern
define PATTERN_SHAPES             = CIRCULAR_SHAPES;     // select your chape. choose:
 
 
//#################################################################################################
 
 
//Cofigure angle
define ANGLE_INCREMENT             = 22;
define ANGLE_SAMLING_RATE        = 25;
 
 
//#################################################################################################
 
 
//Configure Radius
define MAX_RADIUS                 = 22;   // Warning !!!!! Max value if ELLIPSOID_SHAPES if selected 20 otherwise 30
define MIN_RADIUS                 = 8;
 
 
//#################################################################################################
 
 
// Configure Steady aim
                                                       // CIRCULAR_SHAPES or LINEAR_SHAPES
define USE_STEADY_AIM             = TRUE;
define STEADY_AIM_RESOLUTION    = 6;
 
 
//#################################################################################################
 
 
// configure SIROID
 
 
//don't change!
 
 
define INSIDE_SENS                = 0;
define OUTSIDE_SENS                = 1;
 
 
//select  sens
define SPIN_SENS                = OUTSIDE_SENS;                    // Increase value decrease spinning speed Only for SPIROIDE_AIM_ASSIST or DYSPIROIDE_AIM_ASSIST
 
 
//configure speed
define SPIN_SPEED                = 8;
 
 
//#################################################################################################
 
 
//Configure movement smoothness
define MAX_MAGNITUDE             = 12;
 
 
define SMOOTHING                 = 25; // smoothing time = vm update date x SMOOTHING
 
 
//#################################################################################################
 
 
//Configure Virtual machine update time
 
 
define VM_UPDATE                = 10;
 
 
//#################################################################################################
 
 
//Configure AR
 
 
define USE_ANTI_RECOIL                 = TRUE;
 
 
define MAX_ANTI_RECOIL_CORRECTION     = 24;
define FIXED_ANTI_RECOIL             = 2;
define PROGRESSIVE_ANTI_RECOIL         = 80//bigger value less progressive
define ANTI_RECOIL_SRENGTH            = 3; // use 4 for warzone 2 for mp
 
 
//#################################################################################################
 
 
//Configure Slide cancel
 
 
define USE_SLIDE_CANCEL            = TRUE;
 
 
define CROUCH_BUTTON             = PS4_CIRCLE
 
 
define JUMP_BUTTON              = PS4_CROSS;
 
 
//#################################################################################################
 
 
//Configure Controller
 
 
define ADS_BUTTON                 = PS4_L2;
 
 
define FIRE_BUTTON                 = PS4_R2;
 
 
define DEAD_ZONE_LIMIT            = 2;
 
 
//#################################################################################################
 
 
int Rx;
int Ry;
int Rx_Polar;
int Ry_Polar;
int Angle;
int Polar_Process_Done;
int Angle_Increment_State;
int Angle_Update_Cycle;
int Init_Agnle_Update_Cycle
int Radius;
int Radius_Increment_State;
int Ellipse_Radius;
int Smoothing;
int SE_PRO_AIM_STATE;
int Anti_Recoil_Angle;
int Anti_Recoil_Correction;
 
 
//#################################################################################################
 
 
int ret;
int val1;
int val2;
 
 
//#################################################################################################
 
 
init
{
    Angle  = 0;
    Smoothing = SMOOTHING;
    Polar_Process_Done = TRUE;
    SE_PRO_AIM_STATE = PROCESS_SE_AIM_PRO;
    Anti_Recoil_Angle = (180/ANGLE_INCREMENT) * ANGLE_INCREMENT;
    Init_Agnle_Update_Cycle = ANGLE_SAMLING_RATE * (360/ANGLE_INCREMENT);
    Anti_Recoil_Correction = FIXED_ANTI_RECOIL;
 
    if((AIM_ASSIST_TYPE == SPIROIDE_AIM_ASSIST) || (AIM_ASSIST_TYPE == DYSPIROIDE_AIM_ASSIST))
    {
        if(SPIN_SENS == OUTSIDE_SENS)
        {
            Ellipse_Radius = MIN_RADIUS;
            Radius = MIN_RADIUS;
            Radius_Increment_State = TRUE;           
        }
        else if(SPIN_SENS == INSIDE_SENS)
        {
            Ellipse_Radius = MAX_RADIUS;
            Radius = MAX_RADIUS;
            Radius_Increment_State = FALSE;       
        }
    }
    else
    {
        Ellipse_Radius = MAX_RADIUS;
        Radius = MAX_RADIUS;
        Radius_Increment_State = FALSE;
    }
}
//#################################################################################################
 
 
main
{   
    vm_tctrl(VM_UPDATE);
 
    if((get_val(ADS_BUTTON) > 50) || (get_val(FIRE_BUTTON)> 50))
    {   
        if( SE_PRO_AIM_STATE == PROCESS_SE_AIM_PRO)
        {
            Rx = get_val(PS4_RX);
            Ry = get_val(PS4_RY);
 
 
            if((check_magnitude_overflow(PATTERN_SHAPES, MAX_MAGNITUDE) == TRUE))
            {       
                Polar_Process_Done = TRUE;           
                Smoothing = SMOOTHING;
 
                /*
                Angle = 0;
                Angle_Update_Cycle = Init_Agnle_Update_Cycle;           
 
                if((AIM_ASSIST_TYPE == SPIROIDE_AIM_ASSIST) || (AIM_ASSIST_TYPE == DYSPIROIDE_AIM_ASSIST))
                {
                    if(SPIN_SENS == OUTSIDE_SENS)
                    {
                        Ellipse_Radius = MIN_RADIUS;
                        Radius = MIN_RADIUS;
                        Radius_Increment_State = TRUE;           
                    }
                    else if(SPIN_SENS == INSIDE_SENS)
                    {
                        Ellipse_Radius = MAX_RADIUS;
                        Radius = MAX_RADIUS;
                        Radius_Increment_State = FALSE;       
                    }
                }
                else
                {
                    Ellipse_Radius = MAX_RADIUS;
                    Radius = MAX_RADIUS;
                    Radius_Increment_State = FALSE;
                }
                */

                SE_PRO_AIM_STATE = PROCESS_SMOOTHING;
            }
            else   
            {                               
                if(USE_STEADY_AIM == TRUE)
                {
                    Rx = get_steady_aim(Rx, STEADY_AIM_RESOLUTION);
                    Ry = get_steady_aim(Ry, STEADY_AIM_RESOLUTION);
                }
 
                if( Polar_Process_Done == TRUE)
                {   
                    Polar_Process_Done = FALSE;                   
 
 
                    if( (abs(Ry) > DEAD_ZONE_LIMIT) && (abs(Rx) > DEAD_ZONE_LIMIT))
                    {   
                        Angle = get_full_quadrant_angle(atan2_16bits(inv(Ry),Rx));
 
                        Angle_Update_Cycle = Init_Agnle_Update_Cycle;
 
                        if(    (Angle >= 0 && Angle <= 90) || (Angle >= 270))
                        {
                            Angle_Increment_State = TRUE;
                        }
                        else
                        {
                            Angle_Increment_State = FALSE;
                        }
                    }
                    else
                    {
                        Angle = 0;
                        Angle_Increment_State = TRUE;
                    }
                }
 
                if(AIM_ASSIST_TYPE == DYNAMIC_AIM_ASSIST || AIM_ASSIST_TYPE == DYSPIROIDE_AIM_ASSIST)
                {
                    ret = MAX_RADIUS - ((abs(get_val(PS4_RX)) * abs(get_val(PS4_RX)) + abs(get_val(PS4_RY)) * abs(get_val(PS4_RY)))/1000);
 
                    if(AIM_ASSIST_TYPE == DYSPIROIDE_AIM_ASSIST)
                    {               
                        if(PATTERN_SHAPES == ELLIPSOID_SHAPES)
                        {                   
                            if(ret < Ellipse_Radius)
                            {
                                Ellipse_Radius = ret;
                                Radius_Increment_State = FALSE;
                            }
                        }   
                        else  // (PATTERN_SHAPES == ELLIPSOID_SHAPES))
                        {
                            if(ret < Radius)
                            {                       
                                Radius = ret;
                                Radius_Increment_State = FALSE;
                            }
                        }               
                    }
                    else
                    {
                        Radius = ret;           
                        Ellipse_Radius = ret;
                    }
                }
 
                if(PATTERN_SHAPES == ELLIPSOID_SHAPES)
                {
                    //set_val(TRACE_6,Ellipse_Radius);
                    Radius = calculate_ellipsoid_RADIUS(Ellipse_Radius,cos(Angle));   
                }
 
 
                Rx_Polar = get_polar_coordinate(Radius, cos(Angle));
                Ry_Polar = get_polar_coordinate(Radius, sin(Angle));
 
                Rx = process_overflow_check(Rx, Rx_Polar);
                Ry = process_overflow_check(Ry, Ry_Polar);
 
 
                if((USE_ANTI_RECOIL == TRUE) && (get_val(ADS_BUTTON) > 50)&& (get_val(FIRE_BUTTON) > 50))
                {
                    if( ((ANTI_RECOIL_SRENGTH!= 0) && (Angle <=  (180 + (ANTI_RECOIL_SRENGTH * Anti_Recoil_Angle))) &&  (Angle >=  (180 - (ANTI_RECOIL_SRENGTH * Anti_Recoil_Angle))))
 
                    || ((ANTI_RECOIL_SRENGTH == 0) && (Angle  == Anti_Recoil_Angle)))
                    {
                        ret = get_ptime(PS4_R2);
 
                        if( ret >= 100)
                        {
                            Anti_Recoil_Correction = (ret/PROGRESSIVE_ANTI_RECOIL) + FIXED_ANTI_RECOIL;
 
                            if(Anti_Recoil_Correction > MAX_ANTI_RECOIL_CORRECTION)
                            {
                                Anti_Recoil_Correction = MAX_ANTI_RECOIL_CORRECTION;
                            }
                            set_val(TRACE_1,Anti_Recoil_Correction);
                            Ry += Anti_Recoil_Correction;
                            Ry = process_overflow_check(Ry, 0);
                            set_val(TRACE_2,Ry);
                        }
                    }
                }
 
                if(USE_STEADY_AIM == TRUE)
                {
                    Rx = get_steady_aim(Rx, STEADY_AIM_RESOLUTION);
                    Ry = get_steady_aim(Ry, STEADY_AIM_RESOLUTION);   
 
                    Rx = process_overflow_check(Rx, 0);
                    Ry = process_overflow_check(Ry, 0);
                }
 
                set_right_joystick(Rx, Ry, PATTERN_SHAPES);
 
                if(((AIM_ASSIST_TYPE == SPIROIDE_AIM_ASSIST) || (AIM_ASSIST_TYPE == DYSPIROIDE_AIM_ASSIST)) && ((Angle_Update_Cycle % SPIN_SPEED) == 0))
                {
 
                    if(Radius_Increment_State == FALSE)
                    {
                        if(PATTERN_SHAPES == ELLIPSOID_SHAPES)
                        {
                            Ellipse_Radius -= 1;
 
                            if(Ellipse_Radius < MIN_RADIUS)
                            {
                                Radius_Increment_State = TRUE;
                                Ellipse_Radius = MIN_RADIUS;
                            }
                        }
                        else
                        {
                            Radius -= 1;       
 
                            if(Radius < MIN_RADIUS)
                            {
                                Radius_Increment_State = TRUE;
                                Radius = MIN_RADIUS;
                            }
                        }
                    }
                    else if(Radius_Increment_State == TRUE)
                    {
                        if(PATTERN_SHAPES == ELLIPSOID_SHAPES)
                        {
                            Ellipse_Radius += 1;
 
                            if(Ellipse_Radius > MAX_RADIUS)
                            {
                                Radius_Increment_State = FALSE;
                                Ellipse_Radius = MAX_RADIUS;
                            }
                        }
                        else
                        {
                            Radius += 1;
 
                            if(Radius > MAX_RADIUS)
                            {
                                Radius_Increment_State = FALSE;
                                Radius = MAX_RADIUS;
                            }
                        }
                    }
 
                    //set_val(TRACE_6,Ellipse_Radius);
                }
 
                Angle_Update_Cycle--;
 
                //set_val(TRACE_2,Angle_Update_Cycle);
 
                if(Angle_Update_Cycle == 0)
                {
                    Polar_Process_Done = TRUE;
 
                    Angle_Update_Cycle = Init_Agnle_Update_Cycle;                                               
                }
                else
                {
                    Angle = update_angle(Angle, Angle_Increment_State, ANGLE_INCREMENT);
                }
            }
        }
        else if( SE_PRO_AIM_STATE == PROCESS_SMOOTHING)
        {
 
            if(USE_STEADY_AIM == TRUE)
            {           
                if((USE_ANTI_RECOIL == TRUE) && (get_val(ADS_BUTTON) > 50) && (get_val(FIRE_BUTTON) > 50) && (Smoothing == (SMOOTHING/2)))
                {                               
                    Rx = get_val(PS4_RX);
                    Ry = get_val(PS4_RY);
 
                    Ry += Anti_Recoil_Correction;
 
                    Rx = get_steady_aim(Rx, STEADY_AIM_RESOLUTION);
                    Ry = get_steady_aim(Ry, STEADY_AIM_RESOLUTION);
 
                    Rx = process_overflow_check(Rx, 0);
                    Ry = process_overflow_check(Ry, 0);
 
                    set_val(PS4_RX, Rx);
                    set_val(PS4_RY, Ry);
                }
                else if((Smoothing % 2) == 0)
                {
                    Rx = get_val(PS4_RX);
                    Ry = get_val(PS4_RY);
 
                    Rx = get_steady_aim(Rx, STEADY_AIM_RESOLUTION);
                    Ry = get_steady_aim(Ry, STEADY_AIM_RESOLUTION);
 
                    Rx = process_overflow_check(Rx, 0);
                    Ry = process_overflow_check(Ry, 0);
 
                    set_val(PS4_RX, Rx);
                    set_val(PS4_RY, Ry);
                }
            }
            else if((USE_ANTI_RECOIL == TRUE) && (get_val(ADS_BUTTON) > 50) && (get_val(FIRE_BUTTON) > 50) && (Smoothing == (SMOOTHING/2)))
            {
                Ry = get_val(PS4_RY);               
                Ry += Anti_Recoil_Correction;
                Ry = process_overflow_check(Ry, 0);
                set_val(PS4_RY, Ry);
            }
 
            if(Smoothing == 0)
            {       
                SE_PRO_AIM_STATE = PROCESS_SE_AIM_PRO;
            }
 
            Smoothing--;               
        }
    }
    else
    {
        Angle = 0;
        Polar_Process_Done = TRUE;
        Angle_Update_Cycle = Init_Agnle_Update_Cycle;
 
        Anti_Recoil_Correction = FIXED_ANTI_RECOIL;
 
        Smoothing = SMOOTHING;
        SE_PRO_AIM_STATE = PROCESS_SE_AIM_PRO;
 
        if(AIM_ASSIST_TYPE == SPIROIDE_AIM_ASSIST || AIM_ASSIST_TYPE == DYSPIROIDE_AIM_ASSIST)
        {
            if(SPIN_SENS == OUTSIDE_SENS)
            {
                Ellipse_Radius = MIN_RADIUS;
                Radius = MIN_RADIUS;
                Radius_Increment_State = TRUE;           
            }
            else if(SPIN_SENS == INSIDE_SENS)
            {
                Ellipse_Radius = MAX_RADIUS;
                Radius = MAX_RADIUS;
                Radius_Increment_State = FALSE;       
            }
        }
        else
        {
            Ellipse_Radius = MAX_RADIUS;
            Radius = MAX_RADIUS;
            Radius_Increment_State = FALSE;
        }
    }
 
    if(USE_SLIDE_CANCEL == TRUE) 
      {                                                                                                 
        if((get_val(PS4_LY) < -60) || (get_val(PS4_LY) > 60) || (get_val(PS4_LX) < -60) || (get_val(PS4_LX) > 60))
        {
              if(event_release(CROUCH_BUTTON))
              {
                 combo_run(COMBO_SLIDE_CANCEL);
              }
        }                                                                                             
    }     
}
 
 
//#################################################################################################
/*
function calculate_eccentricity_coef(max_ellipsoid_RADIUS, min_ellipsoid_RADIUS)
{
    val1 = pow(min_ellipsoid_RADIUS, 2);
    val2 = pow(max_ellipsoid_RADIUS, 2);
    val1 *= 10;
    ret = val1/val2;
    ret = 10 - ret;
 
    return ret;
}
*/

//#################################################################################################
 
 
function calculate_ellipsoid_RADIUS(Radius, cosinus)
{       
    // factor 50%
    ret = (cosinus * (Radius/2));   
    ret = (1000 * Radius )- ret;
    ret /= 100;
 
    return (ret);
}
 
 
//#################################################################################################
 
 
function update_angle(angle, increment_state, val)
{
    if(increment_state == TRUE)
    {
        angle += val;
 
        if(angle >= 360)
        {
            angle -= 360;
        }
    }
    else
    {
        angle -= val;
 
        if(angle <= 0)
        {
            angle = 360 + angle;
        }
    }
 
    return angle;
}
 
//#################################################################################################
 
 
function set_right_joystick(x , y, pattern)
{   
    set_val(PS4_RX, x);
 
    if(pattern != LINEAR_SHAPES)
    {
        set_val(PS4_RY, y);   
    }
}
 
 
//#################################################################################################
 
 
function check_magnitude_overflow(pattern, max_val)
{
    ret = TRUE;
    val2 = 0;
 
    val1 = isqrt(pow((get_lval(PS4_RX) - get_val(PS4_RX)), 2));
 
    if( pattern != LINEAR_SHAPES)
    {
        val2 = isqrt(pow((get_lval(PS4_RY) - get_val(PS4_RY)), 2));       
    }
 
    if( (val1 <=  max_val) && (val2 <=  max_val))
    {
        ret = FALSE;
    }
 
    //set_val(TRACE_1,val1);
    //set_val(TRACE_2,val2);
 
    return ret;
}
 
 
//#################################################################################################
 
 
function get_steady_aim(axis, resolution)
{
    if(axis >= 0)
    {
        ret = (axis % resolution);
 
        if(ret >= (resolution / 2))
        {
            axis = axis + (resolution - ret);
        }
        else
        {
            axis -= ret;
        }
    }
    else
    {
        ret = (axis % resolution);
 
        if( abs(ret) >= (resolution / 2))
        {
            axis = axis - (resolution + ret);
        }
        else
        {
            axis += abs(ret);
        }
    }
 
    if(axis > 100)
    {
        axis = 100;
    }
    else if(axis < -100)
    {
        axis = -100;
    }
 
    return axis;
}
 
 
//#################################################################################################
 
 
function get_polar_coordinate(Radius, coef)
{
    if(Radius > 32)
    {
        Radius = 32;
    }
 
    return((Radius * coef) / 1000);       
}
 
 
//#################################################################################################
 
 
function process_overflow_check(x, y)
{
    ret = x + y;
 
    if( ret > 100)
    {
        ret = 100;
    }
    else if (ret < -100)
    {
        ret = -100;
    }
 
    return ret;
}
 
 
//#################################################################################################
 
 
function sin(angle)
{   
    if(angle <= 90)
    {             
        ret = (Lookup_Table[angle]);
    }
    else if (angle <= 180)
    {     
        ret = (Lookup_Table[180 - angle]);
    }
    else if (angle <= 270)
    {
        ret = inv(Lookup_Table[angle - 180]);     
    }
    else
    {
           ret = inv(Lookup_Table[360 - angle]);     
    }
 
    return ret;
}
 
 
//#################################################################################################
 
 
function cos(angle)
{   
    if(angle <= 90)
    {             
        ret = (Lookup_Table[90 - angle]);
    }
    else if (angle <= 180)
    {     
        ret = inv(Lookup_Table[angle - 90]);
    }
    else if (angle <= 270)
    {
        ret = inv(Lookup_Table[270 - angle]);       
    }
    else
    {
        ret = (Lookup_Table[angle - 270]);       
    }
 
    return ret;
}
 
 
//#################################################################################################
 
 
function atan2_16bits(y, x)
{   
    // determine Angle
    if (y >= 0)
    { // oct 0,1,2,3
        if (x >= 0) { // oct 0,1
            if (x > y)
            {
                ret = ( (y * 300) / x );
            }
            else
            {
                if (y == 0)
                ret = 0; // (x=0,y=0)
                else
                ret = 540 - ( (x * 300) / y );
 
 
            }
        }
        else
        { // oct 2,3
          // if (inv(x) <= y) {
            if (x >= inv(y))
            {
                ret = 540 - ( (x * 300) / y );
            }
            else
            {
                ret = 1080 + ( (y * 300) / x );
            }
        }
    }
    else
    { // oct 4,5,6,7
        if (x < 0)
        { // oct 4,5
          // if (inv(x) > inv(y)) {
            if (x < y)
            {
                ret = ( (y * 300) / x ) - 1080;
            }
            else
            {
                ret = ( (inv(x) * 300) / y ) - 540;
            }
        } else
        { // oct 6,7
          // if (x <= inv(y)) {
            if (inv(x) >= y)
            {
                ret = ( (inv(x) * 300) / y ) - 540;
            }
            else
            {
                ret = ( (y * 300) / x );
            }
        }
    }
 
    return (ret/6);
}
 
 
//#################################################################################################
 
 
function get_full_quadrant_angle(angle)
{
 
 
    if(angle < 0)
    {
        angle += 360;
    }
 
    return angle
}
 
 
//#################################################################################################
 
 
combo COMBO_SLIDE_CANCEL
{             
    set_val(CROUCH_BUTTON, 100);
 
    wait(120);     
 
    set_val(CROUCH_BUTTON, 0);
 
    wait(60);               
 
    set_val(CROUCH_BUTTON, 100);
 
    wait(50);               
 
    set_val(CROUCH_BUTTON, 100);         
    set_val(JUMP_BUTTON, 100);           
    wait(60)
 
    set_val(CROUCH_BUTTON, 0);           
    set_val(JUMP_BUTTON, 100);
 
    wait(10)
 
    set_val(JUMP_BUTTON, 0);         
}
User avatar
sebascu
Sergeant Major
Sergeant Major
 
Posts: 68
Joined: Sat Aug 03, 2019 5:32 pm

PreviousNext

Return to GPC1 Script Programming

Who is online

Users browsing this forum: No registered users and 46 guests