`/*DEADZONE AND ANTIDEADZONE*/ //This script will let you set a circular deadzone, counter circular and square//deadzones, and set inner and outer deadzones.//Note: The circular antideadzone is relative to the remaining range of the//square antideadzone.  I.E, both at 50 will give you a 75 antideadzone, since//25 is half of the remaining 50.  //Use values 0 to 100.  Avoid using deadzones/antideadzones larger than the//outerdeadzone and midpointX values larger than midpoint2X values. //A simpler conversion of the TitanTwo script, using previous fixes from ME/DontAtMe. //https://www.desmos.com/calculator/7vg5zh5wdl      //CHANGE THESE VALUES     //RIGHT STICK SETTINGS    int  deadZone              = 0;      //Set the circular deadzone the player wants to use    int  antiCircleDeadZone    = 0;      //Set the value of the game's circular deadzone the player wishes to counter    int  antiSquareDeadZone    = 0;      //The value of the game's square deadzone the player wishes to counter    int  outerDeadZoneIn       = 100;    //The value that the play will input that will be considered 100% stick tilt    int  outerDeadZoneOut      = 100;    //The maximum value that will be output to the game    int  midPointX             = 25;     //Curve control.  Edit horizontal position of first X-node.    int  midPointY             = 25;     //Curve control.  Edit vertical position of first Y-node.    int  midPoint2X            = 50;     //Curve control.  Edit horizontal position of second-node.    int  midPoint2Y            = 50;     //Curve control.  Edit vertical position of second Y-node.    int  angularRestrict       = 0;      //Restricts diagonal movement around the axes.    int  angularAnti           = 0;      //Skips diagonal movement around the axes.    int  uncapValues           = TRUE;   //Allows diagonal values to exceed the outerDeadZoneOut distance                                         //set to TRUE if unable to trigger maximum game movements    int  useAlternate          = 30;     //Choose to use alternate settings when a button is held down.  Use the identifier    int  useAlternate2         = 30;     //value of the button.  This can be found in Help > GPC Scripting Guide > GPC Language Reference >                                         //Data Representation > Use the Index value for the button.     //RIGHT STICK ALTERNATE SETTINGS    int  deadZoneA             = 0;    int  antiCircleDeadZoneA   = 0;    int  antiSquareDeadZoneA   = 0;    int  outerDeadZoneInA      = 100;    int  outerDeadZoneOutA     = 100;    int  midPointXA            = 25;    int  midPointYA            = 25;    int  midPoint2XA           = 50;    int  midPoint2YA           = 50;    int  angularRestrictA      = 0;    int  angularAntiA          = 0;    int  uncapValuesA          = TRUE;       //RIGHT STICK ALTERNATE 2 SETTINGS    int  deadZoneA2            = 0;    int  antiCircleDeadZoneA2  = 0;    int  antiSquareDeadZoneA2  = 0;    int  outerDeadZoneInA2     = 100;    int  outerDeadZoneOutA2    = 100;    int  midPointXA2           = 25;    int  midPointYA2           = 25;    int  midPoint2XA2          = 50;    int  midPoint2YA2          = 50;    int  angularRestrictA2     = 0;    int  angularAntiA2         = 0;    int  uncapValuesA2         = TRUE;                                           //````````````````````````````````````````````//     //LEFT STICK SETTINGS    int  deadZoneL              = 0;      //Set the circular deadzone the player wants to use    int  antiCircleDeadZoneL    = 0;      //Set the value of the game's circular deadzone the player wishes to counter    int  antiSquareDeadZoneL    = 0;      //The value of the game's square deadzone the player wishes to counter    int  outerDeadZoneInL       = 100;    //The value that the play will input that will be considered 100% stick tilt    int  outerDeadZoneOutL      = 100;    //The maximum value that will be output to the game    int  midPointXL             = 25;     //Curve control.  Edit horizontal position of first node.    int  midPointYL             = 25;     //Curve control.  Edit vertical position of first node.    int  midPoint2XL            = 50;     //Curve control.  Edit horizontal position of second node.    int  midPoint2YL            = 50;     //Curve control.  Edit vertical position of second node.    int  angularRestrictL       = 0;      //Restricts diagonal movement around the axes.    int  angularAntiL           = 0;      //Skips diagonal movement around the axes.    int  uncapValuesL           = TRUE;   //Allows diagonal values to exceed the outerDeadZoneOut distance                                          //set to TRUE if unable to trigger maximum game movements    int  useAlternateL          = 30;     //Choose to use alternate settings when a button is held down.  Use the identifier    int  useAlternateL2         = 30;     //value of the button.  This can be found in Help > GPC Language Reference >                                          //Data Representation > Use the Index value for the button.     //LEFT STICK ALTERNATE SETTINGS    int  deadZoneLA             = 0;    int  antiCircleDeadZoneLA   = 0;    int  antiSquareDeadZoneLA   = 0;    int  outerDeadZoneInLA      = 100;    int  outerDeadZoneOutLA     = 100;    int  midPointXLA            = 25;    int  midPointYLA            = 25;    int  midPoint2XLA           = 50;    int  midPoint2YLA           = 50;    int  angularRestrictLA      = 0;    int  angularAntiLA          = 0;    int  uncapValuesLA          = TRUE;      //LEFT STICK ALTERNATE 2 SETTINGS    int  deadZoneLA2            = 0;    int  antiCircleDeadZoneLA2  = 0;    int  antiSquareDeadZoneLA2  = 0;    int  outerDeadZoneInLA2     = 100;    int  outerDeadZoneOutLA2    = 100;    int  midPointXLA2           = 25;    int  midPointYLA2           = 25;    int  midPoint2XLA2          = 50;    int  midPoint2YLA2          = 50;    int  angularRestrictLA2     = 0;    int  angularAntiLA2         = 0;    int  uncapValuesLA2         = TRUE;         int x, y, newX, newY, outputX, outputY;    int magnitude, angleMagnitude, outputMagnitude;    int normX, normY;     int currRX, currRY;    int prevRX, prevRY;    int currLX, currLY;    int prevLX, prevLY;     int stickRX, stickRY;    int stickLX, stickLY;    int smallValue;     main {          //Apply Right Stick        currRX = get_val(XB1_RX);        currRY = get_val(XB1_RY);        if(prevRX != currRX || prevRY != currRY){             if(get_val(useAlternate) > 0){                applyStick(deadZoneA, antiCircleDeadZoneA, antiSquareDeadZoneA, outerDeadZoneInA, outerDeadZoneOutA, midPointXA, midPointYA, midPoint2XA, midPoint2YA, angularRestrictA, angularAntiA, uncapValuesA, 1);            }            else if(get_val(useAlternate2) > 0){                applyStick(deadZoneA2, antiCircleDeadZoneA2, antiSquareDeadZoneA2, outerDeadZoneInA2, outerDeadZoneOutA2, midPointXA2, midPointYA2, midPoint2XA2, midPoint2YA2, angularRestrictA2, angularAntiA2, uncapValuesA2, 1);            }             else{                applyStick(deadZone, antiCircleDeadZone, antiSquareDeadZone, outerDeadZoneIn, outerDeadZoneOut, midPointX, midPointY, midPoint2X, midPoint2Y, angularRestrict, angularAnti, uncapValues, 1);            }             prevRX = currRX;            prevRY = currRY;        }         set_val(XB1_RX, stickRX);        set_val(XB1_RY, stickRY);          //Apply Left Stick        currLX = get_val(XB1_LX);        currLY = get_val(XB1_LY);        if(prevLX != currLX || prevLY != currLY){             if(get_val(useAlternateL) > 0){                applyStick(deadZoneLA, antiCircleDeadZoneLA, antiSquareDeadZoneLA, outerDeadZoneInLA, outerDeadZoneOutLA, midPointXLA, midPointYLA, midPoint2XLA, midPoint2YLA, angularRestrictLA, angularAntiLA,uncapValuesLA, 2);            }            else if(get_val(useAlternateL2) > 0){                applyStick(deadZoneLA2, antiCircleDeadZoneLA2, antiSquareDeadZoneLA2, outerDeadZoneInLA2, outerDeadZoneOutLA2, midPointXLA2, midPointYLA2, midPoint2XLA2, midPoint2YLA2, angularRestrictLA2, angularAntiLA2, uncapValuesLA2, 2);            }            else{                applyStick(deadZoneL, antiCircleDeadZoneL, antiSquareDeadZoneL, outerDeadZoneInL, outerDeadZoneOutL, midPointXL, midPointYL, midPoint2XL, midPoint2YL, angularRestrictL, angularAntiL, uncapValuesL, 2);            }            prevLX = currLX;            prevLY = currLY;        }         set_val(XB1_LX, stickLX);        set_val(XB1_LY, stickLY);     }     function applyStick(dead, antiCDead, antiSDead, outerDeadIn, outerDeadOut, midX, midY, mid2X, mid2Y, angleRestrict, angleAnti, uncap, stick){         if(stick == 1){            x = currRX;            y = currRY;        }        else{            x = currLX;            y = currLY;        }         magnitude = isqrt(x*x + y*y);         smallValue = 0;         //precision        if(magnitude <= 10){            smallValue = 1;             x = x*10;            y = y*10;            magnitude = isqrt(x*x + y*y);        }         //Angle Restriction and countering        normX = 0;        if(abs(x) > (abs(y)*angleRestrict)/100){            normX = ((abs(x) - (abs(y)*angleRestrict)/100)*(100 - (abs(y)*angleAnti)/100))/(100 - (abs(y)*angleRestrict)/100) + (abs(y)*angleAnti)/100;        }        normY = 0;        if(abs(y) > (abs(x)*angleRestrict)/100){             normY = ((abs(y) - (abs(x)*angleRestrict)/100)*(100 - (abs(x)*angleAnti)/100))/(100 - (abs(x)*angleRestrict)/100) + (abs(x)*angleAnti)/100;        }                     angleMagnitude = isqrt(normX*normX + normY*normY);         normX = (normX*100)/angleMagnitude;        normY = (normY*100)/angleMagnitude;         if(smallValue == 0){             //Increasing antiCircleDeadZone to counter shrinkage with antiSquareDeadzone scaling below            antiCDead = (antiCDead*((antiCDead*(100 - antiSDead))/((antiCDead*(100 - (antiSDead*100)/outerDeadOut))/100)) )/100;             if(uncapValues == FALSE){                if(magnitude > outerDeadIn){magnitude = outerDeadIn;}            }             //DeadZone and antiCircleDeadZone scaling            outputMagnitude = 0;            if(magnitude > dead){                outputMagnitude = (((magnitude - dead)*(100))/(outerDeadIn - dead));  //Converting to 0-100 range                 //Piece-wise curve customization                if(outputMagnitude < midX ){                    outputMagnitude = (outputMagnitude*midY)/midX;                }                else if(outputMagnitude < mid2X){                    outputMagnitude = (((outputMagnitude - midX)*(mid2Y - midY))/(mid2X - midX)) + midY;                 }                else{                    outputMagnitude = (((outputMagnitude - mid2X)*(100 - mid2Y))/(100 - mid2X)) + mid2Y;                }                 //AntiDeadzone conversion                outputMagnitude = (((outputMagnitude)*(outerDeadZoneOut - antiCDead))/(100)) + antiCDead;                  newX = (normX*outputMagnitude)/100;                newY = (normY*outputMagnitude)/100;                 //antiSquareDeadZone scaling                outputX = (abs(newX)*(100 - (antiSDead*100)/outerDeadOut))/100 + antiSDead;                if(outputX > 100){outputX = 100;}                if(x < 0){outputX = outputX*(-1);}                if(x == 0){outputX = 0;}                 outputY = (abs(newY)*(100 -(antiSDead*100)/outerDeadOut))/100 + antiSDead;                if(outputY > 100){outputY = 100;}                if(y < 0){outputY = outputY*(-1);}                if(y == 0){outputY = 0;}                 if(stick == 1){                    stickRX = outputX;                    stickRY = outputY;                }                else{                    stickLX = outputX;                    stickLY = outputY;                }             }            else{                if(stick == 1){                    stickRX = 0;                    stickRY = 0;                }                else{                    stickLX = 0;                    stickLY = 0;                }            }        }     ///////////////////PRECISION//////////////////////         else{             //Increasing antiCircleDeadZone to counter shrinkage with antiSquareDeadzone scaling below            antiCDead = (antiCDead*((antiCDead*(100 - antiSDead))/((antiCDead*(100 - (antiSDead*100)/outerDeadOut))/100)) )/100;             //DeadZone and antiCircleDeadZone scaling            outputMagnitude = 0;            if(magnitude > dead*10){                outputMagnitude = (((magnitude - dead*10)*(100))/(outerDeadIn - dead));  //Converting to 0-1000 range             //Piece-wise curve customization            if(outputMagnitude < midX*10 ){                outputMagnitude = (outputMagnitude*midY)/midX;            }            else if(outputMagnitude < mid2X*10){                outputMagnitude = (((outputMagnitude - midX*10)*(mid2Y*10 - midY*10))/(mid2X*10 - midX*10)) + midY*10;            }            else{                outputMagnitude = (((outputMagnitude - mid2X*10)*(1000 - mid2Y*10))/(1000 - mid2X*10)) + mid2Y*10;            }              //AntiDeadzone conversion 0 - 1000            outputMagnitude = (((outputMagnitude)*(outerDeadZoneOut - antiCDead))/(100)) + (antiCDead*10);                 newX = ((normX/10)*outputMagnitude)/100;                newY = ((normY/10)*outputMagnitude)/100;                      //antiSquareDeadZone scaling                outputX = (abs(newX)*(100 - (antiSDead*100)/outerDeadOut))/100 + antiSDead;                if(x < 0){outputX = outputX*(-1);}                if(x == 0){outputX = 0;}                 outputY = (abs(newY)*(100 -(antiSDead*100)/outerDeadOut))/100 + antiSDead;                if(y < 0){outputY = outputY*(-1);}                if(y == 0){outputY = 0;}                 if(stick == 1){                    stickRX = outputX;                    stickRY = outputY;                }                else{                    stickLX = outputX;                    stickLY = outputY;                }             }            else{                if(stick == 1){                    stickRX = 0;                    stickRY = 0;                }                else{                    stickLX = 0;                    stickLY = 0;                }            }        }      }`