https://usetunez.com/_next/static/chunks/4033.db30970eeeb48107.js

1"use strict";(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[4033],{74033:(e,i,t)=>{t.d(i,{getScriptPresetMemoryUsage:()=>T});var n=t(36459);let a=`
2
3enum {
4	STATE_OFF,
5	STATE_RESTART,
6	STATE_LOADING,
7	STATE_PLAYING,
8	STATE_SETUP_MENU,
9	STATE_SETUP_SUBMENU,
10	STATE_SCREEN_SAVER,
11	STATE_SAVING,
12	STATE_CLEAN_SCREEN,
13	STATE_QUICK_ACTION
14}
15enum {
16// @[ANCHOR_CORE_MOD_ENUM_PRE]
17AntiRecoilEnum, AimAssistEnum, RapidFireEnum,
18// @[ANCHOR_MOD_ENUM]
19MiscEnum, InfoEnum
20}
21const uint8 modId[]  = {
22// @[ANCHOR_CORE_MOD_ID_ARRAY_PRE]
23AntiRecoilEnum, AimAssistEnum, RapidFireEnum,
24// @[ANCHOR_MOD_ID_ARRAY]
25MiscEnum, InfoEnum
26};
27int profileId = 0;
28enum { Profile1Enum=0 , Profile2Enum }
29enum { CircularEnum=0, TallOvalEnum, WideOvalEnum, SpiralEnum, HelixEnum, LeftRightEnum, SwayEnum, CrossEnum, OscillirateEnum }
30int quickActionModId;
31int quickActionType;
32int feedbackModId;
33int feedbackState;
34int feedbackTextAddr;
35int feedbackMode;
36int feedbackTime = 0;
37// @[ANCHOR_RUNTIME_DEFINES]
38define FEEDBACK_MODE_SAVED = 3;
39define FEEDBACK_MODE_PROFILE = 4;
40define FEEDBACK_MODE_NUMBER = 5;
41const string PROFILE_ACTIVE_TEXT = "ACTIVE";
42define ANTI_RECOIL_STAGE_TIMER_MAX = 4000;
43int toggle[__TOGGLE_ARRAY_SIZE__]; // \${TOGGLE_ARRAY_SIZE}
44enum {
45    ToggleRapidFireEnum=0,
46    ToggleAimAssistEnum
47    // @[ANCHOR_TOGGLE_ENUM]
48}
49
50init {
51	cls_oled(OLED_BLACK);
52	currentLedColor = Pink;
53	SetLEDColor(currentLedColor);
54	loadSettings();
55	setButtonsLayout(settings[buttonLayoutEnum]);
56    // @[ANCHOR_INIT]
57}
58
59main {
60    // @[ANCHOR_MAIN_START]
61    updateFeedbackTimer();
62    switch (currentState) {
63	case STATE_OFF: {
64	  handleOffState();
65	  break;
66	}
67	case STATE_RESTART: {
68	  handleRestartState();
69	  break;
70	}
71	case STATE_LOADING: {
72	  handleLoadingState();
73	  break;
74	}
75	case STATE_PLAYING: {
76	  handlePlayingState();
77	  break;
78	}
79	case STATE_SETUP_MENU: {
80	  handleUserSetupMenuSateInput();
81	  break;
82	}
83	case STATE_SETUP_SUBMENU: {
84	  handleSubMenuState();
85	  break;
86	}
87	case STATE_SCREEN_SAVER: {
88	  handleScreenSaverState();
89	  break;
90	}
91	case STATE_SAVING: {
92	  handleSavingState();
93	  break;
94	}
95	case STATE_CLEAN_SCREEN: {
96	  handleCleanScreenState();
97	  break;
98	}
99	case STATE_QUICK_ACTION: {
100	  handleQuickActionState();
101	  break;
102	}
103  }
104  blockSavedCircleUntilRelease();
105  set_val(TRACE_1, currentState);
106  // @[ANCHOR_MAIN_END]
107}
108
109define LOADING_TIMER          = 3000;
110define SCREEN_SAVER_TIMER     = 10000;
111define MENU_SCREENSAVER_TIMER = 60000;
112define STATE_TRANSITION_TIMER = 100;
113define SCROLL_INTERVAL        = 40;
114define OLED_MENU_RENDER_INTERVAL = 30;
115define FEEDBACK_MODE_MOD_TOGGLE = 0;
116define FEEDBACK_MODE_TEXT = 1;
117define FEEDBACK_MODE_TEXT_TOGGLE = 2;
118define QUICK_ACTION_TOGGLE = 0;
119define QUICK_ACTION_OPEN_SETUP = 1;
120define AMOUNT_OF_MOD_TOGGLE = __MOD_COUNT__;     // \${MOD_COUNT}
121int currentState = STATE_LOADING;
122int previousState;
123int tempState;
124int stateScreenDisplayed = FALSE;
125int currentMod = 0;
126int currentSubCfg = 0;
127int modNameId = 0;
128int xPos, currentModId, withModProfile;
129int blockCircleUntilRelease = FALSE;
130int settingMin, settingMax, drawingValue;
131int sizeArray;
132int range, filled_width, cursor_position;
133int stringLength;
134int bufferIndex, digitIndex, charIndex;
135int logVal;
136int qrRow, qrCol, qrByteIndex, qrMask;
137int loadingTime = 0;
138int screenSaverTimer = 0;
139int stateTransitionTime = 0;
140int setupScreenSaverTime = 0;
141int oledMenuRenderTime = 0;
142int oledSubmenuDraw = FALSE;
143int miscStep;
144int currentLedColor = Black;
145const int16 Color[][] = {
146    { 20, 50, 50 },
147    { 0, 0, 0 },
148    { 0, 100, 100 },
149    { 240, 100, 93 },
150    { 120, 100, 50 },
151    { 300, 100, 75 },
152    { 20, 50, 30 }
153};
154enum { Hue=0, Saturation, Brightness }
155enum { White=0, Black, Red, Blue, Green, Purple, Pink }
156const uint8 introN[] = __INTRO_NAME_BYTES__;
157const uint8 introV[] = { 117, 115, 101, 116, 117, 110, 101, 122, 46, 99, 111, 109, 0 };
158const uint8 scriptVersion[] = __SCRIPT_VERSION_BYTES__;
159const string DSAVED = "SAVED";
160const string SPROFILE_1 = "PROFILE 1";
161const string SPROFILE_2 = "PROFILE 2";
162const string SNOPROFILE = "NO PROFILE";
163const string MENU_HINT_TEXT = __CONTROLLER_MENU_HINT__;
164const string OFF_HINT_TEXT = __CONTROLLER_OFF_HINT__;
165const string ONOFF[] = {"OFF","ON"};
166const string RANDOMETEXT[] = {"OPEN SETUP"};

167// @[REPLACE:\${CORE_HOLSTERED_TEXT}]
168const uint8 INFO_QR_BYTES[] = {
169    254, 147, 248, 130, 250, 8, 186, 170, 232, 186, 154, 232, 186, 66, 232, 130, 90, 8, 254, 171, 248,
170    0, 48, 0, 186, 156, 120, 201, 115, 224, 43, 219, 160, 16, 13, 40, 226, 113, 248, 0, 151, 120,
171    254, 74, 56, 130, 51, 152, 186, 215, 136, 186, 147, 72, 186, 225, 168, 130, 108, 192, 254, 224, 16
172};
173const uint8 QR_BIT_MASKS[] = { 128, 64, 32, 16, 8, 4, 2, 1 };
174const string ALL_BUTTONS[] = __CONTROLLER_BUTTON_LABELS__;
175// @[ANCHOR_STRINGS]
176const uint8 MODNAME[][] = {
177    // @[ANCHOR_CORE_MOD_DISPLAY_NAME_PRE]
178    { 65, 78, 84, 73, 32, 82, 69, 67, 79, 73, 76, 0, 0, 0, 0, 0 },
179    { 65, 73, 77, 32, 65, 83, 83, 73, 83, 84, 0, 0, 0, 0, 0, 0 },
180    { 82, 65, 80, 73, 68, 32, 70, 73, 82, 69, 0, 0, 0, 0, 0, 0 },
181    // @[ANCHOR_MOD_DISPLAY_NAME]
182    { 77, 73, 83, 67, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
183    { 73, 78, 70, 79, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
184};
185const string SETTINGSAAP[] = {
186    "LEFT SIZE",
187    "LEFT SPEED",
188    "LEFT SHAPE",
189    "RIGHT SIZE",
190    "RIGHT SPEED",
191    "RIGHT SHAPE",
192    "AA ACTIVATION",
193    "ADS LEFT SIZE",
194    "ADS LEFT SPEED",
195    "ADS RIGHT SIZE",
196    "ADS RIGHT SPEED",
197    "ACTIVATION MAX",
198    "ACTIVATION MIN",
199    "BOOST STRENGTH",
200    "SMOOTHING FACTOR",
201    "AIM LOCK STRENGTH",
202    "RAPID FIRE SPEED",
203    "RF HOLD TIME",
204    "INVERTED",
205    "NO RUMBLE",
206    "BUTTONS LAYOUT",
207    // @[ANCHOR_MISC_SETTINGS_LABEL]
208    "VERTICAL",
209    "HORIZONTAL",
210    "ACTIVATION",
211    "MODE",
212    "INITIAL BOOST",
213    "INITIAL TIME",
214    "INITIAL VERTICAL",
215    "INITIAL HORIZONTAL",
216    "RAMP",
217    "RAMP TIME",
218    "DECAY",
219    "DECAY START",
220    "DECAY TIME",
221    "DECAY FLOOR",
222    "AIM OVERRIDE",
223    "OVERRIDE THRESHOLD",
224    "OVERRIDE STRENGTH"
225    // @[ANCHOR_SETTINGS_LABEL]
226};
227function handleCleanScreenState() {
228    if (previousState == STATE_SETUP_MENU || previousState == STATE_SETUP_SUBMENU) {
229        blockMenuInputs();
230    }
231    if ((previousState == STATE_PLAYING
232        || previousState == STATE_SCREEN_SAVER
233        || tempState == STATE_PLAYING
234        || tempState == STATE_SCREEN_SAVER)
235        && previousState != STATE_SETUP_MENU
236        && previousState != STATE_SETUP_SUBMENU
237        && previousState != STATE_SAVING) {
238        \${CORE_WEAPON_TRACKING_LOGIC}
239    }
240    if (stateTransitionTime == 0) {
241        cls_oled(OLED_BLACK);
242    }
243	if (stateTransitionTime > STATE_TRANSITION_TIMER) {
244    		currentState = tempState;
245    		previousState = currentState;
246    		stateTransitionTime = 0;
247    		resetDisplay();
248	} else {
249			stateTransitionTime += get_rtime();
250	}
251}
252function handleLoadingState() {
253    if (loadingTime >= LOADING_TIMER) {
254       combo_stop(IntroDisplayCombo);
255       cls_oled(OLED_BLACK);
256       resetToProfile1();
257       currentState = STATE_PLAYING;
258    } else {
259        loadingTime += get_rtime();
260        combo_run(IntroDisplayCombo);
261    }
262}
263function screenDisplayed() {
264	stateScreenDisplayed = TRUE;
265}
266function showFeedback(mode, feedbackSourceModId, textAddr, state) {
267    feedbackModId = feedbackSourceModId;
268    feedbackState = state;
269    feedbackTextAddr = textAddr;
270    feedbackMode = mode;
271    feedbackTime = 1000;
272    resetDisplay();
273}
274function showToggleFeedback(toggleFeedbackModId, state) {
275    showFeedback(FEEDBACK_MODE_MOD_TOGGLE, toggleFeedbackModId, 0, state);
276}
277function requestQuickAction(quickActionSourceModId, actionType) {
278    quickActionModId = quickActionSourceModId;
279    quickActionType = actionType;
280    if (actionType == QUICK_ACTION_TOGGLE) {
281        handleQuickActionState();
282    } else {
283        tempState = STATE_QUICK_ACTION;
284        currentState = STATE_CLEAN_SCREEN;
285    }
286}
287function resetDisplay() {
288	stateScreenDisplayed = FALSE;
289    oledMenuRenderTime = OLED_MENU_RENDER_INTERVAL;
290}
291function canClearMenuOled() {
292    oledMenuRenderTime = min(OLED_MENU_RENDER_INTERVAL, oledMenuRenderTime + get_rtime());
293    if (stateScreenDisplayed == FALSE && oledMenuRenderTime >= OLED_MENU_RENDER_INTERVAL) {
294        oledMenuRenderTime = 0;
295        return TRUE;
296    }
297    return FALSE;
298}
299function setScreenSaver() {
300    if (feedbackTime > 0) { return; }
301    if (screenSaverTimer >= SCREEN_SAVER_TIMER) {
302    	tempState = STATE_SCREEN_SAVER;
303    	currentState = STATE_CLEAN_SCREEN;
304    } else {
305    	screenSaverTimer += get_rtime();
306    }
307}
308function initScreenSaver() {
309	 screenSaverTimer = 0;
310	 currentState = STATE_PLAYING;
311}
312function displayArrowRight( dar_x,  dar_y,  dar_sizePercent, dar_color) {
313    sizeArray = (dar_sizePercent * 10) / 100;
314    line_oled(dar_x, dar_y, dar_x + sizeArray, dar_y, 1, dar_color);
315    line_oled(dar_x + sizeArray, dar_y, dar_x + sizeArray - (sizeArray / 2), dar_y - (sizeArray / 2), 1, dar_color);
316    line_oled(dar_x + sizeArray, dar_y, dar_x + sizeArray - (sizeArray / 2), dar_y + (sizeArray / 2), 1, dar_color);
317}
318function displayArrowLeft( dal_x, dal_y, dal_sizePercent, dal_color) {
319    sizeArray = (dal_sizePercent * 10) / 100;
320    line_oled(dal_x, dal_y, dal_x + sizeArray, dal_y, 1, dal_color);
321    line_oled(dal_x, dal_y, dal_x + (sizeArray / 2), dal_y - (sizeArray / 2), 1, dal_color);
322    line_oled(dal_x, dal_y, dal_x + (sizeArray / 2), dal_y + (sizeArray / 2), 1, dal_color);
323}
324function drawProgressBarWithCursor(dpb_x,  dpb_y,  dpb_width,  dpb_height,  dpb_value,  dpb_min_value,  dpb_max_value) {
325	range = dpb_max_value - dpb_min_value;
326    if (range <= 0) {
327        cursor_position = dpb_x + (dpb_width / 2);
328    } else if (dpb_min_value < 0 && dpb_max_value > 0) {
329        filled_width = dpb_x + (dpb_width / 2);
330        if (dpb_value >= 0) {
331            cursor_position = filled_width + ((dpb_value * (dpb_width / 2)) / dpb_max_value);
332        } else {
333            cursor_position = filled_width - ((abs(dpb_value) * (dpb_width / 2)) / abs(dpb_min_value));
334        }
335    } else {
336        cursor_position = dpb_x + (((dpb_value - dpb_min_value) * d

336pb_width) / range);
337    }
338    cursor_position = clamp(cursor_position, dpb_x, dpb_x + dpb_width);
339    filled_width = dpb_y + (dpb_height / 2);
340    line_oled(dpb_x, filled_width, dpb_x + dpb_width, filled_width, 1, OLED_WHITE);
341    line_oled(dpb_x, filled_width - 4, dpb_x, filled_width + 4, 1, OLED_WHITE);
342    line_oled(dpb_x + dpb_width, filled_width - 4, dpb_x + dpb_width, filled_width + 4, 1, OLED_WHITE);
343    if (dpb_min_value < 0 && dpb_max_value > 0) {
344        line_oled(dpb_x + (dpb_width / 2), filled_width - 3, dpb_x + (dpb_width / 2), filled_width + 3, 1, OLED_WHITE);
345    }
346    line_oled(cursor_position, filled_width - 5, cursor_position, filled_width + 5, 2, OLED_WHITE);
347}
348function centerX(f_chars,f_font) {
349    return (OLED_WIDTH / 2) - ((f_chars * f_font) / 2);
350}
351function numberToString(f_val,f_digits, fontSize, fontSizeWidth, xPosition, yPosition, color) {
352    bufferIndex = 1;
353    digitIndex = 10000;
354    if(f_val < 0) {
355         putc_oled(bufferIndex,45);
356         bufferIndex += 1;
357         f_val = abs(f_val);
358    }
359    for(charIndex = 5; charIndex >= 1; charIndex--) {
360        if(f_digits >= charIndex) {
361            putc_oled(bufferIndex,(f_val / digitIndex) + 48);
362            f_val %= digitIndex;
363            bufferIndex ++;
364            if(charIndex == 4) {
365                putc_oled(bufferIndex,44);
366                bufferIndex ++;
367            }
368        }
369        digitIndex /= 10;
370    }
371    puts_oled(iif(xPosition > 127, centerX(bufferIndex - 1, fontSizeWidth), xPosition) , yPosition, fontSize, bufferIndex - 1,color);
372}
373function findDigits(num) {
374   logVal = 0;
375   do {
376      num /= 10;
377      logVal++;
378   } while (num);
379   return logVal;
380}
381function printCentered(yPosition, font, fontWidth, color, textAddr) {
382    print(centerX(getStringLength(textAddr), fontWidth), yPosition, font, color, textAddr);
383}
384function printCenteredBold(yPosition, font, fontWidth, color, textAddr) {
385    xPos = centerX(getStringLength(textAddr), fontWidth);
386    print(xPos, yPosition, font, color, textAddr);
387    print(xPos + 1, yPosition, font, color, textAddr);
388}
389function drawTextSettingValue(textAddr) {
390    printCenteredBold(45, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, textAddr);
391}
392function drawOnOffValue(state, yPosition) {
393    stringLength = getStringLength(ONOFF[state]);
394    drawingValue = (stringLength * OLED_FONT_SMALL_WIDTH) + 11;
395    xPos = (OLED_WIDTH / 2) - (drawingValue / 2);
396    drawStatusDot(xPos + 1, yPosition + 2, state);
397    print(xPos + 11, yPosition, OLED_FONT_SMALL, OLED_WHITE, ONOFF[state]);
398}
399function drawStatusDot(dotX, dotY, state) {
400    line_oled(dotX + 1, dotY, dotX + 3, dotY, 1, OLED_WHITE);
401    line_oled(dotX + 1, dotY + 4, dotX + 3, dotY + 4, 1, OLED_WHITE);
402    if (state) {
403        line_oled(dotX, dotY + 1, dotX + 4, dotY + 1, 1, OLED_WHITE);
404        line_oled(dotX, dotY + 2, dotX + 4, dotY + 2, 1, OLED_WHITE);
405        line_oled(dotX, dotY + 3, dotX + 4, dotY + 3, 1, OLED_WHITE);
406    } else {
407        pixel_oled(dotX, dotY + 1, OLED_WHITE);
408        pixel_oled(dotX + 4, dotY + 1, OLED_WHITE);
409        pixel_oled(dotX, dotY + 2, OLED_WHITE);
410        pixel_oled(dotX + 4, dotY + 2, OLED_WHITE);
411        pixel_oled(dotX, dotY + 3, OLED_WHITE);
412        pixel_oled(dotX + 4, dotY + 3, OLED_WHITE);
413    }
414}
415function drawShortcutFeedbackValue(textAddr) {
416    printCenteredBold(36, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, textAddr);
417}
418function drawShortcutOnOffValue(state) {
419    drawOnOffValue(state, 36);
420}
421function getStringLength(stringOffset) {
422    stringLength = 0;
423    do {
424        stringOffset++;
425        stringLength++;
426    } while (duint8(stringOffset));
427    return stringLength;
428}
429function blockMenuInputs() {
430    block_all_inputs();
431    set_val(PS5_CIRCLE, 0);
432}
433function blockSavedCircleUntilRelease() {
434    if (blockCircleUntilRelease) {
435        if (get_ival(PS5_CIRCLE)) {
436            set_val(PS5_CIRCLE, 0);
437        } else {
438            blockCircleUntilRelease = FALSE;
439        }
440    }
441}
442function handleOffState() {
443    if (stateScreenDisplayed == FALSE) {
444        combo_stop_all();
445        currentLedColor = Black;
446        SetLEDColor(currentLedColor);
447        cls_oled(OLED_BLACK);
448        printCenteredBold(22, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, ONOFF[0]);
449        printCentered(45, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, OFF_HINT_TEXT[0]);
450        screenDisplayed();
451    }
452	handleUserOffSateInput();
453}
454function handleRestartState() {
455    resetToProfile1();
456    previousState = currentState;
457	tempState = STATE_PLAYING;
458	currentState = STATE_CLEAN_SCREEN;
459}
460function handlePlayingState() {
461	previousState = currentState;
462	resetBlinkLedAndRumble();
463    handleUserPlayingSateInput();
464    if (currentState != STATE_PLAYING) { return; }
465    // @[ANCHOR_GAMEPLAY_DISPLAY_UPDATE]
466    displayMainScreen();
467    setScreenSaver();
468}
469function handleScreenSaverState() {
470    previousState = currentState;
471    handleUserPlayingSateInput();
472    if (currentState != STATE_SCREEN_SAVER) { return; }
473    // @[ANCHOR_GAMEPLAY_DISPLAY_UPDATE]
474    if (!renderFeedback() && stateScreenDisplayed == FALSE) {
475        cls_oled(OLED_BLACK);

476        // @[REPLACE:\${CORE_HOLSTERED_SCREEN_SAVER_SCREEN}]
477        // @[ANCHOR_SCREEN_SAVER_SCREEN]
478        // @[REPLACE:\${CORE_HOLSTERED_SCREEN_SAVER_SCREEN_END}]
479        screenDisplayed();
480    }
481}
482function handleSavingState() {
483    SetLEDColor(currentLedColor);
484    blockMenuInputs();
485    showFeedback(FEEDBACK_MODE_SAVED, 0, 0, 0);
486    feedbackTime = 1500;
487    previousState = STATE_PLAYING;
488    currentState = STATE_PLAYING;
489    screenSaverTimer = 0;
490}
491function handleQuickActionState() {
492	previousState = currentState;
493	set_val(PS5_UP, 0);
494	set_val(PS5_DOWN, 0);
495	set_val(PS5_LEFT, 0);
496	set_val(PS5_RIGHT, 0);
497    if (quickActionType == QUICK_ACTION_TOGGLE) {
498        if (quickActionModId == RapidFireEnum) {
499            toggleRapidFire[profileId] = !toggleRapidFire[profileId];
500            showToggleFeedback(RapidFireEnum, toggleRapidFire[profileId]);
501        } else if (quickActionModId == AntiRecoilEnum) {
502            toggleAntiRecoil[profileId] = !toggleAntiRecoil[profileId];
503            showToggleFeedback(AntiRecoilEnum, toggleAntiRecoil[profileId]);
504        } else if (quickActionModId == AimAssistEnum) {
505            toggle[ToggleAimAssistEnum] = !toggle[ToggleAimAssistEnum];
506            showToggleFeedback(AimAssistEnum, toggle[ToggleAimAssistEnum]);
507        }
508        persistSettings();
509        if (currentState == STATE_QUICK_ACTION) {
510            tempState = STATE_PLAYING;
511            currentState = STATE_CLEAN_SCREEN;
512        }
513    } else if (quickActionType == QUICK_ACTION_OPEN_SETUP) {
514        displaySubModScreen(quickActionModId);
515    }
516}
517function handleUserSetupMenuSateInput() {
518	previousState = currentState;
519    combo_stop_all();
520    blockMenuInputs();
521    displayCurrentModScreen();
522    mainMenuProfileHandling();
523    // @[ANCHOR_SETUP_MENU_INPUT]
524    if (event_press(PS5_DOWN) && modId[currentMod] != InfoEnum) {
525        switchActiveModState();
526        resetDisplay();
527		blinkLedAndRumble();
528    }
529	resetBlinkLedAndRumble();
530    if (event_press(PS5_CROSS)
531    // @[ANCHOR_SUBMENU_BLOCK]
532    && modId[currentMod] != InfoEnum
533    ) {
534        currentState = STATE_SETUP_SUBMENU;
535        resetDisplay();
536    }
537    if (event_press(PS5_CIRCLE)) {
538    	blinkLedAndRumble();
539        saveSettings();
540    }
541	if (event_press(PS5_RIGHT)) {
542		modNameId += 1;
543		currentMod = modId[modNameId];
544        resetDisplay();
545	}
546	if (event_press(PS5_LEFT)) {
547		modNameId -= 1;
548		currentMod = modId[modNameId];
549        resetDisplay();
550	}
551	if(modNameId > AMOUNT_OF_MOD_TOGGLE - 1) {
552		modNameId = 0;
553		currentMod = modId[modNameId];
554	}
555	if(modNameId < 0) {
556		modNameId = AMOUNT_OF_MOD_TOGGLE - 1;
557		currentMod = modId[modNameId];
558	}
559}
560function handleSubMenuState() {
561	previousState = currentState;
562	displaySubModScreen(modId[currentMod]);
563    mainMenuProfileHandling();
564    if (event_press(PS5_CIRCLE)) {
565        tempState = STATE_SETUP_MENU;
566    	currentState = STATE_CLEAN_SCREEN;
567    }
568}
569function handleLeftRight(settingIndex) {
570    if (press_hold(PS5_LEFT)) {
571        settings[settingIndex] = clamp(settings[settingIndex] - 1, settingMinMax[settingIndex][0], settingMinMax[settingIndex][1]);
572        if (settingMinMax[settingIndex][1] == 21 && settings[settingIndex] <= 12 && settings[settingIndex] >= 9) {
573            settings[settingIndex] = 8;
574        }
575    }
576    if (press_hold(PS5_RIGHT)) {
577        settings[settingIndex] = clamp(settings[settingIndex] + 1, settingMinMax[settingIndex][0], settingMinMax[settingIndex][1]);
578        if (settingMinMax[settingIndex][1] == 21 && settings[settingIndex] >= 9 && settings[settingIndex] <= 12) {
579            settings[settingIndex] = 13;
580        }
581    }
582}
583 function handleUpDown(minEnum, maxEnum) {
584     if (press_hold(PS5_UP)) {
585         currentSubCfg--;
586     }
587     if (press_hold(PS5_DOWN)) {
588         currentSubCfg++;
589     }
590     if (currentSubCfg > maxEnum) {
591         currentSubCfg = minEnum;
592     } else if (currentSubCfg < minEnum) {
593         currentSubCfg = maxEnum;
594     }
595 }
596function handleExitAndSave() {
597    if (get_val(CROUCH_BTN) || event_press(CROUCH_BTN)) {
598        saveSettings();
599    }
600}
601function setSetupScreenSaver() {
602	handleButtonPression();
603 	if (setupScreenSaverTime >= MENU_SCREENSAVER_TIMER) {
604			setupScreenSaverTime = 0;
605		saveSettings();
606	    } else {
607		setupScreenSaverTime += get_rtime();
608	    }
609}
610function displayMainScreen() {
611    if (renderFeedback()) { return; }
612	if (stateScreenDisplayed == FALSE) {
613		cls_oled(OLED_BLACK);

614        // @[REPLACE:\${CORE_HOLSTERED_PLAYING_SCREEN}]
615        // @[ANCHOR_PLAYING_SCREEN_OVERRIDE]
616		line_oled(12, 16, 25, 16, 1, OLED_WHITE);
617		line_oled(103, 16, 116, 16, 1, OLED_WHITE);
618		displayProfileNameCentered(12, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE);
619        // @[ANCHOR_PLAYING_SCREEN]
620		displayPressToOpenMenu();
621        // @[ANCHOR_PLAYING_SCREEN_DEFAULT_END]
622        // @[REPLACE:\${CORE_HOLSTERED_PLAYING_SCREEN_END}]
623		screenDisplayed();
624    }
625}
626function displayCurrentModScreen() {
627	if(stateScreenDisplayed == FALSE) {
628		currentModId = modId[currentMod];
629        // @[ANCHOR_MOD_SCREEN]
630        if (currentModId == InfoEnum) {
631            cls_oled(OLED_BLACK);
632            renderInfoMainScreen();
633            screenDisplayed();
634            setSetupScreenSaver();
635            return;
636        }
637	    withModProfile = iif(currentModId == AntiRecoilEnum || currentModId == RapidFireEnum
638        // @[ANCHOR_WITH_PROFILE_MOD]
639        , TRUE, FALSE);
640        cls_oled(OLED_BLACK);
641        displayModScreen(addr(MODNAME[currentModId]), getModToggleState(modId[currentMod]), withModProfile);
642    	screenDisplayed();
643    }
644    setSetupScreenSaver();
645}
646function displayModScreen(f_print, f_toggle, withProfile) {
647    if (withProfile == TRUE) {
648        drawProfileNameRight(5, OLED_WHITE);
649    }
650    drawModCounterLeft(5, OLED_WHITE);
651    line_oled(0, 18, 127, 18, 1, OLED_WHITE);
652	if (f_print !=  addr( MODNAME[MiscEnum] )) {
653        drawMainMenuModName(f_print);
654        drawOnOffValue(f_toggle, 45);
655	} else {
656        drawMainMenuModName(f_print);
657		printCentered(45, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, RANDOMETEXT[0]);
658	}
659}
660function drawMainMenuModName(textAddr) {
661    stringLength = getStringLength(textAddr);
662    xPos = centerX(stringLength, OLED_FONT_SMALL_WIDTH);
663    displayArrowLeft(8, 31, 70, OLED_WHITE);
664    print(xPos, 28, OLED_FONT_SMALL, OLED_WHITE, textAddr);
665    displayArrowRight(113, 31, 70, OLED_WHITE);
666}
667function displaySubModScreen(modMenu) {
668    // @[ANCHOR_SUBMENU_OVERRIDE]
669    blockMenuInputs();
670    oledSubmenuDraw = canClearMenuOled();
671    if (oledSubmenuDraw) {
672        cls_oled(OLED_BLACK);
673        screenDisplayed();
674    }
675	switch (modMenu) {
676        case AntiRecoilEnum: {
677 			renderAntiRecoilSubMenu();
678            break;
679        }
680        case AimAssistEnum: {
681 			renderAimAssistSubMenu();
682            break;
683        }
684        case RapidFireEnum: {
685            renderRapidFireSubMenu();
686            break;
687        }
688        case MiscEnum: {
689            renderMiscSubMenu(modMenu);
690            break;
691        }
692        // @[ANCHOR_SUBMENU_DISPATCHER]
693    }
694    if (press_hold(PS5_LEFT) || press_hold(PS5_RIGHT)
695        || press_hold(PS5_UP) || press_hold(PS5_DOWN)) {
696        stateScreenDisplayed = FALSE;
697    }
698    setSetupScreenSaver();
699    handleExitAndSave();
700}
701function drawModTitle(modMenu) {
702     print(0, 5, OLED_FONT_SMALL, OLED_WHITE, addr(MODNAME[modMenu]));
703     if (modMenu == AntiRecoilEnum || modMenu == RapidFireEnum) {
704         drawProfileBadge(116, 5, OLED_FONT_SMALL, OLED_WHITE);
705     }
706     line_oled(0, 18, 127, 18, 1, OLED_WHITE);
707}

708function drawSettingLabel(settingIndex) {
709     print(0, 24, OLED_FONT_SMALL, OLED_WHITE, SETTINGSAAP[settingIndex]);
710}
711function drawStandardSetting(settingIndex, usePercent) {
712     drawSettingLabel(settingIndex);
713     drawingValue = settings[settingIndex];
714     settingMin = settingMinMax[settingIndex][0];
715     settingMax = settingMinMax[settingIndex][1];
716     if (usePercent) {
717         drawingValue *= 100; settingMin *= 100; settingMax *= 100;
718     }
719     numberToString(drawingValue, findDigits(drawingValue), OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, 128, 38, OLED_WHITE);
720     drawProgressBarWithCursor(18, 51, 92, 8, drawingValue, settingMin, settingMax);
721}
722function drawButtonsSetting(settingIndex) {
723    drawSettingLabel(settingIndex);
724    drawingValue = settings[settingIndex];
725    drawTextSettingValue(ALL_BUTTONS[drawingValue]);
726}
727
728function renderGenericSettingBar(modMenu, settingIndex) {
729    if (oledSubmenuDraw) {
730         drawModTitle(modMenu);
731         drawStandardSetting(settingIndex, FALSE);
732    }
733     handleLeftRight(settingIndex);
734}
735function renderGenericSubMenu(modMenu, minEnum, maxEnum) {
736    if (currentSubCfg < minEnum || currentSubCfg > maxEnum) {
737        currentSubCfg = minEnum;
738    }
739    if (oledSubmenuDraw) {
740        drawModTitle(modMenu);
741        drawSettingLabel(currentSubCfg);
742        drawStandardSetting(currentSubCfg, FALSE);
743    }
744    handleLeftRight(currentSubCfg);
745    handleUpDown(minEnum, maxEnum);
746}

747function renderSubMenuWithButton(modMenu, minEnum, maxEnum) {
748    if (oledSubmenuDraw) {
749        drawModTitle(modMenu);
750        drawSettingLabel(currentSubCfg);
751        if (currentSubCfg != maxEnum) {
752            drawStandardSetting(currentSubCfg, FALSE);
753        } else {
754            drawButtonsSetting(currentSubCfg);
755        }
756    }
757    handleLeftRight(currentSubCfg);
758    handleUpDown(minEnum, maxEnum);
759}
760function renderSubMenuWithPercent(minEnum, maxEnum, percentEnum) {
761    if (oledSubmenuDraw) {
762        drawModTitle(modId[currentMod]);
763        drawSettingLabel(currentSubCfg);
764        drawStandardSetting(currentSubCfg, currentSubCfg == percentEnum);
765    }
766    handleLeftRight(currentSubCfg);
767    handleUpDown(minEnum, maxEnum);
768}
769function renderMiscSubMenu(modMenu) {
770    if (currentSubCfg < InvertEnum || currentSubCfg > __LAST_MISC_ENUM__) {
771        currentSubCfg = InvertEnum;
772} // \${LAST_MISC_ENUM}
773    if (oledSubmenuDraw) {
774        drawModTitle(modMenu);
775        drawSettingLabel(currentSubCfg);
776        switch (currentSubCfg) {
777            case InvertEnum: {
778                drawOnOffValue(iif(settings[InvertEnum] == 1, 0, 1), 45);
779                break;
780            }
781            case NoRumbleEnum: {
782                drawOnOffValue(settings[NoRumbleEnum], 45);
783                break;
784            }
785            case buttonLayoutEnum: {
786                drawTextSettingValue(BtnLayouts[settings[buttonLayoutEnum]]);
787                break;
788            }
789            // @[ANCHOR_MISC_RENDER]
790        }
791    }
792    if (event_press(PS5_LEFT) || event_press(PS5_RIGHT)) {
793        switch (currentSubCfg) {
794            case InvertEnum: {
795                settings[InvertEnum] = iif(settings[InvertEnum] == 1, -1, 1);
796                blinkLedAndRumble();
797                break;
798            }
799            case NoRumbleEnum: {
800                settings[NoRumbleEnum] = !settings[NoRumbleEnum];
801                blinkLedAndRumble();
802                break;
803            }
804            case buttonLayoutEnum: {
805                miscStep = iif(press_hold(PS5_LEFT), -1, 1);
806                settings[buttonLayoutEnum] = clamp(settings[buttonLayoutEnum] + miscStep, 0, 21);
807                setButtonsLayout(settings[buttonLayoutEnum]);
808                break;
809            }
810            // @[ANCHOR_MISC_INPUT]
811        }
812    }
813    handleUpDown(InvertEnum, __LAST_MISC_ENUM__); // \${LAST_MISC_ENUM_2}
814}
815function renderAntiRecoilSubMenu() {
816    if (currentSubCfg < antiRecoilVerticalEnum || currentSubCfg > antiRecoilAimOverrideStrengthEnum) {
817        currentSubCfg = antiRecoilVerticalEnum;
818    }
819    set_val(TRACE_1, currentSubCfg);
820    set_val(TRACE_2, antiRecoilVerticalEnum);
821    set_val(TRACE_3, antiRecoilModeEnum);
822    if (oledSubmenuDraw) {
823        drawModTitle(AntiRecoilEnum);
824        drawSettingLabel(currentSubCfg);
825        switch (currentSubCfg) {
826            case antiRecoilActivationEnum: {
827                drawTextSettingValue(arActivation[settings[currentSubCfg]]);
828                break;
829            }
830            case antiRecoilVerticalEnum: {
831                drawProfileSettingValue(antiRecoilVertical[profileId], antiRecoilVerticalEnum);
832                break;
833            }
834            case antiRecoilHorizontalEnum: {
835                drawProfileSettingValue(antiRecoilHorizontal[profileId], antiRecoilHorizontalEnum);
836                break;
837            }
838            case antiRecoilModeEnum: {
839                drawTextSettingValue(arModeNames[settings[currentSubCfg]]);
840                break;
841            }
842            case antiRecoilInitialEnabledEnum: {
843                drawOnOffValue(antiRecoilInitialEnabled[profileId], 45);
844                break;
845            }
846            case antiRecoilInitialTimeEnum: {
847                drawProfileSettingValue(antiRecoilInitialTime[profileId], antiRecoilInitialTimeEnum);
848                break;
849            }
850            case antiRecoilInitialVerticalEnum: {
851                drawProfileSettingValue(antiRecoilInitialVertical[profileId], antiRecoilInitialVerticalEnum);
852                break;
853            }
854            case antiRecoilInitialHorizontalEnum: {
855                drawProfileSettingValue(antiRecoilInitialHorizontal[profileId], antiRecoilInitialHorizontalEnum);
856                break;
857            }
858            case antiRecoilRampEnabledEnum: {
859                drawOnOffValue(antiRecoilRampEnabled[profileId], 45);
860                break;
861            }
862            case antiRecoilRampTimeEnum: {
863                drawProfileSettingValue(antiRecoilRampTime[profileId], antiRecoilRampTimeEnum);
864                break;
865            }
866            case antiRecoilDecayEnabledEnum: {
867                drawOnOffValue(antiRecoilDecayEnabled[profileId], 45);
868                break;
869            }
870            case antiRecoilDecayStartEnum: {
871                drawProfileSettingValue(antiRecoilDecayStart[profileId], antiRecoilDecayStartEnum);
872                break;
873            }
874            case antiRecoilDecayTimeEnum: {
875                drawProfileSettingValue(antiRecoilDecayTime[profileId], antiRecoilDecayTimeEnum);
876                break;
877            }
878            case antiRecoilDecayFloorEnum: {
879                drawProfileSettingValue(antiRecoilDecayFloor[profileId], antiRecoilDecayFloorEnum);
880                break;
881            }
882            case antiRecoilAimOverrideEnabledEnum: {
883                drawOnOffValue(antiRecoilAimOverrideEnabled[profileId], 45);
884                break;
885            }
886            case antiRecoilAimOverrideThresholdEnum: {
887                drawProfileSettingValue(antiRecoilAimOverrideThreshold[profileId], antiRecoilAimOverrideThresholdEnum);
888                break;
889            }
890            case antiRecoilAimOverrideStrengthEnum: {
891                drawProfileSettingValue(antiRecoilAimOverrideStrength[profileId], antiRecoilAimOverrideStrengthEnum);
892                break;
893            }
894            default {
895                if (settings[antiRecoilModeEnum] == TRUE) {
896                    drawOnOffValue(settings[currentSubCfg], 45);
897                }
898                break;
899            }
900        }
901    }
902    if (currentSubCfg == antiRecoilVerticalEnum) {
903        handleAntiRecoilVertical();
904    } else if (currentSubCfg == antiRecoilHorizontalEnum) {
905        handleAntiRecoilHorizontal();
906    } else if (currentSubCfg == antiRecoilInitialEnabledEnum) {
907        handleAntiRecoilInitialEnabled();
908    } else if (currentSubCfg == antiRecoilInitialTimeEnum) {
909        handleAntiRecoilInitialTime();
910    } else if (currentSubCfg == antiRecoilInitialVerticalEnum) {
911        handleAntiRecoilInitialVertical();
912    } else if (currentSubCfg == antiRecoilInitialHorizontalEnum) {
913        handleAntiRecoilInitialHorizontal();
914    } else if (currentSubCfg == antiRecoilRampEnabledEnum) {
915        handleAntiRecoilRampEnabled();
916    } else if (currentSubCfg == antiRecoilRampTimeEnum) {
917        handleAntiRecoilRampTime();
918    } else if (currentSubCfg == antiRecoilDecayEnabledEnum) {
919        handleAntiRecoilDecayEnabled();
920    } else if (currentSubCfg == antiRecoilDecayStartEnum) {
921        handleAntiRecoilDecayStart();
922    } else if (currentSubCfg == antiRecoilDecayTimeEnum) {
923        handleAntiRecoilDecayTime();
924    } else if (currentSubCfg == antiRecoilDecayFloorEnum) {
925        handleAntiRecoilDecayFloor();
926    } else if (currentSubCfg == antiRecoilAimOverrideEnabledEnum) {
927        handleAntiRecoilAimOverrideEnabled();
928    } else if (currentSubCfg == antiRecoilAimOverrideThresholdEnum) {
929        handleAntiRecoilAimOverrideThreshold();
930    } else if (currentSubCfg == antiRecoilAimOverrideStrengthEnum) {
931        handleAntiRecoilAimOverrideStrength();
932    } else {
933        handleLeftRight(currentSubCfg);
934    }
935    handleUpDown(antiRecoilVerticalEnum, antiRecoilAimOverrideStrengthEnum);
936}
937function renderRapidFireSubMenu() {
938    if (currentSubCfg < rapidFireShotsPerSecondEnum || currentSubCfg > rapidFireHoldTimeEnum) {
939        currentSubCfg = rapidFireShotsPerSecondEnum;
940    }
941    if (oledSubmenuDraw) {
942        drawModTitle(RapidFireEnum);
943        drawSettingLabel(currentSubCfg);
944        switch (currentSubCfg) {
945            case rapidFireShotsPerSecondEnum: {
946                drawProfileSettingValue(rapidFireShotsPerSecond[profileId], rapidFireShotsPerSecondEnum);
947                break;
948            }
949            case rapidFireHoldTimeEnum: {
950                drawProfileSettingValue(rapidFireHoldTime[profileId], rapidFireHoldTimeEnum);
951                break;
952            }
953        }
954    }
955    if (currentSubCfg == rapidFireShotsPerSecondEnum) {
956        handleRapidFireShotsPerSecond();
957    } else {
958        handleRapidFireHoldTime();
959    }
960    handleUpDown(rapidFireShotsPerSecondEnum, rapidFireHoldTimeEnum);
961}
962function renderAimAssistSubMenu() {
963    if (currentSubCfg < LeftSizeEnum || currentSubCfg > AimLockStrengthEnum) {
964        currentSubCfg = LeftSizeEnum;
965    }
966    if (oledSubmenuDraw) {
967        drawModTitle(AimAssistEnum);
968        drawSettingLabel(currentSubCfg);
969        switch (currentSubCfg) {
970            case AAShapeEnum: {
971                drawTextSettingValue(SHAPES[aimAssistShape[profileId]]);
972                break;
973            }
974            case LeftShapeEnum: {
975                drawTextSettingValue(SHAPES[settings[LeftShapeEnum]]);
976                break;
977            }
978            case OutSideFocusEnum: {
979                drawTextSettingValue(aaActivation[settings[currentSubCfg]]);
980                break;
981            }
982            default {
983                drawStandardSetting(currentSubCfg, FALSE);
984                break;
985            }
986        }
987    }
988    if (currentSubCfg == AAShapeEnum) {
989        handleAimAssistShape();
990    } else {
991        handleLeftRight(currentSubCfg);
992    }
993    handleUpDown(LeftSizeEnum, AimLockStrengthEnum);
994}

995// @[ANCHOR_RENDER_SUBMENU]
996function renderInfoMainScreen() {
997    drawInfoQr();
998    print(64, 52, OLED_FONT_SMALL, OLED_WHITE, addr(scriptVersion));
999}
1000function drawInfoQr() {
1001    rect_oled(3, 3, 58, 58, 1, OLED_WHITE);
1002    for (qrRow = 0; qrRow < 21; qrRow++) {
1003        for (qrCol = 0; qrCol < 21; qrCol++) {
1004            qrByteIndex = (qrRow * 3) + (qrCol / 8);
1005            qrMask = QR_BIT_MASKS[qrCol % 8];
1006            if (INFO_QR_BYTES[qrByteIndex] & qrMask) {
1007                rect_oled(11 + (qrCol * 2), 11 + (qrRow * 2), 2, 2, 1, OLED_BLACK);
1008            }
1009        }
1010    }
1011}
1012function displayProfileNameCentered(yPosition, font, fontWidth, color) {
1013    print(centerX(getProfileStringSize(), fontWidth), yPosition, font, color, getProfileStringAddr());
1014}
1015function drawProfileBadge(xPosition, yPosition, font, color) {
1016    putc_oled(1, ASCII_UPPER_P);
1017    if (profileId == Profile1Enum) {
1018        putc_oled(2, ASCII_DIGIT1);
1019    } else {
1020        putc_oled(2, ASCII_DIGIT2);
1021    }
1022    puts_oled(xPosition, yPosition, font, 2, color);
1023}
1024function drawModCounterLeft(yPosition, color) {
1025    drawingValue = currentMod + 1;
1026    stringLength = findDigits(drawingValue);
1027    logVal = findDigits(AMOUNT_OF_MOD_TOGGLE);
1028    xPos = 2;
1029    numberToString(drawingValue, stringLength, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, xPos, yPosition, color);
1030    putc_oled(1, 47);
1031    puts_oled(xPos + (stringLength * OLED_FONT_SMALL_WIDTH), yPosition, OLED_FONT_SMALL, 1, color);
1032    numberToString(AMOUNT_OF_MOD_TOGGLE, logVal, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, xPos + ((stringLength + 1) * OLED_FONT_SMALL_WIDTH), yPosition, color);
1033}
1034function drawProfileNameRight(yPosition, color) {
1035    drawProfileBadge(114, yPosition, OLED_FONT_SMALL, color);
1036}
1037function getProfileStringAddr() {
1038    if (profileId == Profile1Enum) {
1039        return SPROFILE_1[0];
1040    } else if (profileId == Profile2Enum) {
1041        return SPROFILE_2[0];
1042    }
1043    return SNOPROFILE[0];
1044}
1045function getProfileStringSize() {
1046    if (profileId == Profile1Enum) {
1047        return sizeof(SPROFILE_1) - 1;
1048    } else if (profileId == Profile2Enum) {
1049        return sizeof(SPROFILE_2) - 1;
1050    }
1051    return sizeof(SNOPROFILE) - 1;
1052}
1053function displayPressToOpenMenu() {
1054    putc_oled(1, 62);
1055    puts_oled(15, 51, OLED_FONT_SMALL, 1, OLED_WHITE);
1056    printCentered(51, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, MENU_HINT_TEXT[0]);
1057    putc_oled(1, 60);
1058    puts_oled(106, 51, OLED_FONT_SMALL, 1, OLED_WHITE);
1059}
1060int FIRE_BTN, ADS_BTN, LETHAL_BTN, TACTICAL_BTN, JUMP_BTN, CROUCH_BTN, MELEE_BTN, SPRINT_BTN, RELOAD_BTN, SWITCHWEAPON_BTN, PING_BTN;
1061const string BtnLayouts[] = {"DEFAULT", "TACTICAL", "LEFTY", "N0M4D/CHARLIE", "N0M4D/CHARLIE TAC", "N0M4D/CHARLIE LEFT", "BUMPER JUMPER", "BUMPER JUMPER TAC", "1-HAND GUNSLINGER", "STICK & MOVE",
1062"BRAWLER", "BEAST","BUMPER PING","BUMPER PING TAC", "DEFAULT FLIPPED","TACTICAL FLIPPED", "B.JUMPER FLIPPED", "B.JUMPRTAC FLIPPED", "STICK&MOVE FLIPPED","BEASTY SWAPPED","B.PING FLIPPED","B.PING.TAC.FLIPPED"};
1063const uint8 Layouts[][] = {
1064	{ PS5_R2, PS5_L2, PS5_R1, PS5_L1, PS5_CROSS,  PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1065	{ PS5_R2, PS5_L2, PS5_R1, PS5_L1, PS5_CROSS,  PS5_R3, PS5_CIRCLE,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1066	{ PS5_L2, PS5_R2, PS5_L1, PS5_R1, PS5_CROSS,  PS5_CIRCLE,  PS5_L3, PS5_R3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1067	{ PS5_R2, PS5_R1, PS5_L2, PS5_L1, PS5_CROSS,  PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1068	{ PS5_R2, PS5_R1, PS5_L2, PS5_L1, PS5_CROSS,  PS5_R3, PS5_CIRCLE,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1069	{ PS5_L2, PS5_L1, PS5_R2, PS5_R1, PS5_CROSS,  PS5_CIRCLE,  PS5_L3, PS5_R3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1070	{ PS5_R2, PS5_L2, PS5_R1, PS5_CROSS,  PS5_L1, PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1071	{ PS5_R2, PS5_L2, PS5_R1, PS5_CROSS,  PS5_L1, PS5_R3, PS5_CIRCLE,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1072	{ PS5_L1, PS5_L2, PS5_R2, PS5_R1, PS5_CROSS,  PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1073	{ PS5_R2, PS5_L2, PS5_R1, PS5_L1, PS5_R3, PS5_CIRCLE,  PS5_CROSS,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1074	{ PS5_R2, PS5_L2, PS5_R1, PS5_L1, PS5_CROSS,  PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1075	{ PS5_R2, PS5_L2, PS5_R3, PS5_CROSS,  PS5_L1, PS5_CIRCLE,  PS5_R1, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1076	{ PS5_R2, PS5_L2, PS5_R1, PS5_R1, PS5_CROSS,  PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_L1 },
1077	{ PS5_R2, PS5_L2, PS5_R1, PS5_R1, PS5_CROSS,  PS5_R3, PS5_CIRCLE,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_L1 },
1078	{ PS5_R1, PS5_L1, PS5_R2, PS5_L2, PS5_CROSS,  PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1079	{ PS5_R1, PS5_L1, PS5_R2, PS5_L2, PS5_CROSS,  PS5_R3, PS5_CIRCLE,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1080	{ PS5_R1, PS5_L1, PS5_R2, PS5_CROSS,  PS5_L2, PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1081	{ PS5_R1, PS5_L1, PS5_R2, PS5_CROSS,  PS5_L2, PS5_R3, PS5_CIRCLE,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1082	{ PS5_R1, PS5_L1, PS5_R2, PS5_L2, PS5_R3, PS5_CIRCLE,  PS5_CROSS,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1083	{ PS5_R1, PS5_L1, PS5_R3, PS5_CROSS,  PS5_L1, PS5_CIRCLE,  PS5_R1, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_UP },
1084	{ PS5_R1, PS5_L1, PS5_R2, PS5_R2, PS5_CROSS,  PS5_CIRCLE,  PS5_R3, PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_L2 },
1085	{ PS5_R1, PS5_L1, PS5_R2, PS5_R2, PS5_CROSS,  PS5_R3, PS5_CIRCLE,  PS5_L3 ,PS5_SQUARE, PS5_TRIANGLE, PS5_L2 }
1086};
1087function setButtonsLayout(Type) {
1088    FIRE_BTN         = Layouts[Type][0];
1089    ADS_BTN          = Layouts[Type][1];
1090    LETHAL_BTN       = Layouts[Type][2];
1091    TACTICAL_BTN     = Layouts[Type][3];
1092    JUMP_BTN         = Layouts[Type][4];
1093    CROUCH_BTN       = Layouts[Type][5];
1094    MELEE_BTN        = Layouts[Type][6];
1095    SPRINT_BTN       = Layouts[Type][7];
1096    RELOAD_BTN       = Layouts[Type][8];
1097    SWITCHWEAPON_BTN = Layouts[Type][9];
1098    PING_BTN         = Layouts[Type][10];
1099}
1100function handleButtonPression() {
1101    if (

1102        get_ival(FIRE_BTN)         ||
1103        get_ival(ADS_BTN)          ||
1104        get_ival(LETHAL_BTN)       ||
1105        get_ival(TACTICAL_BTN)     ||
1106        get_ival(JUMP_BTN)         ||
1107        get_ival(CROUCH_BTN)       ||
1108        get_ival(MELEE_BTN)        ||
1109        get_ival(SPRINT_BTN)       ||
1110        get_ival(RELOAD_BTN)       ||
1111        get_ival(SWITCHWEAPON_BTN) ||
1112        get_ival(PING_BTN)         ||
1113        get_ival(PS5_UP)           ||
1114        get_ival(PS5_DOWN)         ||
1115        get_ival(PS5_LEFT)         ||
1116        get_ival(PS5_RIGHT)
1117    ) {
1118        setupScreenSaverTime = 0;
1119    }
1120}
1121function handleUserOffSateInput() {
1122	// @[ANCHOR_OFF_STATE_INPUT]
1123	if (get_val(PS5_L2) && event_release(PS5_SHARE)) {
1124		tempState = STATE_RESTART;
1125		currentState = STATE_CLEAN_SCREEN;
1126	}
1127}
1128function handleUserPlayingSateInput() {
1129    // @[ANCHOR_PRIORITY_LOGIC]
1130	if (get_val(PS5_L2) && event_release(PS5_SHARE)) {
1131		block_all_inputs();
1132	    tempState = STATE_OFF;
1133    	currentState = STATE_CLEAN_SCREEN;
1134	}
1135	if (get_val(PS5_L2) && get_val(PS5_OPTIONS)) {
1136    	set_val(PS5_OPTIONS, 0);
1137    	set_val(PS5_L2, 0);
1138    }
1139	if (get_val(PS5_L2) && event_release(PS5_OPTIONS)) {
1140		block_all_inputs();
1141        tempState = STATE_SETUP_MENU;
1142    	currentState = STATE_CLEAN_SCREEN;
1143    }
1144	if (event_press(PS5_SHARE)) {
1145		initScreenSaver();
1146		resetDisplay();
1147	}
1148	\${CORE_WEAPON_TRACKING_LOGIC}
1149	setPassiveMode();
1150	if(toggleRapidFire[profileId]\${CORE_RF_WEAPON_GATE} && !passiveMod/* @[INLINE_SUPPRESS_COMBAT] */) {
1151		rapidFire();
1152	} else {
1153		combo_stop(RapidFireCombo);
1154	}
1155	if (toggleAntiRecoil[profileId] && getVibrationState() && !toggle[ToggleAimAssistEnum] && !passiveMod && !no_gun_state && !utility_state/* @[INLINE_SUPPRESS_COMBAT] */) {
1156		if (!settings[antiRecoilModeEnum]) {
1157			StandardAntiRecoil();
1158		} else {
1159			RumbleAntiRecoil();
1160		}
1161	} else {
1162        if (combo_running(AntiRecoilCombo)) {
1163            combo_stop(AntiRecoilCombo);
1164        }
1165        if (!(toggle[ToggleAimAssistEnum] && !passiveMod && !no_gun_state && !utility_state)) {
1166            resetAntiRecoilRuntime();
1167        }
1168	}
1169	if (toggle[ToggleAimAssistEnum] && !passiveMod && !no_gun_state && !utility_state/* @[INLINE_SUPPRESS_COMBAT] */) {
1170		AimAssist();
1171		if (settings[OutSideFocusEnum] && event_release(ADS_BTN)) {
1172	        resetXY();
1173	    }
1174	}
1175    // @[ANCHOR_MAIN_LOGIC]
1176	if (settings[NoRumbleEnum]) {
1177		muteRumbleOutput();
1178	}
1179}
1180function press_hold(f_btn) {
1181    return event_press(f_btn) || (get_ival(f_btn) && get_ptime(f_btn) >= 500);
1182}
1183function SetLEDColor(color) {
1184	if (passiveMod) {
1185		return;
1186	}
1187	set_hsb(Color[color][Hue], Color[color][Saturation], Color[color][Brightness]);
1188}
1189function blinkLedAndRumble() {
1190        set_ledx(3, 3);
1191        resetBlinkLedAndRumble();
1192}
1193function resetBlinkLedAndRumble() {
1194	if(!get_ledx()) {
1195		SetLEDColor(currentLedColor);
1196    }
1197}
1198function mainMenuProfileHandling() {
1199	if (event_press(PS5_R1)) {
1200		profileHandling(0);
1201        resetDisplay();
1202	}
1203	if (event_press(PS5_L1)) {
1204		profileHandling(1);
1205        resetDisplay();
1206	}
1207}
1208function profileHandling(action) {
1209	switch (action) {
1210		case 0: {
1211			profileId = clamp(profileId + 1, Profile1Enum, Profile2Enum);
1212			break;
1213		}
1214		case 1: {
1215			profileId = clamp(profileId - 1, Profile1Enum, Profile2Enum);
1216			break;
1217		}
1218		default {
1219			break;
1220		}
1221	}
1222	if (profileId == Profile1Enum) {
1223		resetToProfile1();
1224	} else {
1225		resetToProfile2();
1226	}
1227}
1228function switchProfile() {
1229	if (profileId == Profile1Enum) {
1230		resetToProfile2();
1231	} else {
1232		resetToProfile1();
1233	}
1234	 resetDisplay();
1235}
1236function resetToProfile1() {
1237	profileId = Profile1Enum;
1238	resetAntiRecoilRuntime();
1239	currentLedColor = Red;
1240	SetLEDColor(currentLedColor);
1241    resetDisplay();
1242    // @[ANCHOR_PROFILE_CHANGED]
1243}
1244function resetToProfile2() {
1245	profileId = Profile2Enum;
1246	resetAntiRecoilRuntime();
1247	currentLedColor = White;
1248	SetLEDColor(currentLedColor);
1249    resetDisplay();
1250    // @[ANCHOR_PROFILE_CHANGED]
1251}
1252function getModToggleState(mod) {
1253    switch (mod) {
1254        case AntiRecoilEnum: {
1255         return toggleAntiRecoil[profileId];
1256        }
1257        case AimAssistEnum: {
1258        	return toggle[ToggleAimAssistEnum];
1259        }
1260        case RapidFireEnum: {
1261            return toggleRapidFire[profileId];
1262        }
1263        // @[ANCHOR_GET_TOGGLE_STATE]
1264    }
1265    return 0;
1266}
1267function switchActiveModState() {
1268    switch (modId[currentMod]) {
1269        case AntiRecoilEnum:  {
1270         toggleAntiRecoil[profileId] = !toggleAntiRecoil[profileId];
1271         break;
1272        }
1273        case AimAssistEnum: {
1274         toggle[ToggleAimAssistEnum] = !toggle[ToggleAimAssistEnum];
1275         break;
1276        }
1277        case RapidFireEnum: {
1278         toggleRapidFire[profileId] = !toggleRapidFire[profileId];
1279         break;
1280        }
1281        // @[ANCHOR_SWITCH_ACTIVE_MOD]
1282    }
1283}
1284function iif(expression, truepart, falsepart) {
1285	if (expression) {
1286		return truepart;
1287	}
1288	return falsepart;

1289}
1290int settings[128];
1291const int16 settingMinMax[][] = {
1292	{ 0, 50 },
1293	{ 0, 50 },
1294	{ 0, 8 },
1295	{ 0, 50 },
1296	{ 0, 50 },
1297	{ 0, 8 },
1298	{ 0, 1 },
1299	{ 0, 50 },
1300	{ 0, 50 },
1301	{ 0, 50 },
1302	{ 0, 50 },
1303	{ 0, 100 },
1304	{ 0, 100 },
1305	{ 10, 100 },
1306	{ 0, 30 },
1307	{ 0, 100 },
1308	{ 1, 20 },
1309	{ 20, 500 },
1310	{ -1, 1 },
1311	{ 0, 1 },
1312	{ 0, 21 },
1313    // @[ANCHOR_MISC_MIN_MAX_TABLE]
1314	{ -50, 50 },
1315	{ -50, 50 },
1316	{ 0, 2 },
1317	{ 0, 1 },
1318	{ 0, 1 },
1319	{ 1, 500 },
1320	{ -50, 50 },
1321	{ -50, 50 },
1322	{ 0, 1 },
1323	{ 1, 500 },
1324	{ 0, 1 },
1325	{ 100, 2000 },
1326	{ 1, 2000 },
1327	{ 50, 100 },
1328	{ 0, 1 },
1329	{ 0, 100 },
1330	{ 0, 100 }
1331    // @[ANCHOR_MIN_MAX_TABLE]
1332};
1333enum { LeftSizeEnum=0, LeftSpeedEnum, LeftShapeEnum, RightSizeEnum,
1334RightSpeedEnum, AAShapeEnum, OutSideFocusEnum, AdsLeftSizeEnum, AdsLeftSpeedEnum, AdsRightSizeEnum, AdsRightSpeedEnum, activationRangeMaxEnum,
1335	activationRangeMinEnum, boostStrengthEnum,
1336	SmoothingFactorEnum, AimLockStrengthEnum,
1337	rapidFireShotsPerSecondEnum, rapidFireHoldTimeEnum,
1338InvertEnum, NoRumbleEnum, buttonLayoutEnum,
1339// @[ANCHOR_MISC_SETTING_ENUM]
1340antiRecoilVerticalEnum, antiRecoilHorizontalEnum, antiRecoilActivationEnum, antiRecoilModeEnum,
1341antiRecoilInitialEnabledEnum, antiRecoilInitialTimeEnum, antiRecoilInitialVerticalEnum,
1342antiRecoilInitialHorizontalEnum, antiRecoilRampEnabledEnum, antiRecoilRampTimeEnum,
1343antiRecoilDecayEnabledEnum, antiRecoilDecayStartEnum, antiRecoilDecayTimeEnum, antiRecoilDecayFloorEnum,
1344antiRecoilAimOverrideEnabledEnum, antiRecoilAimOverrideThresholdEnum, antiRecoilAimOverrideStrengthEnum
1345// @[ANCHOR_SETTING_ENUM]
1346}
1347define BVAR_MAGIC_SLOT = 1;
1348define BVAR_SCHEMA_SLOT = 2;
1349define BVAR_MAGIC_VALUE = 2849;
1350define BVAR_SCHEMA_VERSION = \${CORE_BVAR_SCHEMA_VERSION};
1351define BVAR_RESERVED_END_SLOT = 9;
1352define BVAR_CORE_NEXT_SLOT = 71;
1353define BVAR_TOGGLEANTIRECOIL_P1 = 10;
1354define BVAR_ANTIRECOILVERTICAL_P1 = 11;
1355define BVAR_ANTIRECOILHORIZONTAL_P1 = 12;
1356define BVAR_TOGGLEANTIRECOIL_P2 = 13;
1357define BVAR_ANTIRECOILVERTICAL_P2 = 14;
1358define BVAR_ANTIRECOILHORIZONTAL_P2 = 15;
1359define BVAR_TOGGLEAIMASSIST = 16;
1360define BVAR_AIMASSISTSHAPE_P1 = 17;
1361define BVAR_AIMASSISTSHAPE_P2 = 18;
1362define BVAR_TOGGLERAPIDFIRE_P1 = 19;
1363define BVAR_ADSLEFTSPEED = 20;
1364define BVAR_LEFTSHAPE = 21;
1365define BVAR_ADSRIGHTSPEED = 22;
1366define BVAR_ADSLEFTSIZE = 23;
1367define BVAR_ADSRIGHTSIZE = 24;
1368define BVAR_ANTIRECOILMODE = 25;
1369define BVAR_LEFTSIZE = 26;
1370define BVAR_LEFTSPEED = 27;
1371define BVAR_RIGHTSIZE = 28;
1372define BVAR_RIGHTSPEED = 29;
1373define BVAR_BOOSTSTRENGTH = 30;
1374define BVAR_OUTSIDEFOCUS = 31;
1375define BVAR_NORUMBLE = 32;
1376define BVAR_ACTIVATIONRANGEMIN = 33;
1377define BVAR_ACTIVATIONRANGEMAX = 34;
1378define BVAR_SMOOTHINGFACTOR = 35;
1379define BVAR_AIMLOCKSTRENGTH = 36;
1380define BVAR_INVERT = 37;
1381define BVAR_BUTTONLAYOUT = 38;
1382define BVAR_ANTIRECOILACTIVATION = 39;
1383define BVAR_RAPIDFIRESHOTSPERSECOND_P1 = 40;
1384define BVAR_RAPIDFIREHOLDTIME_P1 = 41;
1385define BVAR_TOGGLERAPIDFIRE_P2 = 42;
1386define BVAR_RAPIDFIRESHOTSPERSECOND_P2 = 43;
1387define BVAR_RAPIDFIREHOLDTIME_P2 = 44;
1388define BVAR_ANTIRECOILINITIALENABLED_P1 = 45;
1389define BVAR_ANTIRECOILINITIALTIME_P1 = 46;
1390define BVAR_ANTIRECOILINITIALVERTICAL_P1 = 47;
1391define BVAR_ANTIRECOILINITIALHORIZONTAL_P1 = 48;
1392define BVAR_ANTIRECOILRAMPENABLED_P1 = 49;
1393define BVAR_ANTIRECOILRAMPTIME_P1 = 50;
1394define BVAR_ANTIRECOILINITIALENABLED_P2 = 51;
1395define BVAR_ANTIRECOILINITIALTIME_P2 = 52;
1396define BVAR_ANTIRECOILINITIALVERTICAL_P2 = 53;
1397define BVAR_ANTIRECOILINITIALHORIZONTAL_P2 = 54;
1398define BVAR_ANTIRECOILRAMPENABLED_P2 = 55;
1399define BVAR_ANTIRECOILRAMPTIME_P2 = 56;
1400define BVAR_ANTIRECOILAIMOVERRIDEENABLED_P1 = 57;
1401define BVAR_ANTIRECOILAIMOVERRIDETHRESHOLD_P1 = 58;
1402define BVAR_ANTIRECOILAIMOVERRIDESTRENGTH_P1 = 59;
1403define BVAR_ANTIRECOILAIMOVERRIDEENABLED_P2 = 60;
1404define BVAR_ANTIRECOILAIMOVERRIDETHRESHOLD_P2 = 61;
1405define BVAR_ANTIRECOILAIMOVERRIDESTRENGTH_P2 = 62;
1406define BVAR_ANTIRECOILDECAYENABLED_P1 = 63;
1407define BVAR_ANTIRECOILDECAYSTART_P1 = 64;
1408define BVAR_ANTIRECOILDECAYTIME_P1 = 65;
1409define BVAR_ANTIRECOILDECAYFLOOR_P1 = 66;
1410define BVAR_ANTIRECOILDECAYENABLED_P2 = 67;
1411define BVAR_ANTIRECOILDECAYSTART_P2 = 68;
1412define BVAR_ANTIRECOILDECAYTIME_P2 = 69;
1413define BVAR_ANTIRECOILDECAYFLOOR_P2 = 70;
1414// @[ANCHOR_BVAR_SLOT_DEFINES]
1415int bvar_tmp;
1416function save_bvar(slot, val, min, max) {
1417    set_bvar(slot, clamp(val, min, max) - min);
1418}
1419function read_bvar(slot, min, max, def) {
1420    bvar_tmp = get_bvar(slot) + min;
1421    if (bvar_tmp < min || bvar_tmp > max) {
1422        return def;
1423    }
1424    return bvar_tmp;
1425}
1426function persistSettings() {
1427    set_bvar(BVAR_MAGIC_SLOT, BVAR_MAGIC_VALUE);
1428    set_bvar(BVAR_SCHEMA_SLOT, BVAR_SCHEMA_VERSION);
1429    save_bvar(BVAR_TOGGLEANTIRECOIL_P1, toggleAntiRecoil[Profile1Enum], 0, 1);
1430    save_bvar(BVAR_ANTIRECOILVERTICAL_P1, antiRecoilVertical[Profile1Enum], -50, 50);
1431    save_bvar(BVAR_ANTIRECOILHORIZONTAL_P1, antiRecoilHorizontal[Profile1Enum], -50, 50);
1432    save_bvar(BVAR_TOGGLEANTIRECOIL_P2, toggleAntiRecoil[Profile2Enum], 0, 1);
1433    save_bvar(BVAR_ANTIRECOILVERTICAL_P2, antiRecoilVertical[Profile2Enum], -50, 50);
1434    save_bvar(BVAR_ANTIRECOILHORIZONTAL_P2, antiRecoilHorizontal[Profile2Enum], -50, 50);
1435    save_bvar(BVAR_TOGGLEAIMASSIST, toggle[ToggleAimAssistEnum], 0, 1);
1436    save_bvar(BVAR_AIMASSISTSHAPE_P1, aimAssistShape[Profile1Enum], CircularEnum, OscillirateEnum);
1437    save_bvar(BVAR_AIMASSISTSHAPE_P2, aimAssistShape[Profile2Enum], CircularEnum, OscillirateEnum);
1438    save_bvar(BVAR_TOGGLERAPIDFIRE_P1, toggleRapidFire[Profile1Enum], 0, 1);

1439    save_bvar(BVAR_ADSLEFTSPEED, settings[AdsLeftSpeedEnum], settingMinMax[AdsLeftSpeedEnum][0], settingMinMax[AdsLeftSpeedEnum][1]);
1440    save_bvar(BVAR_LEFTSHAPE, settings[LeftShapeEnum], settingMinMax[LeftShapeEnum][0], settingMinMax[LeftShapeEnum][1]);
1441    save_bvar(BVAR_ADSRIGHTSPEED, settings[AdsRightSpeedEnum], settingMinMax[AdsRightSpeedEnum][0], settingMinMax[AdsRightSpeedEnum][1]);
1442    save_bvar(BVAR_ADSLEFTSIZE, settings[AdsLeftSizeEnum], settingMinMax[AdsLeftSizeEnum][0], settingMinMax[AdsLeftSizeEnum][1]);
1443    save_bvar(BVAR_ADSRIGHTSIZE, settings[AdsRightSizeEnum], settingMinMax[AdsRightSizeEnum][0], settingMinMax[AdsRightSizeEnum][1]);
1444    save_bvar(BVAR_ANTIRECOILMODE, settings[antiRecoilModeEnum], settingMinMax[antiRecoilModeEnum][0], settingMinMax[antiRecoilModeEnum][1]);
1445    save_bvar(BVAR_LEFTSIZE, settings[LeftSizeEnum], settingMinMax[LeftSizeEnum][0], settingMinMax[LeftSizeEnum][1]);
1446    save_bvar(BVAR_LEFTSPEED, settings[LeftSpeedEnum], settingMinMax[LeftSpeedEnum][0], settingMinMax[LeftSpeedEnum][1]);
1447    save_bvar(BVAR_RIGHTSIZE, settings[RightSizeEnum], settingMinMax[RightSizeEnum][0], settingMinMax[RightSizeEnum][1]);
1448    save_bvar(BVAR_RIGHTSPEED, settings[RightSpeedEnum], settingMinMax[RightSpeedEnum][0], settingMinMax[RightSpeedEnum][1]);
1449    save_bvar(BVAR_BOOSTSTRENGTH, settings[boostStrengthEnum], settingMinMax[boostStrengthEnum][0], settingMinMax[boostStrengthEnum][1]);
1450    save_bvar(BVAR_OUTSIDEFOCUS, settings[OutSideFocusEnum], settingMinMax[OutSideFocusEnum][0], settingMinMax[OutSideFocusEnum][1]);
1451    save_bvar(BVAR_NORUMBLE, settings[NoRumbleEnum], 0, 1);
1452    save_bvar(BVAR_ACTIVATIONRANGEMIN, settings[activationRangeMinEnum], settingMinMax[activationRangeMinEnum][0], settingMinMax[activationRangeMinEnum][1]);
1453    save_bvar(BVAR_ACTIVATIONRANGEMAX, settings[activationRangeMaxEnum], settingMinMax[activationRangeMaxEnum][0], settingMinMax[activationRangeMaxEnum][1]);
1454    save_bvar(BVAR_SMOOTHINGFACTOR, settings[SmoothingFactorEnum], settingMinMax[SmoothingFactorEnum][0], settingMinMax[SmoothingFactorEnum][1]);
1455    save_bvar(BVAR_AIMLOCKSTRENGTH, settings[AimLockStrengthEnum], settingMinMax[AimLockStrengthEnum][0], settingMinMax[AimLockStrengthEnum][1]);
1456    save_bvar(BVAR_INVERT, settings[InvertEnum], -1, 1);
1457    save_bvar(BVAR_BUTTONLAYOUT, settings[buttonLayoutEnum], 0, 21);
1458    save_bvar(BVAR_ANTIRECOILACTIVATION, settings[antiRecoilActivationEnum], 0, 2);
1459    save_bvar(BVAR_RAPIDFIRESHOTSPERSECOND_P1, rapidFireShotsPerSecond[Profile1Enum], 1, 20);
1460    save_bvar(BVAR_RAPIDFIREHOLDTIME_P1, rapidFireHoldTime[Profile1Enum], 20, 500);
1461    save_bvar(BVAR_TOGGLERAPIDFIRE_P2, toggleRapidFire[Profile2Enum], 0, 1);
1462    save_bvar(BVAR_RAPIDFIRESHOTSPERSECOND_P2, rapidFireShotsPerSecond[Profile2Enum], 1, 20);
1463    save_bvar(BVAR_RAPIDFIREHOLDTIME_P2, rapidFireHoldTime[Profile2Enum], 20, 500);
1464    save_bvar(BVAR_ANTIRECOILINITIALENABLED_P1, antiRecoilInitialEnabled[Profile1Enum], 0, 1);
1465    save_bvar(BVAR_ANTIRECOILINITIALTIME_P1, antiRecoilInitialTime[Profile1Enum], 1, 500);
1466    save_bvar(BVAR_ANTIRECOILINITIALVERTICAL_P1, antiRecoilInitialVertical[Profile1Enum], -50, 50);
1467    save_bvar(BVAR_ANTIRECOILINITIALHORIZONTAL_P1, antiRecoilInitialHorizontal[Profile1Enum], -50, 50);
1468    save_bvar(BVAR_ANTIRECOILRAMPENABLED_P1, antiRecoilRampEnabled[Profile1Enum], 0, 1);
1469    save_bvar(BVAR_ANTIRECOILRAMPTIME_P1, antiRecoilRampTime[Profile1Enum], 1, 500);
1470    save_bvar(BVAR_ANTIRECOILINITIALENABLED_P2, antiRecoilInitialEnabled[Profile2Enum], 0, 1);
1471    save_bvar(BVAR_ANTIRECOILINITIALTIME_P2, antiRecoilInitialTime[Profile2Enum], 1, 500);
1472    save_bvar(BVAR_ANTIRECOILINITIALVERTICAL_P2, antiRecoilInitialVertical[Profile2Enum], -50, 50);
1473    save_bvar(BVAR_ANTIRECOILINITIALHORIZONTAL_P2, antiRecoilInitialHorizontal[Profile2Enum], -50, 50);
1474    save_bvar(BVAR_ANTIRECOILRAMPENABLED_P2, antiRecoilRampEnabled[Profile2Enum], 0, 1);
1475    save_bvar(BVAR_ANTIRECOILRAMPTIME_P2, antiRecoilRampTime[Profile2Enum], 1, 500);
1476    // @[ANCHOR_SAVE_BVAR]
1477    save_bvar(BVAR_ANTIRECOILAIMOVERRIDEENABLED_P1, antiRecoilAimOverrideEnabled[Profile1Enum], 0, 1);
1478    save_bvar(BVAR_ANTIRECOILAIMOVERRIDETHRESHOLD_P1, antiRecoilAimOverrideThreshold[Profile1Enum], 0, 100);
1479    save_bvar(BVAR_ANTIRECOILAIMOVERRIDESTRENGTH_P1, antiRecoilAimOverrideStrength[Profile1Enum], 0, 100);
1480    save_bvar(BVAR_ANTIRECOILAIMOVERRIDEENABLED_P2, antiRecoilAimOverrideEnabled[Profile2Enum], 0, 1);
1481    save_bvar(BVAR_ANTIRECOILAIMOVERRIDETHRESHOLD_P2, antiRecoilAimOverrideThreshold[Profile2Enum], 0, 100);
1482    save_bvar(BVAR_ANTIRECOILAIMOVERRIDESTRENGTH_P2, antiRecoilAimOverrideStrength[Profile2Enum], 0, 100);
1483    save_bvar(BVAR_ANTIRECOILDECAYENABLED_P1, antiRecoilDecayEnabled[Profile1Enum], 0, 1);
1484    save_bvar(BVAR_ANTIRECOILDECAYSTART_P1, antiRecoilDecayStart[Profile1Enum], 100, 2000);
1485    save_bvar(BVAR_ANTIRECOILDECAYTIME_P1, antiRecoilDecayTime[Profile1Enum], 1, 2000);
1486    save_bvar(BVAR_ANTIRECOILDECAYFLOOR_P1, antiRecoilDecayFloor[Profile1Enum], 50, 100);
1487    save_bvar(BVAR_ANTIRECOILDECAYENABLED_P2, antiRecoilDecayEnabled[Profile2Enum], 0, 1);
1488    save_bvar(BVAR_ANTIRECOILDECAYSTART_P2, antiRecoilDecayStart[Profile2Enum], 100, 2000);
1489    save_bvar(BVAR_ANTIRECOILDECAYTIME_P2, antiRecoilDecayTime[Profile2Enum], 1, 2000);
1490    save_bvar(BVAR_ANTIRECOILDECAYFLOOR_P2, antiRecoilDecayFloor[Profile2Enum], 50, 100);
1491}
1492function saveSettings() {
1493    persistSettings();
1494    blockCircleUntilRelease = TRUE;
1495    previousState = currentState;
1496    currentState = STATE_SAVING;
1497}
1498function loadSettings() {
1499    if (get_bvar(BVAR_MAGIC_SLOT) == BVAR_MAGIC_VALUE && get_bvar(BVAR_SCHEMA_SLOT) == BVAR_SC

1499HEMA_VERSION) {
1500        toggleAntiRecoil[Profile1Enum] = read_bvar(BVAR_TOGGLEANTIRECOIL_P1, 0, 1, 0);
1501        antiRecoilVertical[Profile1Enum] = read_bvar(BVAR_ANTIRECOILVERTICAL_P1, -50, 50, 22);
1502        antiRecoilHorizontal[Profile1Enum] = read_bvar(BVAR_ANTIRECOILHORIZONTAL_P1, -50, 50, 0);
1503        toggleAntiRecoil[Profile2Enum] = read_bvar(BVAR_TOGGLEANTIRECOIL_P2, 0, 1, 0);
1504        antiRecoilVertical[Profile2Enum] = read_bvar(BVAR_ANTIRECOILVERTICAL_P2, -50, 50, 20);
1505        antiRecoilHorizontal[Profile2Enum] = read_bvar(BVAR_ANTIRECOILHORIZONTAL_P2, -50, 50, 0);
1506        toggle[ToggleAimAssistEnum] = read_bvar(BVAR_TOGGLEAIMASSIST, 0, 1, 0);
1507        aimAssistShape[Profile1Enum] = read_bvar(BVAR_AIMASSISTSHAPE_P1, CircularEnum, OscillirateEnum, LeftRightEnum);
1508        aimAssistShape[Profile2Enum] = read_bvar(BVAR_AIMASSISTSHAPE_P2, CircularEnum, OscillirateEnum, LeftRightEnum);
1509        toggleRapidFire[Profile1Enum] = read_bvar(BVAR_TOGGLERAPIDFIRE_P1, 0, 1, 0);
1510        settings[AdsLeftSpeedEnum] = read_bvar(BVAR_ADSLEFTSPEED, settingMinMax[AdsLeftSpeedEnum][0], settingMinMax[AdsLeftSpeedEnum][1], 1);
1511        settings[LeftShapeEnum] = read_bvar(BVAR_LEFTSHAPE, settingMinMax[LeftShapeEnum][0], settingMinMax[LeftShapeEnum][1], 0);
1512        settings[AdsRightSpeedEnum] = read_bvar(BVAR_ADSRIGHTSPEED, settingMinMax[AdsRightSpeedEnum][0], settingMinMax[AdsRightSpeedEnum][1], 0);
1513        settings[AdsLeftSizeEnum] = read_bvar(BVAR_ADSLEFTSIZE, settingMinMax[AdsLeftSizeEnum][0], settingMinMax[AdsLeftSizeEnum][1], 0);
1514        settings[AdsRightSizeEnum] = read_bvar(BVAR_ADSRIGHTSIZE, settingMinMax[AdsRightSizeEnum][0], settingMinMax[AdsRightSizeEnum][1], 0);
1515        settings[antiRecoilModeEnum] = read_bvar(BVAR_ANTIRECOILMODE, settingMinMax[antiRecoilModeEnum][0], settingMinMax[antiRecoilModeEnum][1], 0);
1516        settings[LeftSizeEnum] = read_bvar(BVAR_LEFTSIZE, settingMinMax[LeftSizeEnum][0], settingMinMax[LeftSizeEnum][1], 10);
1517        settings[LeftSpeedEnum] = read_bvar(BVAR_LEFTSPEED, settingMinMax[LeftSpeedEnum][0], settingMinMax[LeftSpeedEnum][1], 20);
1518        settings[RightSizeEnum] = read_bvar(BVAR_RIGHTSIZE, settingMinMax[RightSizeEnum][0], settingMinMax[RightSizeEnum][1], 5);
1519        settings[RightSpeedEnum] = read_bvar(BVAR_RIGHTSPEED, settingMinMax[RightSpeedEnum][0], settingMinMax[RightSpeedEnum][1], 42);
1520        settings[boostStrengthEnum] = read_bvar(BVAR_BOOSTSTRENGTH, settingMinMax[boostStrengthEnum][0], settingMinMax[boostStrengthEnum][1], 18);
1521        settings[OutSideFocusEnum] = read_bvar(BVAR_OUTSIDEFOCUS, settingMinMax[OutSideFocusEnum][0], settingMinMax[OutSideFocusEnum][1], 1);
1522        settings[NoRumbleEnum] = read_bvar(BVAR_NORUMBLE, 0, 1, 0);
1523        settings[activationRangeMinEnum] = read_bvar(BVAR_ACTIVATIONRANGEMIN, settingMinMax[activationRangeMinEnum][0], settingMinMax[activationRangeMinEnum][1], 0);
1524        settings[activationRangeMaxEnum] = read_bvar(BVAR_ACTIVATIONRANGEMAX, settingMinMax[activationRangeMaxEnum][0], settingMinMax[activationRangeMaxEnum][1], 100);
1525        settings[SmoothingFactorEnum] = read_bvar(BVAR_SMOOTHINGFACTOR, settingMinMax[SmoothingFactorEnum][0], settingMinMax[SmoothingFactorEnum][1], 3);
1526        settings[AimLockStrengthEnum] = read_bvar(BVAR_AIMLOCKSTRENGTH, settingMinMax[AimLockStrengthEnum][0], settingMinMax[AimLockStrengthEnum][1], 100);
1527        settings[InvertEnum] = read_bvar(BVAR_INVERT, -1, 1, 1);
1528        settings[buttonLayoutEnum] = read_bvar(BVAR_BUTTONLAYOUT, 0, 21, 0);
1529        settings[antiRecoilActivationEnum] = read_bvar(BVAR_ANTIRECOILACTIVATION, 0, 2, 0);
1530        rapidFireShotsPerSecond[Profile1Enum] = read_bvar(BVAR_RAPIDFIRESHOTSPERSECOND_P1, 1, 20, 10);
1531        rapidFireHoldTime[Profile1Enum] = read_bvar(BVAR_RAPIDFIREHOLDTIME_P1, 20, 500, 40);
1532        toggleRapidFire[Profile2Enum] = read_bvar(BVAR_TOGGLERAPIDFIRE_P2, 0, 1, 0);
1533        rapidFireShotsPerSecond[Profile2Enum] = read_bvar(BVAR_RAPIDFIRESHOTSPERSECOND_P2, 1, 20, 10);
1534        rapidFireHoldTime[Profile2Enum] = read_bvar(BVAR_RAPIDFIREHOLDTIME_P2, 20, 500, 40);
1535        antiRecoilInitialEnabled[Profile1Enum] = read_bvar(BVAR_ANTIRECOILINITIALENABLED_P1, 0, 1, 1);
1536        antiRecoilInitialTime[Profile1Enum] = read_bvar(BVAR_ANTIRECOILINITIALTIME_P1, 1, 500, 100);
1537        antiRecoilInitialVertical[Profile1Enum] = read_bvar(BVAR_ANTIRECOILINITIALVERTICAL_P1, -50, 50, 4);
1538        antiRecoilInitialHorizontal[Profile1Enum] = read_bvar(BVAR_ANTIRECOILINITIALHORIZONTAL_P1, -50, 50, 0);
1539        antiRecoilRampEnabled[Profile1Enum] = read_bvar(BVAR_ANTIRECOILRAMPENABLED_P1, 0, 1, 1);
1540        antiRecoilRampTime[Profile1Enum] = read_bvar(BVAR_ANTIRECOILRAMPTIME_P1, 1, 500, 150);
1541        antiRecoilInitialEnabled[Profile2Enum] = read_bvar(BVAR_ANTIRECOILINITIALENABLED_P2, 0, 1, 1);
1542        antiRecoilInitialTime[Profile2Enum] = read_bvar(BVAR_ANTIRECOILINITIALTIME_P2, 1, 500, 100);
1543        antiRecoilInitialVertical[Profile2Enum] = read_bvar(BVAR_ANTIRECOILINITIALVERTICAL_P2, -50, 50, 4);
1544        antiRecoilInitialHorizontal[Profile2Enum] = read_bvar(BVAR_ANTIRECOILINITIALHORIZONTAL_P2, -50, 50, 0);
1545        antiRecoilRampEnabled[Profile2Enum] = read_bvar(BVAR_ANTIRECOILRAMPENABLED_P2, 0, 1, 1);
1546        antiRecoilRampTime[Profile2Enum] = read_bvar(BVAR_ANTIRECOILRAMPTIME_P2, 1, 500, 150);
1547        settings[rapidFireShotsPerSecondEnum] = rapidFireShotsPerSecond[Profile1Enum];
1548        settings[rapidFireHoldTimeEnum] = rapidFireHoldTime[Profile1Enum];
1549        // @[ANCHOR_LOAD_BVAR]
1550        antiRecoilAimOverrideEnabled[Profile1Enum] = read_bvar(BVAR_ANTIRECOILAIMOVERRIDEENABLED_P1, 0, 1, 1);
1551        antiRecoilAimOverrideThreshold[Profile1Enum] = read_bvar(BVAR_ANTIRECOILAIMOVERRIDETHRESHOLD_P1, 0, 100, 25);
1552        antiRecoilAimOverrideStrength[Profile1Enum] = read_bvar(BVAR_ANTIRECOILAIMOVERRIDESTRENGTH_P1, 0, 100, 50);
1553        antiRecoilAimOverrideEnabled[Profile2Enum] = read_bvar(BVAR_ANTIRECOILAIMOVERRIDEENABLED_P2, 0, 1, 1);
1554        antiRecoilAimOverrideThreshold[Profile2Enum] = read_bvar(BVAR_ANTIRECOILAIMOVERRIDETHRESHOLD_P2, 0, 100, 25);
1555        antiRecoilAimOverrideStrength[Profile2Enum] = read_bvar(BVAR_ANTIRECOILAIMOVERRIDESTRENGTH_P2, 0, 100, 50);
1556        antiRecoilDecayEnabled[Profile1Enum] = read_bvar(BVAR_ANTIRECOILDECAYENABLED_P1, 0, 1, 0);
1557        antiRecoilDecayStart[Profile1Enum] = read_bvar(BVAR_ANTIRECOILDECAYSTART_P1, 100, 2000, 900);
1558        antiRecoilDecayTime[Profile1Enum] = read_bvar(BVAR_ANTIRECOILDECAYTIME_P1, 1, 2000, 700);
1559        antiRecoilDecayFloor[Profile1Enum] = read_bvar(BVAR_ANTIRECOILDECAYFLOOR_P1, 50, 100, 85);
1560        antiRecoilDecayEnabled[Profile2Enum] = read_bvar(BVAR_ANTIRECOILDECAYENABLED_P2, 0, 1, 0);
1561        antiRecoilDecayStart[Profile2Enum] = read_bvar(BVAR_ANTIRECOILDECAYSTART_P2, 100, 2000, 900);
1562        antiRecoilDecayTime[Profile2Enum] = read_bvar(BVAR_ANTIRECOILDECAYTIME_P2, 1, 2000, 700);
1563        antiRecoilDecayFloor[Profile2Enum] = read_bvar(BVAR_ANTIRECOILDECAYFLOOR_P2, 50, 100, 85);
1564    } else {
1565        loadDefaultSettings();
1566        persistSettings();
1567    }
1568    if (settings[InvertEnum] != -1 && settings[InvertEnum] != 1) {
1569        settings[InvertEnum] = 1;
1570    }
1571}
1572function loadDefaultSettings() {
1573    toggleAntiRecoil[Profile1Enum] = \${CORE_AR_P1_EN};
1574    antiRecoilVertical[Profile1Enum] = \${CORE_AR_P1_V};
1575    antiRecoilHorizontal[Profile1Enum] = \${CORE_AR_P1_H};
1576    toggleAntiRecoil[Profile2Enum] = \${CORE_AR_P2_EN};
1577    antiRecoilVertical[Profile2Enum] = \${CORE_AR_P2_V};
1578    antiRecoilHorizontal[Profile2Enum] = \${CORE_AR_P2_H};
1579    toggle[ToggleAimAssistEnum] = \${CORE_AA_EN};
1580    aimAssistShape[Profile1Enum] = \${CORE_AA_P1_SHP};
1581    aimAssistShape[Profile2Enum] = \${CORE_AA_P2_SHP};
1582    toggleRapidFire[Profile1Enum] = \${CORE_RF_P1_EN};
1583    rapidFireShotsPerSecond[Profile1Enum] = \${CORE_RF_P1_SPD};
1584    rapidFireHoldTime[Profile1Enum] = \${CORE_RF_P1_HLD};
1585    toggleRapidFire[Profile2Enum] = \${CORE_RF_P2_EN};
1586    rapidFireShotsPerSecond[Profile2Enum] = \${CORE_RF_P2_SPD};
1587    rapidFireHoldTime[Profile2Enum] = \${CORE_RF_P2_HLD};
1588    settings[rapidFireShotsPerSecondEnum] = rapidFireShotsPerSecond[Profile1Enum];
1589    settings[rapidFireHoldTimeEnum] = rapidFireHoldTime[Profile1Enum];
1590    settings[AdsLeftSpeedEnum] = \${CORE_AA_ADS_L_SP};
1591    settings[LeftShapeEnum] = \${CORE_AA_L_SHP};
1592    settings[AdsRightSpeedEnum] = \${CORE_AA_ADS_R_SP};
1593    settings[AdsLeftSizeEnum] = \${CORE_AA_ADS_L_SZ};
1594    settings[AdsRightSizeEnum] = \${CORE_AA_ADS_R_SZ};
1595    settings[antiRecoilModeEnum] = \${CORE_AR_MODE};
1596    settings[LeftSizeEnum] = \${CORE_AA_L_SZ};
1597    settings[LeftSpeedEnum] = \${CORE_AA_L_SP};
1598    settings[RightSizeEnum] = \${CORE_AA_R_SZ};
1599    settings[RightSpeedEnum] = \${CORE_AA_R_SP};
1600    settings[boostStrengthEnum] = \${CORE_AA_BOOST};
1601    settings[OutSideFocusEnum] = \${CORE_AA_FOCUS};
1602    settings[NoRumbleEnum] = \${CORE_NO_RUM};
1603    settings[activationRangeMinEnum] = \${CORE_AA_ACT_MIN};
1604    settings[activationRangeMaxEnum] = \${CORE_AA_ACT_MAX};
1605    settings[SmoothingFactorEnum] = \${CORE_AA_SMOOTH};
1606    settings[AimLockStrengthEnum] = \${CORE_AA_LOCK};
1607    settings[InvertEnum] = \${CORE_INV};
1608    settings[buttonLayoutEnum] = 0;
1609    settings[antiRecoilActivationEnum] = \${CORE_AR_ACT};
1610    antiRecoilInitialEnabled[Profile1Enum] = \${CORE_AR_P1_INIT_EN};
1611    antiRecoilInitialTime[Profile1Enum] = \${CORE_AR_P1_INIT_TIME};
1612    antiRecoilInitialVertical[Profile1Enum] = \${CORE_AR_P1_INIT_V};
1613    antiRecoilInitialHorizontal[Profile1Enum] = \${CORE_AR_P1_INIT_H};
1614    antiRecoilRampEnabled[Profile1Enum] = \${CORE_AR_P1_RAMP_EN};
1615    antiRecoilRampTime[Profile1Enum] = \${CORE_AR_P1_RAMP_TIME};
1616    antiRecoilInitialEnabled[Profile2Enum] = \${CORE_AR_P2_INIT_EN};
1617    antiRecoilInitialTime[Profile2Enum] = \${CORE_AR_P2_INIT_TIME};
1618    antiRecoilInitialVertical[Profile2Enum] = \${CORE_AR_P2_INIT_V};
1619    antiRecoilInitialHorizontal[Profile2Enum] = \${CORE_AR_P2_INIT_H};
1620    antiRecoilRampEnabled[Profile2Enum] = \${CORE_AR_P2_RAMP_EN};
1621    antiRecoilRampTime[Profile2Enum] = \${CORE_AR_P2_RAMP_TIME};
1622    // @[ANCHOR_LOAD_DEFAULTS]
1623    antiRecoilAimOverrideEnabled[Profile1Enum] = \${CORE_AR_P1_OVERRIDE_EN};
1624    antiRecoilAimOverrideThreshold[Profile1Enum] = \${CORE_AR_P1_OVERRIDE_THRESHOLD};
1625    antiRecoilAimOverrideStrength[Profile1Enum] = \${CORE_AR_P1_OVERRIDE_STRENGTH};
1626    antiRecoilAimOverrideEnabled[Profile2Enum] = \${CORE_AR_P2_OVERRIDE_EN};
1627    antiRecoilAimOverrideThreshold[Profile2Enum] = \${CORE_AR_P2_OVERRIDE_THRESHOLD};
1628    antiRecoilAimOverrideStrength[Profile2Enum] = \${CORE_AR_P2_OVERRIDE_STRENGTH};
1629    antiRecoilDecayEnabled[Profile1Enum] = \${CORE_AR_P1_DECAY_EN};
1630    antiRecoilDecayStart[Profile1Enum] = \${CORE_AR_P1_DECAY_START};
1631    antiRecoilDecayTime[Profile1Enum] = \${CORE_AR_P1_DECAY_TIME};
1632    antiRecoilDecayFloor[Profile1Enum] = \${CORE_AR_P1_DECAY_FLOOR};
1633    antiRecoilDecayEnabled[Profile2Enum] = \${CORE_AR_P2_DECAY_EN};
1634    antiRecoilDecayStart[Profile2Enum] = \${CORE_AR_P2_DECAY_START};
1635    antiRecoilDecayTime[Profile2Enum] = \${CORE_AR_P2_DECAY_TIME};
1636    antiRecoilDecayFloor[Profile2Enum] = \${CORE_AR_P2_DECAY_FLOOR};
1637}
1638int smartRumble;
1639int rumble_a, rumble_b;
1640function rumbleToUse() {
1641     rumble_a = get_rumble(RUMBLE_A);
1642     rumble_b = get_rumble(RUMBLE_B);
1643     if(rumble_a == rumble_b)
1644     {
1645         return RUMBLE_A;
1646     }
1647     if(rumble_a == 100)
1648     {
1649         return RUMBLE_B;
1650     }
1651     if(rumble_b == 100)
1652     {
1653         return RUMBLE_A;
1654     }
1655     if(rumble_a > rumble_b)
1656     {
1657         return RUMBLE_A;
1658     }
1659     return RUMBLE_B;
1660}
1661function muteRumbleOutput() {
1662	set_val(RUMBLE_A, 0);
1663	set_val(RUMBLE_B, 0);
1664	set_val(RUMBLE_RT, 0);
1665	set_val(RUMBLE_LT, 0);
1666}
1667function getVibrationState() {
1668 	return TRUE;
1669}
1670
1671int antiRecoilAds = FALSE;
1672int antiRecoilFire = FALSE;
1673int comboAntiRecoilVertical;
1674int comboAntiRecoilHorizontal;
1675int antiRecoilVertical[2];
1676int antiRecoilHorizontal[2];
1677int antiRecoilInitialEnabled[2];
1678int antiRecoilInitialTime[2];
1679int antiRecoilInitialVertical[2];
1680int antiRecoilInitialHorizontal[2];
1681int antiRecoilRampEnabled[2];
1682int antiRecoilRampTime[2];
1683int antiRecoilDecayEnabled[2];
1684int antiRecoilDecayStart[2];
1685int antiRecoilDecayTime[2];
1686int antiRecoilDecayFloor[2];
1687int antiRecoilAimOverrideEnabled[2];
1688int antiRecoilAimOverrideThreshold[2];
1689int antiRecoilAimOverrideStrength[2];
1690int toggleAntiRecoil[2];
1691const string arActivation[]  = {"ADS+FIRE", "FIRE", "ADS+FIRE/FIRE"};
1692const string arModeNames[]  = {"STANDARD", "RUMBLE"};
1693int vertAntiRecoil, horizAntiRecoil;
1694int antiRecoilTimer;
1695int antiRecoilRampScale;
1696int antiRecoilDecayElapsed;
1697int antiRecoilDecayScale;
1698int antiRecoilVerticalEffective;
1699int antiRecoilHorizontalEffective;
1700// @[REPLACE:\${CORE_AR_HUMANIZER_VARS}]
1701function offsetAR(Stick,Value) {
1702  set_val(Stick, clamp(Value * (100 - abs(get_val(Stick))) / 100 + get_val(Stick) * 

1702settings[InvertEnum], -100, 100));
1703  return;
1704}
1705// @[REPLACE:\${CORE_AR_HUMANIZER_FUNCTIONS}]
1706function antirecoilActivation(setting) {
1707    antiRecoilAds = get_ival(ADS_BTN);
1708    antiRecoilFire = get_ival(FIRE_BTN);
1709    switch(setting) {
1710        case 0: {
1711            return (antiRecoilAds && antiRecoilFire);
1712        }
1713        case 1: {
1714            return (!antiRecoilAds && antiRecoilFire);
1715        }
1716        case 2: {
1717            return (antiRecoilAds && antiRecoilFire) || antiRecoilFire;
1718        }
1719        default {
1720            return FALSE;
1721        }
1722    }
1723    return FALSE;
1724}
1725function resetAntiRecoilRuntime() {
1726    antiRecoilTimer = 0;
1727    antiRecoilVerticalEffective = antiRecoilVertical[profileId];
1728    antiRecoilHorizontalEffective = antiRecoilHorizontal[profileId];
1729}
1730function updateAntiRecoilEffectiveValues() {
1731    if (antirecoilActivation(settings[antiRecoilActivationEnum])) {
1732        if (antiRecoilTimer < ANTI_RECOIL_STAGE_TIMER_MAX) {
1733            antiRecoilTimer = antiRecoilTimer + get_rtime();
1734            if (antiRecoilTimer > ANTI_RECOIL_STAGE_TIMER_MAX) {
1735                antiRecoilTimer = ANTI_RECOIL_STAGE_TIMER_MAX;
1736            }
1737        }
1738    } else {
1739        resetAntiRecoilRuntime();
1740        return;
1741    }
1742    antiRecoilVerticalEffective = antiRecoilVertical[profileId];
1743    antiRecoilHorizontalEffective = antiRecoilHorizontal[profileId];
1744    if (antiRecoilInitialEnabled[profileId] && antiRecoilTimer <= antiRecoilInitialTime[profileId]) {
1745        antiRecoilVerticalEffective = antiRecoilVerticalEffective + antiRecoilInitialVertical[profileId];
1746        antiRecoilHorizontalEffective = antiRecoilHorizontalEffective + antiRecoilInitialHorizontal[profileId];
1747    }
1748    if (antiRecoilRampEnabled[profileId] && antiRecoilTimer < antiRecoilRampTime[profileId]) {
1749        antiRecoilRampScale = antiRecoilTimer * 100 / antiRecoilRampTime[profileId];
1750        antiRecoilVerticalEffective = antiRecoilVerticalEffective * antiRecoilRampScale / 100;
1751        antiRecoilHorizontalEffective = antiRecoilHorizontalEffective * antiRecoilRampScale / 100;
1752    }
1753    if (antiRecoilDecayEnabled[profileId] && antiRecoilTimer > antiRecoilDecayStart[profileId]) {
1754        antiRecoilDecayElapsed = antiRecoilTimer - antiRecoilDecayStart[profileId];
1755        if (antiRecoilDecayElapsed > antiRecoilDecayTime[profileId]) {
1756            antiRecoilDecayElapsed = antiRecoilDecayTime[profileId];
1757        }
1758        antiRecoilDecayScale = 100 - ((100 - antiRecoilDecayFloor[profileId]) * antiRecoilDecayElapsed / antiRecoilDecayTime[profileId]);
1759        antiRecoilVerticalEffective = antiRecoilVerticalEffective * antiRecoilDecayScale / 100;
1760        antiRecoilHorizontalEffective = antiRecoilHorizontalEffective * antiRecoilDecayScale / 100;
1761    }
1762    if (antiRecoilAimOverrideEnabled[profileId]) {
1763        if (abs(get_val(PS5_RX)) > antiRecoilAimOverrideThreshold[profileId] || abs(get_val(PS5_RY)) > antiRecoilAimOverrideThreshold[profileId]) {
1764            antiRecoilVerticalEffective = antiRecoilVerticalEffective * (100 - antiRecoilAimOverrideStrength[profileId]) / 100;
1765            antiRecoilHorizontalEffective = antiRecoilHorizontalEffective * (100 - antiRecoilAimOverrideStrength[profileId]) / 100;
1766        }
1767    }
1768}
1769function drawProfileSettingValue(value, settingIndex) {
1770    numberToString(
1771        value,
1772        findDigits(value),

1773        OLED_FONT_SMALL,
1774        OLED_FONT_SMALL_WIDTH,
1775        128,
1776        38,
1777        OLED_WHITE
1778    );
1779    drawProgressBarWithCursor(
1780        18,
1781        51,
1782        92,
1783        8,
1784        value,
1785        settingMinMax[settingIndex][0],
1786        settingMinMax[settingIndex][1]
1787    );
1788}
1789function handleAntiRecoilVertical() {
1790    if (press_hold(PS5_LEFT) || press_hold(PS5_RIGHT)) {
1791        set_val(TRACE_4, antiRecoilVertical[profileId]);
1792        set_val(TRACE_5, settingMinMax[antiRecoilVerticalEnum][0]);
1793        set_val(TRACE_6, settingMinMax[antiRecoilVerticalEnum][1]);
1794    }
1795    if (press_hold(PS5_LEFT)) {
1796        antiRecoilVertical[profileId] = clamp(antiRecoilVertical[profileId] - 1,
1797            settingMinMax[antiRecoilVerticalEnum][0], settingMinMax[antiRecoilVerticalEnum][1]);
1798    }
1799    if (press_hold(PS5_RIGHT)) {
1800        antiRecoilVertical[profileId] = clamp(antiRecoilVertical[profileId] + 1,
1801            settingMinMax[antiRecoilVerticalEnum][0], settingMinMax[antiRecoilVerticalEnum][1]);
1802    }
1803}
1804function handleAntiRecoilHorizontal() {
1805    if (press_hold(PS5_LEFT)) {
1806        antiRecoilHorizontal[profileId] = clamp(antiRecoilHorizontal[profileId] - 1,
1807            settingMinMax[antiRecoilHorizontalEnum][0], settingMinMax[antiRecoilHorizontalEnum][1]);
1808    }
1809    if (press_hold(PS5_RIGHT)) {
1810        antiRecoilHorizontal[profileId] = clamp(antiRecoilHorizontal[profileId] + 1,
1811            settingMinMax[antiRecoilHorizontalEnum][0], settingMinMax[antiRecoilHorizontalEnum][1]);
1812    }
1813}
1814function handleAntiRecoilInitialEnabled() {
1815    if (press_hold(PS5_LEFT)) {
1816        antiRecoilInitialEnabled[profileId] = 0;
1817    }
1818    if (press_hold(PS5_RIGHT)) {
1819        antiRecoilInitialEnabled[profileId] = 1;
1820    }
1821}
1822function handleAntiRecoilInitialTime() {
1823    if (press_hold(PS5_LEFT)) {
1824        antiRecoilInitialTime[profileId] = clamp(antiRecoilInitialTime[profileId] - 1,
1825            settingMinMax[antiRecoilInitialTimeEnum][0], settingMinMax[antiRecoilInitialTimeEnum][1]);
1826    }
1827    if (press_hold(PS5_RIGHT)) {
1828        antiRecoilInitialTime[profileId] = clamp(antiRecoilInitialTime[profileId] + 1,
1829            settingMinMax[antiRecoilInitialTimeEnum][0], settingMinMax[antiRecoilInitialTimeEnum][1]);
1830    }
1831}
1832function handleAntiRecoilInitialVertical() {
1833    if (press_hold(PS5_LEFT)) {
1834        antiRecoilInitialVertical[profileId] = clamp(antiRecoilInitialVertical[profileId] - 1,
1835            settingMinMax[antiRecoilInitialVerticalEnum][0], settingMinMax[antiRecoilInitialVerticalEnum][1]);
1836    }
1837    if (press_hold(PS5_RIGHT)) {
1838        antiRecoilInitialVertical[profileId] = clamp(antiRecoilInitialVertical[profileId] + 1,
1839            settingMinMax[antiRecoilInitialVerticalEnum][0], settingMinMax[antiRecoilInitialVerticalEnum][1]);
1840    }
1841}
1842function handleAntiRecoilInitialHorizontal() {
1843    if (press_hold(PS5_LEFT)) {
1844        antiRecoilInitialHorizontal[profileId] = clamp(antiRecoilInitialHorizontal[profileId] - 1,
1845            settingMinMax[antiRecoilInitialHorizontalEnum][0], settingMinMax[antiRecoilInitialHorizontalEnum][1]);
1846    }
1847    if (press_hold(PS5_RIGHT)) {
1848        antiRecoilInitialHorizontal[profileId] = clamp(antiRecoilInitialHorizontal[profileId] + 1,
1849            settingMinMax[antiRecoilInitialHorizontalEnum][0], settingMinMax[antiRecoilInitialHorizontalEnum][1]);
1850    }
1851}
1852function handleAntiRecoilRampEnabled() {
1853    if (press_hold(PS5_LEFT)) {
1854        antiRecoilRampEnabled[profileId] = 0;
1855    }
1856    if (press_hold(PS5_RIGHT)) {
1857        antiRecoilRampEnabled[profileId] = 1;
1858    }
1859}
1860function handleAntiRecoilRampTime() {
1861    if (press_hold(PS5_LEFT)) {
1862        antiRecoilRampTime[profileId] = clamp(antiRecoilRampTime[profileId] - 1,
1863            settingMinMax[antiRecoilRampTimeEnum][0], settingMinMax[antiRecoilRampTimeEnum][1]);
1864    }
1865    if (press_hold(PS5_RIGHT)) {
1866        antiRecoilRampTime[profileId] = clamp(antiRecoilRampTime[profileId] + 1,
1867            settingMinMax[antiRecoilRampTimeEnum][0], settingMinMax[antiRecoilRampTimeEnum][1]);
1868    }
1869}
1870function handleAntiRecoilDecayEnabled() {
1871    if (press_hold(PS5_LEFT)) {
1872        antiRecoilDecayEnabled[profileId] = 0;
1873    }
1874    if (press_hold(PS5_RIGHT)) {
1875        antiRecoilDecayEnabled[profileId] = 1;
1876    }
1877}
1878function handleAntiRecoilDecayStart() {

1879    if (press_hold(PS5_LEFT)) {
1880        antiRecoilDecayStart[profileId] = clamp(antiRecoilDecayStart[profileId] - 1,
1881            settingMinMax[antiRecoilDecayStartEnum][0], settingMinMax[antiRecoilDecayStartEnum][1]);
1882    }
1883    if (press_hold(PS5_RIGHT)) {
1884        antiRecoilDecayStart[profileId] = clamp(antiRecoilDecayStart[profileId] + 1,
1885            settingMinMax[antiRecoilDecayStartEnum][0], settingMinMax[antiRecoilDecayStartEnum][1]);
1886    }
1887}
1888function handleAntiRecoilDecayTime() {
1889    if (press_hold(PS5_LEFT)) {
1890        antiRecoilDecayTime[profileId] = clamp(antiRecoilDecayTime[profileId] - 1,
1891            settingMinMax[antiRecoilDecayTimeEnum][0], settingMinMax[antiRecoilDecayTimeEnum][1]);
1892    }
1893    if (press_hold(PS5_RIGHT)) {
1894        antiRecoilDecayTime[profileId] = clamp(antiRecoilDecayTime[profileId] + 1,
1895            settingMinMax[antiRecoilDecayTimeEnum][0], settingMinMax[antiRecoilDecayTimeEnum][1]);
1896    }
1897}
1898function handleAntiRecoilDecayFloor() {
1899    if (press_hold(PS5_LEFT)) {
1900        antiRecoilDecayFloor[profileId] = clamp(antiRecoilDecayFloor[profileId] - 1,
1901            settingMinMax[antiRecoilDecayFloorEnum][0], settingMinMax[antiRecoilDecayFloorEnum][1]);
1902    }
1903    if (press_hold(PS5_RIGHT)) {
1904        antiRecoilDecayFloor[profileId] = clamp(antiRecoilDecayFloor[profileId] + 1,
1905            settingMinMax[antiRecoilDecayFloorEnum][0], settingMinMax[antiRecoilDecayFloorEnum][1]);
1906    }
1907}
1908function handleAntiRecoilAimOverrideEnabled() {
1909    if (press_hold(PS5_LEFT)) {
1910        antiRecoilAimOverrideEnabled[profileId] = 0;
1911    }
1912    if (press_hold(PS5_RIGHT)) {
1913        antiRecoilAimOverrideEnabled[profileId] = 1;
1914    }
1915}
1916function handleAntiRecoilAimOverrideThreshold() {
1917    if (press_hold(PS5_LEFT)) {
1918        antiRecoilAimOverrideThreshold[profileId] = clamp(antiRecoilAimOverrideThreshold[profileId] - 1,
1919            settingMinMax[antiRecoilAimOverrideThresholdEnum][0], settingMinMax[antiRecoilAimOverrideThresholdEnum][1]);
1920    }
1921    if (press_hold(PS5_RIGHT)) {
1922        antiRecoilAimOverrideThreshold[profileId] = clamp(antiRecoilAimOverrideThreshold[profileId] + 1,
1923            settingMinMax[antiRecoilAimOverrideThresholdEnum][0], settingMinMax[antiRecoilAimOverrideThresholdEnum][1]);
1924    }
1925}
1926function handleAntiRecoilAimOverrideStrength() {
1927    if (press_hold(PS5_LEFT)) {
1928        antiRecoilAimOverrideStrength[profileId] = clamp(antiRecoilAimOverrideStrength[profileId] - 1,
1929            settingMinMax[antiRecoilAimOverrideStrengthEnum][0], settingMinMax[antiRecoilAimOverrideStrengthEnum][1]);
1930    }
1931    if (press_hold(PS5_RIGHT)) {
1932        antiRecoilAimOverrideStrength[profileId] = clamp(antiRecoilAimOverrideStrength[profileId] + 1,
1933            settingMinMax[antiRecoilAimOverrideStrengthEnum][0], settingMinMax[antiRecoilAimOverrideStrengthEnum][1]);
1934    }
1935}
1936function handleRapidFireShotsPerSecond() {
1937    if (press_hold(PS5_LEFT)) {
1938        rapidFireShotsPerSecond[profileId] = clamp(
1939            rapidFireShotsPerSecond[profileId] - 1,
1940            settingMinMax[rapidFireShotsPerSecondEnum][0],
1941            settingMinMax[rapidFireShotsPerSecondEnum][1]
1942        );
1943    }
1944    if (press_hold(PS5_RIGHT)) {
1945        rapidFireShotsPerSecond[profileId] = clamp(
1946            rapidFireShotsPerSecond[profileId] + 1,
1947            settingMinMax[rapidFireShotsPerSecondEnum][0],
1948            settingMinMax[rapidFireShotsPerSecondEnum][1]
1949        );
1950    }
1951}
1952function handleRapidFireHoldTime() {
1953    if (press_hold(PS5_LEFT)) {
1954        rapidFireHoldTime[profileId] = clamp(
1955            rapidFireHoldTime[profileId] - 1,
1956            settingMinMax[rapidFireHoldTimeEnum][0],
1957            settingMinMax[rapidFireHoldTimeEnum][1]
1958        );
1959    }
1960    if (press_hold(PS5_RIGHT)) {
1961        rapidFireHoldTime[profileId] = clamp(
1962            rapidFireHoldTime[profileId] + 1,
1963            settingMinMax[rapidFireHoldTimeEnum][0],
1964            settingMinMax[rapidFireHoldTimeEnum][1]
1965        );
1966    }
1967}
1968function StandardAntiRecoil() {
1969	if (antirecoilActivation(settings[antiRecoilActivationEnum])) {
1970        updateAntiRecoilEffectiveValues();
1971        // @[REPLACE:\${CORE_AR_COMBO_PREP}]
1972		if (!combo_running(AntiRecoilCombo)) {
1973			combo_run(AntiRecoilCombo);
1974		}
1975	} else {
1976		if (combo_running(AntiRecoilCombo)) {
1977			combo_stop(AntiRecoilCombo);
1978		}
1979        resetAntiRecoilRuntime();
1980	}
1981}
1982function RumbleAntiRecoil() {
1983	antiRecoilValues();
1984    offsetAR(PS5_RY,vertAntiRecoil);
1985	offsetAR(PS5_RX,horizAntiRecoil);
1986}
1987function antiRecoilValues(){
1988    smartRumble = get_rumble(rumbleToUse());
1989    if(toggleAntiRecoil[profileId] == 1 && smartRumble > 10 && antirecoilActivation(settings[antiRecoilActivationEnum])){
1990        updateAntiRecoilEffectiveValues();
1991        // @[REPLACE:\${CORE_AR_DYNAMIC_VALUES}]
1992    } else {
1993        resetAntiRecoilRuntime();
1994    	vertAntiRecoil = 0;
1995    	horizAntiRecoil = 0;
1996    }
1997}
1998function calculateAntiRecoilYVibrating() {
1999	if (!settings[antiRecoilModeEnum]) {
2000		if (getVibrationState() && toggleAntiRecoil[profileId] == 1 && antiRecoilVerticalEffective) {
2001			return antiRecoilVerticalEffective; // @[REPLACE:\${CORE_AR_AA_STANDARD_VERTICAL_RETURN}]
2002		}
2003	} else {
2004		antiRecoilValues();
2005		return vertAntiRecoil;
2006	}
2007	return 0;
2008}
2009function calculateAntiRecoilXVibrating() {
2010	if (!settings[antiRecoilModeEnum]) {
2011	    if (getVibrationState() && toggleAntiRecoil[profileId] == 1 && antiRecoilHorizontalEffective) {
2012	        return antiRecoilHorizontalEffective; // @[REPLACE:\${CORE_AR_AA_STANDARD_HORIZONTAL_RETURN}]
2013	    }
2014	} else {
2015		antiRecoilValues();
2016    	return horizAntiRecoil;
2017	}
2018	return 0;
2019}
2020const int16 pollarArr[] = { 23170,  23167,  23156,  23139,  23114,  23082,  23044,  22998,  22945,  22885,  22818,  22745,  22664,  22577,  22482,  22381,  22273,  22158,  22036,  21908,  21773,  21632,  21483,  21329,  21167,  21000,  20825,  20645,  20458,  20265,  20066,  19861,  19650,  19432,  19209,  18980,  18745,  18505,  18259,  18007,  17750,  17487,  17219,  16946,  16667,  16384,  16096,  15802,  15504,  15201,  14894,  14582,  14265,  13944,  13619,  13290,  12957,  12620,  12278,  11934,  11585,  11233,  10878,  10519,  10157,  9792,  9424,  9053,  8680,  8304,  7925,  7544,  7160,  6774,  6387,  5997,  5605,  5212,  4817,  4421,  4024,  3625,  3225,  2824,  2422,  2019,  1616,  1213,  809,  404,  00,  -404,  -809,  -1213,  -1616,  -2019,  -2422,  -2824,  -3225,  -3625,  -4024,  -4421,  -4817,  -5212,  -5605,  -5997,  -6387,  -6774,  -7160,  -7544,  -7925,  -8304,  -8680,  -9053,  -9424,  -9792,  -10157,  -10519,  -10878,  -11233,  -11585,  -11934,  -12278,  -12620,  -12957,  -13290,  -13619,  -13944,  -14265,  -14582,  -14894,  -15201,  -15504,  -15802,  -16096,  -16384,  -16667,  -16946,  -17219,  -17487,  -17750,  -18007,  -18259,  -18505,  -18745,  -18980,  -19209,  -19432,  -19650,  -19861,  -20066,  -20265,  -20458,  -20645,  -20825,  -21000,  -21167,  -21329,  -21483,  -21632,  -21773,  -21908,  -22036,  -22158,  -22273,  -22381,  -22482,  -22577,  -22664,  -22745,  -22818,  -22885,  -22945,  -22998,  -23044,  -23082,  -23114,  -23139,  -23156,  -23167,  -23170,  -23167,  -23156,  -23139,  -23114,  -23082,  -23044,  -22998,  -22945,  -22885,  -22818,  -22745,  -22664,  -22577,  -22482,  -22381,  -22273,  -22158,  -22036,  -21908,  -21773,  -21632,  -21483,  -21329,  -21167,  -21000,  -20825,  -20645,  -20458,  -20265,  -20066,  -19861,  -19650,  -19432,  -19209,  -18980,  -18745,  -18505,  -18259,  -18007,  -17750,  -17487,  -17219,  -16946,  -16667,  -16384,  -16096,  -15802,  -15504,  -15201,  -14894,  -14582,  -14265,  -13944,  -13619,  -13290,  -12957,  -12620,  -12278,  -11934,  -11585,  -11233,  -10878,  -10519,  -10157,  -9792,  -9424,  -9053,  -8680,  -8304,  -7925,  -7544,  -7160,  -6774,  -6387,  -5997,  -5605,  -5212,  -4817,  -4421,  -4024,  -3625,  -3225,  -2824,  -2422,  -2019,  -1616,  -1213,  -809,  -404,  00,  404,  809,  1213,  1616,  2019,  2422,  2824,  3225,  3625,  4024,  4421,  4817,  5212,  5605,  5997,  6387,  6774,  7160,  7544,  7925,  8304,  8680,  9053,  9424,  9792,  10157,  10519,  10878,  11233,  11585,  11934,  12278,  12620,  12957,  13290,  13619,  13944,  14265,  14582,  14894,  15201,  15504,  15802,  16096,  16384,  16667,  16946,  17219,  17487,  17750,  18007,  18259,  18505,  18745,  18980,  19209,  19432,  19650,  19861,  20066,  20265,  20458,  20645,  20825,  21000,  21167,  21329,  21483,  21632,  21773,  21908,  22036,  22158,  22273,  22381,  22482,  22577,  22664,  22745,  22818,  22885,  22945,  22998,  23044,  23082,  23114,  23139,  23156,  23167,  23170 };
2021const int8 cosTableCircle[] = { 100, 98, 92, 83, 71, 56, 38, 20, 0, -20, -38, -56, -71, -83, -92, -98, -100, -98, -92, -83, -71, -56, -38, -20, 0, 20, 38, 56, 71, 83, 92, 98, 100, 98, 92, 83, 71, 56, 38, 20, 0, -20, -38, -56, -71, -83, -92, -98, -100, -98, -92, -83, -71, -56, -38, -20, 0, 20, 38, 56, 71, 83, 92, 98 };
2022const int8 sinTableCircle[] = { 0, 20, 38, 56, 71, 83, 92, 98, 100, 98, 92, 83, 71, 56, 38, 20, 0, -20, -38, -56, -71, -83, -92, -98, -100, -98, -92, -83, -71, -56, -38, -20, 0, 20, 38, 56, 71, 83, 92, 98, 100, 98, 92, 83, 71, 56, 38, 20, 0, -20, -38, -56, -71, -83, -92, -98, -100, -98, -92, -83, -71, -56, -38, -20 };
2023int angle;
2024int aimAssistShape[2];
2025int boostStrength;
2026int activationRangeMin;
2027int activationRangeMax;
2028int inActivationRange;
2029int antiRecoilY = 0;
2030int antiRecoilX = 0;
2031int RX, RY;
2032int cos_angle, sin_angle;
2033int actual_Magnitude;
2034int max_Magnitude;
2035int Position;
2036int timer;
2037int adjustment;
2038int new_sin_angle, new_cos_angle;
2039int adjustmentFactor;
2040int dynamicSmoothingFactor;
2041int magnitudeInfluence;
2042int activeRightSize;
2043int aimStrength;
2044int lsOffsetX, lsOffsetY;
2045int circleStep;
2046int leftStickDelayCounter = 0;
2047int leftStickDelayThreshold = 10;
2048int spiralSize, radiusMod;
2049int helixPos, modX, modY;
2050int swayY;
2051int crossPhase;
2052int oscillPhase, oscillAngle, oscPhase;
2053int angle_rx, angle_ry;
2054int SpiralPosition1, SpiralPosition2;
2055int InnerSpiral, OuterSpiral;
2056const string SHAPES[] = {"CIRCULAR", "TALL OVAL", "WIDE OVAL",
2057 "SPIRAL", "HELIX", "LEFT-RIGHT", "SWAY", "CROSS", "CARDINAL"  };
2058const string aaActivation[] = {"FIRE", "ADS/FIRE"};
2059function isAimingActive() {
2060    return ( settings[OutSideFocusEnum] && get_val(ADS_BTN) ||  (get_ival(ADS_BTN) && get_ival(FI

2060RE_BTN)) || get_ival(FIRE_BTN) );
2061}
2062function isLeftAimAssistActive() {
2063	return isLeftAdsAimAssistActivated() || isLeftNormalAimAssistActivated();
2064}
2065function isLeftNormalAimAssistActivated() {
2066	if (get_val(FIRE_BTN) > 0 && settings[LeftSpeedEnum] > 0 && settings[LeftSizeEnum] > 0) {
2067		return TRUE;
2068	}
2069	return FALSE;
2070}
2071function isLeftAdsAimAssistActivated() {
2072	if (settings[OutSideFocusEnum] && get_val(ADS_BTN) > 0 && get_val(FIRE_BTN) == 0 && settings[AdsLeftSpeedEnum] > 0 && settings[AdsLeftSizeEnum] > 0) {
2073		return TRUE;
2074	}
2075	return FALSE;
2076}
2077function isRightAimAssistActive() {
2078	return isRightAdsAimAssistActivated() || isRightNormalAimAssistActivated();
2079}
2080function isRightNormalAimAssistActivated() {
2081	if (get_val(FIRE_BTN) > 0 && settings[RightSpeedEnum] > 0 && settings[RightSizeEnum] > 0) {
2082		return TRUE;
2083	}
2084	return FALSE;
2085}
2086function isRightAdsAimAssistActivated() {
2087	if (settings[OutSideFocusEnum] && get_val(ADS_BTN) > 0 && get_val(FIRE_BTN) == 0 && settings[AdsRightSpeedEnum] > 0 && settings[AdsRightSizeEnum] > 0) {
2088		return TRUE;
2089	}
2090	return FALSE;
2091}
2092function isRightAdsSpeedMode() {
2093	return settings[OutSideFocusEnum] &&
2094	       get_val(ADS_BTN) &&
2095	       get_val(FIRE_BTN) == 0 &&
2096	       settings[AdsRightSpeedEnum] > 0;
2097}
2098function isInActivationRange() {
2099    return (abs(RX) > activationRangeMin || abs(RY) > activationRangeMin) &&
2100           (abs(RX) < activationRangeMax || abs(RY) < activationRangeMax);
2101}
2102function handleActivation() {
2103    if (event_release(FIRE_BTN) || event_release(ADS_BTN)) {
2104    	resetXY();
2105        resetAngleAndCombo();
2106    }
2107    if (isAimingActive()) {
2108        handleAimAssist();
2109    }
2110}
2111function AimAssist() {
2112    activationRangeMin = settings[activationRangeMinEnum];
2113    activationRangeMax = settings[activationRangeMaxEnum];
2114    boostStrength = settings[boostStrengthEnum] / 10;
2115    RX = get_val(PS5_RX);
2116    RY = get_val(PS5_RY);
2117    actual_Magnitude = isqrt(pow(RX, 2) + pow(RY, 2));
2118    max_Magnitude = (actual_Magnitude < 100);
2119    updateAngle();
2120    if (toggleAntiRecoil[profileId] == 1 && antirecoilActivation(settings[antiRecoilActivationEnum])  == TRUE) {
2121        if (settings[antiRecoilModeEnum]) {
2122            antiRecoilValues();
2123            antiRecoilY = vertAntiRecoil;
2124            antiRecoilX = horizAntiRecoil;
2125        } else {
2126            updateAntiRecoilEffectiveValues();
2127            // @[REPLACE:\${CORE_AR_AA_STANDARD_HUMANIZER_UPDATE}]
2128            antiRecoilY = calculateAntiRecoilYVibrating();
2129            antiRecoilX = calculateAntiRecoilXVibrating();
2130        }
2131	} else {
2132        resetAntiRecoilRuntime();
2133		antiRecoilY =  0;
2134		antiRecoilX =  0;
2135	}
2136		adjustAngleValues();
2137    handleActivation();
2138}
2139function updateAngle() {
2140	if(isRightAdsSpeedMode()) {
2141		angle += settings[AdsRightSpeedEnum];
2142	} else {
2143		angle += settings[RightSpeedEnum];
2144    }
2145    if (angle >= 360) {
2146        angle = angle % 360;
2147    }
2148    sin_angle = tunez_sin_lut(angle)  / 200;
2149    cos_angle = tunez_cos_lut(angle) / 200;
2150}
2151function calculateDynamicSmoothingFactor() {
2152    magnitudeInfluence = actual_Magnitude / 10;
2153    dynamicSmoothingFactor = settings[SmoothingFactorEnum] + magnitudeInfluence;
2154    if (dynamicSmoothingFactor > 30) {
2155        dynamicSmoothingFactor = 30;
2156    }
2157    return dynamicSmoothingFactor;
2158}
2159function adjustAngleValues() {
2160    if (isRightAdsAimAssistActivated()) {
2161        activeRightSize = settings[AdsRightSizeEnum];
2162    } else {
2163        activeRightSize = settings[RightSizeEnum];
2164    }
2165    if (actual_Magnitude <= activeRightSize) {
2166        new_sin_angle = sin_angle - RY;
2167        new_cos_angle = cos_angle - RX;
2168    } else {
2169        adjustmentFactor = (200 - ((abs(RY) + actual_Magnitude) / 10) * 10) / 200;
2170        new_sin_angle = (sin_angle * adjustmentFactor) * max_Magnitude;
2171        new_cos_angle = (cos_angle * adjustmentFactor) * max_Magnitude;
2172    }
2173    aimStrength = settings[AimLockStrengthEnum];
2174    new_sin_angle -= (RY * aimStrength / 100);
2175    new_cos_angle -= (RX * aimStrength / 100);
2176    dynamicSmoothingFactor = calculateDynamicSmoothingFactor();
2177    sin_angle = sin_angle * (100 - dynamicSmoothingFactor) / 100
2178              + new_sin_angle * dynamicSmoothingFactor / 100;
2179    cos_angle = cos_angle * (100 - dynamicSmoothingFactor) / 100
2180              + new_cos_angle * dynamicSmoothingFactor / 100;
2181}
2182function resetAngleAndCombo() {
2183    angle = 0;
2184}
2185function resetXY() {

2186	circleStep = 0;
2187	lsOffsetX = 0;
2188	lsOffsetY = 0;
2189}
2190function correctAngle(angleValue) {
2191  if (angleValue < 0) angleValue = 360 + (angleValue % 360);
2192  angleValue = (angleValue + 90) % 360;
2193  return angleValue;
2194}
2195function handleAimAssist() {
2196    if (isLeftAimAssistActive()) {
2197        leftStickDelayCounter += 1;
2198        if (leftStickDelayCounter > leftStickDelayThreshold) {
2199            leftStickDelayCounter = leftStickDelayThreshold;
2200        }
2201    } else {
2202        leftStickDelayCounter = 0;
2203    }
2204    switch (settings[LeftShapeEnum]) {
2205        case CircularEnum: {
2206            if (isLeftAdsAimAssistActivated()) {
2207                setLsOffsetXY(cosTableCircle[circleStep], sinTableCircle[circleStep], AdsLeftSizeEnum);
2208                if (leftStickDelayCounter + settings[AdsLeftSpeedEnum] >= leftStickDelayThreshold) {
2209                    leftStickDelayCounter = 0;
2210                    circleStep = (circleStep + 1) % 64;
2211                }
2212            } else if (isLeftNormalAimAssistActivated()) {
2213                setLsOffsetXY(cosTableCircle[circleStep], sinTableCircle[circleStep], LeftSizeEnum);
2214                if (leftStickDelayCounter + settings[LeftSpeedEnum] >= leftStickDelayThreshold) {
2215                    leftStickDelayCounter = 0;
2216                    circleStep = (circleStep + 1) % 64;
2217                }
2218            }
2219            break;
2220        }
2221        case TallOvalEnum: {
2222            if (isLeftAdsAimAssistActivated()) {
2223                setLsOffsetXY(cosTableCircle[circleStep] / 2, sinTableCircle[circleStep], AdsLeftSizeEnum);
2224                if (leftStickDelayCounter + settings[AdsLeftSpeedEnum] >= leftStickDelayThreshold) {
2225                    leftStickDelayCounter = 0;
2226                    circleStep = (circleStep + 1) % 64;
2227                }
2228            } else if (isLeftNormalAimAssistActivated()) {
2229                setLsOffsetXY(cosTableCircle[circleStep] / 2, sinTableCircle[circleStep], LeftSizeEnum);
2230                if (leftStickDelayCounter + settings[LeftSpeedEnum] >= leftStickDelayThreshold) {
2231                    leftStickDelayCounter = 0;
2232                    circleStep = (circleStep + 1) % 64;
2233                }
2234            }
2235            break;
2236        }
2237        case WideOvalEnum: {
2238            if (isLeftAdsAimAssistActivated()) {
2239                setLsOffsetXY(cosTableCircle[circleStep], sinTableCircle[circleStep] / 2, AdsLeftSizeEnum);
2240                if (leftStickDelayCounter + settings[AdsLeftSpeedEnum] >= leftStickDelayThreshold) {
2241                    leftStickDelayCounter = 0;
2242                    circleStep = (circleStep + 1) % 64;
2243                }
2244            } else if (isLeftNormalAimAssistActivated()) {
2245                setLsOffsetXY(cosTableCircle[circleStep], sinTableCircle[circleStep] / 2, LeftSizeEnum);
2246                if (leftStickDelayCounter + settings[LeftSpeedEnum] >= leftStickDelayThreshold) {
2247                    leftStickDelayCounter = 0;
2248                    circleStep = (circleStep + 1) % 64;
2249                }
2250            }
2251            break;
2252        }
2253        case SpiralEnum: {
2254            if (isLeftAdsAimAssistActivated()) {
2255                spiralSize = settings[AdsLeftSizeEnum];
2256                radiusMod = (circleStep * spiralSize) / 64;
2257                setLsOffsetXY(cosTableCircle[circleStep] * radiusMod / 100, sinTableCircle[circleStep] * radiusMod / 100, AdsLeftSizeEnum);
2258                if (leftStickDelayCounter + settings[AdsLeftSpeedEnum] >= leftStickDelayThreshold) {
2259                    leftStickDelayCounter = 0;
2260                    circleStep = (circleStep + 1) % 64;
2261                }
2262            } else if (isLeftNormalAimAssistActivated()) {
2263                spiralSize = settings[LeftSizeEnum];
2264                radiusMod = (circleStep * spiralSize) / 64;
2265                setLsOffsetXY(cosTableCircle[circleStep] * radiusMod / 100, sinTableCircle[circleStep] * radiusMod / 100, LeftSizeEnum);
2266                if (leftStickDelayCounter + settings[LeftSpeedEnum] >= leftStickDelayThreshold) {
2267                    leftStickDelayCounter = 0;
2268                    circleStep = (circleStep + 1) % 64;
2269                }
2270            }
2271            break;
2272        }
2273        case HelixEnum: {
2274            if (isLeftAdsAimAssistActivated()) {
2275                helixPos = (circleStep / 16) % 4;
2276                modX = iif(helixPos == 0 || helixPos == 2, cosTableCircle[circleStep], 0);
2277                modY = iif(helixPos == 1 || helixPos == 3, sinTableCircle[circleStep], 0);
2278                setLsOffsetXY(modX, modY, AdsLeftSizeEnum);
2279                if (leftStickDelayCounter + settings[AdsLeftSpeedEnum] >= leftStickDelayThreshold) {
2280                    leftStickDelayCounter = 0;
2281                    circleStep = (circleStep + 1) % 64;
2282                }
2283            } else if (isLeftNormalAimAssistActivated()) {
2284                helixPos = (circleStep / 16) % 4;
2285                modX = iif(helixPos == 0 || helixPos == 2, cosTableCircle[circleStep], 0);
2286                modY = iif(helixPos == 1 || helixPos == 3, sinTableCircle[circleStep], 0);
2287                setLsOffsetXY(modX, modY, LeftSizeEnum);
2288                if (leftStickDelayCounter + settings[LeftSpeedEnum] >= leftStickDelayThreshold) {
2289                    leftStickDelayCounter = 0;
2290                    circleStep = (circleStep + 1) % 64;
2291                }
2292            }
2293            break;
2294        }
2295        case LeftRightEnum: {
2296                  if (isLeftAdsAimAssistActivated()) {
2297                      lsOffsetX = (cosTableCircle[circleStep] * settings[AdsLeftSizeEnum]) / 100;
2298                      lsOffsetY = 0;
2299                      if (leftStickDelayCounter + settings[AdsLeftSpeedEnum] >= leftStickDelayThreshold) {
2300                          leftStickDelayCounter = 0;
2301                          circleStep = (circleStep + 1) % 64;
2302                      }
2303                  } else if (isLeftNormalAimAssistActivated()) {
2304                      lsOffsetX = (cosTableCircle[circleStep] * settings[LeftSizeEnum]) / 100;
2305                      lsOffsetY = 0;
2306                      if (leftStickDelayCounter + settings[LeftSpeedEnum] >= leftStickDelayThreshold) {
2307                          leftStickDelayCounter = 0;
2308                          circleStep = (circleStep + 1) % 64;
2309                      }
2310                  }
2311                  break;
2312                }
2313        case SwayEnum: {
2314            if (isLeftAdsAimAssistActivated()) {
2315                swayY = sinTableCircle[circleStep] * cosTableCircle[circleStep] / 100;
2316                lsOffsetX = (sinTableCircle[circleStep] * settings[AdsLeftSizeEnum]) / 100;
2317                lsOffsetY = (swayY * settings[AdsLeftSizeEnum]) / 100;
2318                if (leftStickDelayCounter + settings[AdsLeftSpeedEnum] >= leftStickDelayThreshold) {
2319                    leftStickDelayCounter = 0;
2320                    circleStep = (circleStep + 1) % 64;
2321                }
2322            } else if (isLeftNormalAimAssistActivated()) {
2323                swayY = sinTableCircle[circleStep] * cosTableCircle[circleStep] / 100;
2324                lsOffsetX = (sinTableCircle[circleStep] * settings[LeftSizeEnum]) / 100;
2325                lsOffsetY = (swayY * settings[LeftSizeEnum]) / 100;
2326                if (leftStickDelayCounter + settings[LeftSpeedEnum] >= leftStickDelayThreshold) {
2327                    leftStickDelayCounter = 0;
2328                    circleStep = (circleStep + 1) % 64;
2329                }
2330            }
2331            break;
2332        }
2333        case CrossEnum: {
2334            crossPhase = (circleStep / 16) % 4;
2335            switch(crossPhase) {
2336                case 0: {
2337                    lsOffsetX = (71 * settings[LeftSizeEnum]) / 100;
2338                    lsOffsetY = (71 * settings[LeftSizeEnum]) / 100;
2339                    break;
2340                }
2341                case 1: {
2342                    lsOffsetX = (-71 * settings[LeftSizeEnum]) / 100;
2343                    lsOffsetY = (71 * settings[LeftSizeEnum]) / 100;
2344                    break;
2345                }
2346                case 2: {
2347                    lsOffsetX = (-71 * settings[LeftSizeEnum]) / 100;
2348                    lsOffsetY = (-71 * settings[LeftSizeEnum]) / 100;
2349                    break;
2350                }
2351                case 3: {
2352                    lsOffsetX = (71 * settings[LeftSizeEnum]) / 100;
2353                    lsOffsetY = (-71 * settings[LeftSizeEnum]) / 100;
2354                    break;
2355                }
2356            }
2357            if (isLeftAdsAimAssistActivated()) {
2358                switch(crossPhase) {
2359                    case 0: {
2360                        lsOffsetX = (71 * settings[AdsLeftSizeEnum]) / 100;
2361                        lsOffsetY = (71 * settings[AdsLeftSizeEnum]) / 100;
2362                        break;
2363                    }
2364                    case 1: {
2365                        lsOffsetX = (-71 * settings[AdsLeftSizeEnum]) / 100;
2366                        lsOffsetY = (71 * settings[AdsLeftSizeEnum]) / 100;
2367                        break;
2368                    }
2369                    case 2: {
2370                        lsOffsetX = (-71 * settings[AdsLeftSizeEnum]) / 100;
2371                        lsOffsetY = (-71 * settings[AdsLeftSizeEnum]) / 100;
2372                        break;
2373                    }
2374                    case 3: {
2375                        lsOffsetX = (71 * settings[AdsLeftSizeEnum]) / 100;
2376                        lsOffsetY = (-71 * settings[AdsLeftSizeEnum]) / 100;
2377                        break;
2378                    }
2379                }
2380            }
2381            if (leftStickDelayCounter + iif(isLeftAdsAimAssistActivated(), settings[AdsLeftSpeedEnum], settings[LeftSpeedEnum]) >= leftStickDelayThreshold) {
2382                leftStickDelayCounter = 0;
2383                circleStep = (circleStep + 1) % 64;
2384            }
2385            break;
2386        }
2387        case OscillirateEnum: {
2388            oscillPhase = (circleStep / 8) % 4;
2389            oscillAngle = oscillPhase * 16;
2390            if (isLeftAdsAimAssistActivated()) {
2391                lsOffsetX = (cosTableCircle[oscillAngle] * settings[AdsLeftSizeEnum]) / 100;
2392                lsOffsetY = (sinTableCircle[oscillAngle] * settings[AdsLeftSizeEnum]) / 100;
2393                if (leftStickDelayCounter + settings[AdsLeftSpeedEnum] >= leftStickDelayThreshold) {
2394                    leftStickDelayCounter = 0;
2395                    circleStep = (circleStep + 1) % 64;
2396                }
2397            } else if (isLeftNormalAimAssistActivated()) {
2398                lsOffsetX = (cosTableCircle[oscillAngle] * settings[LeftSizeEnum]) / 100;
2399                lsOffsetY = (sinTableCircle[oscillAngle] * settings[LeftSizeEnum]) / 100;
2400                if (leftStickDelayCounter + settings[LeftSpeedEnum] >= leftStickDelayThreshold) {
2401                    leftStickDelayCounter = 0;
2402                    circleStep = (circleStep + 1) % 64;
2403                }
2404            }
2405            break;
2406        }
2407    }
2408    if (isLeftAimAssistActive()) {
2409        set_val(PS5_LX, clamp(get_val(PS5_LX) + (lsOffsetX), -100, 100) * settings[InvertEnum]);
2410        set_val(PS5_LY, clamp(get_val(PS5_LY) + (lsOffsetY), -100, 100) * settings[InvertEnum]);
2411    }
2412    if (isRightAimAssistActive()) {
2413        inActivationRange = isInActivationRange();
2414        if (isRightAdsAimAssistActivated()) {
2415            getShapes(settings[AdsRightSizeEnum]);
2416        } else {
2417            getShapes(settings[RightSizeEnum]);
2418        }
2419        angle_rx = cos_angle;
2420        angle_ry = sin_angle;
2421        if (inActivationRange) {
2422            applyBoostedOutput();
2423        } else {
2424            applyNormalOutput();
2425        }
2426    }
2427}
2428function getShapes(f_var) {
2429    if (!SpiralPosition1) {
2430        InnerSpiral -= 1;
2431        if (InnerSpiral < 1)
2432            SpiralPosition1 = TRUE;
2433    } else {
2434        InnerSpiral += 1;
2435        if (InnerSpiral > f_var)
2436            SpiralPosition1 = FALSE;
2437    }
2438    if (!SpiralPosition2) {
2439        OuterSpiral -= 1;
2440        if (OuterSpiral < 1)
2441            SpiralPosition2 = TRUE;
2442    } else {
2443        OuterSpiral += 1;
2444        if (OuterSpiral > f_var)
2445            SpiralPosition2 = FALSE;
2446    }
2447    switch (aimAssistShape[profileId]) {
2448        case CircularEnum: {
2449            RY = (sin_angle * f_var) / 100;
2450            RX = (cos_angle * f_var) / 100;
2451            break;
2452        }
2453        case TallOvalEnum: {
2454            RY = (sin_angle * f_var) / 100;
2455            RX = (cos_angle * (f_var / 2)) / 100;
2456            break;
2457        }
2458        case WideOvalEnum: {
2459            RY = (sin_angle * (f_var / 2)) / 100;
2460            RX = (cos_angle * f_var) / 100;
2461            break;
2462        }
2463        case SpiralEnum: {
2464            RY = (sin_angle * InnerSpiral) / 100;
2465            RX = (cos_angle * OuterSpiral) / 100;
2466            break;
2467        }
2468        case HelixEnum: {
2469            RX = (cos_angle * Position) / 100;
2470            RY = (sin_angle * Position) / 100;
2471            if (Position == 0)
2472                RX = (cos_angle * f_var) / 100;
2473            if (Position == 1)
2474                RY = (sin_angle * f_var) / 100;
2475            if (Position == 2)
2476                RX = (cos_angle * f_var) / 100 * -1;
2477            if (Position == 3)
2478                RY = (sin_angle * f_var) / 100 * -1;
2479            timer++;
2480            if (isRightAdsSpeedMode() && timer >= settings[AdsRightSpeedEnum]) {
2481                Position++;
2482                timer = 0;
2483            } else if (!isRightAdsSpeedMode() && timer >= settings[RightSpeedEnum]) {
2484                Position++;
2485                timer = 0;
2486            }
2487            if (Position == 4)
2488                Position = 0;
2489            break;
2490        }
2491        case LeftRightEnum: {
2492            RX = iif((angle % 2 == 0), f_var, -f_var);
2493            RY = 0;
2494            break;
2495        }
2496        case SwayEnum: {
2497            RX = (sin_angle * f_var) / 100;
2498            RY = (sin_angle * cos_angle * f_var) / 10000;
2499            break;
2500        }
2501        case CrossEnum: {
2502            crossPhase = (angle / 16) % 4;
2503            switch(crossPhase) {
2504                case 0: {
2505                    RX = (f_var * 71) / 100;
2506                    RY = (f_var * 71) / 100;
2507                    break;
2508                }
2509                case 1: {
2510                    RX = (f_var * -71) / 100;
2511                    RY = (f_var * 71) / 100;
2512                    break;
2513                }
2514                case 2: {
2515                    RX = (f_var * -71) / 100;
2516                    RY = (f_var * -71) / 100;
2517                    break;
2518                }
2519                case 3: {
2520                    RX = (f_var * 71) / 100;
2521                    RY = (f_var * -71) / 100;
2522                    break;
2523                }
2524            }
2525            break;
2526        }
2527        case OscillirateEnum: {
2528            oscPhase = (angle / 16) % 4;
2529            switch(oscPhase) {
2530                case 0: { RX = (f_var * cos_angle) / 100; RY = 0; break; }
2531                case 1: { RX = 0; RY = (f_var * sin_angle) / 100; break; }
2532                case 2: { RX = (f_var * cos_angle * -1) / 100; RY = 0; break; }
2533                case 3: { RX = 0; RY = (f_var * sin_angle * -1) / 100; break; }
2534            }
2535            break;
2536        }
2537    }
2538    cos_angle = RX;
2539    sin_angle = RY;
2540}
2541function setLsOffsetXY(val1, val2, settingEnum) {
2542	lsOffsetX = (val1 * settings[settingEnum]) / 100;
2543    lsOffsetY = (val2 * settings[settingEnum]) / 100;
2544}
2545function handleAimAssistShape() {

2546    if (press_hold(PS5_LEFT)) {
2547        aimAssistShape[0] = iif(aimAssistShape[profileId] > 0, aimAssistShape[profileId] - 1, OscillirateEnum);
2548        aimAssistShape[1] = aimAssistShape[0];
2549    }
2550    if (press_hold(PS5_RIGHT)) {
2551        aimAssistShape[0] = iif(aimAssistShape[profileId] < OscillirateEnum, aimAssistShape[profileId] + 1, 0);
2552        aimAssistShape[1] = aimAssistShape[0];
2553    }
2554}
2555function applyBoostedOutput() {
2556    output(POLAR_RX, boostStrength * angle_rx + antiRecoilX );
2557	if (antirecoilActivation(settings[antiRecoilActivationEnum]) == TRUE) {
2558		output(POLAR_RY, boostStrength * angle_ry + antiRecoilY);
2559	} else {
2560		output(POLAR_RY, boostStrength * angle_ry);
2561	}
2562}
2563function applyNormalOutput() {
2564    output(POLAR_RX, angle_rx + antiRecoilX );
2565    if (antirecoilActivation(settings[antiRecoilActivationEnum])  == TRUE) {
2566		output(POLAR_RY, angle_ry + antiRecoilY);
2567	} else {
2568		output(POLAR_RY, angle_ry);
2569	}
2570}
2571function output(stick, value) {
2572    adjustment = (value * 327);
2573    set_val(stick, clamp(get_val(stick) + adjustment, -32767, 32767) * settings[InvertEnum]);
2574}
2575function tunez_sin_lut(angleValue) {
2576   return lerp_16(pollarArr[(correctAngle(angleValue - 1))], pollarArr[(correctAngle(angleValue + 1))], 0x8000);
2577}
2578function tunez_cos_lut(angleValue) {
2579   return lerp_16(pollarArr[((correctAngle(angleValue - 1) + 90) % 360)],  pollarArr[((correctAngle(angleValue + 1) + 90) % 360)], 0x8000);
2580}
2581function lerp_16(a, b, t) { return fix_to_int(lerp(int_to_fix(a), int_to_fix(b), t)); }
2582function int_to_fix(a) { return a * 0x10000; }
2583function fix_to_int(a) { if (a >= 0) return (a + 0x10000 >> 1) / 0x10000; return (a - 0x10000 >> 1) / 0x10000; }
2584function fix_mul(v1, v2) { return ((v1 >> 8) * (v2 >> 8)); }
2585function lerp(a, b, f) { return fix_mul((0x10000 - f), a) + fix_mul(f, b); }
2586int toggleRapidFire[2];
2587int rapidFireShotsPerSecond[2];
2588int rapidFireHoldTime[2];
2589define RAPID_FIRE_ACTIVATION_MODE = \${CORE_RF_ACT};
2590int rapidFireActiveHoldTime;
2591int rapidFireRestTime;
2592int currentShotsPerSec;
2593int totalCycleTime;
2594function rapidFireActivation(setting) {
2595    antiRecoilAds = get_val(ADS_BTN);
2596    antiRecoilFire = get_val(FIRE_BTN);
2597    switch(setting) {
2598        case 0: {
2599            return (antiRecoilAds && antiRecoilFire);
2600        }
2601        case 1: {
2602            return (!antiRecoilAds && antiRecoilFire);
2603        }
2604        case 2: {
2605            return (antiRecoilAds && antiRecoilFire) || antiRecoilFire;
2606        }
2607        default {
2608            return FALSE;
2609        }
2610    }
2611    return FALSE;
2612}
2613function rapidFire() {
2614    currentShotsPerSec = rapidFireShotsPerSecond[profileId];
2615    totalCycleTime = 1000 / currentShotsPerSec;
2616    rapidFireActiveHoldTime = clamp(rapidFireHoldTime[profileId], 1, totalCycleTime - 1);
2617    rapidFireRestTime = totalCycleTime - rapidFireActiveHoldTime;
2618    if(rapidFireActivation(RAPID_FIRE_ACTIVATION_MODE) == TRUE && !no_gun_state && !utility_state) {
2619        // @[REPLACE:\${CORE_RF_HUMANIZER_UPDATE}]
2620        combo_run(RapidFireCombo);
2621    } else {
2622        combo_stop(RapidFireCombo);
2623    }
2624}
2625int no_gun_state = FALSE;
2626int utility_state = FALSE;
2627// @[REPLACE:\${CORE_WEAPON_TRACKING_FUNCTION}]
2628int passiveMod          = FALSE;
2629int passiveModFirePress = 0;
2630int pmModBtn   = \${CORE_PM_MOD_BTN};
2631int pmActBtn   = \${CORE_PM_ACT_BTN};
2632int pmDeactBtn = \${CORE_PM_DEACT_BTN};
2633function setPassiveMode() {
2634    if (get_val(pmModBtn) && event_press(pmActBtn)) {
2635        if (passiveModFirePress < 1) {
2636            passiveModFirePress++;
2637        }
2638        else if (passiveModFirePress == 1) {
2639            passiveModFirePress = 0;
2640            SetLEDColor(Purple);
2641            passiveMod = TRUE;
2642        }
2643    }
2644    if (passiveMod && event_press(pmDeactBtn)) {
2645        passiveMod = FALSE;
2646        passiveModFirePress = 0;
2647        SetLEDColor(currentLedColor);
2648    }
2649}
2650// @[ANCHOR_FUNCTIONS]
2651function updateFeedbackTimer() {
2652    if (feedbackTime <= 0) { return; }
2653    if (currentState != STATE_PLAYING && currentState != STATE_SCREEN_SAVER) {
2654        feedbackTime = 0;
2655        resetDisplay();
2656        return;
2657    }
2658    feedbackTime = max(0, feedbackTime - get_rtime());
2659    if (feedbackTime == 0) { resetDisplay(); }
2660}
2661function renderFeedback() {
2662    if (feedbackTime <= 0) { return FALSE; }
2663    if (stateScreenDisplayed) { return TRUE; }
2664    cls_oled(OLED_BLACK);
2665    if (feedbackMode == FEEDBACK_MODE_SAVED) {
2666        printCentered(29, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, DSAVED[0]);
2667    } else if (feedbackMode == FEEDBACK_MODE_PROFILE) {

2668        drawProfileBadge(57, 20, OLED_FONT_SMALL, OLED_WHITE);
2669        printCentered(34, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, PROFILE_ACTIVE_TEXT[0]);
2670    } else if (feedbackMode == FEEDBACK_MODE_TEXT) {
2671        printCentered(28, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, feedbackTextAddr);
2672    } else if (feedbackMode == FEEDBACK_MODE_TEXT_TOGGLE) {
2673        printCentered(20, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, feedbackTextAddr);
2674        drawShortcutOnOffValue(feedbackState);
2675    } else if (feedbackMode == FEEDBACK_MODE_NUMBER) {
2676        printCentered(20, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, feedbackTextAddr);
2677        numberToString(feedbackState, findDigits(feedbackState), OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, 255, 36, OLED_WHITE);
2678    } else {
2679        printCentered(20, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, addr(MODNAME[feedbackModId]));
2680        drawShortcutOnOffValue(feedbackState);
2681    }
2682    screenDisplayed();
2683    return TRUE;
2684}
2685 
2686combo IntroDisplayCombo {
2687	wait(50);
2688	printCentered(28, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, addr(introN));
2689	printCentered(48, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, addr(introV));
2690}
2691combo AntiRecoilCombo {
2692    comboAntiRecoilVertical = \${CORE_AR_COMBO_VERTICAL_ASSIGN};
2693    if(comboAntiRecoilVertical > 100) {
2694    	comboAntiRecoilVertical = 100;
2695	}
2696    if (abs(get_val(PS5_RY)) < abs(antiRecoilVerticalEffective)) { // @[REPLACE:\${CORE_AR_COMBO_VERTICAL_IF}]
2697    	set_val(PS5_RY, (comboAntiRecoilVertical * settings[InvertEnum]));
2698   	}
2699    comboAntiRecoilHorizontal = \${CORE_AR_COMBO_HORIZONTAL_ASSIGN};
2700   	if(comboAntiRecoilHorizontal > 100) {
2701    	comboAntiRecoilHorizontal = 100;
2702	}
2703    if(abs(get_val(PS5_RX)) < abs(antiRecoilHorizontalEffective)) { // @[REPLACE:\${CORE_AR_COMBO_HORIZONTAL_IF}]
2704    	set_val(PS5_RX, comboAntiRecoilHorizontal);
2705	}
2706}
2707// @[ANCHOR_COMBOS]`;var o=t(90012),r=t(51152),l=t(60328),s=t(76592),_=t(92614),c=t(98446),E=t(32865),d=t(80067),R=t(41947),u=t(96848),A=t(68764);class S{static{this.DEFAULT_INTRO_TITLE="My script"}static{this.TUNEZ_MODS_URL="https://usetunez.com/mods"}static{this.TUNEZ_TOOLS_URL="https://usetunez.com/tools"}static{this.TUNEZ_HELP_URL="https://usetunez.com/help-center"}static{this.TUNEZ_LOGO_LINES=["████████ ██    ██ ███    ██ ███████ ███████","   ██    ██    ██ ████   ██ ██         ███","   ██    ██    ██ ██ ██  ██ █████     ███","   ██    ██    ██ ██  ██ ██ ██       ███","   ██     ██████  ██   ████ ███████ ███████"]}static{this.HEADER_GROUP_AIM="\uD83C\uDFAF AIM & RECOIL"}static{this.HEADER_GROUP_WEAPON="\uD83D\uDD2B WEAPON & PROFILES"}static{this.HEADER_GROUP_MOVEMENT="\uD83C\uDFAE MOVEMENT"}static{this.HEADER_GROUP_UTILITY="⚙️  UTILITY & SYSTEM"}static{this.HEADER_GROUP_CUSTOM="\uD83E\uDDE9 CUSTOM MODS"}static{this.CORE_MOD_DESCRIPTIONS={"Anti-Recoil":"Pushes aim against recoil while firing. Tune values for your own weapon.","Aim Assist":"Adds small stick movement while aiming or firing to help keep aim active.","Rapid Fire":"Turns held fire into timed taps for semi-auto weapons.","Weapon Profiles":"Exports selected weapon settings into Profile 1 and Profile 2. Set recoil values yourself.","Weapon Sync":"Pauses combat mods when your weapon is holstered or a utility item is equipped.","Passive Mode":"Temporarily pauses combat mods for vehicles, looting, menus, or non-combat moments.","Inverted Look":"Flips vertical recoil direction for inverted-look players.","Controller Vibration":"Controls physical vibration output while keeping script logic available."}}static{this.HEADER_MOD_DESCRIPTION_OVERRIDES={"Prime Ability":"Activates your ultimate with one shortcut instead of pressing the full button combo manually."}}static{this.GENERATED_MONTHS=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]}static{this.UTILITY_WHEEL_SELECTION_BUTTONS=["PS5_UP","PS5_DOWN","PS5_LEFT","PS5_RIGHT","PS5_L1","PS5_R1","PS5_L2","PS5_R2","PS5_L3","PS5_R3","PS5_TRIANGLE","PS5_CROSS","PS5_SQUARE","PS5_CIRCLE"]}static{this.OLED_WIDTH=128}static{this.OLED_FONT_SMALL_WIDTH=7}

2707static{this.INTRO_SIDE_PADDING=this.OLED_FONT_SMALL_WIDTH}static{this.INTRO_MAX_CHARS=Math.floor((this.OLED_WIDTH-2*this.INTRO_SIDE_PADDING)/this.OLED_FONT_SMALL_WIDTH)}static{this.INTRO_CHAR_MAP={А:"A",а:"a",Б:"B",б:"b",В:"V",в:"v",Г:"G",г:"g",Д:"D",д:"d",Е:"E",е:"e",Ё:"E",ё:"e",Ж:"Zh",ж:"zh",З:"Z",з:"z",И:"I",и:"i",Й:"Y",й:"y",К:"K",к:"k",Л:"L",л:"l",М:"M",м:"m",Н:"N",н:"n",О:"O",о:"o",П:"P",п:"p",Р:"R",р:"r",С:"S",с:"s",Т:"T",т:"t",У:"U",у:"u",Ф:"F",ф:"f",Х:"Kh",х:"kh",Ц:"Ts",ц:"ts",Ч:"Ch",ч:"ch",Ш:"Sh",ш:"sh",Щ:"Sch",щ:"sch",Ъ:"",ъ:"",Ы:"Y",ы:"y",Ь:"",ь:"",Э:"E",э:"e",Ю:"Yu",ю:"yu",Я:"Ya",я:"ya"}}static generate(e,i,t={}){var n;let o,r,_=a,c=(0,l.S)(l.P,e),E=(0,s.jx)(c.core.system.weaponTracking,c.buttonLayout,t.controllerLabels);if(E)throw Error(`Turbo knife: ${E}`);let R=this.initializeAnchors();c.core.rapidFire.humanizer?(R.function.push(`int rfJitterSeed = 73;
2708int rfHoldJitter;
2709int rfRestJitter;
2710int rfHumanizedHoldTime;
2711int rfHumanizedRestTime;`),R.function.push(`function updateRfJitter() {
2712    rfJitterSeed = (rfJitterSeed * 1103515245 + 12345) ^ get_rtime();
2713    rfHoldJitter = (abs(rfJitterSeed) % 9) - 4;
2714    rfRestJitter = (abs(rfJitterSeed / 17) % 11) - 5;
2715    rfHumanizedHoldTime = rapidFireActiveHoldTime + rfHoldJitter;
2716    rfHumanizedRestTime = rapidFireRestTime + rfRestJitter;
2717    if (rfHumanizedHoldTime < 20) {
2718        rfHumanizedHoldTime = 20;
2719    }
2720    if (rfHumanizedRestTime < 10) {
2721        rfHumanizedRestTime = 10;
2722    }
2723    if (rfHumanizedHoldTime + rfHumanizedRestTime > totalCycleTime) {
2724        rfHumanizedRestTime = totalCycleTime - rfHumanizedHoldTime;
2725        if (rfHumanizedRestTime < 10) {
2726            rfHumanizedRestTime = 10;
2727            rfHumanizedHoldTime = totalCycleTime - rfHumanizedRestTime;
2728            if (rfHumanizedHoldTime < 1) {
2729                rfHumanizedHoldTime = 1;
2730            }
2731        }
2732    }
2733}`),R.combo.push(`combo RapidFireCombo {
2734    set_val(FIRE_BTN, 100);
2735    wait(rfHumanizedHoldTime);
2736    set_val(FIRE_BTN, 0);
2737    wait(rfHumanizedRestTime);
2738}`)):R.combo.push(`combo RapidFireCombo {
2739    set_val(FIRE_BTN, 100);
2740    wait(rapidFireActiveHoldTime);
2741    set_val(FIRE_BTN, 0);
2742    wait(rapidFireRestTime);
2743}`),this.usesPhysicalIdleDetector(i)&&R.function.push(this.buildPhysicalIdleDetectorHelpers()),this.collectModTemplates(this.buildWeaponProfilesTemplates(c),R),this.collectModTemplates(this.buildWeaponTrackingRuntimeTemplates(c),R),this.collectModTemplates(function(e){if(!0!==e.turboKnifeEnabled||!0!==e.holsterEnabled)return{};let i=e.turboKnifeButton,t="fire"===e.returnMechanic?` && ${i} != FIRE_BTN && ${i} != ADS_BTN`:"";return{runtimeDefines:`int turboKnifeSeed = 73;
2744int turboKnifeHoldTime;
2745int turboKnifeRestTime;`,mainLogicBlock:"handleTurboKnife();",function:`// Turbo knife: physical hold drives an independent, humanized attack cycle.
2746function prepareTurboKnifeTiming() {
2747    // Bounded integer arithmetic; update only once per new attack cycle.
2748    turboKnifeSeed = (turboKnifeSeed * 109 + 89 + get_rtime()) % 32749;
2749    turboKnifeHoldTime = 36 + turboKnifeSeed % 9;
2750    turboKnifeSeed = (turboKnifeSeed * 109 + 89) % 32749;
2751    turboKnifeRestTime = 55 + turboKnifeSeed % 11;
2752}
2753
2754function handleTurboKnife() {
2755    if ((currentState == STATE_PLAYING || currentState == STATE_SCREEN_SAVER)
2756        && no_gun_state && !utility_state && !passiveMod/* @[INLINE_SUPPRESS_COMBAT] */
2757        && ${i} != SWITCHWEAPON_BTN${t}
2758        && get_ival(${i}) > 0) {
2759        if (!combo_running(TurboKnifeCombo)) {
2760            prepareTurboKnifeTiming();
2761            combo_run(TurboKnifeCombo);
2762        }
2763    } else {
2764        combo_stop(TurboKnifeCombo);
2765    }
2766}`,combo:`combo TurboKnifeCombo {
2767    set_val(${i}, 100);
2768    wait(turboKnifeHoldTime);
2769    set_val(${i}, 0);
2770    wait(turboKnifeRestTime);
2771}`}}(c.core.system.weaponTracking),R),this.collectModTemplates((0,A.K2)(c,i),R),this.collectModTemplates((0,u.YV)(c,i),R),t.weaponTrackingDiagnostics&&this.collectModTemplates((n=(0,A.ck)(c,i),r=(o=c.core.system.weaponTracking).utilityWheelEnabled&&o.utilityWheelButton&&"swap"===o.returnMechanic,{mainStart:"captureWeaponTraceInput();",mainEnd:"publishWeaponTrace();",runtimeDefines:`// Weapon diagnostics: see docs/weapon-tracking-diagnostics.md.
2772int weaponTraceRaw;
2773int weaponTracePreviousRaw;
2774int weaponTraceRelease;
2775int weaponTracePressCount;
2776int weaponTraceHold;
2777int weaponTraceFlags;
2778int weaponTraceResult;
2779int weaponTraceState;`,function:`function captureWeaponTraceInput() {

2780    weaponTraceRaw = get_ival(SWITCHWEAPON_BTN) != 0;
2781    weaponTraceRelease = weaponTracePreviousRaw && !weaponTraceRaw;
2782    if (weaponTraceRaw && !weaponTracePreviousRaw) {
2783        weaponTracePressCount = (weaponTracePressCount + 1) % 1000000;
2784        weaponTraceFlags = 0;
2785        weaponTraceHold = 0;
2786    }
2787    if (weaponTraceRaw) {
2788        weaponTraceHold = clamp(get_ptime(SWITCHWEAPON_BTN), 0, 32767);
2789    }
2790}
2791
2792function observeWeaponTrackingInput() {
2793    if (weaponTraceRaw || weaponTraceRelease) {
2794        if (weaponTraceRaw && !weaponTracePreviousRaw) { weaponTraceFlags = weaponTraceFlags | 512; }
2795        if (weaponTraceRelease) { weaponTraceFlags = weaponTraceFlags | 1; }
2796        if (event_release(SWITCHWEAPON_BTN)) { weaponTraceFlags = weaponTraceFlags | 2; }
2797        if (get_val(PS5_SHARE)) { weaponTraceFlags = weaponTraceFlags | 32; }
2798        ${n?"if (gamepadShortcutSuppressWeaponSwitch) { weaponTraceFlags = weaponTraceFlags | 64; }":""}
2799        ${r?"if (utility_wheel_ignore_return) { weaponTraceFlags = weaponTraceFlags | 128; }":""}
2800    }
2801}
2802
2803function publishWeaponTrace() {
2804    if (weaponTraceRaw || weaponTraceRelease) { weaponTraceResult = weaponTraceFlags; }
2805    weaponTraceState = profileId + 1;
2806    if (no_gun_state) { weaponTraceState = 3; }
2807    else if (utility_state) { weaponTraceState = 4; }
2808    set_val(TRACE_1, weaponTraceState);
2809    set_val(TRACE_2, profileId + 1);
2810    set_val(TRACE_3, weaponTracePressCount * 10 + weaponTraceRaw);
2811    set_val(TRACE_4, weaponTraceHold);
2812    set_val(TRACE_5, weaponTraceResult);
2813    set_val(TRACE_6, currentState);
2814    weaponTracePreviousRaw = weaponTraceRaw;
2815}`}),R);let S=this.orderModsForRuntime(i).flatMap(e=>{let i=this.resolveRuntimeModConfig(e,c);return e.templates&&i?[{mod:e,modConfig:i}]:[]}),f=Array.from(new Set(S.flatMap(({mod:e})=>e.suppressCombatFlag?[e.suppressCombatFlag]:[])));S.forEach(({mod:e,modConfig:i})=>{let t=this.applyModDynamicConfig(e,i),n=f.filter(i=>i!==e.suppressCombatFlag).map(e=>` && !${e}`).join("");this.injectInlineSuppressFlags(t,n),this.collectModTemplates(t,R)});let p=5+R.coreModEnumPre.length+R.modEnum.length,m=3+R.toggleEnum.length;R.modCount.push(String(p)),R.toggleArraySize.push(String(m)),this.appendBvarExtensionAnchors(R),this.collectModTemplates(this.buildWeaponRecoilPersistenceTemplates(c),R),this.allocateBvarSlots(R,_),_=this.replaceAnchors(_,R);let T=(0,d.h)(c.core.system.weaponProfiles),g=c.core.system.weaponProfiles.enabled&&T?function(e,i){let t=JSON.stringify(["weapons-v2",e.id,e.weapons.map(e=>e.id),i]),n=0x811c9dc5;for(let e=0;e<t.length;e++)n=Math.imul(n^t.charCodeAt(e),0x1000193)>>>0;return 2+n%32765}(T.library,R.bvarSlotDefines.join("\n")+R.saveBvar.join("\n")):1;_=_.replace("${CORE_BVAR_SCHEMA_VERSION}",String(g)),_=this.substituteValues(_,c,i,m,p,R,t);let I=f.map(e=>` && !${e}`).join("");_=(_=_.split("/* @[INLINE_SUPPRESS_COMBAT] */").join(I)).split("\n").flatMap(e=>{if(e.includes("@[ANCHOR_")){let i=e.split("// @[ANCHOR_")[0].split("@[ANCHOR_")[0].trimRight();return""===i.trim()?[]:[i]}return[e]}).join("\n"),_=this.removeUnusedQuickActionRuntime(_),_=this.removeUnusedToggleFeedbackWrapper(_),_=this.removeUnusedGenericRenderers(_);let O=this.buildScriptHeader(e,i,t);return this.normalizeGeneratedFormatting(`${O}
2816${_}`).trim()}static buildWeaponTrackingRuntimeTemplates(e){let i=e.core.system.weaponTracking;return i.utilityWheelEnabled&&i.utilityWheelButton?{runtimeDefines:`int utility_wheel_was_held;
2817int utility_wheel_ignore_return;`}:{}}static removeUnusedGenericRenderers(e){let i=(e,i)=>(e.match(RegExp(`\\b${i}\\s*\\(`,"g"))||[]).length>1?e:e.replace(RegExp(`\\n?function ${i}\\([^)]*\\) \\{[\\s\\S]*?\\n\\}\\n?`,"m"),"\n");for(let t of(e=i(e,"renderGenericSettingBar"),e=i(e,"renderGenericSubMenu"),e=i(e,"renderSubMenuWithPercent"),e=i(e,"renderSubMenuWithButton"),e=i(e,"drawButtonsSetting"),e=i(e,"drawShortcutOnOffValue"),e=i(e,"drawShortcutFeedbackValue"),e=i(e,"displayProfileNameCentered"),e=i(e,"displayPressToOpenMenu"),e=i(e,"getProfileStringAddr"),e=i(e,"getProfileStringSize"),["MENU_HINT_TEXT","SPROFILE_1","SPROFILE_2","SNOPROFILE"]))(e.match(RegExp(`\\b${t}\\b`,"g"))||[]).length<=1&&(e=e.replace(RegExp(`^const string ${t} = .*;\\n?`,"m"),""));return(e.match(/\bALL_BUTTONS\b/g)||[]).length<=1&&(e=e.replace(/\n?const string ALL_BUTTONS\[] = \{[\s\S]*?\n\};\n?/m,"\n")),e}static removeUnusedToggleFeedbackWrapper(e){return(e.match(/showToggleFeedback\s*\(/g)||[]).length>1?e:e.replace(/\n?function showToggleFeedback\(toggleFeedbackModId, state\) \{\n    showFeedback\(FEEDBACK_MODE_MOD_TOGGLE, toggleFeedbackModId, 0, state\);\n\}\n?/m,"\n")}static removeUnusedQuickActionRuntime(e){return(e.match(/requestQuickAction\s*\(/g)||[]).length>1?e:e.replace(/,\n\s*STATE_QUICK_ACTION/g,"").replace(/\nint quickActionModId;\nint quickActionType;/g,"").replace(/\n\s*case STATE_QUICK_ACTION: \{\n\s*handleQuickActionState\(\);\n\s*break;\n\s*\}/g,"").replace(/\ndefine QUICK_ACTION_TOGGLE = 0;\ndefine QUICK_ACTION_OPEN_SETUP = 1;/g,"").replace(/\n?function requestQuickAction\(quickActionSourceModId, actionType\) \{\n    quickActionModId = quickActionSourceModId;\n    quickActionType = actionType;\n    if \(actionType == QUICK_ACTION_TOGGLE\) \{\n        handleQuickActionState\(\);\n    \} else \{\n        tempState = STATE_QUICK_ACTION;\n        currentState = STATE_CLEAN_SCREEN;\n    \}\n\}\n?/m,"\n").replace(/\n?function handleQuickActionState\(\) \{\n\tpreviousState = currentState;\n\tset_val\(PS5_UP, 0\);\n\tset_val\(PS5_DOWN, 0\);\n\tset_val\(PS5_LEFT, 0\);\n\tset_val\(PS5_RIGHT, 0\);\n    if \(quickActionType == QUICK_ACTION_TOGGLE\) \{\n        if \(quickActionModId == RapidFireEnum\) \{\n            toggleRapidFire\[profileId\] = !toggleRapidFire\[profileId\];\n            showToggleFeedback\(RapidFireEnum, toggleRapidFire\[profileId\]\);\n        \} else if \(quickActionModId == AntiRecoilEnum\) \{\n            toggleAntiRecoil\[profileId\] = !toggleAntiRecoil\[profileId\];\n            showToggleFeedback\(AntiRecoilEnum, toggleAntiRecoil\[profileId\]\);\n        \} else if \(quickActionModId == AimAssistEnum\) \{\n            toggle\[ToggleAimAssistEnum\] = !toggle\[ToggleAimAssistEnum\];\n            showToggleFeedback\(AimAssistEnum, toggle\[ToggleAimAssistEnum\]\);\n        \}\n        persistSettings\(\);\n        if \(currentState == STATE_QUICK_ACTION\) \{\n            tempState = STATE_PLAYING;\n            currentState = STATE_CLEAN_SCREEN;\n        \}\n    \} else if \(quickActionType == QUICK_ACTION_OPEN_SETUP\) \{\n        displaySubModScreen\(quickActionModId\);\n    \}\n\}\n?/m,"\n")}static normalizeGeneratedFormatting(e){return e.split("\n").filter(e=>""!==e.trim()).join("\n")}static buildScriptHeader(e,i,t){let a=(0,l.S)(l.P,e),o=this.toHeaderText(t.scriptTitle||this.DEFAULT_INTRO_TITLE,this.DEFAULT_INTRO_TITLE),r=this.toHeaderText(t.scriptDescription||"",""),s=this.toHeaderText(t.scriptVersion||"1.0.0","1.0.0"),_=this.getHeaderFeatureLines(a,i),c=this.getHeaderShortcutLines(a,i,t.controllerLabels),E=e=>(0,n.YL)(e,a.buttonLayout,t.controllerLabels),d=this.getHeaderWeaponSyncProfileLines(a,t.controllerLabels);return["/*",...this.TUNEZ_LOGO_LINES,"============================================================",`📜 SCRIPT: ${o}`,`Version: ${s}`,...r?["------------------------------------------------------------","\uD83D\uDCDD DESCRIPTION",r]:[],"------------------------------------------------------------","\uD83D\uDEE0️ EDIT WITH TUNEZ","E

2817dit this script visually in Tunez instead of hand-editing GPC:",this.TUNEZ_MODS_URL,"Tune mods, recoil values, Aim Assist, weapon profiles, hotkeys,","button layout, custom mods, and script presets from one place.","------------------------------------------------------------","\uD83E\uDDED HOW TO NAVIGATE THE MENU",`OPEN MENU: ${E("PS5_L2")} + ${E("PS5_OPTIONS")}`,`NAVIGATE: D-Pad Up/Down | SELECT: ${E("PS5_CROSS")} | BACK: ${E("PS5_CIRCLE")}`,`ADJUST VALUES: D-Pad Left/Right (+/-1), ${E("PS5_L1")}/${E("PS5_R1")} (+/-10)`,"TOGGLE VALUES: D-Pad Left/Right in submenus",`SWITCH PROFILE: ${E("PS5_L1")}/${E("PS5_R1")} while inside the menu`,`TURN SCRIPT OFF/ON: ${E("PS5_L2")} + ${E("PS5_SHARE")}`,...d,"------------------------------------------------------------","\uD83C\uDFAF AIM ASSIST CALCULATOR","Use Tunez Tools to tune Aim Assist mod for controller or mouse:",this.TUNEZ_TOOLS_URL,"------------------------------------------------------------","⚠️ COMPILER WARNINGS","Please ignore any compiler warnings, they are intended.","------------------------------------------------------------","\uD83D\uDDB1️ MOUSE & KEYBOARD MENU SUPPORT","Use Tunez to configure mouse and keyboard controls.","Set menu bindings in Tunez: Controls > Keyboard shortcuts.","------------------------------------------------------------","\uD83D\uDCD8 HELP & DOCUMENTATION","Setup guides, menu explanations, and troubleshooting:",this.TUNEZ_HELP_URL,"------------------------------------------------------------","⚡ SHORTCUTS",...c,"------------------------------------------------------------","\uD83E\uDDE9 FEATURES & SETTINGS",..._,"------------------------------------------------------------","\uD83C\uDFA8 COLOR INDICATORS","- Red: Profile 1 is active","- White: Profile 2 is active","- Purple: Passive Mode is active; combat mods are paused","- Black: Script is turned off","============================================================","\uD83E\uDD16 GENERATED BY TUNEZ","This script was generated by Tunez.",`Generated at: ${this.formatGeneratedAt(t.generatedAt||new Date)}`,"============================================================","*/"].join("\n")}static getHeaderFeatureLines(e,i){let t=this.getHeaderFeatureEntries(e,i);if(0===t.length)return[this.HEADER_GROUP_UTILITY,"- Core menu and profile system: Menu, profiles, and script controls."];let n=[this.HEADER_GROUP_AIM,this.HEADER_GROUP_WEAPON,this.HEADER_GROUP_MOVEMENT,this.HEADER_GROUP_UTILITY,this.HEADER_GROUP_CUSTOM],a=[];for(let e of n){let i=t.filter(i=>i.group===e);if(0!==i.length)for(let t of(a.push(e),i))a.push(`- ${t.name}: ${this.truncateHeaderText(t.description,110)}`),a.push(`  Use when: ${this.truncateHeaderText(t.useWhen,112)}`),t.settings.length>0&&(a.push("  Settings:"),t.settings.slice(0,8).forEach(e=>a.push(`  • ${this.truncateHeaderText(e,112)}`)))}return a}static getHeaderFeatureEntries(e,i){let t=[],n=(e,i,n,a,o=[])=>{t.push({name:e,description:this.CORE_MOD_DESCRIPTIONS[e]||"Built-in Tunez feature.",useWhen:n,tune:a,settings:o,group:i})};n("Anti-Recoil",this.HEADER_GROUP_AIM,"your weapon pulls up or sideways while firing.","set Vertical first, then Horizontal, then refine Initial Boost, Ramp, and Aim Override.",["Profile active: enable recoil control separately for Profile 1 and Profile 2.","Vertical / Horizontal: pull strength and sideways correction for each profile.","Activation: choose Fire, ADS + Fire, or mixed activation depending on your game.","Initial Boost: extra correction at the start of firing.","Ramp: smoothly builds recoil correction over time.","Aim Override: reduces recoil correction while you manually move the aim stick."]),n("Aim Assist",this.HEADER_GROUP_AIM,"you want small stick movement that keeps the game aim assist active.","choose a shape, keep Size low enough to avoid shake, then tune Speed and ADS values.",["Shape: movement pattern for the left and right stick assist.","Size: how wide the assist movement is. Too high can shake.","Speed: how fast the assist pattern moves.","ADS Size / ADS Speed: separate values used while aiming down sights.","Boost / Smoothing / Aim Lock: fine tuning for strength, smoothness, and stickiness.",`Use the Aim Assist Calculator for controller or mouse values: ${this.TUNEZ_TOOLS_URL}`]),n("Rapid Fire",this.HEADER_GROUP_AIM,"you use semi-auto weapons and want held fire to send clean repeated trigger taps.","start with Shots Per Second, adjust Hold Time only if the game misses taps.",["Shots Per Second: fire rate for semi-auto weapons.","Hold Time: how long each trigger tap is held.","Activation: ADS + Fire, hip-fire only, or any fire.","Humanized Fire: adds tiny timing variation while keeping the same overall rate."]),n("Weapon Profiles",this.HEADER_GROUP_WEAPON,"you want Profile 1 and Profile 2 to carry separate weapon recoil and fire settings.","pick a game library, choose Primary and Secondary weapons, then enter your own recoil values.",["Game Library: weapon list used to fill Profile 1 and Profile 2.","Primary / Secondary Weapon: selected weapons for the two profiles.","Per-weapon Recoil: vertical and horizontal values exported into each profile.","Per-weapon Rapid Fire: whether rapid fire should run for the selected weapon.","No preset recoil values are included. Test and set your own values."]),n("Weapon Sync",this.HEADER_GROUP_WEAPON,"your game has holster, utility items, grenades, or looting states where combat mods should pause.","set holster timing, utility buttons, return action, and whether profile resets or stays active.",["Hold to holster: holding the swap button marks your weapon as put away.","Holster hold time: delay before holster triggers.","Turbo knife: hold the selected knife attack button while holstered for repeated attacks with small timing variations.","Utility items: buttons that equip grenades, tools, melee, or other non-gun items.","Utility wheel: holding a wheel button can select utility without triggering return-to-gun.","Return to gun action: choose swap button or fire button to resume weapon state.","Profile on return: keep the active profile or reset to Profile 1."]),n("Inverted Look",this.HEADER_GROUP_MOVEMENT,"your in-game vertical look axis is inverted.","turn it on so Anti-Recoil pulls in the correct direction for your layout.",["Enable this if you play with a flipped vertical look axis.","Required for Anti-Recoil to pull in the correct direction."]),n("Passive Mode",this.HEADER_GROUP_UTILITY,"you are driving, looting, navigating menus, or doing anything where combat mods should stop.","set the activation and deactivation buttons in Controls.",["Activation combo: configured in Tunez Controls.","When active, Aim Assist, Anti-Recoil, Rapid Fire, and combat mods are paused.","Purple LED means Passive Mode is active."]),n("Controller Vibration",this.HEADER_GROUP_UTILITY,"you want to mute physical rumble while keeping the script stable.","toggle vibration output; Rumble Anti-Recoil detection can still use internal rumble reads.",["Turn physical vibration output on or off.","Rumble Anti-Recoil detection stays available internally."]),i.forEac

2817h(e=>{t.push({name:this.toHeaderText(e.name,"Mod"),description:this.toHeaderText(this.HEADER_MOD_DESCRIPTION_OVERRIDES[e.name]||e.description||"Ready-made Tunez mod.","Ready-made Tunez mod."),useWhen:this.getHeaderModUseWhen(e),tune:this.getHeaderModTuneAdvice(e),settings:this.getHeaderSettingLines(e.settings),group:this.getHeaderGroupForMod(e)})});let a=new Set;return t.filter(({name:e})=>{let i=e.trim().toLowerCase();return!a.has(i)&&(a.add(i),!0)})}static getHeaderSettingLines(e){return e.filter(e=>!1!==e.editable&&!e.hideInUI).slice(0,8).map(e=>{let i=this.toHeaderText(e.label,"Setting"),t=this.toHeaderText(e.hint||"",""),n=e.options&&e.options.length>0?` Options: ${e.options.map(e=>this.toHeaderText(e,e)).join(" / ")}.`:"",a="number"==typeof e.min&&"number"==typeof e.max?` Range: ${e.min}-${e.max}.`:"",o=`${t}${n}${a}`.trim();return o?`${i}: ${o}`:i})}static getHeaderModUseWhen(e){let i=e.name.toLowerCase();return i.includes("ping")?"you want enemy pings to happen automatically while aiming or firing.":i.includes("sprint")||i.includes("run")?"you want sprint to trigger automatically while moving.":i.includes("crouch")?"you want crouch taps tied to shooting for harder-to-hit gunfights.":i.includes("strafe")?"you want automatic side movement while firing.":i.includes("hop")||i.includes("jump")?"you want repeated jumps while holding the selected movement button.":i.includes("trigger")?"you want triggers to respond instantly with a lighter press.":i.includes("slide")?"you want slide or dodge movement to cancel at a consistent timing.":i.includes("breath")?"you want scope breath held automatically for long-range shots.":i.includes("speed")?"you want to tune Cronus VM timing for stability or lower input delay.":i.includes("stick")?"you want looting or interaction controls moved to a more comfortable stick.":i.includes("prime")?"you want to activate your ultimate with one shortcut.":i.includes("heal")?"you want healing item selection automated from your current health state.":i.includes("flashlight")?"you want flashlight toggling on a simple shortcut.":"movement"===e.category?"you want movement automation for faster or harder-to-hit gameplay.":"aim"===e.category||"fire"===e.category||"shot"===e.category?"you want combat automation tied to aiming, firing, or shooting rhythm.":"utility"===e.category||"tactical"===e.category?"you want a utility action handled by the script instead of manual inputs.":"you want this added mod available inside the generated script."}static getHeaderModTuneAdvice(e){if(e.settings.length>0){let i=e.settings.filter(e=>!1!==e.editable&&!e.hideInUI).slice(0,3).map(e=>this.toHeaderText(e.label,"Setting"));if(i.length>0)return`open this mod settings and adjust ${i.join(", ")} for your game.`}return"embedded"===e.type?"configure its shortcut or custom code in Tunez before exporting.":"open this mod settings in Tunez and adjust timing, activation, and startup state."}static getHeaderGroupForMod(e){return"embedded"===e.type||"toggle-only"===e.type?"movement"===e.category?this.HEADER_GROUP_MOVEMENT:"aim"===e.category||"fire"===e.category||"shot"===e.category?this.HEADER_GROUP_AIM:this.HEADER_GROUP_UTILITY:"movement"===e.category?this.HEADER_GROUP_MOVEMENT:"aim"===e.category||"fire"===e.category||"shot"===e.category?this.HEADER_GROUP_AIM:"tactical"===e.category||"utility"===e.category?this.HEADER_GROUP_UTILITY:this.HEADER_GROUP_CUSTOM}static getHeaderWeaponSyncProfileLines(e,i="playstation"){let t=[],n=e.core.system.weaponTracking;return(n.holsterEnabled||n.utilityButtons.length>0||n.utilityWheelEnabled||e.core.system.weaponProfiles.enabled)&&t.push("------------------------------------------------------------","\uD83D\uDD2B WEAPON SYNC & PROFILES"),(n.holsterEnabled||n.utilityButtons.length>0||n.utilityWheelEnabled)&&(t.push("- Weapon Sync pauses combat mods when your weapon is holstered or a utility item is equipped."),t.push("- Returning to your weapon resumes combat mods and can keep or reset your active profile."),n.holsterEnabled&&n.turboKnifeEnabled&&t.push(`- Turbo knife: hold ${this.getGamepadInputLabel(n.turboKnifeButton,e.buttonLayout,i)} while holstered for humanized knife attacks.`),n.utilityWheelEnabled&&t.push("- Utility Wheel ignores the configured return action while a 

2817wheel selection is being made.")),e.core.system.weaponProfiles.enabled&&(t.push("- Profile 1 and Profile 2 keep separate recoil, rapid-fire, and mod settings."),t.push("- Weapon Profiles fill those profiles from the weapons selected in Tunez."),t.push("!! NO RECOIL VALUES, SET UP YOUR OWN !!")),t}static getHeaderShortcutLines(e,i,t="playstation"){let n=(0,A.V0)(e,i).map(i=>`- ${this.toHeaderText(i.action.label,"Shortcut")}: ${this.formatGamepadShortcut(i.modifier,i.button,e.buttonLayout,t)}`),a=(0,u.FE)(e,i).map(e=>`- ${this.toHeaderText(e.action.label,"Shortcut")}: ${this.formatKeyboardShortcut(e.modifier,e.key)}`),o=[];return n.length>0&&o.push("\uD83C\uDFAE CONTROLLER SHORTCUTS",...n),a.length>0?o.push("⌨️ KEYBOARD SHORTCUTS","- Keyboard play is fully supported. Manage bindings in Tunez: Controls > Keyboard shortcuts.",...a):o.push("⌨️ KEYBOARD SHORTCUTS","- Keyboard play is fully supported. Add bindings in Tunez: Controls > Keyboard shortcuts."),o.length>0?o:["- No custom shortcuts configured in Controls."]}static formatGamepadShortcut(e,i,t,n){let a=this.getGamepadInputLabel(e,t,n),o=this.getGamepadInputLabel(i,t,n);return`${a} + ${o}`}static getGamepadInputLabel(e,i,t){return this.toHeaderText((0,n.YL)(e,i,t),e)}static formatKeyboardShortcut(e,i){let t=this.toHeaderText((0,r.k8)(i),i);return e?`${this.toHeaderText((0,r.k8)(e),e)} + ${t}`:t}static truncateHeaderText(e,i){return e.length<=i?e:`${e.slice(0,i-3).trimEnd()}...`}static formatGeneratedAt(e){let i=e=>String(e).padStart(2,"0"),t=this.GENERATED_MONTHS[e.getMonth()]||"Jan";return`${t} ${e.getDate()}, ${e.getFullYear()}, ${i(e.getHours())}:${i(e.getMinutes())}:${i(e.getSeconds())}`}static toHeaderText(e,i){return Array.from((e||"").normalize("NFKD")).map(e=>this.INTRO_CHAR_MAP[e]??e).join("").replace(/[\u0300-\u036f]/g,"").replace(/[^\x20-\x7E]/g," ").replace(/\/\*/g,"/ *").replace(/\*\//g,"* /").replace(/\s+/g," ").trim()||i}static buildWeaponProfilesTemplates(e){let i,t,n,a,o,r=(0,l.S)(l.P,e),s=r.core.system.weaponProfiles;if(!s.enabled)return{};let _=(0,d.h)(s);if(!_)return{};let c=!!r.mods.ScopeAssist?.enabled,{library:E,primaryIndex:u,secondaryIndex:A}=_,S=E.weapons.map(e=>{let i=s.values[e.id],t=this.clampInt(i?.scopeAssistMode??0,0,4);return{recoilVertical:this.clampInt(i?.recoilVertical??0,-50,50),recoilHorizontal:this.clampInt(i?.recoilHorizontal??0,-50,50),rapidFireEnabled:+!!i?.rapidFireEnabled,scopeAssistMode:t}}),f=E.weapons.map(e=>`"${this.escapeGpcString(this.toOledWeaponLabel(e.name))}"`).join(", "),p=S.map(e=>e.recoilVertical).join(", "),m=S.map(e=>e.recoilHorizontal).join(", "),T=S.map(e=>e.rapidFireEnabled).join(", "),g=S.map(e=>e.scopeAssistMode).join(", "),I=c?`
2818int weaponProfileScopeAssist;
2819const int8 WEAPON_PROFILE_SCOPE_ASSIST[] = { ${g} };`:"",O=c?`scopeAssistUseWeaponModes = TRUE;
2820weaponProfileScopeAssist = WEAPON_PROFILE_SCOPE_ASSIST[weaponProfileSelection[profileId]];
2821scopeAssistWeaponMode = weaponProfileScopeAssist;`:"",P=c?`
2822    weaponProfileScopeAssist = WEAPON_PROFILE_SCOPE_ASSIST[weaponProfileSelection[profileId]];
2823    scopeAssistWeaponMode = weaponProfileScopeAssist;
2824    resetScopeAssistRuntime();`:"",L=c?`weaponProfileScopeAssist = WEAPON_PROFILE_SCOPE_ASSIST[weaponProfileSelection[profileId]];
2825scopeAssistWeaponMode = weaponProfileScopeAssist;`:"",N={coreModEnumPre:"WeaponProfilesEnum,",coreModIdArrayPre:"WeaponProfilesEnum,",coreAsciiNamePre:`${this.toOledModNameLiteral("WEAPONS")}, // WEAPONS`,runtimeDefines:`define WEAPON_PROFILE_MAX_INDEX = ${E.weapons.length-1};
2826define WEAPON_PROFILE_COUNT = ${E.weapons.length};
2827int weaponProfileSelection[2];
2828int weaponProfileRapidFire[2];
2829int weaponProfileApplied[2];
2830int weaponProfileRecoilV[${2*E.weapons.length}];
2831int weaponProfileRecoilH[${2*E.weapons.length}];
2832int weaponProfileRecoilSaved;
2833int weaponProfileRecoilIndex;
2834const string WEAPON_PROFILE_NAMES[] = { ${f} };
2835const int8 WEAPON_PROFILE_AR_V[] = { ${p} };
2836const int8 WEAPON_PROFILE_AR_H[] = { ${m} };
2837const int8 WEAPON_PROFILE_RF[] = { ${T} };${I}`,init:O,modScreen:`if (currentModId == WeaponProfilesEnum) {
2838            renderWeaponProfilesMainScreen();
2839            screenDisplayed();
2840            setSetupScreenSaver();
2841            return;
2842        }`,switchActiveMod:"case WeaponProfilesEnum: { break; }",function:`function renderWeaponProfilesMainScreen() {
2843    if (weaponProfileSelection[profileId] < 0 || weaponProfileSelection[profileId] > WEAPON_PROFILE_MAX_INDEX) {
2844        weaponProfileSelection[profileId] = 0;
2845    }
2846
2847    cls_oled(OLED_BLACK);
2848    drawModCounterLeft(5, OLED_WHITE);
2849    drawProfileNameRight(5, OLED_WHITE);
2850    line_oled(0, 18, 127, 18, 1, OLED_WHITE);
2851    drawMainMenuModName(addr(MODNAME[WeaponProfilesEnum]));
2852    drawWeaponProfileName(45);
2853}
2854
2855function drawWeaponProfileName(yPosition) {
2856    printCentered(yPosition, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, WEAPON_PROFILE_NAMES[weaponProfileSelection[profileId]]);
2857}
2858
2859function applyWeaponProfileSelection() {
2860    rememberWeaponProfileRecoil(profileId);
2861    weaponProfileApplied[profileId] = weaponProfileSelection[profileId];
2862    restoreWeaponProfileRecoil(profileId);
2863    weaponProfileRapidFire[profileId] = WEAPON_PROFILE_RF[weaponProfileSelection[profileId]];${P}
2864}
2865
2866function rememberWeaponProfileRecoil(profile) {
2867    weaponProfileRecoilIndex = profile * WEAPON_PROFILE_COUNT + weaponProfileApplied[profile];
2868    weaponProfileRecoilV[weaponProfileRecoilIndex] = antiRecoilVertical[profile];
2869    weaponProfileRecoilH[weaponProfileRecoilIndex] = antiRecoilHorizontal[profile];
2870}
2871
2872function restoreWeaponProfileRecoil(profile) {
2873    weaponProfileRecoilIndex = profile * WEAPON_PROFILE_COUNT + weaponProfileApplied[profile];
2874    antiRecoilVertical[profile] = weaponProfileRecoilV[weaponProfileRecoilIndex];
2875    antiRecoilHorizontal[profile] = weaponProfileRecoilH[weaponProfileRecoilIndex];
2876}
2877
2878function initWeaponProfileRecoil() {
2879    for (weaponProfileRecoilIndex = 0; weaponProfileRecoilIndex < WEAPON_PROFILE_COUNT; weaponProfileRecoilIndex++) {

2880        weaponProfileRecoilV[weaponProfileRecoilIndex] = WEAPON_PROFILE_AR_V[weaponProfileRecoilIndex];
2881        weaponProfileRecoilH[weaponProfileRecoilIndex] = WEAPON_PROFILE_AR_H[weaponProfileRecoilIndex];
2882        weaponProfileRecoilV[WEAPON_PROFILE_COUNT + weaponProfileRecoilIndex] = WEAPON_PROFILE_AR_V[weaponProfileRecoilIndex];
2883        weaponProfileRecoilH[WEAPON_PROFILE_COUNT + weaponProfileRecoilIndex] = WEAPON_PROFILE_AR_H[weaponProfileRecoilIndex];
2884    }
2885    weaponProfileApplied[Profile1Enum] = weaponProfileSelection[Profile1Enum];
2886    weaponProfileApplied[Profile2Enum] = weaponProfileSelection[Profile2Enum];
2887    rememberWeaponProfileRecoil(Profile1Enum);
2888    rememberWeaponProfileRecoil(Profile2Enum);
2889}`,profileChanged:L,getToggleState:`case WeaponProfilesEnum: {
2890    return TRUE;
2891}`,saveBvar:`save_bvar_auto(weaponProfileSelection[Profile1Enum], 0, WEAPON_PROFILE_MAX_INDEX);
2892save_bvar_auto(weaponProfileSelection[Profile2Enum], 0, WEAPON_PROFILE_MAX_INDEX);`,readBvar:`weaponProfileSelection[Profile1Enum] = read_bvar_auto(0, WEAPON_PROFILE_MAX_INDEX, ${u});
2893weaponProfileSelection[Profile2Enum] = read_bvar_auto(0, WEAPON_PROFILE_MAX_INDEX, ${A});
2894weaponProfileRapidFire[Profile1Enum] = WEAPON_PROFILE_RF[weaponProfileSelection[Profile1Enum]];
2895weaponProfileRapidFire[Profile2Enum] = WEAPON_PROFILE_RF[weaponProfileSelection[Profile2Enum]];`,loadDefaults:`weaponProfileSelection[Profile1Enum] = ${u};
2896weaponProfileSelection[Profile2Enum] = ${A};
2897weaponProfileRapidFire[Profile1Enum] = WEAPON_PROFILE_RF[weaponProfileSelection[Profile1Enum]];
2898weaponProfileRapidFire[Profile2Enum] = WEAPON_PROFILE_RF[weaponProfileSelection[Profile2Enum]];`},h=(i=r.core.system.weaponProfiles,t=function(e,i){let t=(0,R.f)(e,R.ws,"",i),n=new Map(e.weapons.map((e,i)=>[e.id,i])),a=t.flatMap(e=>e.weapons.map(e=>n.get(e.id))),o=e.weapons.map((e,i)=>a.indexOf(i)),r=e.weapons.map(e=>t.findIndex(i=>i.id===e.categoryId)+1),l=[0],s=[a.length],_=["ALL"],c=0;for(let e of t){if(!/^[A-Z0-9]{1,4}$/.test(e.oledLabel))throw Error(`Invalid OLED category label: ${e.id}`);l.push(c),s.push(e.weapons.length),_.push(e.oledLabel),c+=e.weapons.length}if(a.length!==e.weapons.length||new Set(a).size!==a.length)throw Error(`Every weapon must belong to a category: ${e.id}`);return{ordered:a,positions:o,categories:r,starts:l,counts:s,labels:_}}(E,i.orderByGame?.[E.id]),n=(e,i)=>`const ${i.every(e=>e<=127)?"int8":"int16"} ${e}[] = { ${i.join(", ")} };`,a=E.weapons.map(e=>Number((i.values[e.id]?.scopeAssistMode??0)>0)),o=r.mods.ScopeAssist?.enabled?" && !(toggleScopeAssist[profileId] && scopeAssistWeaponMode == 4)":"",{runtimeDefines:`define WEAPON_CATEGORY_MAX = ${t.labels.length-1};
2899int weaponCategoryFilter = 0;
2900int weaponBrowseTime = 0;
2901int weaponDisplayCategory;
2902int weaponDisplayPosition;
2903int weaponNavPosition;
2904int weaponNavStart;
2905int weaponNavCount;
2906int weaponDisplayFlags;
2907int weaponDisplayLastFlags = -1;
2908int weaponDisplayLastProfile = -1;
2909int weaponDisplayLastV = 101;
2910int weaponDisplayLastH = 101;
2911int weaponDisplayLastSubmenu = FALSE;
2912${n("WEAPON_ORDER",t.ordered)}
2913${n("WEAPON_POSITION",t.positions)}
2914${n("WEAPON_CATEGORY",t.categories)}
2915${n("WEAPON_CATEGORY_START",t.starts)}
2916${n("WEAPON_CATEGORY_COUNT",t.counts)}
2917${n("WEAPON_SA_ENABLED",a)}
2918const string WEAPON_CATEGORY_LABELS[] = { ${t.labels.map(e=>`"${e}"`).join(", ")} };
2919const string WEAPON_FILTER_LABEL = "FILTER:";
2920const string WEAPON_DETAIL_LABELS[] = { "V", "H", "AR", "RF", "SA", "-" };`,miscSettingEnum:"WeaponDetailsEnum,",miscSettingsLabel:'"WEAPON DETAILS",',miscMinMaxTable:"{ 0, 1 }, // WeaponDetailsEnum",miscNavigation:"WeaponDetailsEnum",miscRender:"case WeaponDetailsEnum: { drawOnOffValue(settings[WeaponDetailsEnum], 45); break; }",miscInput:"case WeaponDetailsEnum: { settings[WeaponDetailsEnum] = !settings[WeaponDetailsEnum]; resetDisplay(); break; }",saveBvar:"save_bvar_auto(settings[WeaponDetailsEnum], 0, 1);",readBvar:`settings[WeaponDetailsEnum] = read_bvar_auto(0, 1, ${+!!i.showDetail

2920s});`,loadDefaults:`settings[WeaponDetailsEnum] = ${+!!i.showDetails};`,playingScreenOverride:"drawWeaponGameplayScreen();",screenSaverScreen:"drawWeaponGameplayScreen();",gameplayDisplayUpdate:"handleWeaponDisplayTick();",profileChanged:`if (currentState == STATE_RESTART) {
2921    weaponCategoryFilter = 0;
2922    weaponBrowseTime = 0;
2923}`,submenuOverride:`if (modMenu == WeaponProfilesEnum) {
2924    blockMenuInputs();
2925    renderWeaponPicker();
2926    setSetupScreenSaver();
2927    return;
2928}`,setupMenuInput:`weaponBrowseTime = 0;
2929weaponDisplayLastSubmenu = FALSE;
2930if (event_press(PS5_CROSS) && modId[currentMod] == WeaponProfilesEnum) { resetDisplay(); }`,function:`function stepWeaponCategory(direction) {
2931    weaponCategoryFilter = weaponCategoryFilter + direction;
2932    if (weaponCategoryFilter < 0) { weaponCategoryFilter = WEAPON_CATEGORY_MAX; }
2933    if (weaponCategoryFilter > WEAPON_CATEGORY_MAX) { weaponCategoryFilter = 0; }
2934    resetDisplay();
2935}
2936
2937function stepWeaponSelection(direction) {
2938    weaponNavStart = WEAPON_CATEGORY_START[weaponCategoryFilter];
2939    weaponNavCount = WEAPON_CATEGORY_COUNT[weaponCategoryFilter];
2940    weaponNavPosition = WEAPON_POSITION[weaponProfileSelection[profileId]] - weaponNavStart;
2941    if (weaponNavPosition < 0 || weaponNavPosition >= weaponNavCount) {
2942        weaponNavPosition = iif(direction > 0, 0, weaponNavCount - 1);
2943    } else {
2944        weaponNavPosition = weaponNavPosition + direction;
2945        if (weaponNavPosition < 0) { weaponNavPosition = weaponNavCount - 1; }
2946        if (weaponNavPosition >= weaponNavCount) { weaponNavPosition = 0; }
2947    }
2948    weaponNavPosition = WEAPON_ORDER[weaponNavStart + weaponNavPosition];
2949    if (weaponNavPosition == weaponProfileSelection[profileId]) { return FALSE; }
2950    weaponProfileSelection[profileId] = weaponNavPosition;
2951    applyWeaponProfileSelection();
2952    resetAntiRecoilRuntime();
2953    resetDisplay();
2954    return TRUE;
2955}
2956
2957function showWeaponBrowseFeedback() {
2958    feedbackTime = 0;
2959    weaponBrowseTime = 1000;
2960    resetDisplay();
2961}
2962
2963function weaponRapidFireVisible() {
2964    return toggleRapidFire[profileId] && weaponProfileRapidFire[profileId]${o};
2965}
2966
2967function handleWeaponDisplayTick() {
2968    if (weaponBrowseTime > 0) {
2969        weaponBrowseTime = max(0, weaponBrowseTime - get_rtime());
2970        if (weaponBrowseTime == 0) { resetDisplay(); }
2971    }
2972    weaponDisplayFlags = toggleAntiRecoil[profileId] + weaponRapidFireVisible() * 2 + settings[WeaponDetailsEnum] * 4;
2973    if (weaponDisplayLastProfile != profileId || weaponDisplayLastFlags != weaponDisplayFlags || weaponDisplayLastV != antiRecoilVertical[profileId] || weaponDisplayLastH != antiRecoilHorizontal[profileId]) {
2974        weaponDisplayLastProfile = profileId;
2975        weaponDisplayLastFlags = weaponDisplayFlags;
2976        weaponDisplayLastV = antiRecoilVertical[profileId];
2977        weaponDisplayLastH = antiRecoilHorizontal[profileId];
2978        resetDisplay();
2979    }
2980}
2981
2982function drawWeaponGameplayScreen() {
2983    weaponDisplayCategory = WEAPON_CATEGORY[weaponProfileSelection[profileId]];
2984    if (weaponBrowseTime > 0) { weaponDisplayCategory = weaponCategoryFilter; }
2985    drawProfileBadge(2, 3, OLED_FONT_SMALL, OLED_WHITE);
2986    if (profileId == Profile1Enum) {
2987        circle_oled(64, 7, 2, TRUE, OLED_WHITE);
2988    } else {
2989        circle_oled(60, 7, 2, TRUE, OLED_WHITE);
2990        circle_oled(68, 7, 2, TRUE, OLED_WHITE);
2991    }
2992    print(126 - getStringLength(WEAPON_CATEGORY_LABELS[weaponDisplayCategory]) * OLED_FONT_SMALL_WIDTH, 3, OLED_FONT_SMALL, OLED_WHITE, WEAPON_CATEGORY_LABELS[weaponDisplayCategory]);
2993    line_oled(0, 16, 127, 16, 1, OLED_WHITE);
2994    drawWeaponProfileName(23);
2995    if (weaponBrowseTime > 0) { drawWeaponPosition(); }
2996    if (settings[WeaponDetailsEnum]) { drawWeaponDetails(); }
2997}
2998
2999function drawWeaponPosition() {
3000    weaponDisplayPosition = WEAPON_POSITION[weaponProfileSelection[profileId]] - WEAPON_CATEGORY_START[weaponDisplayCategory];
3001    weaponNavCount = WEAPON_CATEGORY_COUNT[weaponDisplayCategory];
3002    weaponNavPosition = 1;
3003    if (weaponDisplayPosition >= 0 && weaponDisplayPosition < weaponNavCount) {
3004        weaponNavPosition = findDigits(weaponDisplayPosition + 1);
3005    }
3006    weaponNavStart = (128 - (weaponNavPosition + 1 + findDigits(weaponNavCount)) * OLED_FONT_SMALL_WIDTH) / 2;
3007    if (weaponDisplayPosition < 0 || weaponDisplayPosition >= weaponNavCount) {

3008        print(weaponNavStart, 35, OLED_FONT_SMALL, OLED_WHITE, WEAPON_DETAIL_LABELS[5]);
3009    } else {
3010        numberToString(weaponDisplayPosition + 1, weaponNavPosition, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, weaponNavStart, 35, OLED_WHITE);
3011    }
3012    putc_oled(1, 47);
3013    puts_oled(weaponNavStart + weaponNavPosition * OLED_FONT_SMALL_WIDTH, 35, OLED_FONT_SMALL, 1, OLED_WHITE);
3014    numberToString(weaponNavCount, findDigits(weaponNavCount), OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, weaponNavStart + (weaponNavPosition + 1) * OLED_FONT_SMALL_WIDTH, 35, OLED_WHITE);
3015}
3016
3017function drawWeaponDetails() {
3018    print(2, 52, OLED_FONT_SMALL, OLED_WHITE, WEAPON_DETAIL_LABELS[0]);
3019    numberToString(antiRecoilVertical[profileId], findDigits(antiRecoilVertical[profileId]), OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, 9, 52, OLED_WHITE);
3020    print(30, 52, OLED_FONT_SMALL, OLED_WHITE, WEAPON_DETAIL_LABELS[1]);
3021    numberToString(antiRecoilHorizontal[profileId], findDigits(antiRecoilHorizontal[profileId]), OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, 37, 52, OLED_WHITE);
3022    drawWeaponStatus(70, WEAPON_DETAIL_LABELS[2], toggleAntiRecoil[profileId]);
3023    drawWeaponStatus(90, WEAPON_DETAIL_LABELS[3], weaponRapidFireVisible());
3024    drawWeaponStatus(110, WEAPON_DETAIL_LABELS[4], WEAPON_SA_ENABLED[weaponProfileSelection[profileId]]);
3025}
3026
3027function drawWeaponStatus(statusX, textAddr, enabled) {
3028    if (enabled) {
3029        rect_oled(statusX - 2, 50, 18, 12, TRUE, OLED_WHITE);
3030        print(statusX, 52, OLED_FONT_SMALL, OLED_BLACK, textAddr);
3031    } else {
3032        print(statusX, 52, OLED_FONT_SMALL, OLED_WHITE, textAddr);
3033    }
3034}
3035
3036function drawWeaponPickerName() {
3037    weaponNavCount = min(14, getStringLength(WEAPON_PROFILE_NAMES[weaponProfileSelection[profileId]]));
3038    for (charIndex = 0; charIndex < weaponNavCount; charIndex++) {
3039        putc_oled(charIndex + 1, duint8(WEAPON_PROFILE_NAMES[weaponProfileSelection[profileId]] + charIndex));
3040    }
3041    puts_oled(centerX(weaponNavCount, OLED_FONT_SMALL_WIDTH), 45, OLED_FONT_SMALL, weaponNavCount, OLED_WHITE);
3042    displayArrowLeft(0, 48, 70, OLED_WHITE);
3043    displayArrowRight(120, 48, 70, OLED_WHITE);
3044}
3045
3046function renderWeaponPicker() {
3047    if (!weaponDisplayLastSubmenu) { resetDisplay(); weaponDisplayLastSubmenu = TRUE; }
3048    if (event_press(PS5_UP)) { stepWeaponCategory(-1); }
3049    if (event_press(PS5_DOWN)) { stepWeaponCategory(1); }
3050    if (event_press(PS5_LEFT)) { stepWeaponSelection(-1); }
3051    if (event_press(PS5_RIGHT)) { stepWeaponSelection(1); }
3052    if (stateScreenDisplayed) { return; }
3053    cls_oled(OLED_BLACK);
3054    print(0, 5, OLED_FONT_SMALL, OLED_WHITE, addr(MODNAME[WeaponProfilesEnum]));
3055    drawProfileBadge(114, 5, OLED_FONT_SMALL, OLED_WHITE);
3056    line_oled(0, 18, 127, 18, 1, OLED_WHITE);
3057    print(0, 23, OLED_FONT_SMALL, OLED_WHITE, WEAPON_FILTER_LABEL[0]);
3058    print(56, 23, OLED_FONT_SMALL, OLED_WHITE, WEAPON_CATEGORY_LABELS[weaponCategoryFilter]);
3059    drawWeaponPickerName();
3060    screenDisplayed();
3061}`});return{...N,...h,runtimeDefines:`${N.runtimeDefines}
3062${h.runtimeDefines}`,function:`${N.function}
3063${h.function}`,profileChanged:`${N.profileChanged}
3064${h.profileChanged}`,saveBvar:`${N.saveBvar}
3065${h.saveBvar}`,readBvar:`${N.readBvar}
3066${h.readBvar}`,loadDefaults:`${N.loadDefaults}
3067${h.loadDefaults}`}}static buildWeaponRecoilPersistenceTemplates(e){let i=e.core.system.weaponProfiles;if(!i.enabled)return{};let t=(0,d.h)(i);if(!t)return{};let n=[],a=[];for(let e=0;e<2*t.library.weapons.length;e++)for(let i of["V","H"]){let t=`weaponProfileRecoil${i}[${e}]`;n.push(`save_bvar_auto(${t}, -50, 50);`),a.push(`${t} = read_bvar_auto(-50, 50, ${t});`)}return{saveBvar:`// Weapon recoil persistence begin
3068rememberWeaponProfileRecoil(Profile1Enum);
3069rememberWeaponProfileRecoil(Profile2Enum);
3070weaponProfileRecoilSaved = 1;
3071save_bvar_auto(weaponProfileRecoilSaved, 0, 1);
3072${n.join("\n")}
3073// Weapon recoil persistence end`,readBvar:`// Weapon recoil persistence begin
3074initWeaponProfileRecoil();
3075weaponProfileRecoilSaved = read_bvar_auto(0, 1, 0);
3076if (weaponProfileRecoilSaved) {
3077${a.join("\n")}
3078    restoreWeaponProfileRecoil(Profile1Enum);
3079    restoreWeaponProfileRecoil(Profile2Enum);
3080}
3081// Weapon recoil persistence end`,loadDefaults:"initWeaponProfileRecoil();"}}static clampInt(e,i,t){return Number.isFinite(e)?Math.max(i,Math.min(t,Math.round(e))):i}static escapeGpcString(e){return e.replace(/\\/g,"\\\\").replace(/"/g,'\\"')}static toOledWeaponLabel(e){let i=e.toUpperCase();return i.length>18?i.slice(0,18):i}static applyModDynamicConfig(e,i){let t={...e.templates};if(e.dynamicHandler){let n=i.handler||e.dynamicHandler,a=(0,c.s)(e.id,n,{deferTapHandling:!1,symbolPrefix:"",stopComboOnRelease:!!("string"==typeof t.combo&&t.combo.trim())}),o=!!("string"==typeof t.combo&&t.combo.trim()),r="loop"===n.execution?`function ${a.toggleFunctionName}() {
3082    ${a.stateVariableName} = !${a.stateVariableName};${o?`
3083    if (!${a.stateVariableName}) {
3084        combo_stop(${a.comboName});
3085    }`:""}
3086}`:"",l="misc-toggle"===e.type?`settings[${e.id}

3086Enum]`:`toggle[Toggle${e.id}Enum]`,s=`// ${e.name} Mod (Handler)
3087function handle${e.id}() {
3088${(0,E.Mz)(a.inputHook)}
3089}`;t.mainLogicBlock=`// ${e.name} Mod
3090if (${l}) {
3091    handle${e.id}();
3092}`;let _=[s,r].filter(Boolean).join("\n\n"),d="function"==typeof t.function?t.function(i.settings):t.function;t.function=[_,d].filter(Boolean).join("\n\n"),t.runtimeDefines=[t.runtimeDefines,a.runtimeDefines,a.runtimeVars].filter(Boolean).join("\n"),t.priorityLogic=[t.priorityLogic,a.priorityLogic].filter(Boolean).join("\n")}let n=e.dynamicHandler?i.handler||e.dynamicHandler:void 0,a=n?n.secondaryButton||n.primaryButton||"NONE":i.activation?.button||e.activation?.button||"NONE",r=i.activation?.modifier||e.activation?.modifier||"NONE",l=n?n.secondaryButton?`${(0,E.$O)(n.primaryButton,n.device)} && ${(0,E.$O)(n.secondaryButton,n.device)}`:(0,E.$O)(n.primaryButton,n.device):"NONE"===a?"FALSE":`get_val(${a})`,s=i.enabled?"1":"0",_=this.normalizeBinaryFlag(i.settings?.active,s),d={BUTTON:a,INPUT_EXPR:l,MODIFIER:"NONE"===r?"0":r,active:_},R={BUTTON:String(o.gy[a]??0),MODIFIER:"NONE"===r?"0":String(o.gy[r]??0),active:_};e.settings.forEach(e=>{let t=i.settings[e.id]??e.default;"boolean"==typeof t&&(t=+!!t),d[e.id]=String(t);let n=t;"string"==typeof t&&void 0!==o.gy[t]&&(n=o.gy[t]),R[e.id]=String(n)});let u=["loadDefaults","loadDefaultsAppend","readBvar","readBvarAppend","saveBvar","saveBvarAppend","minMaxTable","miscMinMaxTable"],A=e=>{let i=Object.keys(e);return 0===i.length?null:RegExp(i.map(e=>`\${${e}}`.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")).join("|"),"g")},S=A(d),f=A(R);for(let e of Object.keys(t)){let n=t[e];if("function"==typeof n&&(n=n(i.settings)),"string"==typeof n){let i=u.includes(e),a=i?R:d,o=i?f:S;o&&(n=n.replace(o,e=>a[e.slice(2,-1)]??e)),t[e]=n}}return t}static injectInlineSuppressFlags(e,i){for(let t of Object.keys(e)){let n=e[t];"string"==typeof n&&(e[t]=n.split("/* @[INLINE_SUPPRESS_COMBAT] */").join(i))}}static normalizeBinaryFlag(e,i){if(null==e)return i;if("boolean"==typeof e)return e?"1":"0";if("number"==typeof e)return e>0?"1":"0";if("string"==typeof e){let i=e.trim().toLowerCase();if("true"===i||"on"===i||"yes"===i)return"1";if("false"===i||"off"===i||"no"===i)return"0";let t=Number(e);if(!Number.isNaN(t))return t>0?"1":"0"}return i}static initializeAnchors(){return{coreModEnumPre:[],coreModIdArrayPre:[],coreAsciiNamePre:[],modEnum:[],modIdArray:[],toggleArraySize:[],toggleEnum:[],init:[],modCount:[],strings:[],runtimeDefines:[],asciiName:[],miscSettingsLabel:[],settingsLabel:[],submenuBlock:[],submenuDispatcher:[],miscNavigation:[],miscRender:[],miscInput:[],submenuRender:[],withProfileMod:[],modScreen:[],priorityLogic:[],offStateInput:[],mainStart:[],mainEnd:[],gameplayDisplayUpdate:[],playingScreenOverride:[],submenuOverride:[],playingScreen:[],screenSaverScreen:[],mainLogicBlock:[],profileChanged:[],getToggleState:[],switchActiveMod:[],setupMenuInput:[],miscMinMaxTable:[],minMaxTable:[],miscSettingEnum:[],settingEnum:[],bvarSlotDefines:[],saveBvar:[],readBvar:[],loadDefaults:[],saveBvarAppend:[],readBvarAppend:[],loadDefaultsAppend:[],function:[],combo:[]}}static usesPhysicalIdleDetector(e){return e.some(e=>"AntiAfk"===e.id||"LobbyKeepalive"===e.id)}static orderModsForRuntime(e){let i={HairTrigger:0,GrenadeAssist:9,ScopeAssist:10};return e.map((e,i)=>({mod:e,index:i})).sort((e,t)=>{let n=i[e.mod.id]??5,a=i[t.mod.id]??5;return n===a?e.index-t.index:n-a}).map(e=>e.mod)}static buildPhysicalIdleDetectorHelpers(){return`// Shared physical inactivity helpers
3093function tunezPhysicalButtonChanged() {
3094    return get_ival(PS5_PS) != get_lval(PS5_PS) ||
3095           get_ival(PS5_SHARE) != get_lval(PS5_SHARE) ||
3096           get_ival(PS5_OPTIONS) != get_lval(PS5_OPTIONS) ||
3097           get_ival(PS5_R1) != get_lval(PS5_R1) ||
3098           get_ival(PS5_R2) != get_lval(PS5_R2) ||
3099           get_ival(PS5_R3) != get_lval(PS5_R3) ||
3100           get_ival(PS5_L1) != get_lval(PS5_L1) ||
3101           get_ival(PS5_L2) != get_lval(PS5_L2) ||
3102           get_ival(PS5_L3) != get_lval(PS5_L3) ||
3103           get_ival(PS5_UP) != get_lval(PS5_UP) ||
3104           get_ival(PS5_DOWN) != get_lval(PS5_DOWN) ||
3105           get_ival(PS5_LEFT) != get_lval(PS5_LEFT) ||
3106           get_ival(PS5_RIGHT) != get_lval(PS5_RIGHT) ||
3107           get_ival(PS5_TRIANGLE) != get_lval(PS5_TRIANGLE) ||
3108           get_ival(PS5_CIRCLE) != get_lval(PS5_CIRCLE) ||
3109           get_ival(PS5_CROSS) != get_lval(PS5_CROSS) ||
3110           get_ival(PS5_SQUARE) != get_lval(PS5_SQUARE);
3111}
3112
3113function tunezPhysicalStickMoved(deadzone) {
3114    return abs(get_ival(PS5_LX)) > deadzone ||
3115           abs(get_ival(PS5_LY)) > deadzone ||
3116           abs(get_ival(PS5_RX)) > deadzone ||
3117           abs(get_ival(PS5_RY)) > deadzone;
3118}
3119
3120function tunezPhysicalActivity(deadzone) {
3121    return tunezPhysicalButtonChanged() || tunezPhysicalStickMoved(deadzone);
3122}`}static collectModTemplates(e,i){let t=new Set(["runtimeDefines","strings"]);for(let n of Object.keys(e)){let a=e[n];if(a&&i[n]&&"string"==typeof a){if("combo"===n){a.split(/\n\s*\n(?=combo\s+)/).map(e=>e.trimRight()).filter(e=>

3122""!==e.trim()).forEach(e=>{i[n].includes(e)||i[n].push(e)});continue}if(t.has(n)){a.split("\n").map(e=>e.trimRight()).filter(e=>""!==e.trim()).forEach(e=>{i[n].includes(e)||i[n].push(e)});continue}i[n].includes(a)||i[n].push(a)}}}static splitGpcArgs(e){let i=[],t="",n=0;for(let a of e)("["===a||"("===a)&&n++,("]"===a||")"===a)&&n--,","===a&&0===n?(i.push(t.trim()),t=""):t+=a;return t.trim()&&i.push(t.trim()),i}static buildBvarSlotName(e,i,t){let n=e.replace(/settings\[|toggle\[|\]|\[/g,"_").replace(/Enum/g,"").replace(/Profile1/g,"P1").replace(/Profile2/g,"P2").replace(/[^A-Za-z0-9]+/g,"_").replace(/^_|_$/g,"").toUpperCase(),a=`BVAR_${n||"FIELD"}_${i}`,o=2;for(;t.has(a);)a=`BVAR_${n||"FIELD"}_${i}_${o++}`;return t.add(a),a}static getBvarCoreNextSlot(e){let i=e.match(/\bdefine\s+BVAR_CORE_NEXT_SLOT\s*=\s*(\d+)\s*;/);if(!i)throw Error("Missing BVAR_CORE_NEXT_SLOT define in master script template");return Number(i[1])}static appendBvarExtensionAnchors(e){e.saveBvar.push(...e.saveBvarAppend),e.readBvar.push(...e.readBvarAppend),e.loadDefaults.push(...e.loadDefaultsAppend),e.saveBvarAppend=[],e.readBvarAppend=[],e.loadDefaultsAppend=[]}static allocateBvarSlots(e,i){let t=new Set,n=[],a=this.getBvarCoreNextSlot(i);e.saveBvar=e.saveBvar.map(i=>i.replace(/save_bvar_auto\s*\(([^;]+)\)\s*;/g,(i,o)=>{let[r,l,s]=this.splitGpcArgs(o);if(!r||!l||!s)throw Error(`Invalid save_bvar_auto call: ${o}`);let _=this.buildBvarSlotName(r,a,t);return e.bvarSlotDefines.push(`define ${_} = ${a};`),n.push({name:_,target:r,min:l,max:s}),a++,`save_bvar(${_}, ${r}, ${l}, ${s});`}));let o=0;if(e.readBvar=e.readBvar.map(e=>e.replace(/read_bvar_auto\s*\(([^)]+)\)/g,(e,i)=>{let t=n[o++];if(!t)throw Error(`read_bvar_auto has no matching save_bvar_auto: ${i}`);return`read_bvar(${t.name}, ${i.trim()})`})),o!==n.length)throw Error(`BVAR save/read mismatch: ${n.length} save fields, ${o} read fields`);let r=n.filter(e=>/^weaponProfileRecoil[VH]\[\d+\]$/.test(e.target));if(0===r.length)return;let l=[],s=[];for(let e of r)l.push(`save_bvar(${e.name}, ${e.target}, -50, 50);`),s.push(`${e.target} = read_bvar(${e.name}, -50, 50, ${e.target});`);let _=e=>`for (weaponProfileRecoilIndex = 0; weaponProfileRecoilIndex < WEAPON_PROFILE_COUNT * 2; weaponProfileRecoilIndex++) {
3123${e}
3124}`,c=[],E=[];for(let[e,i]of[["V",0],["H",1]]){let t=`${r[i].name} + weaponProfileRecoilIndex * 2`,n=`weaponProfileRecoil${e}[weaponProfileRecoilIndex]`;c.push(`    save_bvar(${t}, ${n}, -50, 50);`),E.push(`    ${n} = read_bvar(${t}, -50, 50, ${n});`)}e.saveBvar=e.saveBvar.map(e=>e.replace(l.join("\n"),_(c.join("\n")))),e.readBvar=e.readBvar.map(e=>e.replace(s.join("\n"),_(E.join("\n"))))}static replaceAnchors(e,i){i.playingScreenOverride.some(e=>e.trim())&&(e=e.replace(/(\/\/ @\[ANCHOR_PLAYING_SCREEN_OVERRIDE\])[\s\S]*?\/\/ @\[ANCHOR_PLAYING_SCREEN_DEFAULT_END\]/,"$1"));let t=e.split("\n");for(let[e,n]of Object.entries({coreModEnumPre:"ANCHOR_CORE_MOD_ENUM_PRE",coreModIdArrayPre:"ANCHOR_CORE_MOD_ID_ARRAY_PRE",coreAsciiNamePre:"ANCHOR_CORE_MOD_DISPLAY_NAME_PRE",modEnum:"ANCHOR_MOD_ENUM",modIdArray:"ANCHOR_MOD_ID_ARRAY",toggleArraySize:"ANCHOR_TOGGLE_ARRAY_SIZE",toggleEnum:"ANCHOR_TOGGLE_ENUM",init:"ANCHOR_INIT",modCount:"ANCHOR_MOD_COUNT",strings:"ANCHOR_STRINGS",runtimeDefines:"ANCHOR_RUNTIME_DEFINES",asciiName:"ANCHOR_MOD_DISPLAY_NAME",miscSettingsLabel:"ANCHOR_MISC_SETTINGS_LABEL",settingsLabel:"ANCHOR_SETTINGS_LABEL",submenuBlock:"ANCHOR_SUBMENU_BLOCK",submenuDispatcher:"ANCHOR_SUBMENU_DISPATCHER",withProfileMod:"ANCHOR_WITH_PROFILE_MOD",modScreen:"ANCHOR_MOD_SCREEN",playingScreenOverride:"ANCHOR_PLAYING_SCREEN_OVERRIDE",submenuOverride:"ANCHOR_SUBMENU_OVERRIDE",playingScreen:"ANCHOR_PLAYING_SCREEN",screenSaverScreen:"ANCHOR_SCREEN_SAVER_SCREEN",setupMenuInput:"ANCHOR_SETUP_MENU_INPUT",miscNavigation:"ANCHOR_MISC_NAVIGATION",miscRender:"ANCHOR_MISC_RENDER",miscInput:"ANCHOR_MISC_INPUT",submenuRender:"ANCHOR_RENDER_SUBMENU",priorityLogic:"ANCHOR_PRIORITY_LOGIC",mainStart:"ANCHOR_MAIN_START",mainEnd:"ANCHOR_MAIN_END",gameplayDisplayUpdate:"ANCHOR_GAMEPLAY_DISPLAY_UPDATE",offStateInput:"ANCHOR_OFF_STATE_INPUT",mainLogicBlock:"ANCHOR_MAIN_LOGIC",profileChanged:"ANCHOR_PROFILE_CHANGED",getToggleState:"ANCHOR_GET_TOGGLE_STATE",switchActiveMod:"ANCHOR_SWITCH_ACTIVE_MOD",miscMinMaxTable:"ANCHOR_MISC_MIN_MAX_TABLE",minMaxTable:"ANCHOR_MIN_MAX_TABLE",miscSettingEnum:"ANCHOR_MISC_SETTING_ENUM",settingEnum:"ANCHOR_SETTING_ENUM",bvarSlotDefines:"ANCHOR_BVAR_SLOT_DEFINES",saveBvar:"ANCHOR_SAVE_BVAR",readBvar:"ANCHOR_LOAD_BVAR",loadDefaults:"ANCHOR_LOAD_DEFAULTS",function:"ANCHOR_FUNCTIONS",combo:"ANCHOR_COMBOS"})){let a=i[e],o=`// @[${n}]`,r=`@[${n}]`;(0!==a.length||["toggleArraySize","modCount"].includes(e))&&(t=t.flatMap(i=>{if(i.includes(o)){let e=i.substring(0,i.indexOf("//"));return a.flatMap(i=>{if(!i||""===i.trim())return[];let t=i.split("\n");for(;t.length>0&&""===t[0].trim();)t.shift();for(;t.length>0&&""===t[t.length-1].trim();)t.pop();if(0===t.length)return[];let n=t.filter(e=>e.trim().length>0).reduce((e,i)=>{let t=i.search(/\S/);return t<e?t:e},1/0);return t.map(i=>{let t=n===1/0?i.trim():i.substring(n).trimRight();return""===t?"":e+t})})}if(i.includes(r)){let t=a.filter(e=>e&&""!==e.trim()),n="";return n="toggleArraySize"===e||"modCount"===e?t[0]||"0":t.join("").trim(),[i.replace(r,n)]}return[i]}))}return t.join("\n")}static resolveRuntimeModConfig(e,i){let t=i.mods[e.id];return t||{enabled:!0,settings:Object.fromEntries(e.settings.map(e=>[e.id,e.default])),activation:e.activation}}static getCoreReplacements(e,i,t=!1){let n=(0,d.Q)((0,l.S)(l.P,e)),a=n.core,o={[_.am[0]]:"0",[_.am[1]]:"1",[_.am[2]]:"2"},r={[_.ss[0]]:"0",[_.ss[1]]:"1",[_.ss[2]]:"2"},s=Object.fromEntries(_.LK.map((e,i)=>[e,String(i)])),c=!!a.antiRecoil.humanizer,E=c?`int antiRecoilHumanizerSeed = 17;
3125int antiRecoilVerticalVariance;
3126int antiRecoilHorizontalVariance;
3127int antiRecoilVerticalValue;
3128int antiRecoilHorizontalValue;`:"",R=c?`function updateAntiRecoilHumanizer() {
3129    antiRecoilHumanizerSeed = (antiRecoilHumanizerSeed * 1103515245 + 12345) ^ get_rtime();
3130    antiRecoilVerticalVariance = (abs(antiRecoilHumanizerSeed) % 31) - 15;
3131    antiRecoilHorizontalVariance = (abs(antiRecoilHumanizerSeed / 31) % 23) - 11;
3132}
3133
3134function getHumanizedAntiRecoilVertical(value) {
3135    if (value == 0) {
3136        return value;
3137    }
3138    return value + (antiRecoilVerticalVariance * abs(value) / 100);
3139}
3140
3141function getHumanizedAntiRecoilHorizontal(value) {
3142    if (value == 0) {
3143        return value;
3144    }
3145    return value + (antiRecoilHorizontalVariance * abs(value) / 100);
3146}`:"",u=c?`updateAntiRecoilHumanizer();
3147        vertAntiRecoil = getHumanizedAntiRecoilVertical(antiRecoilVerticalEffective);
3148        horizAntiRecoil = getHumanizedAntiRecoilHorizontal(antiRecoilHorizontalEffective);`:`vertAntiRecoil = antiRecoilVerticalEffective;
3149        horizAntiRecoil = antiRecoilHorizontalEffective;`,S=c?`updateAntiRecoilHumanizer();
3150    antiRecoilVerticalValue = getHumanizedAntiRecoilVertical(antiRecoilVerticalEffective);
3151    antiRecoilHorizontalValue = getHumanizedAntiRecoilHorizontal(antiRecoilHorizontalEffective);`:"",f=c?"antiRecoilVerticalValue":"antiRecoilVerticalEffective",p=c?"antiRecoilHorizontalValue":"antiRecoilHorizontalEffective",m=`get_val(PS5_RY) + ${f}`,T=`get_val(PS5_RX) + ${p}`,g=`if (abs(get_val(PS5_RY)) < abs(${f}

3151)) {`,I=`if(abs(get_val(PS5_RX)) < abs(${p})) {`,O=a.rapidFire.humanizer?"updateRfJitter();":"",P=a.system.weaponTracking,L=!!P?.holsterEnabled,N=!!(P?.utilityButtons?.length||P?.utilityWheelEnabled),h=L||N,C=[L?'const string HOLSTERED_TEXT = "HOLSTERED";':"",N?'const string UTILITY_TEXT = "UTILITY";':""].filter(Boolean).join("\n"),M=[L?"if (no_gun_state) {\n            printCentered(28, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, HOLSTERED_TEXT[0]);":"",N?`${L?"        } else if":"if"} (utility_state) {
3152            printCentered(28, OLED_FONT_SMALL, OLED_FONT_SMALL_WIDTH, OLED_WHITE, UTILITY_TEXT[0]);`:"",h?"        } else {":""].filter(Boolean).join("\n"),D={"${CORE_AR_P1_EN}":a.antiRecoil.p1.enabled?"1":"0","${CORE_AR_P1_V}":String(a.antiRecoil.p1.vertical),"${CORE_AR_P1_H}":String(a.antiRecoil.p1.horizontal),"${CORE_AR_P1_INIT_EN}":a.antiRecoil.p1.initialEnabled?"1":"0","${CORE_AR_P1_INIT_TIME}":String(a.antiRecoil.p1.initialTimeMs),"${CORE_AR_P1_INIT_V}":String(a.antiRecoil.p1.initialVertical),"${CORE_AR_P1_INIT_H}":String(a.antiRecoil.p1.initialHorizontal),"${CORE_AR_P1_RAMP_EN}":a.antiRecoil.p1.rampEnabled?"1":"0","${CORE_AR_P1_RAMP_TIME}":String(a.antiRecoil.p1.rampTimeMs),"${CORE_AR_P1_DECAY_EN}":a.antiRecoil.p1.decayEnabled?"1":"0","${CORE_AR_P1_DECAY_START}":String(a.antiRecoil.p1.decayStartMs),"${CORE_AR_P1_DECAY_TIME}":String(a.antiRecoil.p1.decayTimeMs),"${CORE_AR_P1_DECAY_FLOOR}":String(a.antiRecoil.p1.decayFloorPercent),"${CORE_AR_P1_OVERRIDE_EN}":a.antiRecoil.p1.aimOverrideEnabled?"1":"0","${CORE_AR_P1_OVERRIDE_THRESHOLD}":String(a.antiRecoil.p1.aimOverrideThreshold),"${CORE_AR_P1_OVERRIDE_STRENGTH}":String(a.antiRecoil.p1.aimOverrideStrength),"${CORE_AR_P2_EN}":a.antiRecoil.p2.enabled?"1":"0","${CORE_AR_P2_V}":String(a.antiRecoil.p2.vertical),"${CORE_AR_P2_H}":String(a.antiRecoil.p2.horizontal),"${CORE_AR_P2_INIT_EN}":a.antiRecoil.p2.initialEnabled?"1":"0","${CORE_AR_P2_INIT_TIME}":String(a.antiRecoil.p2.initialTimeMs),"${CORE_AR_P2_INIT_V}":String(a.antiRecoil.p2.initialVertical),"${CORE_AR_P2_INIT_H}":String(a.antiRecoil.p2.initialHorizontal),"${CORE_AR_P2_RAMP_EN}":a.antiRecoil.p2.rampEnabled?"1":"0","${CORE_AR_P2_RAMP_TIME}":String(a.antiRecoil.p2.rampTimeMs),"${CORE_AR_P2_DECAY_EN}":a.antiRecoil.p2.decayEnabled?"1":"0","${CORE_AR_P2_DECAY_START}":String(a.antiRecoil.p2.decayStartMs),"${CORE_AR_P2_DECAY_TIME}":String(a.antiRecoil.p2.decayTimeMs),"${CORE_AR_P2_DECAY_FLOOR}":String(a.antiRecoil.p2.decayFloorPercent),"${CORE_AR_P2_OVERRIDE_EN}":a.antiRecoil.p2.aimOverrideEnabled?"1":"0","${CORE_AR_P2_OVERRIDE_THRESHOLD}":String(a.antiRecoil.p2.aimOverrideThreshold),"${CORE_AR_P2_OVERRIDE_STRENGTH}":String(a.antiRecoil.p2.aimOverrideStrength),"// @[REPLACE:${CORE_AR_HUMANIZER_VARS}]":E,"// @[REPLACE:${CORE_AR_HUMANIZER_FUNCTIONS}]":R,"// @[REPLACE:${CORE_AR_DYNAMIC_VALUES}]":u,"// @[REPLACE:${CORE_AR_COMBO_PREP}]":S,"${CORE_AR_COMBO_VERTICAL_ASSIGN}":m,"${CORE_AR_COMBO_HORIZONTAL_ASSIGN}":T,"if (abs(get_val(PS5_RY)) < abs(antiRecoilVerticalEffective)) { // @[REPLACE:${CORE_AR_COMBO_VERTICAL_IF}

3152]":g,"if(abs(get_val(PS5_RX)) < abs(antiRecoilHorizontalEffective)) { // @[REPLACE:${CORE_AR_COMBO_HORIZONTAL_IF}]":I,"// @[REPLACE:${CORE_AR_AA_STANDARD_HUMANIZER_UPDATE}]":c?"updateAntiRecoilHumanizer();":"","return antiRecoilVerticalEffective; // @[REPLACE:${CORE_AR_AA_STANDARD_VERTICAL_RETURN}]":c?"return getHumanizedAntiRecoilVertical(antiRecoilVerticalEffective);":"return antiRecoilVerticalEffective;","return antiRecoilHorizontalEffective; // @[REPLACE:${CORE_AR_AA_STANDARD_HORIZONTAL_RETURN}]":c?"return getHumanizedAntiRecoilHorizontal(antiRecoilHorizontalEffective);":"return antiRecoilHorizontalEffective;","// @[REPLACE:${CORE_RF_HUMANIZER_UPDATE}]":O,"// @[REPLACE:${CORE_HOLSTERED_TEXT}]":C,"// @[REPLACE:${CORE_HOLSTERED_PLAYING_SCREEN}]":M,"// @[REPLACE:${CORE_HOLSTERED_PLAYING_SCREEN_END}]":h?"        }":"","// @[REPLACE:${CORE_HOLSTERED_SCREEN_SAVER_SCREEN}]":M,"// @[REPLACE:${CORE_HOLSTERED_SCREEN_SAVER_SCREEN_END}]":h?"        }":"","// @[REPLACE:${CORE_WEAPON_TRACKING_FUNCTION}]":"","${CORE_AA_EN}":a.aimAssist.enabled?"1":"0","${CORE_AA_P1_SHP}":s[a.aimAssist.rightShape]||"0","${CORE_AA_P2_SHP}":s[a.aimAssist.rightShape]||"0","${CORE_RF_P1_EN}":a.rapidFire.p1.enabled?"1":"0","${CORE_RF_P1_SPD}":String(a.rapidFire.p1.shotsPerSecond),"${CORE_RF_P1_HLD}":String(a.rapidFire.p1.holdTime),"${CORE_RF_P2_EN}":a.rapidFire.p2.enabled?"1":"0","${CORE_RF_P2_SPD}":String(a.rapidFire.p2.shotsPerSecond),"${CORE_RF_P2_HLD}":String(a.rapidFire.p2.holdTime),"${CORE_RF_ACT}":r[a.rapidFire.activation]||"0","${CORE_RF_WEAPON_GATE}":a.system.weaponProfiles.enabled?" && weaponProfileRapidFire[profileId]":"","${CORE_AA_ADS_L_SP}":String(a.aimAssist.adsLeftSpeed),"${CORE_AA_L_SHP}":s[a.aimAssist.leftShape]||"0","${CORE_AA_ADS_R_SP}":String(a.aimAssist.adsRightSpeed),"${CORE_AA_ADS_L_SZ}":String(a.aimAssist.adsLeftSize),"${CORE_AA_ADS_R_SZ}":String(a.aimAssist.adsRightSize),"${CORE_AR_MODE}":a.antiRecoil.mode?"1":"0","${CORE_AA_L_SZ}":String(a.aimAssist.leftSize),"${CORE_AA_L_SP}":String(a.aimAssist.leftSpeed),"${CORE_AA_R_SZ}":String(a.aimAssist.rightSize),"${CORE_AA_R_SP}":String(a.aimAssist.rightSpeed),"${CORE_AA_BOOST}":String(a.aimAssist.boostStrength),"${CORE_AA_FOCUS}":a.aimAssist.activeOnAds?"1":"0","${CORE_NO_RUM}":a.system.noRumble?"1":"0","${CORE_AA_ACT_MIN}":String(a.aimAssist.activationRangeMin),"${CORE_AA_ACT_MAX}":String(a.aimAssist.activationRangeMax),"${CORE_AA_SMOOTH}":String(a.aimAssist.smoothingFactor),"${CORE_AA_LOCK}":String(a.aimAssist.aimLockStrength),"${CORE_INV}":a.system.inverted?"-1":"1","${CORE_AR_ACT}":o[a.antiRecoil.activation]||"0","${CORE_PM_MOD_BTN}":a.system.passiveMode.activateModifier,"${CORE_PM_ACT_BTN}":a.system.passiveMode.activateButton,"${CORE_PM_DEACT_BTN}":a.system.passiveMode.deactivateButton},v=a.system.weaponTracking,b="";if(v){let e="",t=!!(v.utilityWheelEnabled&&v.utilityWheelButton),a=v.utilityWheelButton||"PS5_L1",o=(v.utilityButtons||[]).filter(e=>!(t&&e===a));if(o.length>0){let i=o.map(e=>`event_press(${e})`).join(" || ");e=`if (${i}) {
3153        utility_state = TRUE;
3154        no_gun_state = FALSE;
3155        resetDisplay();
3156    }
3157    `}if(t){let i=this.clampInt(Number(v.utilityWheelHoldTime??250),100,1e3),t=this.UTILITY_WHEEL_SELECTION_BUTTONS.filter(e=>e!==a).map(e=>`event_press(${e})`).join(" || "),n=(v.utilityButtons||[]).includes(a)?`
3158        if (!utility_wheel_was_held) {
3159            utility_state = TRUE;
3160            no_gun_state = FALSE;
3161            resetDisplay();
3162        }`:"",o="fire"===v.returnMechanic?`
3163        if (${a} == FIRE_BTN || ${a} == ADS_BTN) {
3164            utility_wheel_ignore_return = TRUE;
3165        }`:`
3166        if (${a} == SWITCHWEAPON_BTN) {
3167            utility_wheel_ignore_return = TRUE;
3168        }`,r="fire"===v.returnMechanic?`
3169        if (get_val(FIRE_BTN) || get_val(ADS_BTN)) {
3170            utility_wheel_ignore_return = TRUE;
3171        }`:`
3172        if (event_press(SWITCHWEAPON_BTN)) {
3173            utility_wheel_ignore_return = TRUE;
3174        }`;e+=`if (event_press(${a})) {
3175        utility_wheel_was_held = FALSE;${o}
3176    }
3177    if (get_val(${a}) && get_ptime(${a}) >= ${i}) {
3178        utility_wheel_was_held = TRUE;
3179    }
3180    if (utility_wheel_was_held && get_val(${a}) && (${t})) {
3181        utility_state = TRUE;
3182        no_gun_state = FALSE;
3183        resetDisplay();${r}
3184    }
3185    if (event_release(${a})) {${n}
3186        utility_wheel_was_held = FALSE;
3187    }
3188    `}let r=(0,A.ck)(n,i);if(b=e,v.holsterEnabled){let e=this.clampInt(Number(v.holsterTime??250),100,1e3),i=v.resetProfileOnHolster?`
3189        resetToProfile1();`:"",n="reset"===v.returnProfile?`
3190            resetToProfile1();`:"",a=["!get_val(PS5_SHARE)"];r&&a.push("!gamepadShortcutSuppressWeaponSwitch"),t&&"swap"===v.returnMechanic&&a.push("!utility_wheel_ignore_return"),b+=`if (get_ival(SWITCHWEAPON_BTN

3190) && !weapon_switch_is_down) {
3191        weapon_switch_is_down = TRUE;
3192        weapon_switch_press_active = FALSE;
3193        weapon_switch_started_without_gun = FALSE;
3194        weapon_switch_long_hold = FALSE;
3195        if (${a.join(" && ")}) {
3196            weapon_switch_press_active = TRUE;
3197            weapon_switch_started_without_gun = utility_state || no_gun_state;
3198            if (weapon_switch_started_without_gun) {
3199                utility_state = FALSE;
3200                no_gun_state = FALSE;
3201                resetDisplay();${n}
3202            }
3203        }
3204    }
3205    if (weapon_switch_is_down && weapon_switch_press_active && !weapon_switch_long_hold
3206        && get_ival(SWITCHWEAPON_BTN) && get_ptime(SWITCHWEAPON_BTN) >= ${e}) {
3207        weapon_switch_long_hold = TRUE;
3208        no_gun_state = TRUE;
3209        utility_state = FALSE;
3210        resetDisplay();${i}
3211    }
3212    `}if(r&&(b+=`if (gamepadShortcutSuppressWeaponSwitch && event_release(SWITCHWEAPON_BTN)) {
3213        gamepadShortcutSuppressWeaponSwitch = FALSE;
3214        ${t?"utility_wheel_ignore_return = FALSE;":""}
3215    } else `),t&&"swap"===v.returnMechanic&&(b+=`if (utility_wheel_ignore_return && event_release(SWITCHWEAPON_BTN)) {
3216        utility_wheel_ignore_return = FALSE;
3217    } else `),b+="if (!get_val(PS5_SHARE) && event_release(SWITCHWEAPON_BTN)) {",v.holsterEnabled)b+=`
3218        if (weapon_switch_press_active && !weapon_switch_long_hold && !weapon_switch_started_without_gun) {
3219            switchProfile();
3220        }`;else{let e="reset"===v.returnProfile?`
3221                resetToProfile1();`:"";b+=`
3222            if (utility_state || no_gun_state) {
3223                utility_state = FALSE;
3224                no_gun_state = FALSE;
3225                resetDisplay();${e}
3226            } else {
3227                switchProfile();
3228            }`}if(b+=`
3229    }`,v.holsterEnabled){let e=[r?"        gamepadShortcutSuppressWeaponSwitch = FALSE;":"",t&&"swap"===v.returnMechanic?"        utility_wheel_ignore_return = FALSE;":""].filter(Boolean).join("\n");b+=`
3230    if (!get_ival(SWITCHWEAPON_BTN)) {${e?`
3231${e}`:""}
3232        if (weapon_switch_is_down) {
3233            weapon_switch_is_down = FALSE;
3234            weapon_switch_press_active = FALSE;
3235            weapon_switch_started_without_gun = FALSE;
3236            weapon_switch_long_hold = FALSE;
3237        }
3238    }`}if("fire"===v.returnMechanic){let e="reset"===v.returnProfile?`
3239            resetToProfile1();`:"",i=t?`if (utility_wheel_ignore_return && !(get_ival(FIRE_BTN) || get_ival(ADS_BTN))) {
3240        utility_wheel_ignore_return = FALSE;
3241    }
3242    if (!utility_wheel_ignore_return && (get_ival(FIRE_BTN) || get_ival(ADS_BTN))) {`:"if (get_ival(FIRE_BTN) || get_ival(ADS_BTN)) {";b+=`
3243    ${i}
3244        if (utility_state || no_gun_state) {
3245            utility_state = FALSE;
3246            no_gun_state = FALSE;
3247            resetDisplay();${e}
3248        }
3249    }`}}else b=(0,A.ck)(n,i)?`if (gamepadShortcutSuppressWeaponSwitch && event_release(SWITCHWEAPON_BTN)) {
3250        gamepadShortcutSuppressWeaponSwitch = FALSE;
3251    } else if (!get_val(PS5_SHARE) && event_release(SWITCHWEAPON_BTN)) {
3252        switchProfile();
3253    }`:`if (!get_val(PS5_SHARE) && event_release(SWITCHWEAPON_BTN)) {
3254        switchProfile();
3255    }`;t&&(b="observeWeaponTrackingInput();\n    "+b.replaceAll("switchProfile();","weaponTraceFlags = weaponTraceFlags | 4;\n            switchProfile();").replaceAll("weapon_switch_press_active = TRUE;","weapon_switch_press_active = TRUE;\n            weaponTraceFlags = weaponTraceFlags | 256;").replaceAll("weapon_switch_long_hold = TRUE;","weapon_switch_long_hold = TRUE;\n        weaponTraceFlags = weaponTraceFlags | 8;").replaceAll("if (weapon_switch_started_without_gun) {","if (weapon_switch_started_without_gun) {\n                weaponTraceFlags = weaponTraceFlags | 16;").replaceAll("if (utility_state || no_gun_state) {","if (utility_state || no_gun_state) {\n                weaponTraceFlags = weaponTraceFlags | 16;"));let w=v?.holsterEnabled?`int weapon_switch_is_down = FALSE;
3256int weapon_switch_press_active = FALSE;
3257int weapon_switch_started_without_gun = FALSE;
3258int weapon_switch_long_hold = FALSE;
3259
3260`:"";return D["${CORE_WEAPON_TRACKING_LOGIC}"]="handleWeaponTrackingInput();",v?.turboKnifeEnabled===!0&&!0===v.holsterEnabled&&(D["${CORE_WEAPON_TRACKING_LOGIC}"]+="\n    if (currentState == STATE_CLEAN_SCREEN) {\n        handleTurboKnife();\n    }"),D["// @[REPLACE:${CORE_WEAPON_TRACKING_FUNCTION}]"]=`${w}function handleWeaponTrackingInput() {
3261    ${b}
3262}`,D}static buildIntroTitle(e){return(Array.from((e||"").normalize("NFKD")).map(e=>this.INTRO_CHAR_MAP[e]??e).join("").replace(/[\u0300-\u036f]/g,"").replace(/[^A-Za-z0-9 .+#&()

3262/_-]/g," ").replace(/\s+/g," ").trim()||this.DEFAULT_INTRO_TITLE).slice(0,this.INTRO_MAX_CHARS).trim().replace(/[ .+#&()/_-]+$/g,"").trim()||this.DEFAULT_INTRO_TITLE}static toUint8ArrayLiteral(e){let i=Array.from(e).map(e=>e.charCodeAt(0));return`{ ${i.join(", ")}, 0 }`}static buildOledScriptVersion(e){let i=this.toHeaderText(e||"1.0.0","1.0.0").replace(/^v/i,"").match(/[A-Za-z0-9._-]+/),t=(i?.[0]||"1.0.0").slice(0,7).trim();return`v${t||"1.0.0"}`.slice(0,8)}static toOledModNameLiteral(e){let i=Array.from(e.toUpperCase().slice(0,15)).map(e=>e.charCodeAt(0));for(i.push(0);i.length<16;)i.push(0);return`{ ${i.join(", ")} }`}static substituteValues(e,i,t,a,o,r,l){let s=r.miscNavigation.length>0?r.miscNavigation[r.miscNavigation.length-1]:"buttonLayoutEnum",_={__CONTROLLER_MENU_HINT__:JSON.stringify("xbox"===l.controllerLabels?"LT+MENU":"L2+OPTIONS"),__CONTROLLER_OFF_HINT__:JSON.stringify("xbox"===l.controllerLabels?"LT+VIEW ON":"L2+SHARE ON"),__CONTROLLER_BUTTON_LABELS__:"{\n    "+(0,n.Kb)(l.controllerLabels).map(e=>JSON.stringify(e)).join(",\n    ")+"\n}",__TOGGLE_ARRAY_SIZE__:a.toString(),__MOD_COUNT__:o.toString(),__INTRO_NAME_BYTES__:this.toUint8ArrayLiteral(this.buildIntroTitle(l.scriptTitle)),__SCRIPT_VERSION_BYTES__:this.toUint8ArrayLiteral(this.buildOledScriptVersion(l.scriptVersion)),__LAST_MISC_ENUM__:s,...this.getCoreReplacements(i,t,l.weaponTrackingDiagnostics)},c=RegExp(Object.keys(_).map(e=>e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")).join("|"),"g"),E=e.replace(c,e=>_[e]??e);return(E=(E=E.replace(/settings\[buttonLayoutEnum\] = read_bvar\(BVAR_BUTTONLAYOUT, 0, 21, \d+\);/,`settings[buttonLayoutEnum] = read_bvar(BVAR_BUTTONLAYOUT, 0, 21, ${i.buttonLayout});`)).replace(/settings\[buttonLayoutEnum\] = 0;/,`settings[buttonLayoutEnum] = ${i.buttonLayout};`)).replace(/\s*\/\/\s*\$\{(?:TOGGLE_ARRAY_SIZE|MOD_COUNT|LAST_MISC_ENUM|LAST_MISC_ENUM_2)\}/g,"")}}var f=t(95168);let p={used:0,total:1024,percentage:0,fields:0,reserved:9,endSlot:9,nextFreeSlot:10},m=e=>e.split("\n").map(e=>e.split("//")[0]).join("\n"),T=(e,i)=>{try{var t;let n,a,o,r,l,s,_=(t=S.generate(e,(0,f.hs)(e,i)),n=(e=>{let i=new Map;for(let t of m(e).matchAll(/define\s+(BVAR_[A-Za-z0-9_]+)\s*=\s*(\d+)\s*;/g))i.set(t[1],Number(t[2]));return i})(t),a=m(t),o=Number(a.match(/define\s+WEAPON_PROFILE_COUNT\s*=\s*(\d+)\s*;/)?.[1]??0),r=new Map([...n].map(([e,i])=>[i,e])),s=(l=[...a.matchAll(/\bsave_bvar\s*\(\s*(BVAR_[^,]+,[^;]+)\);/g)].flatMap(e=>{let[i,t,a,l]=(e=>{let i=[],t="",n=0;for(let a of e)("["===a||"("===a)&&n++,("]"===a||")"===a)&&n--,","===a&&0===n?(i.push(t.trim()),t=""):t+=a;return t.trim()&&i.push(t.trim()),i})(e[1]),s=i.match(/^(BVAR_[A-Za-z0-9_]+) \+ weaponProfileRecoilIndex \* 2$/),_=s?s[1]:i,c=n.get(_);if(!c)throw Error(`Missing BVAR slot define for ${_}`);if(s&&(!o||!/^weaponProfileRecoil[VH]\[weaponProfileRecoilIndex\]$/.test(t)))throw Error(`Invalid weapon recoil BVAR range: ${i}`);return Array.from({length:s?2*o:1},(e,i)=>{let n=c+(s?2*i:0),o=r.get(n);if(!o)throw Error(`Missing BVAR slot define for slot ${n}`);return{slot:n,slotName:o,field:s?t.replace("[weaponProfileRecoilIndex]",`[${i}]`):t,min:a,max:l}})}).sort((e,i)=>e.slot-i.slot).map((e,i)=>({...e,index:i+1}))).reduce((e,i)=>Math.max(e,i.slot),9),{rows:l,usedSlots:9+l.length,reservedSlots:9,endSlot:s,nextFreeSlot:s+1});return{used:_.usedSlots,total:1024,percentage:Math.min(Math.round(_.usedSlots/1024*100),100),fields:_.rows.length,reserved:_.reservedSlots,endSlot:_.endSlot,nextFreeSlot:_.nextFreeSlot}}catch(e){return console.error("Failed to calculate BVAR usage:",e),p}}},76592:(e,i,t)=>{t.d(i,{BZ:()=>o,jx:()=>s,ly:()=>l});var n=t(36459),a=t(90012);let o=["FIRE_BTN","MELEE_BTN",...Object.keys(a.kL).filter(e=>"PS5_SHARE"!==e&&"PS5_OPTIONS"!==e)];function r(e,i){let t=a.tk[i]||a.tk[0],n=a.G.indexOf(e);return -1===n?e:t[n]}function l(e,i="playstation"){let t=(0,n._g)(i),a=r("FIRE_BTN",e),o=r("MELEE_BTN",e);return{...t,FIRE_BTN:`Fire (${t[a]})`,MELEE_BTN:`Melee (${t[o]})`}}function s(e,i,t="playstation"){if(e?.turboKnifeEnabled!==!0||!0!==e.holsterEnabled)return null;if(!o.includes(e.turboKnifeButton))return"Choose a supported knife attack button.";let a=r(e.turboKnifeButton,i),l=(0,n._g)(t)[a];return a===r("SWITCHWEAPON_BTN",i)?`${l} returns to your gun. Choose a different knife attack button.`:"fire"===e.returnMechanic&&(a===r("FIRE_BTN",i)||a===r("ADS_BTN",i))?`${l} returns to your gun when Return to gun action is Fire button. Choose a different knife attack button or use Swap button to return.`:(e.utilityButtons||[]).some(e=>r(e,i)===a)?`${l} is selected in Utility items, which exits holster. Remove it from Utility items or choose a different knife attack button.`:e.utilityWheelEnabled&&r(e.utilityWheelButton,i)===a?`${l} opens the Utility wheel. Choose a different wheel button or knife attack button.`:null}}}]);