nukedbart/EFTCheatPVE
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
EFTCheatPVE/stoopid.raw/Menu2.cs

6283 lines
156 KiB
C#
Raw Blame History

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Threading.Tasks;
using Comfort.Common;
using EFT;
using EFT.Bots;
using EFT.Counters;
using EFT.Interactive;
using EFT.InventoryLogic;
using EFT.UI;
using EFT.Weather;
using Newtonsoft.Json;
using stupid.solutions;
using stupid.solutions.Data;
using stupid.solutions.Features;
using stupid.solutions.stupid.solutions.enums;
using stupid.solutions.Utils;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
public class Menu2 : MonoBehaviour
{
private enum SaveType
{
File,
List
}
private enum KeybindType
{
ClearCache,
Skill,
Aimbot,
UnlockDoors,
teleportitem,
killall,
tpall,
instaheal,
speedhack,
flyhack
}
public class SlotData
{
public string SlotName { get; set; }
public string ContainedItemId { get; set; }
public string ContainedItemName { get; set; }
public string ContainedItemShortName { get; set; }
}
public class BackpackItemData
{
public string ItemId { get; set; }
public string ItemName { get; set; }
public string ItemShortName { get; set; }
public List<SlotData> Slots { get; set; } = new List<SlotData>();
}
public enum ColorCategory
{
ItemESP,
ESP,
Aimbot,
Chams
}
[StructLayout(LayoutKind.Auto)]
[CompilerGenerated]
private struct _003CSpawnSelectedPreset_003Ed__388 : IAsyncStateMachine
{
private static class _003C_003Eo__388
{
public static CallSite<Func<CallSite, object, object>> _003C_003Ep__0;
public static CallSite<Func<CallSite, object, object>> _003C_003Ep__1;
public static CallSite<Func<CallSite, object, bool>> _003C_003Ep__2;
public static CallSite<Action<CallSite, object>> _003C_003Ep__3;
}
public int _003C_003E1__state;
public AsyncTaskMethodBuilder _003C_003Et__builder;
public Menu2 _003C_003E4__this;
private Dictionary<string, stupid.solutions.SlotData> _003CslotsDictionary_003E5__2;
private ItemFactory _003CitemFactory_003E5__3;
private object _003Citem_003E5__4;
private IEnumerator _003C_003E7__wrap4;
private TaskAwaiter _003C_003Eu__1;
private object _003C_003Eu__2;
private void MoveNext()
{
int num = _003C_003E1__state;
Menu2 CS_0024_003C_003E8__locals6 = _003C_003E4__this;
try
{
if (num == 0)
{
goto IL_033e;
}
dynamic val;
if (num == 1)
{
val = _003C_003Eu__2;
_003C_003Eu__2 = null;
num = (_003C_003E1__state = -1);
goto IL_0726;
}
if (string.IsNullOrEmpty(CS_0024_003C_003E8__locals6.selectedPresetName) || CS_0024_003C_003E8__locals6.pullItemPresets == null || CS_0024_003C_003E8__locals6.pullItemPresets.templateList == null)
{
ConsoleScreen.Log("No preset selected or presets list is empty.");
}
else
{
TemplateData templateData = CS_0024_003C_003E8__locals6.pullItemPresets.templateList.FirstOrDefault((TemplateData template) => template.PresetName == CS_0024_003C_003E8__locals6.selectedPresetName);
if (templateData == null)
{
ConsoleScreen.Log("Selected preset not found in the list.");
}
else
{
ConsoleScreen.Log("Spawning preset: " + templateData.PresetName);
KeyValuePair<string, stupid.solutions.ItemTemplate> keyValuePair = templateData.ItemTemplate.FirstOrDefault();
if (keyValuePair.Value == null)
{
ConsoleScreen.Log("No item template found for the selected preset.");
}
else
{
string key = keyValuePair.Key;
_003CslotsDictionary_003E5__2 = keyValuePair.Value.Slots;
_003CitemFactory_003E5__3 = new ItemFactory();
_003Citem_003E5__4 = _003CitemFactory_003E5__3.CreateItem(key);
if (!(((dynamic)_003Citem_003E5__4 == null) ? true : false))
{
((dynamic)_003Citem_003E5__4).SpawnedInSession = true;
dynamic val2 = ((dynamic)_003Citem_003E5__4).AllSlots;
if (val2 != null)
{
_003C_003E7__wrap4 = ((IEnumerable)val2).GetEnumerator();
goto IL_033e;
}
ConsoleScreen.Log("No slots found for the main item.");
goto IL_0587;
}
ConsoleScreen.Log("Failed to create the main item from the template.");
}
}
}
goto end_IL_000e;
IL_0587:
val = CS_0024_003C_003E8__locals6.AddItemToBackpack((dynamic)_003Citem_003E5__4).GetAwaiter();
if (!(bool)val.IsCompleted)
{
num = (_003C_003E1__state = 1);
_003C_003Eu__2 = val;
ICriticalNotifyCompletion awaiter = val as ICriticalNotifyCompletion;
if (awaiter == null)
{
INotifyCompletion awaiter2 = (INotifyCompletion)(object)val;
_003C_003Et__builder.AwaitOnCompleted(ref awaiter2, ref this);
awaiter2 = null;
}
else
{
_003C_003Et__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
}
awaiter = null;
return;
}
goto IL_0726;
IL_0726:
val.GetResult();
goto end_IL_000e;
IL_033e:
try
{
if (num != 0)
{
goto IL_0545;
}
TaskAwaiter awaiter3 = _003C_003Eu__1;
_003C_003Eu__1 = default(TaskAwaiter);
num = (_003C_003E1__state = -1);
goto IL_053e;
IL_053e:
awaiter3.GetResult();
goto IL_0545;
IL_0545:
if (_003C_003E7__wrap4.MoveNext())
{
dynamic current = _003C_003E7__wrap4.Current;
string text = current.FullId;
if (_003CslotsDictionary_003E5__2.TryGetValue(text, out var value))
{
string itemId = value.ItemId;
Item item = _003CitemFactory_003E5__3.CreateItem(itemId);
item.SpawnedInSession = true;
if (item != null)
{
try
{
current.AddWithoutRestrictions(item);
ConsoleScreen.Log("Added component item " + itemId + " to slot '" + text + "'.");
}
catch (Exception ex)
{
ConsoleScreen.Log("Error adding component to slot '" + text + "': " + ex.Message);
}
}
else
{
ConsoleScreen.Log("Failed to create component item with ID " + itemId + ".");
}
}
awaiter3 = Task.Delay(10).GetAwaiter();
if (!awaiter3.IsCompleted)
{
num = (_003C_003E1__state = 0);
_003C_003Eu__1 = awaiter3;
_003C_003Et__builder.AwaitUnsafeOnCompleted(ref awaiter3, ref this);
return;
}
goto IL_053e;
}
}
finally
{
if (num < 0 && _003C_003E7__wrap4 is IDisposable disposable)
{
disposable.Dispose();
}
}
_003C_003E7__wrap4 = null;
goto IL_0587;
end_IL_000e:;
}
catch (Exception exception)
{
_003C_003E1__state = -2;
_003CslotsDictionary_003E5__2 = null;
_003CitemFactory_003E5__3 = null;
_003Citem_003E5__4 = null;
_003C_003Et__builder.SetException(exception);
return;
}
_003C_003E1__state = -2;
_003CslotsDictionary_003E5__2 = null;
_003CitemFactory_003E5__3 = null;
_003Citem_003E5__4 = null;
_003C_003Et__builder.SetResult();
}
void IAsyncStateMachine.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
this.MoveNext();
}
[DebuggerHidden]
private void SetStateMachine(IAsyncStateMachine stateMachine)
{
_003C_003Et__builder.SetStateMachine(stateMachine);
}
void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine stateMachine)
{
//ILSpy generated this explicit interface implementation from .override directive in SetStateMachine
this.SetStateMachine(stateMachine);
}
}
private QuestModule questModule;
private AILister aILister;
[SerializeField]
public GameObject menu;
[SerializeField]
public GameObject menuBar;
[SerializeField]
public GameObject watermark;
[SerializeField]
public GameObject watermarkmagicbullet;
[SerializeField]
public GameObject aimbotPanel;
[SerializeField]
public GameObject playerESPPanel;
[SerializeField]
public GameObject itemESPPanel;
[SerializeField]
public GameObject miscOptionsPanel;
[SerializeField]
public GameObject settingsPanel;
[SerializeField]
public GameObject itemspawnpanel;
[SerializeField]
public GameObject aispawnpanel;
[SerializeField]
public Button aimbotButton;
[SerializeField]
public Button playerESPButton;
[SerializeField]
public Button itemESPButton;
[SerializeField]
public Button miscOptionsButton;
[SerializeField]
public Button settingsButton;
[SerializeField]
public Toggle aimbotToggle;
[SerializeField]
public TMP_Text aimbotSmoothLabel;
[SerializeField]
public Slider aimbotSmoothSlider;
[SerializeField]
public Toggle aimbotDrawFOVToggle;
[SerializeField]
public TMP_Text aimbotFOVLabel;
[SerializeField]
public Slider aimbotFOVSlider;
[SerializeField]
public Toggle noRecoilToggle;
[SerializeField]
public Toggle crosshairToggle;
[SerializeField]
public Toggle silentAimToggle;
[SerializeField]
public Toggle silentTargetLinesToggle;
[SerializeField]
public Toggle instahitToggle;
[SerializeField]
public Toggle ammodrawToggle;
[SerializeField]
public TMP_Dropdown aimboneDropdown;
[SerializeField]
public Toggle CheckVisibletoggle;
[SerializeField]
public Toggle MagicBulletToggle;
[SerializeField]
public Toggle infiniteammo;
[SerializeField]
public Toggle tracers;
[SerializeField]
public Toggle hitmarkers;
[SerializeField]
public Toggle drawPlayersToggle;
[SerializeField]
public Toggle drawPlayerBoxToggle;
[SerializeField]
public Toggle drawPlayerNameToggle;
[SerializeField]
public Toggle drawPlayerLineToggle;
[SerializeField]
public Toggle drawPlayerHealthToggle;
[SerializeField]
public Toggle drawWeaponToggle;
[SerializeField]
public Toggle enableSkeletonToggle;
[SerializeField]
public Toggle ChamsToggle;
[SerializeField]
public Toggle drawRadarToggle;
[SerializeField]
public Slider drawPlayersDistanceSlider;
[SerializeField]
public TMP_Text drawplayerdistancelabel;
[SerializeField]
public Toggle drawaimpostoggle;
[SerializeField]
public Slider radardistanceslider;
[SerializeField]
public TMP_Text radardistancelabel;
[SerializeField]
public Toggle fullbright;
[SerializeField]
public Toggle grenadeesp;
[SerializeField]
public Toggle drawLootItemsToggle;
[SerializeField]
public Slider drawLootItemsDistanceSlider;
[SerializeField]
public TMP_Text drawlootitemsdistancelabel;
[SerializeField]
public Toggle superRareItemsToggle;
[SerializeField]
public Toggle kappaItemsToggle;
[SerializeField]
public Toggle questItemsToggle;
[SerializeField]
public Toggle commonItemsToggle;
[SerializeField]
public Slider commonItemsDistanceSlider;
[SerializeField]
public TMP_Text commonItemsdistancelabel;
[SerializeField]
public Toggle drawLootableContainersToggle;
[SerializeField]
public Slider drawLootableContainersDistanceSlider;
[SerializeField]
public TMP_Text drawcontainerdistancelabel;
[SerializeField]
public Toggle bodyESPToggle;
[SerializeField]
public Toggle playerInventoryESPToggle;
[SerializeField]
public Toggle searchItemToggle;
[SerializeField]
public TMP_InputField searchItemInputField;
[SerializeField]
public Toggle teleportItemsToggle;
[SerializeField]
public Toggle drawExfiltrationPointsToggle;
[SerializeField]
public Toggle flyhackToggle;
[SerializeField]
public Toggle speedhackToggle;
[SerializeField]
public Slider speedSlider;
[SerializeField]
public Toggle maincamfovchanger;
[SerializeField]
public Slider maincamfov;
[SerializeField]
public Toggle infStaminaToggle;
[SerializeField]
public Toggle instaHealToggle;
[SerializeField]
public Toggle thermalVisionToggle;
[SerializeField]
public Toggle godmodeToggle;
[SerializeField]
public Toggle instaSearchToggle;
[SerializeField]
public Toggle noVisorToggle;
[SerializeField]
public Toggle flaresToggle;
[SerializeField]
public Toggle noJamToggle;
[SerializeField]
public Toggle fireRateToggle;
[SerializeField]
public Toggle farreachtoggle;
[SerializeField]
public Toggle invisibletoggle;
[SerializeField]
public Toggle showitemspawnmenu;
[SerializeField]
public Toggle weaponchams;
[SerializeField]
public Button spawnitembutton;
[SerializeField]
public Button spawnbossbutton;
[SerializeField]
public Button addxpsessionbutton;
[SerializeField]
public Button completequestbutton;
[SerializeField]
public Slider xpslider;
[SerializeField]
public TMP_Text xpsliderlabel;
[SerializeField]
public Toggle tppmc;
[SerializeField]
public Toggle tpboss;
[SerializeField]
public Toggle alwayssurvived;
public static string publicSearchString = "Grenade";
public static string itemidstring = "";
public static string spawnid = "";
[SerializeField]
public Button clearCacheKeyButton;
[SerializeField]
public TMP_Text clearCacheKeyLabel;
[SerializeField]
public Button skillKeyButton;
[SerializeField]
public TMP_Text skillKeyLabel;
[SerializeField]
public Button aimbotKeyButton;
[SerializeField]
public TMP_Text aimbotKeyLabel;
[SerializeField]
public Button unlockDoorsKeyButton;
[SerializeField]
public TMP_Text unlockDoorsKeyLabel;
[SerializeField]
public Button teleportitembutton;
[SerializeField]
public TMP_Text teleportitemlabel;
[SerializeField]
public Button killallbutton;
[SerializeField]
public TMP_Text killalllabel;
[SerializeField]
public Button tpallkeybutton;
[SerializeField]
public TMP_Text tpallkeylabel;
[SerializeField]
public Button instahealkeybutton;
[SerializeField]
public TMP_Text instahealkeylabel;
[SerializeField]
private GameObject itembuttontemplate;
[SerializeField]
private Transform buttonContainer;
[SerializeField]
private TMP_InputField searchInputField;
[SerializeField]
private ScrollRect scrollRect;
[SerializeField]
public TMP_Text iteminfotext;
[SerializeField]
public Toggle sicc;
[SerializeField]
public Toggle thicc;
[SerializeField]
public Toggle ammobox;
[SerializeField]
public Toggle fillraidbp;
[SerializeField]
public Toggle bypassrestrictions;
[SerializeField]
private Transform traderbuttonContainer;
[SerializeField]
private ScrollRect traderscrollRect;
[SerializeField]
private Slider traderreputationSlider;
[SerializeField]
private Button applyTraderrepButton;
[SerializeField]
public GameObject traderreppanel;
[SerializeField]
public TMP_Text traderinfotext;
[SerializeField]
public TMP_Text traderreptoaddvalue;
[SerializeField]
private Transform skillButtonContainer;
[SerializeField]
private ScrollRect skillScrollRect;
[SerializeField]
private TMP_Text skillInfoText;
[SerializeField]
private TMP_Text skillLevelToAddText;
[SerializeField]
private Slider skillLevelSlider;
[SerializeField]
private Button applySkillButton;
[SerializeField]
public GameObject skillspanel;
[SerializeField]
private Transform presetButtonContainer;
[SerializeField]
private ScrollRect presetScrollRect;
[SerializeField]
private TMP_Text presetInfoText;
[SerializeField]
private Button spawnpresetitembutton;
[SerializeField]
private GameObject presetsPanel;
[SerializeField]
private TMP_InputField searchInputFieldTemplates;
[SerializeField]
public GameObject updatepanel;
[SerializeField]
private Button closeupdatebutton;
[SerializeField]
private TMP_Text updateinfo;
[SerializeField]
public Toggle stimsItemsToggle;
[SerializeField]
public TMP_InputField TPItemInputField;
[SerializeField]
public Toggle superrareTPToggle;
[SerializeField]
public Toggle KappaTPToggle;
[SerializeField]
public Toggle QuestTPToggle;
[SerializeField]
public Toggle StimsTPToggle;
[SerializeField]
public Toggle SearchTPToggle;
[SerializeField]
private Button saveprimaryweapon;
[SerializeField]
private Button loadfromfilebutton;
[SerializeField]
public Toggle autofillslots;
[SerializeField]
public GameObject aiButtonTemplate;
[SerializeField]
public Transform aiButtonContainer;
[SerializeField]
public TMP_Text aiInfoText;
[SerializeField]
public TMP_InputField aiSearchBar;
[SerializeField]
public ScrollRect aiScrollRect;
[SerializeField]
public GameObject helppanel;
[SerializeField]
private Button closehelpbutton;
[SerializeField]
private Button openhelpbutton;
[SerializeField]
public Toggle QuestESP;
[SerializeField]
public Toggle QuestDescription;
[SerializeField]
public Toggle SimplifiedStrings;
[SerializeField]
public Toggle DrawOutline;
[SerializeField]
public Toggle DrawTripWires;
[SerializeField]
public Toggle Artillery;
[SerializeField]
public Slider SkeletonUpdateSlider;
[SerializeField]
public Slider FONTSIZE;
[SerializeField]
public TMP_Text FONTSIZETXT;
[SerializeField]
public TMP_Text SkeletonUpdateSliderText;
[SerializeField]
public Toggle DrawWatermark;
[SerializeField]
public Toggle DurabilityExploit;
[SerializeField]
public Toggle DrawHideoutItems;
[SerializeField]
public Toggle DrawWishlistItems;
[SerializeField]
public Toggle DrawItemValue;
[SerializeField]
public Toggle filtersuperrare;
[SerializeField]
public Toggle filterkappa;
[SerializeField]
public Toggle filterquest;
[SerializeField]
public Toggle filterwishlist;
[SerializeField]
public Toggle filterstim;
[SerializeField]
public Toggle filterhideout;
[SerializeField]
public Toggle filtervalue;
[SerializeField]
public Slider filtervalueslider;
[SerializeField]
public TMP_Text filtervalueslidertext;
[SerializeField]
public Button addtowishlist;
[SerializeField]
public Button Refresh;
[SerializeField]
private GameObject MainColorSettingsMenu;
[SerializeField]
private GameObject colorButtonTemplate;
[SerializeField]
private Transform colorButtonContainer;
[SerializeField]
private GameObject colorSettingMenu;
[SerializeField]
private Slider redSlider;
[SerializeField]
private Slider greenSlider;
[SerializeField]
private Slider blueSlider;
[SerializeField]
private Image colorPreview;
[SerializeField]
private Button applyColorButton;
[SerializeField]
private TMP_Text colorNameText;
[SerializeField]
private TMP_Dropdown categoryDropdown;
[SerializeField]
private Button CancelColorButton;
[SerializeField]
public Slider ESPfiltervalueslider;
[SerializeField]
public Toggle ESPfiltervalue;
[SerializeField]
private TMP_Text ESPfiltervaluesliderlabel;
[SerializeField]
public Toggle ShowColorMenu;
[SerializeField]
public Button MaxWeaponSkills;
[SerializeField]
public Toggle TPHideoutItems;
[SerializeField]
public Toggle TPWishlistItems;
[SerializeField]
public Toggle TPHVItems;
[SerializeField]
public Toggle SpoofNicknameToggle;
[SerializeField]
public Button speedhacktogglekeybutton1;
[SerializeField]
public TMP_Text speedhacktogglekeylabel1;
[SerializeField]
public Button flyhacktogglekeybutton1;
[SerializeField]
public TMP_Text flyhacktogglekeylabel1;
[SerializeField]
public Toggle disableallinputs;
[SerializeField]
public TMP_Text bulletspershotLabel;
[SerializeField]
public Toggle bulletspershottoggle;
[SerializeField]
public Slider bulletspershot;
[SerializeField]
public Toggle bigheadstoggle;
[SerializeField]
public Slider ItemTPRadiusSlider;
[SerializeField]
public TMP_Text ItemTPRadiusLabel;
[SerializeField]
private GameObject TransitPanel;
[SerializeField]
public GameObject transitButtonTemplate;
[SerializeField]
public Transform transitButtonContainer;
[SerializeField]
public ScrollRect transitScrollRect;
[SerializeField]
public TMP_Text transitInfoText;
[SerializeField]
public Button applyTransitButton;
[SerializeField]
public Button senditemsTransitButton;
[SerializeField]
public Button canceltransitbutton;
[SerializeField]
public Toggle showraidsettingsmenu;
[SerializeField]
private TMP_Text notransitstexttmp;
[SerializeField]
private GameObject RaidSettingsPanel;
[SerializeField]
private TMP_Dropdown botAmountDropdown;
[SerializeField]
private TMP_Dropdown botDifficultyDropdown;
[SerializeField]
private Toggle taggedAndCursedToggle;
[SerializeField]
private Toggle scavwartoggle;
[SerializeField]
private Toggle metabolismDisabledToggle;
[SerializeField]
private TMP_Dropdown windTypeDropdown;
[SerializeField]
private TMP_Dropdown timeFlowTypeDropdown;
[SerializeField]
private TMP_Dropdown cloudinessTypeDropdown;
[SerializeField]
private TMP_Dropdown rainTypeDropdown;
[SerializeField]
public Toggle modifyraidsettingstoggle;
[SerializeField]
private GameObject EntityPanel;
[SerializeField]
private Transform entityButtonContainer;
[SerializeField]
private GameObject entityButtonTemplate;
[SerializeField]
private TMP_Text entityInfoText;
[SerializeField]
private ScrollRect entityScrollRect;
[SerializeField]
private Button killEntityButton;
[SerializeField]
private Button healEntityButton;
[SerializeField]
private Button tpEntityToCrosshairButton;
[SerializeField]
private Button makebraindeadbutton;
[SerializeField]
private Button GiveBotBlickyKit;
[SerializeField]
private Button GiveAllBotsBlickyKitButton;
[SerializeField]
private TMP_Text noentitiestexttmp;
[SerializeField]
public Toggle makeallbotsfriendlytoggle;
[Header("Main Advanced Item Spawning Stuff")]
[SerializeField]
private Button OpenADvancedItemSpawningButton;
[SerializeField]
private GameObject advancedItemPanel;
[SerializeField]
private Button spawnadvancedButton;
[SerializeField]
private Button cancelButton;
[SerializeField]
private Button refreshSlotsButton;
[SerializeField]
private Button saveToFileButton;
[SerializeField]
private Button saveToPresetListButton;
[Header("Buff UI")]
[SerializeField]
private Transform buffListContainer;
[SerializeField]
private GameObject buffButtonTemplate;
[SerializeField]
private GameObject buffEditWindow;
[SerializeField]
private Slider buffSlider;
[SerializeField]
private TMP_Text buffNameText;
[SerializeField]
private TMP_Text buffValueText;
[SerializeField]
private Button applyBuffButton;
[SerializeField]
private TMP_Dropdown buffTypeDropdown;
[Header("Slot UI")]
[SerializeField]
private Transform slotListContainer;
[SerializeField]
private GameObject slotButtonTemplate;
[Header("Slot Item Selection UI")]
[SerializeField]
private GameObject slotItemWindow;
[SerializeField]
private TMP_Text slotItemWindowTitle;
[SerializeField]
private TMP_Text slotItemInfoText;
[SerializeField]
private Transform slotCompatibleItemsContainer;
[SerializeField]
private GameObject compatibleItemButtonTemplate;
[SerializeField]
private Button cancelSlotButton;
[SerializeField]
private Button applySlotButton;
[Header("Item Save Window")]
[SerializeField]
private Button confirmSaveButton;
[SerializeField]
private Button cancelSaveButton;
[SerializeField]
private GameObject popupWindow;
[SerializeField]
private TMP_InputField presetNameInput;
private SaveType currentSaveType;
private List<BuffComponent> cachedBuffs = new List<BuffComponent>();
private List<(string slotName, dynamic slotRef)> cachedSlots = new List<(string, object)>();
private BuffComponent currentEditingBuff;
private string selectedSlotItemId;
private dynamic currentEditingSlotRef;
private string currentSlotName;
private bool populatedTransits;
private bool wasInGame;
private int selectedTransitId = -1;
private string selectedAIName;
private string empty = "";
public static string TPItemInputstring = "Grenade";
private string selectedColorKey;
private string selectedTraderId;
private bool waitingForKey;
private KeybindType currentKeybindType;
private List<ItemData> ItemsList;
public static Main main = new Main();
public static PullItemIDs pullItemIDs;
private string selectedSkillName;
private PullItemPresets pullItemPresets;
private string selectedPresetName;
private bool populatedtemplates;
public static bool showmenu = false;
public static bool closedupdate = false;
public static bool showhelp = false;
public bool hidspawnmenuforcolor;
private static int entitylistcount = 0;
private static float entitylistupdatedelay = 5f;
private static float nextentitycachetime;
private static string advanceditemidcache;
private dynamic advanceditemcache;
public bool updatep = true;
private float debounceTime = 0.5f;
private Coroutine debounceCoroutine;
private float newDebounceTime = 0.5f;
private Coroutine newDebounceCoroutine;
private Coroutine spawnDebounceCoroutine;
private Coroutine searchDebounceCoroutine;
private Coroutine aisearchDebounceCoroutine;
private Dictionary<string, int> skillLevels = new Dictionary<string, int>
{
{ "Strength", 0 },
{ "StressResistance", 0 },
{ "MagDrills", 0 },
{ "Melee", 0 },
{ "HideoutManagement", 0 },
{ "Crafting", 0 },
{ "HeavyVests", 0 },
{ "LightVests", 0 },
{ "RecoilControl", 0 },
{ "LMG", 0 },
{ "Assault", 0 },
{ "Pistol", 0 },
{ "Perception", 0 },
{ "Sniper", 0 },
{ "Sniping", 0 },
{ "Endurance", 0 },
{ "Throwing", 0 },
{ "Charisma", 0 },
{ "BotReload", 0 },
{ "TroubleShooting", 0 },
{ "Health", 0 },
{ "Vitality", 0 },
{ "Metabolism", 0 },
{ "Immunity", 0 },
{ "Intellect", 0 },
{ "Attention", 0 },
{ "Shotgun", 0 },
{ "HMG", 0 },
{ "Launcher", 0 },
{ "DMR", 0 },
{ "AimDrills", 0 },
{ "Surgery", 0 },
{ "CovertMovement", 0 },
{ "Search", 0 },
{ "FieldMedicine", 0 },
{ "FirstAid", 0 },
{ "SMG", 0 },
{ "WeaponTreatment", 0 },
{ "Revolver", 0 },
{ "AttachedLauncher", 0 }
};
private Item item;
private ItemPresetManager presetManager = new ItemPresetManager();
private bool saveFlag;
private Item item12;
private Dictionary<string, string> traderIDs = new Dictionary<string, string>
{
{ "Prapor", "54cb50c76803fa8b248b4571" },
{ "Therapist", "54cb57776803fa99248b456e" },
{ "Fence", "579dc571d53a0658a154fbec" },
{ "Skier", "58330581ace78e27b8b10cee" },
{ "Peacekeeper", "5935c25fb3acc3127c3d8cd9" },
{ "Mechanic", "5a7c2eca46aef81a7ca2145d" },
{ "Ragman", "5ac3b934156ae10c4430e83c" },
{ "Jaeger", "5c0647fdd443bc2504c2d371" },
{ "Lighthouse Keeper", "638f541a29ffd1183d187f57" }
};
public static Dictionary<string, (Func<Color> getColor, Action<Color> setColor, string description, ColorCategory category)> ColorDictionary = new Dictionary<string, (Func<Color>, Action<Color>, string, ColorCategory)>
{
{
"SuperrareColor",
(() => Settings.SuperrareColor, delegate(Color value)
{
Settings.SuperrareColor = value;
}, "Super rare items Color", ColorCategory.ItemESP)
},
{
"KappaColor",
(() => Settings.KappaColor, delegate(Color value)
{
Settings.KappaColor = value;
}, "Kappa items Color", ColorCategory.ItemESP)
},
{
"QuestItemColor",
(() => Settings.QuestItemColor, delegate(Color value)
{
Settings.QuestItemColor = value;
}, "Quest items Color", ColorCategory.ItemESP)
},
{
"StimItemColor",
(() => Settings.StimItemColor, delegate(Color value)
{
Settings.StimItemColor = value;
}, "Stim items Color", ColorCategory.ItemESP)
},
{
"HideoutColor",
(() => Settings.HideoutColor, delegate(Color value)
{
Settings.HideoutColor = value;
}, "Hideout items Color", ColorCategory.ItemESP)
},
{
"WishlistColor",
(() => Settings.WishlistColor, delegate(Color value)
{
Settings.WishlistColor = value;
}, "Wishlist items Color", ColorCategory.ItemESP)
},
{
"SearchedColor",
(() => Settings.SearchedColor, delegate(Color value)
{
Settings.SearchedColor = value;
}, "Searched items Color", ColorCategory.ItemESP)
},
{
"CommonItemColor",
(() => Settings.CommonItemColor, delegate(Color value)
{
Settings.CommonItemColor = value;
}, "Common items Color", ColorCategory.ItemESP)
},
{
"USECColor",
(() => Settings.USECColor, delegate(Color value)
{
Settings.USECColor = value;
}, "USEC Color ", ColorCategory.ESP)
},
{
"BEARColor",
(() => Settings.BEARColor, delegate(Color value)
{
Settings.BEARColor = value;
}, "BEAR Color", ColorCategory.ESP)
},
{
"BossColor",
(() => Settings.BossandGuardColor, delegate(Color value)
{
Settings.BossandGuardColor = value;
}, "Bosses Color", ColorCategory.ESP)
},
{
"GuardColor",
(() => Settings.GuardColor, delegate(Color value)
{
Settings.GuardColor = value;
}, "Guard Color", ColorCategory.ESP)
},
{
"ScavColor",
(() => Settings.ScavColor, delegate(Color value)
{
Settings.ScavColor = value;
}, "Scav Color", ColorCategory.ESP)
},
{
"ZombieColor",
(() => Settings.ZombieColor, delegate(Color value)
{
Settings.ZombieColor = value;
}, "Zombie Color", ColorCategory.ESP)
},
{
"RogueColor",
(() => Settings.RogueColor, delegate(Color value)
{
Settings.RogueColor = value;
}, "Rogue Color", ColorCategory.ESP)
},
{
"RaiderColor",
(() => Settings.RaiderColor, delegate(Color value)
{
Settings.RaiderColor = value;
}, "Raider Color", ColorCategory.ESP)
},
{
"CultistColor",
(() => Settings.CultistColor, delegate(Color value)
{
Settings.CultistColor = value;
}, "Cultist Color", ColorCategory.ESP)
},
{
"BTRColor",
(() => Settings.BTRColor, delegate(Color value)
{
Settings.BTRColor = value;
}, "BTR", ColorCategory.ESP)
},
{
"ESPBoxColor",
(() => Settings.ESPBoxColor, delegate(Color value)
{
Settings.ESPBoxColor = value;
}, "Box ESP Hidden", ColorCategory.ESP)
},
{
"ESPBoxVisColor",
(() => Settings.boxsightline, delegate(Color value)
{
Settings.boxsightline = value;
}, "Box ESP Visible", ColorCategory.ESP)
},
{
"ESPLineColor",
(() => Settings.ESPLineColor, delegate(Color value)
{
Settings.ESPLineColor = value;
}, "Line ESP Hidden", ColorCategory.ESP)
},
{
"ESPLineColorVisible",
(() => Settings.isvisibleline, delegate(Color value)
{
Settings.isvisibleline = value;
}, "Line ESP Visible", ColorCategory.ESP)
},
{
"SkeletonColor",
(() => Settings.SkeletonColor, delegate(Color value)
{
Settings.SkeletonColor = value;
}, "Skeleton ESP Color", ColorCategory.ESP)
},
{
"EnemyWeaponTextColor",
(() => Settings.EnemyWeaponTextColor, delegate(Color value)
{
Settings.EnemyWeaponTextColor = value;
}, "Enemy Weapon Text", ColorCategory.ESP)
},
{
"EnemyWeaponAMMOTextColor",
(() => Settings.EnemyAmmoCounterColor, delegate(Color value)
{
Settings.EnemyAmmoCounterColor = value;
}, "Enemy Ammo Count", ColorCategory.ESP)
},
{
"EnemyHealingTextColor",
(() => Settings.healingcolor, delegate(Color value)
{
Settings.healingcolor = value;
}, "Enemy Healing Indicator", ColorCategory.ESP)
},
{
"TeammateColor",
(() => Settings.teammatecolor, delegate(Color value)
{
Settings.teammatecolor = value;
}, "Teammate Color", ColorCategory.ESP)
},
{
"PlayerScavColor",
(() => Settings.playerscavcolor, delegate(Color value)
{
Settings.playerscavcolor = value;
}, "Player Scav Color", ColorCategory.ESP)
},
{
"Selected Entity Color",
(() => Settings.SelectedEntityColor, delegate(Color value)
{
Settings.SelectedEntityColor = value;
}, "Selected Entity Color", ColorCategory.ESP)
},
{
"CrosshairColor",
(() => Settings.CrosshairColor, delegate(Color value)
{
Settings.CrosshairColor = value;
}, "Crosshair Color", ColorCategory.Aimbot)
},
{
"TargetSnaplineColor",
(() => Settings.TargetSnaplineColor, delegate(Color value)
{
Settings.TargetSnaplineColor = value;
}, "Aim Target snapline Color", ColorCategory.Aimbot)
},
{
"AimFOVColor",
(() => Settings.AimFOVColor, delegate(Color value)
{
Settings.AimFOVColor = value;
}, "Aim FOV circle Color", ColorCategory.Aimbot)
},
{
"AmmoCounterColor",
(() => Settings.AmmoCounterColor, delegate(Color value)
{
Settings.AmmoCounterColor = value;
}, "Ammo counter Color", ColorCategory.Aimbot)
},
{
"TracerColor",
(() => Settings.TracerColor, delegate(Color value)
{
Settings.TracerColor = value;
}, "Tracers Color", ColorCategory.Aimbot)
},
{
"HitmarkerHeadShotColor",
(() => Settings.HitmarkerHeadShotColor, delegate(Color value)
{
Settings.HitmarkerHeadShotColor = value;
}, "Hitmarker for headshots Color", ColorCategory.Aimbot)
},
{
"HitmarkerHitColor",
(() => Settings.HitmarkerHitColor, delegate(Color value)
{
Settings.HitmarkerHitColor = value;
}, "Hitmarker for hits Color", ColorCategory.Aimbot)
},
{
"ExfilColor",
(() => Settings.ExfilESPColor, delegate(Color value)
{
Settings.ExfilESPColor = value;
}, "Exfil Point Color", ColorCategory.ESP)
},
{
"TransitColor",
(() => Settings.TransitPointColor, delegate(Color value)
{
Settings.TransitPointColor = value;
}, "Transit Point Color", ColorCategory.ESP)
},
{
"PChamsHidden",
(() => Settings.PlayerChamsHidden, delegate(Color value)
{
Settings.PlayerChamsHidden = value;
}, "Player Chams Hidden", ColorCategory.Chams)
},
{
"PChamsVisible",
(() => Settings.PlayerChamsVisible, delegate(Color value)
{
Settings.PlayerChamsVisible = value;
}, "Player Chams Visible", ColorCategory.Chams)
},
{
"GChamsHidden",
(() => Settings.GrenadeHidden, delegate(Color value)
{
Settings.GrenadeHidden = value;
}, "Grenade Chams Hidden", ColorCategory.Chams)
},
{
"GChamsVisible",
(() => Settings.GrenadeVisible, delegate(Color value)
{
Settings.GrenadeVisible = value;
}, "Grenade Chams Visible", ColorCategory.Chams)
},
{
"TChamsHidden",
(() => Settings.TripwireHidden, delegate(Color value)
{
Settings.TripwireHidden = value;
}, "Tripwire Chams Hidden", ColorCategory.Chams)
},
{
"TChamsVisible",
(() => Settings.TripwireVisible, delegate(Color value)
{
Settings.TripwireVisible = value;
}, "Tripwire Chams Visible", ColorCategory.Chams)
},
{
"SChamsColor",
(() => Settings.SelfChamsColor, delegate(Color value)
{
Settings.SelfChamsColor = value;
}, "Self Chams Color", ColorCategory.Chams)
}
};
public static Player selectedEntity;
private Dictionary<string, GameObject> activeEntityButtons = new Dictionary<string, GameObject>();
private void Start()
{
questModule = UnityEngine.Object.FindObjectOfType<QuestModule>();
aILister = UnityEngine.Object.FindObjectOfType<AILister>();
pullItemPresets = UnityEngine.Object.FindObjectOfType<PullItemPresets>();
pullItemIDs = UnityEngine.Object.FindObjectOfType<PullItemIDs>();
itembuttontemplate.SetActive(value: false);
PopulateRaidSettingsDropdowns();
LoadSettings();
Initialize();
if (menu != null)
{
Canvas component = menu.GetComponent<Canvas>();
if (component != null)
{
component.sortingOrder = 32767;
}
CanvasGroup component2 = menu.GetComponent<CanvasGroup>();
if (component2 != null)
{
component2.blocksRaycasts = component2.alpha > 0f;
component2.ignoreParentGroups = false;
component2.interactable = true;
}
menuBar.SetActive(value: false);
watermark.SetActive(value: false);
watermarkmagicbullet.SetActive(value: false);
helppanel.SetActive(value: false);
updatepanel.SetActive(value: true);
}
if (searchItemInputField != null)
{
searchItemInputField.onEndEdit.AddListener(OnSearchItemInputEndEdit);
searchItemInputField.onValueChanged.AddListener(OnSearchItemValueChanged);
}
if (TPItemInputField != null)
{
TPItemInputField.onEndEdit.AddListener(TPItemInputEndEdit);
TPItemInputField.onValueChanged.AddListener(TPItemValueChanged);
}
if (closeupdatebutton != null)
{
closeupdatebutton.onClick.AddListener(UpdateWindow);
}
if (openhelpbutton != null)
{
openhelpbutton.onClick.AddListener(ShowHelpPanel);
}
if (closehelpbutton != null)
{
closehelpbutton.onClick.AddListener(HideHelpPanel);
}
if (Refresh != null)
{
Refresh.onClick.AddListener(Refreshsearchupdate);
}
if (addtowishlist != null)
{
addtowishlist.onClick.AddListener(AddItemToWishList);
}
clearCacheKeyButton.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.ClearCache);
});
skillKeyButton.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.Skill);
});
aimbotKeyButton.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.Aimbot);
});
unlockDoorsKeyButton.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.UnlockDoors);
});
teleportitembutton.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.teleportitem);
});
killallbutton.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.killall);
});
tpallkeybutton.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.tpall);
});
instahealkeybutton.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.instaheal);
});
speedhacktogglekeybutton1.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.speedhack);
});
flyhacktogglekeybutton1.onClick.AddListener(delegate
{
OnKeybindButtonClick(KeybindType.flyhack);
});
applyTraderrepButton.onClick.AddListener(OnApplyButtonClick);
applyTransitButton.onClick.AddListener(OnApplyTransitButtonClick);
senditemsTransitButton.onClick.AddListener(OnSendItemsTransitButtonClick);
canceltransitbutton.onClick.AddListener(OnCancelCountdownClick);
if (traderreputationSlider != null)
{
traderreputationSlider.value = Settings.reptoadd;
traderreputationSlider.onValueChanged.AddListener(OnSliderValueChanged);
}
MaxWeaponSkills.onClick.AddListener(MaxWeaponskill);
redSlider.onValueChanged.AddListener(OnColorSliderValueChanged);
blueSlider.onValueChanged.AddListener(OnColorSliderValueChanged);
greenSlider.onValueChanged.AddListener(OnColorSliderValueChanged);
InitializeColorSliders();
categoryDropdown.ClearOptions();
categoryDropdown.AddOptions(Enum.GetNames(typeof(ColorCategory)).ToList());
categoryDropdown.onValueChanged.AddListener(delegate
{
OnCategoryDropdownChanged();
});
PopulateColorList();
colorSettingMenu.SetActive(value: false);
CancelColorButton.onClick.AddListener(OnCancelColorChangeClick);
applyColorButton.onClick.AddListener(OnApplyColorButtonClick);
killEntityButton.onClick.AddListener(OnKillEntityClick);
tpEntityToCrosshairButton.onClick.AddListener(OnTeleportEntityClick);
healEntityButton.onClick.AddListener(OnHealEntityClick);
makebraindeadbutton.onClick.AddListener(onmakebraindeadclick);
GiveBotBlickyKit.onClick.AddListener(ongivebotblickykitclick);
GiveAllBotsBlickyKitButton.onClick.AddListener(ongiveallbotsblickykitclick);
PopulateTraderList();
PopulateSkillList();
PopulateAIMenu();
skillLevelSlider.onValueChanged.AddListener(OnSkillLevelSliderValueChanged);
applySkillButton.onClick.AddListener(OnApplySkillButtonClick);
skillLevelSlider.value = 0f;
skillLevelToAddText.text = $"Level to Set: {skillLevelSlider.value:F0}";
spawnpresetitembutton.onClick.AddListener(SpawnTemplateDelegate);
saveToFileButton.onClick.AddListener(delegate
{
OpenPopupSaveFile();
});
saveToPresetListButton.onClick.AddListener(delegate
{
OpenPopupSaveList();
});
confirmSaveButton.onClick.AddListener(OnConfirmSave);
cancelSaveButton.onClick.AddListener(delegate
{
popupWindow.SetActive(value: false);
});
popupWindow.SetActive(value: false);
InitializeAimboneDropdown();
UpdateAimbotSettingsUI();
UpdatePlayerESPSettingsUI();
UpdateItemESPSettingsUI();
UpdateMiscOptionsSettingsUI();
AddToggleListeners();
AddSliderListeners();
advancedItemPanel.SetActive(value: false);
OpenADvancedItemSpawningButton.onClick.AddListener(Spawnitemadvanced);
}
private void LoadSettings()
{
UpdateAimbotSettingsUI();
UpdatePlayerESPSettingsUI();
UpdateItemESPSettingsUI();
UpdateMiscOptionsSettingsUI();
}
private void SaveSettings()
{
Settings.SaveSettings();
}
public void Initialize()
{
if (aimbotButton != null)
{
aimbotButton.onClick.AddListener(ShowAimbotPanel);
}
if (playerESPButton != null)
{
playerESPButton.onClick.AddListener(ShowPlayerESPPanel);
}
if (itemESPButton != null)
{
itemESPButton.onClick.AddListener(ShowItemESPPanel);
}
if (miscOptionsButton != null)
{
miscOptionsButton.onClick.AddListener(ShowMiscOptionsPanel);
}
if (settingsButton != null)
{
settingsButton.onClick.AddListener(ShowSettingsPanel);
}
if (spawnitembutton != null)
{
spawnitembutton.onClick.AddListener(OnSpawnItemButtonClick);
}
if (saveprimaryweapon != null)
{
saveprimaryweapon.onClick.AddListener(SavePrimaryWeaponToJson);
}
if (loadfromfilebutton != null)
{
loadfromfilebutton.onClick.AddListener(LoadandSpawnitem);
}
if (spawnbossbutton != null)
{
spawnbossbutton.onClick.AddListener(SpawnBot);
}
if (addxpsessionbutton != null)
{
addxpsessionbutton.onClick.AddListener(XPAdder);
}
if (completequestbutton != null)
{
completequestbutton.onClick.AddListener(FinishQuestsWrapper);
}
if (searchInputField != null)
{
searchInputField.onEndEdit.AddListener(OnSearchTextChanged);
}
if (searchInputFieldTemplates != null)
{
searchInputFieldTemplates.onEndEdit.AddListener(OnTemplateSearchTextChanged);
}
if (aiSearchBar != null)
{
aiSearchBar.onEndEdit.AddListener(OnAISearchTextChanged);
}
HideAllPanels();
UpdateKeybindLabels();
}
private void Update()
{
if (!updatep)
{
return;
}
try
{
if (!populatedTransits && LocationsFixerV2.transitPoints.Count > 0 && Main.GameWorld != null && transitButtonTemplate != null)
{
populatedTransits = true;
PopulateTransitList();
}
if (populatedTransits && Main.GameWorld == null)
{
populatedTransits = false;
}
if (LocationsFixerV2.transitPoints.Count == 0 && transitButtonContainer.childCount >= 1 && transitButtonTemplate != null && transitButtonContainer != null)
{
PopulateTransitList();
}
if (Main.GamePlayers.Count > 0 && entityButtonTemplate != null)
{
UpdateEntityList();
}
if (Main.GamePlayers.Count == 0 && entityButtonContainer.childCount >= 1 && entityButtonTemplate != null && entityButtonContainer != null)
{
UpdateEntityList();
}
if (closedupdate && watermark != null && watermarkmagicbullet != null)
{
if (Settings.MagicBullet && Settings.drawwatermark)
{
watermark.SetActive(value: false);
watermarkmagicbullet.SetActive(value: true);
}
else if (Settings.drawwatermark)
{
watermark.SetActive(value: true);
watermarkmagicbullet.SetActive(value: false);
}
else
{
watermark.SetActive(value: false);
watermarkmagicbullet.SetActive(value: false);
}
}
if (Input.GetKeyDown(KeyCode.Insert) && showmenu)
{
if (menuBar != null)
{
menuBar.SetActive(!menuBar.activeSelf);
}
ClearButtons();
}
if (Settings.sicc)
{
Settings.ammobox = false;
}
if (Settings.ammobox)
{
Settings.sicc = false;
}
if (Settings.fillraidbp)
{
Settings.thicc = false;
}
if (Settings.thicc)
{
Settings.fillraidbp = false;
}
UpdateAimbotSettingsUI();
UpdatePlayerESPSettingsUI();
UpdateItemESPSettingsUI();
UpdateMiscOptionsSettingsUI();
if (showmenu)
{
if (itemspawnpanel != null && Settings.Itemspawnmenu)
{
if (Settings.showraidsettingsmenu)
{
Settings.showraidsettingsmenu = false;
itemspawnpanel.SetActive(value: true);
}
else
{
itemspawnpanel.SetActive(value: true);
}
}
else if (itemspawnpanel != null)
{
itemspawnpanel.SetActive(value: false);
}
if (aispawnpanel != null && Settings.Itemspawnmenu)
{
aispawnpanel.SetActive(value: true);
}
else if (aispawnpanel != null)
{
aispawnpanel.SetActive(value: false);
}
if (traderreppanel != null && Settings.Itemspawnmenu)
{
traderreppanel.SetActive(value: true);
}
else if (traderreppanel != null)
{
traderreppanel.SetActive(value: false);
}
if (skillspanel != null && Settings.Itemspawnmenu)
{
skillspanel.SetActive(value: true);
}
else if (skillspanel != null)
{
skillspanel.SetActive(value: false);
}
if (presetsPanel != null && Settings.Itemspawnmenu)
{
presetsPanel.SetActive(value: true);
}
else if (presetsPanel != null)
{
presetsPanel.SetActive(value: false);
}
if (MainColorSettingsMenu != null && Settings.ShowColorSettingsMenu)
{
MainColorSettingsMenu.SetActive(value: true);
if (Settings.Itemspawnmenu && !hidspawnmenuforcolor)
{
hidspawnmenuforcolor = true;
Settings.Itemspawnmenu = false;
}
}
else if (MainColorSettingsMenu != null)
{
MainColorSettingsMenu.SetActive(value: false);
if (!Settings.Itemspawnmenu && hidspawnmenuforcolor)
{
hidspawnmenuforcolor = false;
Settings.Itemspawnmenu = true;
}
}
if (TransitPanel != null && Settings.showraidsettingsmenu)
{
if (Settings.Itemspawnmenu)
{
Settings.Itemspawnmenu = false;
TransitPanel.SetActive(value: true);
RaidSettingsPanel.SetActive(value: true);
EntityPanel.SetActive(value: true);
}
else
{
TransitPanel.SetActive(value: true);
RaidSettingsPanel.SetActive(value: true);
EntityPanel.SetActive(value: true);
}
}
else if (TransitPanel != null)
{
TransitPanel.SetActive(value: false);
RaidSettingsPanel.SetActive(value: false);
EntityPanel.SetActive(value: false);
}
}
if (waitingForKey && Input.anyKeyDown)
{
foreach (KeyCode value in Enum.GetValues(typeof(KeyCode)))
{
if (Input.GetKeyDown(value))
{
AssignKeybind(value);
break;
}
}
waitingForKey = false;
}
if (!populatedtemplates)
{
PopulateAllTemplates();
}
if (Settings.modifyraidsettings)
{
ApplyRaidSettings();
}
}
catch (Exception)
{
}
}
public void UpdateWindow()
{
closedupdate = true;
updatepanel.SetActive(value: false);
menuBar.SetActive(value: true);
menu.SetActive(value: true);
aimbotPanel.SetActive(value: true);
if (Settings.MagicBullet)
{
watermarkmagicbullet.SetActive(value: true);
}
else
{
watermark.SetActive(value: true);
}
showmenu = true;
}
public void ShowHelpPanel()
{
showhelp = true;
if (helppanel != null && showhelp)
{
menuBar.SetActive(value: false);
helppanel.SetActive(value: true);
}
}
public void HideHelpPanel()
{
showhelp = false;
if (helppanel != null && !showhelp)
{
menuBar.SetActive(value: true);
helppanel.SetActive(value: false);
}
}
public void XPAdder()
{
if (!(Main.GameWorld = null))
{
int num = (int)Settings.expamount;
Main.LocalPlayer.Profile.EftStats.SessionCounters.SetLong(num, CounterTag.Exp);
ConsoleScreen.Log("patchedxp");
}
}
public void NullifyRiskyCounters()
{
long value = 0L;
Main.LocalPlayer.Profile.EftStats.SessionCounters.SetLong(value, CounterTag.Money, ECurrencyType.RUB);
Main.LocalPlayer.Profile.EftStats.SessionCounters.SetLong(value, CounterTag.Keys);
Main.LocalPlayer.Profile.EftStats.SessionCounters.SetLong(value, CounterTag.Money, ECurrencyType.EUR);
Main.LocalPlayer.Profile.EftStats.SessionCounters.SetLong(value, CounterTag.Money, ECurrencyType.USD);
}
public void ShowAimbotPanel()
{
HideAllPanels();
aimbotPanel.SetActive(value: true);
}
public void ShowPlayerESPPanel()
{
HideAllPanels();
playerESPPanel.SetActive(value: true);
}
public void ShowItemESPPanel()
{
HideAllPanels();
itemESPPanel.SetActive(value: true);
}
public void ShowMiscOptionsPanel()
{
HideAllPanels();
miscOptionsPanel.SetActive(value: true);
}
private void FinishQuestsWrapper()
{
questModule.FinishQuests();
}
public void ShowSettingsPanel()
{
HideAllPanels();
settingsPanel.SetActive(value: true);
}
public void LoadandSpawnitem()
{
LoadAndSpawnItemFromJson();
}
private void OnSearchTextChanged(string searchTerm)
{
if (debounceCoroutine != null)
{
StopCoroutine(debounceCoroutine);
}
debounceCoroutine = StartCoroutine(DebounceUpdateSearchResults(searchTerm));
}
public void SpawnTemplateDelegate()
{
if (spawnDebounceCoroutine != null)
{
StopCoroutine(spawnDebounceCoroutine);
}
spawnDebounceCoroutine = StartCoroutine(DebounceSpawnSelectedPreset());
}
private IEnumerator DebounceSpawnSelectedPreset()
{
yield return new WaitForSeconds(0.1f);
SpawnSelectedPreset();
}
public void OnTemplateSearchTextChanged(string searchText)
{
if (searchDebounceCoroutine != null)
{
StopCoroutine(searchDebounceCoroutine);
}
searchDebounceCoroutine = StartCoroutine(DebounceUpdateSearchText(searchText));
}
public void OnAISearchTextChanged(string searchText)
{
if (aisearchDebounceCoroutine != null)
{
StopCoroutine(aisearchDebounceCoroutine);
}
aisearchDebounceCoroutine = StartCoroutine(DebounceAISearchText(searchText));
}
private IEnumerator DebounceUpdateSearchText(string searchTerm)
{
yield return new WaitForSeconds(0.1f);
UpdatePresetResults(searchTerm);
}
private IEnumerator DebounceAISearchText(string searchTerm)
{
yield return new WaitForSeconds(0.1f);
UpdateAIResults(searchTerm);
}
private void ClearButtons()
{
foreach (Transform item in buttonContainer)
{
UnityEngine.Object.Destroy(item.gameObject);
}
}
private void ClearPresetButtons()
{
foreach (Transform item in presetButtonContainer)
{
UnityEngine.Object.Destroy(item.gameObject);
}
}
private void OnSpawnItemButtonClick()
{
if (newDebounceCoroutine != null)
{
StopCoroutine(newDebounceCoroutine);
}
newDebounceCoroutine = StartCoroutine(HandleDebouncedEvent());
}
private IEnumerator HandleDebouncedEvent()
{
yield return new WaitForSeconds(newDebounceTime);
SpawnItemHelper();
}
private IEnumerator DebounceUpdateSearchResults(string searchTerm)
{
yield return new WaitForSeconds(debounceTime);
UpdateSearchResults(searchTerm);
}
private void InitializeColorSliders()
{
redSlider.minValue = 0f;
redSlider.maxValue = 1f;
greenSlider.minValue = 0f;
greenSlider.maxValue = 1f;
blueSlider.minValue = 0f;
blueSlider.maxValue = 1f;
redSlider.onValueChanged.AddListener(OnColorSliderValueChanged);
greenSlider.onValueChanged.AddListener(OnColorSliderValueChanged);
blueSlider.onValueChanged.AddListener(OnColorSliderValueChanged);
}
private void PopulateColorList()
{
foreach (Transform item2 in colorButtonContainer)
{
UnityEngine.Object.Destroy(item2.gameObject);
}
ColorCategory value = (ColorCategory)categoryDropdown.value;
foreach (KeyValuePair<string, (Func<Color>, Action<Color>, string, ColorCategory)> item3 in ColorDictionary)
{
string colorName = item3.Key;
Color color = item3.Value.Item1();
string item = item3.Value.Item3;
if (item3.Value.Item4 != value)
{
continue;
}
GameObject gameObject = UnityEngine.Object.Instantiate(colorButtonTemplate, colorButtonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
componentInChildren.text = item ?? "";
}
Image componentInChildren2 = gameObject.GetComponentInChildren<Image>();
if (componentInChildren2 != null)
{
componentInChildren2.color = color;
}
Button component = gameObject.GetComponent<Button>();
if (component != null)
{
component.onClick.AddListener(delegate
{
OnColorButtonClick(colorName);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(colorButtonContainer.GetComponent<RectTransform>());
}
private void OnColorButtonClick(string colorKey)
{
selectedColorKey = colorKey;
Color color = ColorDictionary[colorKey].getColor();
string item = ColorDictionary[colorKey].description;
redSlider.value = color.r;
greenSlider.value = color.g;
blueSlider.value = color.b;
colorPreview.color = color;
colorNameText.text = "Editing: \n" + item;
colorSettingMenu.SetActive(value: true);
}
public void OnColorSliderValueChanged(float value)
{
colorPreview.color = new Color(redSlider.value, greenSlider.value, blueSlider.value, 1f);
}
public void OnApplyColorButtonClick()
{
try
{
if (!string.IsNullOrEmpty(selectedColorKey))
{
Color color = new Color(redSlider.value, greenSlider.value, blueSlider.value);
if (ColorDictionary.ContainsKey(selectedColorKey))
{
ColorDictionary[selectedColorKey].setColor(color);
ConsoleScreen.Log($"Saving color for {selectedColorKey}: {color}");
}
Settings.SaveSettings();
colorSettingMenu.SetActive(value: false);
selectedColorKey = null;
colorNameText.text = "Please Select A Colour To Change";
PopulateColorList();
}
}
catch (Exception ex)
{
ConsoleScreen.Log(ex.Message + " \n " + ex.StackTrace);
}
}
public void OnCancelColorChangeClick()
{
colorSettingMenu.SetActive(value: false);
selectedColorKey = null;
colorNameText.text = "Please Select A Colour To Change";
PopulateColorList();
}
public void OnCategoryDropdownChanged()
{
PopulateColorList();
}
public void PopulateTransitList()
{
try
{
ConsoleScreen.Log("Repopulating Transit List...");
foreach (Transform item in transitButtonContainer)
{
UnityEngine.Object.Destroy(item.gameObject);
}
if (LocationsFixerV2.transitPoints.Count > 0)
{
notransitstexttmp.text = " ";
}
else
{
notransitstexttmp.text = "No Transits to List";
}
transitInfoText.text = "Please Select A Transit from the List";
selectedTransitId = -1;
foreach (TransitPoint transitPoint in LocationsFixerV2.transitPoints)
{
if (transitPoint == null || transitPoint.name == null || transitPoint.parameters == null)
{
continue;
}
GameObject gameObject = UnityEngine.Object.Instantiate(transitButtonTemplate, transitButtonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
componentInChildren.text = RemoveUnderscores(transitPoint.name.Transliterate()) ?? "";
}
Button component = gameObject.GetComponent<Button>();
if (component != null)
{
int id = transitPoint.parameters.id;
string name = RemoveUnderscores(transitPoint.name.Transliterate());
component.onClick.AddListener(delegate
{
OnTransitButtonClick(id, name);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(transitButtonContainer.GetComponent<RectTransform>());
transitScrollRect.verticalNormalizedPosition = 1f;
Canvas.ForceUpdateCanvases();
}
catch (Exception arg)
{
ConsoleScreen.Log($"Error in Populate Transit list : {arg}");
}
}
private string RemoveUnderscores(string input)
{
return input.Replace("_", " ");
}
private void OnTransitButtonClick(int id, string name)
{
selectedTransitId = id;
transitInfoText.text = $"Selected Transit Point:\nName: {name}\nID: {id}";
}
public void OnApplyTransitButtonClick()
{
if (selectedTransitId == -1)
{
ConsoleScreen.Log("[TRANSIT] No transit point selected.");
}
else
{
LocationsFixerV2.StartTransitByID(selectedTransitId);
}
}
public void OnSendItemsTransitButtonClick()
{
if (selectedTransitId == -1)
{
ConsoleScreen.Log("[TRANSIT ITEMS] No transit point selected.");
}
else
{
LocationsFixerV2.TransferItemsFromTempStash(selectedTransitId);
}
}
public void OnCancelCountdownClick()
{
LocationsFixerV2.StopTransitCountdown();
}
private void PopulateTraderList()
{
foreach (KeyValuePair<string, string> trader in traderIDs)
{
GameObject gameObject = UnityEngine.Object.Instantiate(itembuttontemplate, traderbuttonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
componentInChildren.text = trader.Key;
}
Button component = gameObject.GetComponent<Button>();
if (component != null)
{
component.onClick.AddListener(delegate
{
OnTraderButtonClick(trader.Key, trader.Value);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(traderbuttonContainer.GetComponent<RectTransform>());
traderscrollRect.verticalNormalizedPosition = 1f;
Canvas.ForceUpdateCanvases();
}
private void OnTraderButtonClick(string traderName, string traderId)
{
selectedTraderId = traderId;
Player localPlayer = Main.LocalPlayer;
if (!(localPlayer == null))
{
if (localPlayer.Profile.TradersInfo.TryGetValue(selectedTraderId, out var value))
{
traderinfotext.text = $"Trader Info\nSelected Trader: {traderName}\nCurrent Rep Value: {value.Standing:F2}";
traderreptoaddvalue.text = $"Value to Add: {Settings.reptoadd:F2}";
}
else
{
traderinfotext.text = "Trader Info\nSelected Trader: " + traderName + "\nCurrent Rep Value: N/A";
traderreptoaddvalue.text = $"Value to Add: {Settings.reptoadd:F2}";
}
}
}
private void OnApplyButtonClick()
{
if (!string.IsNullOrEmpty(selectedTraderId))
{
Player localPlayer = Main.LocalPlayer;
if (!(localPlayer == null) && localPlayer.Profile.TradersInfo.TryGetValue(selectedTraderId, out var value))
{
float num = (float)(value.Standing + (double)Settings.reptoadd);
value.SetStanding(num);
OnTraderButtonClick(GetTraderNameById(selectedTraderId), selectedTraderId);
}
}
}
private string GetTraderNameById(string traderId)
{
foreach (KeyValuePair<string, string> traderID in traderIDs)
{
if (traderID.Value == traderId)
{
return traderID.Key;
}
}
return "Unknown Trader";
}
private void OnSliderValueChanged(float value)
{
Settings.reptoadd = value;
traderreptoaddvalue.text = $"Value to Add: {Settings.reptoadd:F2}";
}
private void OnSkillLevelSliderValueChanged(float value)
{
skillLevelToAddText.text = $"Level to Set: {value:F0}";
}
private void PopulateSkillList()
{
foreach (string skill in skillLevels.Keys)
{
GameObject gameObject = UnityEngine.Object.Instantiate(itembuttontemplate, skillButtonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
componentInChildren.text = skill;
}
Button component = gameObject.GetComponent<Button>();
if (component != null)
{
component.onClick.AddListener(delegate
{
OnSkillButtonClick(skill);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(skillButtonContainer.GetComponent<RectTransform>());
skillScrollRect.verticalNormalizedPosition = 1f;
Canvas.ForceUpdateCanvases();
}
private void OnApplySkillButtonClick()
{
if (string.IsNullOrEmpty(selectedSkillName))
{
return;
}
Player localPlayer = Main.LocalPlayer;
if (!(localPlayer == null))
{
int num = (int)skillLevelSlider.value;
switch (selectedSkillName)
{
case "Strength":
localPlayer.Skills.Strength.SetLevel(num);
break;
case "StressResistance":
localPlayer.Skills.StressResistance.SetLevel(num);
break;
case "MagDrills":
localPlayer.Skills.MagDrills.SetLevel(num);
break;
case "Melee":
localPlayer.Skills.Melee.SetLevel(num);
break;
case "HideoutManagement":
localPlayer.Skills.HideoutManagement.SetLevel(num);
break;
case "Crafting":
localPlayer.Skills.Crafting.SetLevel(num);
break;
case "HeavyVests":
localPlayer.Skills.HeavyVests.SetLevel(num);
break;
case "LightVests":
localPlayer.Skills.LightVests.SetLevel(num);
break;
case "RecoilControl":
localPlayer.Skills.RecoilControl.SetLevel(num);
break;
case "LMG":
localPlayer.Skills.LMG.SetLevel(num);
break;
case "Assault":
localPlayer.Skills.Assault.SetLevel(num);
break;
case "Pistol":
localPlayer.Skills.Pistol.SetLevel(num);
break;
case "Perception":
localPlayer.Skills.Perception.SetLevel(num);
break;
case "Sniper":
localPlayer.Skills.Sniper.SetLevel(num);
break;
case "Sniping":
localPlayer.Skills.Sniping.SetLevel(num);
break;
case "Endurance":
localPlayer.Skills.Endurance.SetLevel(num);
break;
case "Throwing":
localPlayer.Skills.Throwing.SetLevel(num);
break;
case "Charisma":
localPlayer.Skills.Charisma.SetLevel(num);
break;
case "BotReload":
localPlayer.Skills.BotReload.SetLevel(num);
break;
case "TroubleShooting":
localPlayer.Skills.TroubleShooting.SetLevel(num);
break;
case "Health":
localPlayer.Skills.Health.SetLevel(num);
break;
case "Vitality":
localPlayer.Skills.Vitality.SetLevel(num);
break;
case "Metabolism":
localPlayer.Skills.Metabolism.SetLevel(num);
break;
case "Immunity":
localPlayer.Skills.Immunity.SetLevel(num);
break;
case "Intellect":
localPlayer.Skills.Intellect.SetLevel(num);
break;
case "Attention":
localPlayer.Skills.Attention.SetLevel(num);
break;
case "Shotgun":
localPlayer.Skills.Shotgun.SetLevel(num);
break;
case "HMG":
localPlayer.Skills.HMG.SetLevel(num);
break;
case "Launcher":
localPlayer.Skills.Launcher.SetLevel(num);
break;
case "DMR":
localPlayer.Skills.DMR.SetLevel(num);
break;
case "AimDrills":
localPlayer.Skills.AimDrills.SetLevel(num);
break;
case "Surgery":
localPlayer.Skills.Surgery.SetLevel(num);
break;
case "CovertMovement":
localPlayer.Skills.CovertMovement.SetLevel(num);
break;
case "Search":
localPlayer.Skills.Search.SetLevel(num);
break;
case "FieldMedicine":
localPlayer.Skills.FieldMedicine.SetLevel(num);
break;
case "FirstAid":
localPlayer.Skills.FirstAid.SetLevel(num);
break;
case "SMG":
localPlayer.Skills.SMG.SetLevel(num);
break;
case "WeaponTreatment":
localPlayer.Skills.WeaponTreatment.SetLevel(num);
break;
case "Revolver":
localPlayer.Skills.Revolver.SetLevel(num);
break;
case "AttachedLauncher":
localPlayer.Skills.AttachedLauncher.SetLevel(num);
break;
}
skillLevels[selectedSkillName] = num;
}
}
private void OnSkillButtonClick(string skillName)
{
selectedSkillName = skillName;
Player localPlayer = Main.LocalPlayer;
if (!(localPlayer == null))
{
int num = 0;
num = skillName switch
{
"Strength" => localPlayer.Skills.Strength.Level,
"StressResistance" => localPlayer.Skills.StressResistance.Level,
"MagDrills" => localPlayer.Skills.MagDrills.Level,
"Melee" => localPlayer.Skills.Melee.Level,
"HideoutManagement" => localPlayer.Skills.HideoutManagement.Level,
"Crafting" => localPlayer.Skills.Crafting.Level,
"HeavyVests" => localPlayer.Skills.HeavyVests.Level,
"LightVests" => localPlayer.Skills.LightVests.Level,
"RecoilControl" => localPlayer.Skills.RecoilControl.Level,
"LMG" => localPlayer.Skills.LMG.Level,
"Assault" => localPlayer.Skills.Assault.Level,
"Pistol" => localPlayer.Skills.Pistol.Level,
"Perception" => localPlayer.Skills.Perception.Level,
"Sniper" => localPlayer.Skills.Sniper.Level,
"Sniping" => localPlayer.Skills.Sniping.Level,
"Endurance" => localPlayer.Skills.Endurance.Level,
"Throwing" => localPlayer.Skills.Throwing.Level,
"Charisma" => localPlayer.Skills.Charisma.Level,
"BotReload" => localPlayer.Skills.BotReload.Level,
"TroubleShooting" => localPlayer.Skills.TroubleShooting.Level,
"Health" => localPlayer.Skills.Health.Level,
"Vitality" => localPlayer.Skills.Vitality.Level,
"Metabolism" => localPlayer.Skills.Metabolism.Level,
"Immunity" => localPlayer.Skills.Immunity.Level,
"Intellect" => localPlayer.Skills.Intellect.Level,
"Attention" => localPlayer.Skills.Attention.Level,
"Shotgun" => localPlayer.Skills.Shotgun.Level,
"HMG" => localPlayer.Skills.HMG.Level,
"Launcher" => localPlayer.Skills.Launcher.Level,
"DMR" => localPlayer.Skills.DMR.Level,
"AimDrills" => localPlayer.Skills.AimDrills.Level,
"Surgery" => localPlayer.Skills.Surgery.Level,
"CovertMovement" => localPlayer.Skills.CovertMovement.Level,
"Search" => localPlayer.Skills.Search.Level,
"FieldMedicine" => localPlayer.Skills.FieldMedicine.Level,
"FirstAid" => localPlayer.Skills.FirstAid.Level,
"SMG" => localPlayer.Skills.SMG.Level,
"WeaponTreatment" => localPlayer.Skills.WeaponTreatment.Level,
"Revolver" => localPlayer.Skills.Revolver.Level,
"AttachedLauncher" => localPlayer.Skills.AttachedLauncher.Level,
_ => 0,
};
skillInfoText.text = $"Selected Skill: {selectedSkillName}\nCurrent Level: {num}";
skillLevelToAddText.text = $"Level to Set: {skillLevelSlider.value:F0}";
skillLevelSlider.value = num;
}
}
private void AddItemToWishList()
{
Main.GetWishlistItems();
_E8D9 obj = Main.LocalPlayer.Profile?.WishlistManager;
if (obj != null)
{
if (spawnid != null)
{
obj.AddToWishlist(itemidstring, EWishlistGroup.Other, simulate: false);
}
Refreshsearchupdate();
}
}
private void PopulateAndFilterItemList(string searchTerm = "")
{
if (pullItemIDs == null || pullItemIDs.itemList == null)
{
return;
}
ClearButtons();
VerticalLayoutGroup component = buttonContainer.GetComponent<VerticalLayoutGroup>();
if (component != null)
{
component.enabled = false;
component.enabled = true;
}
List<ItemData> itemList = pullItemIDs.itemList;
bool anyFilterSelected = Settings.filtersuperrare || Settings.filterkappa || Settings.filterquest || Settings.filterwishlist || Settings.filterhideout || Settings.filterstim;
foreach (ItemData item in itemList.Where(delegate(ItemData itemData)
{
bool flag = stupid.solutions.QuestESP.QuestItemIds.Contains(itemData.Name);
bool flag2 = Main.IsSuperrare(itemData.Name);
bool flag3 = Main.IsKappa(itemData.Name);
bool flag4 = Main.IsStim(itemData.Name);
bool flag5 = Main.wishlistitemids.Contains(itemData.Id);
bool flag6 = Main.hideoutitemids.Contains(itemData.Id);
bool flag7 = !anyFilterSelected;
if (Settings.filtersuperrare && flag2)
{
flag7 = true;
}
if (Settings.filterkappa && flag3)
{
flag7 = true;
}
if (Settings.filterquest && flag)
{
flag7 = true;
}
if (Settings.filterwishlist && flag5)
{
flag7 = true;
}
if (Settings.filterhideout && flag6)
{
flag7 = true;
}
if (Settings.filterstim && flag4)
{
flag7 = true;
}
int? itemPriceBYID2 = GameUtils.GetItemPriceBYID(itemData.Id);
if (Settings.filtervalue && (!itemPriceBYID2.HasValue || itemPriceBYID2.Value < Settings.moneyfiltervalue))
{
return false;
}
return (string.IsNullOrEmpty(searchTerm) || itemData.ShortName.Contains(searchTerm) || itemData.Name.Contains(searchTerm) || itemData.Id.Contains(searchTerm)) && flag7;
}).ToList())
{
int? itemPriceBYID = GameUtils.GetItemPriceBYID(item.Id);
GameObject gameObject = UnityEngine.Object.Instantiate(itembuttontemplate, buttonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
if (!Main.wishlistitemids.Contains(item.Id))
{
if (!Settings.filtervalue)
{
componentInChildren.text = item.ShortName;
}
else
{
componentInChildren.text = $"{item.ShortName} - {itemPriceBYID / 1000}K";
}
}
else if (!Settings.filtervalue)
{
componentInChildren.text = item.ShortName ?? "";
componentInChildren.color = Color.magenta;
}
else
{
componentInChildren.text = $"{item.ShortName} - {itemPriceBYID / 1000}K";
componentInChildren.color = Color.magenta;
}
}
Button component2 = gameObject.GetComponent<Button>();
if (component2 != null)
{
component2.onClick.AddListener(delegate
{
SpawnItemDelegate(item.Id, item.Name, item.avg24hPrice, item.BasePrice);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(buttonContainer.GetComponent<RectTransform>());
scrollRect.verticalNormalizedPosition = 1f;
Canvas.ForceUpdateCanvases();
}
private void UpdateSearchResults(string searchTerm)
{
PopulateAndFilterItemList(searchTerm);
}
private void Refreshsearchupdate()
{
string searchTerm = "";
if (searchInputField.text != null)
{
searchTerm = searchInputField.text;
}
PopulateAndFilterItemList(searchTerm);
}
public void PopulateAllTemplates()
{
if (itembuttontemplate == null || pullItemPresets == null || pullItemPresets.templateList == null || pullItemPresets.templateList.Count == 0)
{
return;
}
populatedtemplates = true;
ClearButtons();
foreach (Transform item in presetButtonContainer)
{
UnityEngine.Object.Destroy(item.gameObject);
}
VerticalLayoutGroup component = presetButtonContainer.GetComponent<VerticalLayoutGroup>();
if (component != null)
{
component.enabled = false;
component.enabled = true;
}
foreach (TemplateData template in pullItemPresets.templateList)
{
GameObject gameObject = UnityEngine.Object.Instantiate(itembuttontemplate, presetButtonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
componentInChildren.text = template.PresetName;
}
Button component2 = gameObject.GetComponent<Button>();
if (component2 != null)
{
component2.onClick.AddListener(delegate
{
SelectPreset(template.PresetName, template.ItemTemplate.FirstOrDefault().Value.Description);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(presetButtonContainer.GetComponent<RectTransform>());
presetScrollRect.verticalNormalizedPosition = 1f;
Canvas.ForceUpdateCanvases();
}
private void UpdatePresetResults(string searchTerm)
{
if (pullItemPresets == null || pullItemPresets.templateList == null)
{
return;
}
if (string.IsNullOrEmpty(searchTerm))
{
PopulateAllTemplates();
return;
}
ClearPresetButtons();
VerticalLayoutGroup component = presetButtonContainer.GetComponent<VerticalLayoutGroup>();
if (component != null)
{
component.enabled = false;
component.enabled = true;
}
List<TemplateData> list = pullItemPresets.templateList.Where((TemplateData templateData) => templateData.PresetName.Contains(searchTerm)).ToList();
if (pullItemPresets.templateList == null)
{
ConsoleScreen.Log("template list is null");
}
foreach (TemplateData template in list)
{
GameObject gameObject = UnityEngine.Object.Instantiate(itembuttontemplate, presetButtonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
componentInChildren.text = template.PresetName;
}
Button component2 = gameObject.GetComponent<Button>();
if (component2 != null)
{
component2.onClick.AddListener(delegate
{
SelectPreset(template.PresetName, template.ItemTemplate.FirstOrDefault().Value.Description);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(presetButtonContainer.GetComponent<RectTransform>());
presetScrollRect.verticalNormalizedPosition = 1f;
Canvas.ForceUpdateCanvases();
}
private void SelectPreset(string presetName, string description)
{
selectedPresetName = presetName;
ConsoleScreen.Log("Selected preset: " + presetName);
presetInfoText.text = " Selected preset : " + presetName + "\n Description : " + description;
}
public unsafe async Task SpawnSelectedPreset()
{
if (string.IsNullOrEmpty(selectedPresetName) || pullItemPresets == null || pullItemPresets.templateList == null)
{
ConsoleScreen.Log("No preset selected or presets list is empty.");
return;
}
TemplateData templateData = pullItemPresets.templateList.FirstOrDefault((TemplateData template) => template.PresetName == selectedPresetName);
if (templateData == null)
{
ConsoleScreen.Log("Selected preset not found in the list.");
return;
}
ConsoleScreen.Log("Spawning preset: " + templateData.PresetName);
KeyValuePair<string, stupid.solutions.ItemTemplate> keyValuePair = templateData.ItemTemplate.FirstOrDefault();
if (keyValuePair.Value == null)
{
ConsoleScreen.Log("No item template found for the selected preset.");
return;
}
string key = keyValuePair.Key;
Dictionary<string, stupid.solutions.SlotData> slotsDictionary = keyValuePair.Value.Slots;
ItemFactory itemFactory = new ItemFactory();
dynamic item = itemFactory.CreateItem(key);
if (item == null)
{
ConsoleScreen.Log("Failed to create the main item from the template.");
return;
}
item.SpawnedInSession = true;
dynamic val = item.AllSlots;
if (val != null)
{
foreach (dynamic item3 in val)
{
string text = item3.FullId;
if (slotsDictionary.TryGetValue(text, out var value))
{
string itemId = value.ItemId;
Item item2 = itemFactory.CreateItem(itemId);
item2.SpawnedInSession = true;
if (item2 != null)
{
try
{
item3.AddWithoutRestrictions(item2);
ConsoleScreen.Log("Added component item " + itemId + " to slot '" + text + "'.");
}
catch (Exception ex)
{
ConsoleScreen.Log("Error adding component to slot '" + text + "': " + ex.Message);
}
}
else
{
ConsoleScreen.Log("Failed to create component item with ID " + itemId + ".");
}
}
await Task.Delay(10);
}
}
else
{
ConsoleScreen.Log("No slots found for the main item.");
}
dynamic awaiter = AddItemToBackpack(item).GetAwaiter();
if (!(bool)awaiter.IsCompleted)
{
ICriticalNotifyCompletion awaiter2 = awaiter as ICriticalNotifyCompletion;
AsyncTaskMethodBuilder asyncTaskMethodBuilder = default(AsyncTaskMethodBuilder);
if (awaiter2 == null)
{
INotifyCompletion awaiter3 = (INotifyCompletion)(object)awaiter;
asyncTaskMethodBuilder.AwaitOnCompleted(ref awaiter3, ref *(_003CSpawnSelectedPreset_003Ed__388*)/*Error near IL_06ed: stateMachine*/);
}
else
{
asyncTaskMethodBuilder.AwaitUnsafeOnCompleted(ref awaiter2, ref *(_003CSpawnSelectedPreset_003Ed__388*)/*Error near IL_0700: stateMachine*/);
}
/*Error near IL_0709: leave MoveNext - await not detected correctly*/;
}
awaiter.GetResult();
}
private void SpawnItemDelegate(string itemId, string fullname, int? value, int basevalue)
{
itemidstring = itemId;
string text = ((!value.HasValue) ? $"Value: {basevalue / 1000}K" : $"Value: {value / 1000}K");
iteminfotext.text = "Selected Item Info :\nFull Name : " + fullname + "\nItem ID: " + itemId + "\n" + text;
}
private void UpdateAIResults(string searchTerm)
{
if (string.IsNullOrEmpty(searchTerm))
{
PopulateAIMenu();
}
else
{
if (aILister.aiPresets == null)
{
return;
}
ClearAIButtons();
VerticalLayoutGroup component = aiButtonContainer.GetComponent<VerticalLayoutGroup>();
if (component != null)
{
component.enabled = false;
component.enabled = true;
}
foreach (AIData ai in aILister.aiPresets.Where((AIData aIData) => aIData.Name.Contains(searchTerm)).ToList())
{
GameObject gameObject = UnityEngine.Object.Instantiate(aiButtonTemplate, aiButtonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
componentInChildren.text = ai.Name;
componentInChildren.color = ai.NameColor;
}
Button component2 = gameObject.GetComponent<Button>();
if (component2 != null)
{
component2.onClick.AddListener(delegate
{
SelectAI(ai.Name, ai.EnumID, ai.Description);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(aiButtonContainer.GetComponent<RectTransform>());
if (aiScrollRect != null)
{
aiScrollRect.verticalNormalizedPosition = 1f;
}
Canvas.ForceUpdateCanvases();
}
}
public void PopulateAIMenu()
{
if (aILister.aiPresets == null || aILister.aiPresets.Count == 0)
{
ConsoleScreen.Log("No AI presets available.");
return;
}
if (aILister.aiPresets.Count > 0)
{
ConsoleScreen.Log($"Found {aILister.aiPresets.Count} AI for List");
}
ClearAIButtons();
VerticalLayoutGroup component = aiButtonContainer.GetComponent<VerticalLayoutGroup>();
if (component != null)
{
component.enabled = false;
component.enabled = true;
}
foreach (AIData ai in aILister.aiPresets)
{
GameObject gameObject = UnityEngine.Object.Instantiate(aiButtonTemplate, aiButtonContainer);
if (gameObject == null)
{
continue;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
if (componentInChildren != null)
{
componentInChildren.text = ai.Name;
componentInChildren.color = ai.NameColor;
}
Button component2 = gameObject.GetComponent<Button>();
if (component2 != null)
{
component2.onClick.AddListener(delegate
{
SelectAI(ai.Name, ai.EnumID, ai.Description);
});
}
gameObject.SetActive(value: true);
}
LayoutRebuilder.ForceRebuildLayoutImmediate(aiButtonContainer.GetComponent<RectTransform>());
if (aiScrollRect != null)
{
aiScrollRect.verticalNormalizedPosition = 1f;
}
Canvas.ForceUpdateCanvases();
}
private void SelectAI(string aiName, WildSpawnType aiID, string description)
{
selectedAIName = aiName;
spawnid = aiID.ToString();
aiInfoText.text = "Selected AI: " + aiName + "\nDescription: " + description;
}
private void ClearAIButtons()
{
foreach (Transform item in aiButtonContainer)
{
UnityEngine.Object.Destroy(item.gameObject);
}
}
public void SpawnBot()
{
IBotGame instance = Singleton<IBotGame>.Instance;
string text = spawnid;
try
{
if (instance == null || spawnid == null)
{
return;
}
if (Enum.TryParse<WildSpawnType>(text, out var result))
{
BotSpawnParams botSpawnParams = new BotSpawnParams();
botSpawnParams.Id_spawn = "";
if (result == WildSpawnType.infectedAssault || result == WildSpawnType.infectedLaborant || result == WildSpawnType.infectedPmc || result == WildSpawnType.infectedCivil)
{
botSpawnParams.TriggerType = SpawnTriggerType.botEvent;
}
else
{
botSpawnParams.TriggerType = SpawnTriggerType.none;
}
instance.BotsController.GetSpawner().SpawnBotByTypeForce(1, result, BotDifficulty.normal, botSpawnParams);
ConsoleScreen.Log($"Spawned AI: {selectedAIName} ({result})");
}
else
{
ConsoleScreen.Log("Invalid WildSpawnType: " + text);
}
}
catch (SystemException ex)
{
ConsoleScreen.Log("Error spawning Bot " + ex.Message);
}
}
public void SpawnItemHelper()
{
if (Settings.fillraidbp)
{
FillRaidBag();
}
if (Settings.thicc)
{
AddItemsToThiccCase();
}
else if (Settings.ammobox || Settings.sicc)
{
AddItemsToBackpack();
}
else
{
Spawnitem();
}
}
public void FillRaidBag()
{
if (Main.GameWorld == null)
{
ConsoleScreen.Log("Log: Game world not found to spawn items in.");
return;
}
try
{
ItemFactory itemFactory = new ItemFactory();
dynamic containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).ContainedItem;
if (containedItem == null)
{
Item item = itemFactory.CreateItem("5df8a4d786f77412672a1e3b");
if (item == null)
{
ConsoleScreen.Log("Log: Failed to create backpack.");
return;
}
Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).AddWithoutRestrictions(item);
containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).ContainedItem;
}
if (containedItem == null || containedItem.Grids == null || containedItem.Grids.Length == 0)
{
ConsoleScreen.Log("Log: No valid grid found in backpack.");
return;
}
dynamic val = containedItem.Grids[0];
if (!Settings.sicc && !Settings.ammobox && !Settings.thicc)
{
for (int i = 0; i < val.GridWidth; i++)
{
for (int j = 0; j < val.GridHeight; j++)
{
dynamic val2 = itemFactory.CreateItem(itemidstring);
if (val2 == null)
{
ConsoleScreen.Log("Log: Failed to create item with ID " + itemidstring + ".");
continue;
}
val2.SpawnedInSession = true;
val2.StackObjectsCount = val2.Template.StackMaxSize;
if (Settings.componentexploit)
{
ProcessComponents(val2);
}
LocationInGrid locationInGrid = val.FindFreeSpace(val2);
if (!(locationInGrid != null))
{
ConsoleScreen.Log("Log: No free space left in backpack for more items.");
return;
}
val.AddItemWithoutRestrictions(val2, locationInGrid);
}
}
}
else
{
string text = (Settings.sicc ? Settings.SICCID : "5aafbde786f774389d0cbc0f");
int num = (Settings.sicc ? 1 : 2);
int num2 = 2;
int num3 = val.GridWidth;
int num4 = val.GridHeight;
int num5 = num3 * num4 / (num * num2);
for (int k = 0; k < num5; k++)
{
dynamic val3 = itemFactory.CreateItem(text);
if (val3 == null)
{
ConsoleScreen.Log("Log: Failed to create container with ID " + text + ".");
continue;
}
val3.SpawnedInSession = true;
FillContainerWithNestedItems(val3, itemidstring, itemFactory);
LocationInGrid locationInGrid2 = val.FindFreeSpace(val3);
if (!(locationInGrid2 != null))
{
ConsoleScreen.Log("Log: No free space left in backpack for more containers.");
break;
}
val.AddItemWithoutRestrictions(val3, locationInGrid2);
ConsoleScreen.Log("Log: Container added to backpack successfully.");
}
}
ConsoleScreen.Log("Log: Backpack filled to maximum capacity.");
}
catch (Exception ex)
{
ConsoleScreen.Log("Log: Exception occurred while filling backpack: " + ex.Message);
}
}
public void Spawnitemadvanced()
{
advanceditemidcache = itemidstring;
advanceditemcache = new ItemFactory().CreateItem(advanceditemidcache);
if (advanceditemcache == null)
{
ConsoleScreen.Log("Failed to create advanced item.");
return;
}
cachedBuffs = ExtractBuffs(advanceditemcache);
cachedSlots = ExtractSlots(advanceditemcache);
ShowAdvancedItemMenu();
}
private List<BuffComponent> ExtractBuffs(dynamic item)
{
List<BuffComponent> list = new List<BuffComponent>();
try
{
dynamic itemComponents = item.GetItemComponents<BuffComponent>();
if (itemComponents != null)
{
list.AddRange(itemComponents);
}
}
catch
{
dynamic itemComponent = item.GetItemComponent<BuffComponent>();
if (itemComponent != null)
{
list.Add(itemComponent);
}
}
return list;
}
private List<(string slotName, dynamic slotRef)> ExtractSlots(dynamic item)
{
List<(string, object)> list = new List<(string, object)>();
dynamic val = item.AllSlots;
if (val != null)
{
foreach (dynamic item2 in val)
{
if (item2.ContainedItem == null)
{
list.Add(((string)(object)item2.Name, item2));
}
}
}
return list;
}
private void RefreshslotItems()
{
ConsoleScreen.Log("Updating Items Available Slots...");
int count = cachedSlots.Count;
cachedSlots = ExtractSlots(advanceditemcache);
PopulateSlotListUI(cachedSlots);
ConsoleScreen.Log($"Item Slots Updated : {count} -> {cachedSlots.Count}");
}
private void ShowAdvancedItemMenu()
{
advancedItemPanel.SetActive(value: true);
slotItemWindow.SetActive(value: false);
PopulateBuffListUI(cachedBuffs);
PopulateSlotListUI(cachedSlots);
spawnadvancedButton.onClick.RemoveAllListeners();
spawnadvancedButton.onClick.AddListener(OnSpawnAdvancedConfirmed);
cancelButton.onClick.RemoveAllListeners();
cancelButton.onClick.AddListener(CloseAdvancedSpawnMenuandReset);
refreshSlotsButton.onClick.RemoveAllListeners();
refreshSlotsButton.onClick.AddListener(delegate
{
RefreshslotItems();
});
buffEditWindow.SetActive(cachedBuffs.Count > 0);
slotListContainer.parent.gameObject.SetActive(cachedSlots.Count > 0);
}
private void CloseAdvancedSpawnMenuandReset()
{
advancedItemPanel.SetActive(value: false);
advanceditemcache = null;
cachedBuffs.Clear();
cachedSlots.Clear();
PopulateBuffListUI(cachedBuffs);
PopulateSlotListUI(cachedSlots);
}
private void PopulateBuffListUI(List<BuffComponent> buffs)
{
foreach (Transform item in buffListContainer)
{
UnityEngine.Object.Destroy(item.gameObject);
}
foreach (BuffComponent buff in buffs)
{
string buffname = "Empty Buff Slot";
if (IsValidBuff(buff.BuffType))
{
buffname = buff.BuffType.ToString();
}
GameObject obj = UnityEngine.Object.Instantiate(buffButtonTemplate, buffListContainer);
obj.GetComponentInChildren<TMP_Text>().text = $"{buffname} ({buff.Value:F2})";
obj.GetComponent<Button>().onClick.AddListener(delegate
{
OnBuffSelected(buff, buffname);
});
obj.SetActive(value: true);
}
}
private bool IsValidBuff(ERepairBuffType type)
{
if (Enum.IsDefined(typeof(ERepairBuffType), type))
{
return type != (ERepairBuffType)(-1);
}
return false;
}
private void OnBuffSelected(BuffComponent buff, string buffName)
{
currentEditingBuff = buff;
buffNameText.text = buffName;
buffSlider.value = (float)buff.Value;
buffTypeDropdown.ClearOptions();
List<string> options = Enum.GetNames(typeof(ERepairBuffType)).ToList();
buffTypeDropdown.AddOptions(options);
int buffType = (int)buff.BuffType;
if (buffType >= 0 && buffType < buffTypeDropdown.options.Count)
{
buffTypeDropdown.value = buffType;
}
UpdateBuffInfoText(buff);
buffValueText.text = $"Buff Value: {buff.Value:F2}";
buffSlider.onValueChanged.RemoveAllListeners();
buffSlider.onValueChanged.AddListener(delegate(float value)
{
buffValueText.text = $"Buff Value: {value:F2}";
});
applyBuffButton.onClick.RemoveAllListeners();
applyBuffButton.onClick.AddListener(delegate
{
float value = buffSlider.value;
if (Enum.TryParse<ERepairBuffType>(buffTypeDropdown.options[buffTypeDropdown.value].text, out var result))
{
buff.BuffType = result;
}
buff.Value = value;
currentEditingBuff = null;
buffNameText.text = "Please select a Buff from the List";
buffValueText.text = "";
PopulateBuffListUI(cachedBuffs);
});
}
private void DumpAndSetAllAttributes(dynamic item1)
{
Item item2 = item1 as Item;
if (item2.Attributes == null)
{
ConsoleScreen.Log("No attributes found.");
return;
}
foreach (_EFA5 attribute in item2.Attributes)
{
float num;
try
{
num = ((attribute.Base != null) ? attribute.Base() : float.NaN);
}
catch
{
num = float.NaN;
}
string arg = attribute.DisplayName ?? attribute.Name ?? "Unknown";
ConsoleScreen.Log($"Attribute: {arg} | Current Value: {num}");
attribute.Base = () => 1000000f;
attribute.StringValue = () => "1000000";
attribute.Update();
}
ConsoleScreen.Log("All attribute Base values replaced with 1,000,000.");
}
private void UpdateBuffInfoText(BuffComponent buff)
{
buffNameText.text = $"Buff: {buff.BuffType}";
buffValueText.text = $"Buff Value: {buff.Value:F2}";
}
private void PopulateSlotListUI(List<(string, dynamic)> slots)
{
foreach (Transform item in slotListContainer)
{
UnityEngine.Object.Destroy(item.gameObject);
}
foreach (var slot in slots)
{
string slotName = slot.Item1;
dynamic slotRef = slot.Item2;
GameObject obj = UnityEngine.Object.Instantiate(slotButtonTemplate, slotListContainer);
obj.GetComponentInChildren<TMP_Text>().text = slotName;
obj.GetComponent<Button>().onClick.AddListener(delegate
{
OpenSlotSelectWindow(slotRef, slotName);
});
obj.SetActive(value: true);
}
}
private void OpenSlotSelectWindow(dynamic slot, string slotName)
{
currentEditingSlotRef = slot;
currentSlotName = slotName;
selectedSlotItemId = null;
if (!slotItemWindow.activeSelf)
{
slotItemWindow.SetActive(value: true);
}
slotItemWindowTitle.text = "Slot: " + slotName;
slotItemInfoText.text = "Select an item...";
try
{
foreach (Transform item2 in slotCompatibleItemsContainer)
{
UnityEngine.Object.Destroy(item2.gameObject);
}
}
catch (Exception arg)
{
ConsoleScreen.Log($"[AdvancedItemSpawner] Instance Clearing Error: {arg}");
}
List<ItemData> list = new List<ItemData>();
try
{
if (slot.Filters != null)
{
foreach (dynamic item3 in slot.Filters)
{
dynamic val = item3 == null;
if (val || item3.Filter == null)
{
continue;
}
foreach (object item4 in item3.Filter)
{
try
{
string text = ((dynamic)item4)?.ToString()?.Trim();
if (!string.IsNullOrEmpty(text) && text.Length == 24)
{
ItemData itemDataByID = GetItemDataByID(text);
list.Add(itemDataByID);
}
}
catch (Exception)
{
}
}
}
}
else
{
ConsoleScreen.Log("[AdvancedItemSpawner] Slot '" + slotName + "' has no filters.");
}
}
catch (Exception ex2)
{
ConsoleScreen.Log("[AdvancedItemSpawner] ERROR parsing filters: " + ex2.Message + "\n" + ex2.StackTrace);
}
if (list.Count == 0)
{
slotItemInfoText.text = "No compatible items.";
ConsoleScreen.Log("[AdvancedItemSpawner] No compatible items for slot '" + slotName + "'.");
slotItemWindow.SetActive(value: false);
return;
}
ConsoleScreen.Log($"[AdvancedItemSpawner] Found {list.Count} compatible items for slot '{slotName}':");
foreach (ItemData id in list.Distinct())
{
GameObject obj = UnityEngine.Object.Instantiate(compatibleItemButtonTemplate, slotCompatibleItemsContainer);
obj.GetComponentInChildren<TMP_Text>().text = id.ShortName;
obj.GetComponent<Button>().onClick.AddListener(delegate
{
selectedSlotItemId = id.Id;
slotItemInfoText.text = "Selected Item Name : " + id.Name + "\nSelected Item ID:" + id.Id;
});
obj.SetActive(value: true);
}
cancelSlotButton.onClick.RemoveAllListeners();
cancelSlotButton.onClick.AddListener(delegate
{
HideSlotItemWindow();
});
applySlotButton.onClick.RemoveAllListeners();
applySlotButton.onClick.AddListener(delegate
{
if (!string.IsNullOrEmpty(selectedSlotItemId))
{
try
{
Item item = new ItemFactory().CreateItem(selectedSlotItemId);
if (item != null)
{
item.SpawnedInSession = true;
currentEditingSlotRef.AddWithoutRestrictions(item);
ConsoleScreen.Log("[AdvancedItemSpawner] Applied item " + selectedSlotItemId + " to slot " + currentSlotName);
foreach (BuffComponent item5 in ExtractBuffs(item))
{
if (!cachedBuffs.Contains(item5))
{
cachedBuffs.Add(item5);
}
}
buffEditWindow.SetActive(cachedBuffs.Count > 0);
PopulateBuffListUI(cachedBuffs);
}
else
{
ConsoleScreen.Log("[AdvancedItemSpawner] Failed to create item from ID " + selectedSlotItemId);
}
}
catch (Exception ex3)
{
ConsoleScreen.Log("[AdvancedItemSpawner] Failed to apply item to slot: " + ex3.Message);
}
}
HideSlotItemWindow();
});
}
private void HideSlotItemWindow()
{
RefreshslotItems();
slotItemWindow.SetActive(value: false);
selectedSlotItemId = null;
slotItemInfoText.text = "Select an item...";
}
private ItemData GetItemDataByID(string itemID)
{
if (pullItemIDs.itemList != null && pullItemIDs.itemList.Count > 0)
{
ItemData itemData = pullItemIDs.itemList.FirstOrDefault((ItemData item) => item.Id == itemID);
if (itemData != null && !string.IsNullOrEmpty(itemData.Name))
{
return itemData;
}
}
return new ItemData
{
Id = itemID,
ShortName = "Default Component",
Name = "Default Component",
NormalizedName = "default_component",
Types = new List<string>(),
BasePrice = 0,
avg24hPrice = null
};
}
private void OnSpawnAdvancedConfirmed()
{
if (advanceditemcache != null)
{
AddItemToBackpack(advanceditemcache);
advancedItemPanel.SetActive(value: false);
advanceditemcache = null;
cachedBuffs.Clear();
cachedSlots.Clear();
PopulateBuffListUI(cachedBuffs);
PopulateSlotListUI(cachedSlots);
ConsoleScreen.Log("Advanced item spawned successfully.");
}
}
private void OpenPopupSaveFile()
{
UnityEngine.Debug.Log("Opening popup for save type: " + SaveType.File);
ConsoleScreen.Log("Opening popup for save type: " + SaveType.File);
if (popupWindow == null)
{
UnityEngine.Debug.LogError("popupWindow is not assigned!");
ConsoleScreen.Log("Opening popup for save type: " + SaveType.File);
}
else if (presetNameInput == null)
{
UnityEngine.Debug.LogError("presetNameInput is not assigned!");
ConsoleScreen.Log("Opening popup for save type: " + SaveType.File);
}
else
{
currentSaveType = SaveType.File;
popupWindow.SetActive(value: true);
}
}
private void OpenPopupSaveList()
{
UnityEngine.Debug.Log("Opening popup for save type: " + SaveType.List);
ConsoleScreen.Log("Opening popup for save type: " + SaveType.List);
if (popupWindow == null)
{
UnityEngine.Debug.LogError("popupWindow is not assigned!");
ConsoleScreen.Log("Opening popup for save type: " + SaveType.List);
}
else if (presetNameInput == null)
{
UnityEngine.Debug.LogError("presetNameInput is not assigned!");
ConsoleScreen.Log("Opening popup for save type: " + SaveType.List);
}
else
{
currentSaveType = SaveType.List;
popupWindow.SetActive(value: true);
}
}
private void OnConfirmSave()
{
string text = presetNameInput.text.Trim();
if (string.IsNullOrEmpty(text))
{
ConsoleScreen.Log("Please enter a name.");
return;
}
if (advanceditemcache == null)
{
ConsoleScreen.LogError("No item selected to save.");
return;
}
if (currentSaveType == SaveType.File)
{
SaveItemToFile(advanceditemcache, text);
}
else
{
pullItemPresets.SaveItemToPresetList(advanceditemcache, text);
PopulateAllTemplates();
}
popupWindow.SetActive(value: false);
}
public void Spawnitem()
{
if (Main.GameWorld == null)
{
return;
}
try
{
ItemFactory itemFactory = new ItemFactory();
string text = itemidstring;
dynamic val = itemFactory.CreateItem(text);
dynamic property = val.GetType().GetProperty("AllSlots");
if (val == null)
{
ConsoleScreen.Log("Log: Failed to create item.");
return;
}
if (property == null)
{
ConsoleScreen.Log("Log: Item does not contain a definition for AllSlots. Not attempting to fill.");
}
ConsoleScreen.Log("Log: Item created successfully.");
val.SpawnedInSession = true;
val.StackObjectsCount = val.Template.StackMaxSize;
presetManager.itemParameters["ItemId"] = text;
presetManager.itemParameters["StackMaxSize"] = (object)val.Template.StackMaxSize;
presetManager.itemParameters["QuestItem"] = (object)val.QuestItem;
dynamic val2 = ((property != null) ? property.GetValue(val) : null);
if ((val2 != null) & Settings.fillslots)
{
ProcessSlotsForSpawn(val);
}
if (Settings.componentexploit)
{
ProcessComponents(val);
}
AddItemToBackpack(val);
if (saveFlag)
{
string filePath = Path.Combine(Application.persistentDataPath, "itempresets.json");
presetManager.SaveToJson(filePath);
presetManager.Clear();
saveFlag = false;
}
}
catch (Exception ex)
{
ConsoleScreen.Log("Log: Exception occurred: " + ex.Message);
}
}
private void ProcessComponents(dynamic item)
{
if (item.GetItemComponent<DogtagComponent>() is DogtagComponent dogtagComponent)
{
string text = item.Template.Name;
if (text.Contains("bear") || text.Contains("BEAR") || text.Contains("Bear"))
{
dogtagComponent.Side = EPlayerSide.Bear;
}
else
{
dogtagComponent.Side = EPlayerSide.Usec;
}
dogtagComponent.Level = 75;
dogtagComponent.KillerName = "a Solution by xXBattleyeXx";
dogtagComponent.WeaponName = "Balls WTF";
dogtagComponent.Time = DateTime.Now;
dogtagComponent.CarriedByGroupMember = false;
dogtagComponent.Nickname = "stupid.solutions";
dogtagComponent.Item.SpawnedInSession = true;
dogtagComponent.Status = "My boiiiiiiiiiiiiiiiiiiiiiahahsdgwajh";
}
_ = item.GetItemComponent<EquipmentPenaltyComponent>() is EquipmentPenaltyComponent;
if (item.GetItemComponent<FoodDrinkComponent>() is FoodDrinkComponent foodDrinkComponent)
{
foodDrinkComponent.HpPercent = 999999f;
foodDrinkComponent.Item.SpawnedInSession = true;
}
_ = item.GetItemComponent<GridLayoutComponent>() is GridLayoutComponent;
_ = item.GetItemComponent<StimulatorBuffsComponent>() is StimulatorBuffsComponent;
if (item.GetItemComponent<KeyComponent>() is KeyComponent keyComponent)
{
keyComponent.NumberOfUsages = -100000;
keyComponent.Item.SpawnedInSession = true;
}
if (item.GetItemComponent<KeycardComponent>() is KeycardComponent keycardComponent)
{
keycardComponent.Key.NumberOfUsages = -100000;
keycardComponent.Item.SpawnedInSession = true;
}
if (item.GetItemComponent<MedKitComponent>() is MedKitComponent medKitComponent)
{
medKitComponent.HpResource = 99999f;
medKitComponent.Item.SpawnedInSession = true;
}
if (item.GetItemComponent<RecodableComponent>() is RecodableComponent recodableComponent)
{
recodableComponent.IsEncoded = true;
recodableComponent.SetEncoded(value: true);
recodableComponent.Item.SpawnedInSession = true;
}
if (item.GetItemComponent<RepairKitComponent>() is RepairKitComponent repairKitComponent)
{
repairKitComponent.Resource = 999999f;
repairKitComponent.Item.SpawnedInSession = true;
}
if (item.GetItemComponent<RepairableComponent>() is RepairableComponent repairableComponent)
{
repairableComponent.Durability = 999999f;
repairableComponent.Item.SpawnedInSession = true;
}
_ = item.GetItemComponent<SightComponent>() is SightComponent;
if (item.GetItemComponent<ResourceComponent>() is ResourceComponent resourceComponent)
{
resourceComponent.Value = 999999f;
resourceComponent.Item.SpawnedInSession = true;
}
}
private void ProcessSlotsForSpawn(dynamic item)
{
if (!Settings.fillslots)
{
return;
}
ItemFactory itemFactory = new ItemFactory();
dynamic val = item.AllSlots;
if (val == null)
{
ConsoleScreen.Log("Log: No slots found for the base item.");
return;
}
foreach (dynamic item3 in val)
{
string text = item3.Name;
string text2 = item3.FullId;
Dictionary<string, string> value = new Dictionary<string, string>
{
{ "SlotID", text2 },
{ "SlotName", text }
};
presetManager.itemParameters[text2] = value;
dynamic val2 = item3.Filters;
dynamic val3 = val2 == null;
if (val3 || val2.Length == 0)
{
continue;
}
foreach (dynamic item4 in val2)
{
val3 = item4 == null || item4.Filter == null;
if (val3 || item4.Filter.Length == 0)
{
continue;
}
string text3 = ((item4.Filter.Length == 1) ? item4.Filter[0].ToString() : item4.Filter[UnityEngine.Random.Range(0, item4.Filter.Length)].ToString());
ConsoleScreen.Log("Log: Slot " + text + " - Selected component item ID: " + text3);
if (!string.IsNullOrEmpty(text3))
{
Item item2 = itemFactory.CreateItem(text3);
item2.SpawnedInSession = true;
if (item2 != null)
{
item3.AddWithoutRestrictions(item2);
((Dictionary<string, string>)presetManager.itemParameters[text2])["ItemId"] = text3;
}
}
break;
}
}
}
public async Task LoadAndSpawnItemFromJson()
{
try
{
string filePath = Path.Combine(Application.persistentDataPath, "itempresets.json");
string mainItemId;
Dictionary<string, Dictionary<string, string>> dictionary = presetManager.LoadFromJson(filePath, out mainItemId);
if (dictionary == null || string.IsNullOrEmpty(mainItemId))
{
return;
}
ItemFactory itemFactory = new ItemFactory();
dynamic item = itemFactory.CreateItem(mainItemId);
if ((item == null) || !dictionary.TryGetValue("Slots", out var slotsDictionary) || slotsDictionary == null)
{
return;
}
item.SpawnedInSession = true;
dynamic val = item.AllSlots;
if (val == null)
{
return;
}
foreach (dynamic item3 in val)
{
string key = item3.FullId;
if (slotsDictionary.TryGetValue(key, out var value))
{
slotsDictionary.Remove(key);
Item item2 = itemFactory.CreateItem(value);
item2.SpawnedInSession = true;
if (item2 != null)
{
try
{
item3.AddWithoutRestrictions(item2);
}
catch (Exception)
{
}
}
}
await Task.Delay(10);
}
AddItemToBackpack(item);
}
catch (Exception)
{
}
}
private void SaveItemToFile(dynamic item, string filename)
{
Dictionary<string, object> dictionary = new Dictionary<string, object>();
dictionary.Add(item.TemplateId.ToString(), new Dictionary<string, object>
{
{ "StackMaxSize", 1 },
{ "QuestItem", false },
{
"Slots",
new Dictionary<string, Dictionary<string, string>>()
}
});
Dictionary<string, object> dictionary2 = dictionary;
Dictionary<string, Dictionary<string, string>> dictionary3 = (Dictionary<string, Dictionary<string, string>>)((Dictionary<string, object>)dictionary2[item.TemplateId.ToString()])["Slots"];
foreach (dynamic item2 in item.AllSlots)
{
if (item2.ContainedItem != null)
{
dynamic val = item2.FullId;
Dictionary<string, string> dictionary4 = new Dictionary<string, string>();
dictionary4.Add("SlotID", item2.FullId);
dictionary4.Add("SlotName", item2.Name);
dictionary4.Add("ItemId", item2.ContainedItem.TemplateId);
dictionary3[val] = dictionary4;
}
}
string text = Path.Combine(Application.persistentDataPath, filename + ".json");
File.WriteAllText(text, JsonConvert.SerializeObject(dictionary2, Formatting.Indented));
ConsoleScreen.Log("Saved to file: " + text);
}
public void SavePrimaryWeaponToJson()
{
ConsoleScreen.Log("Attempting to save Primary Weapon...");
try
{
dynamic containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.FirstPrimaryWeapon).ContainedItem;
if (containedItem == null)
{
return;
}
Dictionary<string, object> dictionary = new Dictionary<string, object>();
dictionary.Add(containedItem.TemplateId.ToString(), new Dictionary<string, object>
{
{ "StackMaxSize", 1 },
{ "QuestItem", false },
{
"Slots",
new Dictionary<string, Dictionary<string, string>>()
}
});
Dictionary<string, object> dictionary2 = dictionary;
Dictionary<string, Dictionary<string, string>> dictionary3 = (Dictionary<string, Dictionary<string, string>>)((Dictionary<string, object>)dictionary2[containedItem.TemplateId.ToString()])["Slots"];
foreach (dynamic item in containedItem.AllSlots)
{
if (item.ContainedItem != null)
{
dynamic val = item.FullId;
Dictionary<string, string> dictionary4 = new Dictionary<string, string>();
dictionary4.Add("SlotID", item.FullId);
dictionary4.Add("SlotName", item.Name);
dictionary4.Add("ItemId", item.ContainedItem.TemplateId);
dictionary3[val] = dictionary4;
}
}
string text = Path.Combine(Application.persistentDataPath, "itempresets.json");
File.WriteAllText(text, JsonConvert.SerializeObject(dictionary2, Formatting.Indented));
ConsoleScreen.Log("Saved successfully: " + text);
}
catch (Exception ex)
{
ConsoleScreen.Log("Exception occurred: " + ex.Message);
}
}
private async Task AddItemToBackpack(dynamic item)
{
dynamic containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).ContainedItem;
if (containedItem == null)
{
Item item2 = new ItemFactory().CreateItem("5df8a4d786f77412672a1e3b");
if (item2 != null)
{
Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).AddWithoutRestrictions(item2);
containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).ContainedItem;
}
}
if (containedItem != null)
{
dynamic val = containedItem.Grids[0].FindFreeSpace(item);
if (val == null)
{
ItemFactory.GridHelper gridHelper = new ItemFactory.GridHelper();
dynamic val2 = containedItem.Grids[0];
LocationInGrid locationInGrid = gridHelper.FindFreeSpace(item, val2);
containedItem.Grids[0].AddItemWithoutRestrictions(item, locationInGrid);
ConsoleScreen.Log($"using old method = {locationInGrid}");
}
else if (val != null)
{
containedItem.Grids[0].AddItemWithoutRestrictions(item, val);
ConsoleScreen.Log("Item successfully added to the backpack.");
}
}
else
{
ConsoleScreen.LogError("No backpack found to place the item.");
}
}
private async Task testgrid()
{
dynamic containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.SecuredContainer).ContainedItem;
if (containedItem == null)
{
ItemFactory itemFactory = new ItemFactory();
Gridmanager gridmanager = new Gridmanager();
Item item = itemFactory.CreateItem("5c093ca986f7740a1867ab12");
if (item != null)
{
gridmanager.ReplaceGrid(item, 4, 90);
Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.SecuredContainer).AddWithoutRestrictions(item);
containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.SecuredContainer).ContainedItem;
}
}
if (containedItem != null)
{
string text = "5c0a794586f77461c458f894";
Gridmanager gridmanager2 = new Gridmanager();
gridmanager2.ReplaceGrid(containedItem, 4, 90, text);
}
}
public void AddItemsToThiccCase()
{
if (Main.GameWorld == null)
{
return;
}
try
{
ItemFactory itemFactory = new ItemFactory();
dynamic val = itemFactory.CreateItem("5aafbde786f774389d0cbc0f");
if (val.GetItemComponent<TagComponent>() is TagComponent tagComponent)
{
_ = (string)val.Template.ShortName;
tagComponent.Name = "Contains THICC";
tagComponent.Color = 2;
tagComponent.Item.SpawnedInSession = true;
}
dynamic val2 = itemFactory.CreateItem("5c0a840b86f7742ffa4f2482");
val2.SpawnedInSession = true;
val.SpawnedInSession = true;
if (val2 == null)
{
ConsoleScreen.Log("Log: Failed to create Thicc case.");
return;
}
dynamic containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).ContainedItem;
if (GameUtils.IsInventoryItemValid(containedItem))
{
LocationInGrid locationInGrid = containedItem.Grids[0].FindFreeSpace(val);
LocationInGrid locationInGrid2 = val.Grids[0].FindFreeSpace(val2);
if (locationInGrid != null)
{
HandleThiccCaseContents(val2, itemFactory);
val.Grids[0].AddItemWithoutRestrictions(val2, locationInGrid2);
val.Grids[0].AddItemWithoutRestrictions(val2, locationInGrid2);
containedItem.Grids[0].AddItemWithoutRestrictions(val, locationInGrid);
ConsoleScreen.Log("Log: Thicc case added to the backpack successfully.");
}
return;
}
Item item = itemFactory.CreateItem("5df8a4d786f77412672a1e3b");
if (item != null)
{
Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).AddWithoutRestrictions(item);
dynamic containedItem2 = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).ContainedItem;
LocationInGrid locationInGrid3 = containedItem2.Grids[0].FindFreeSpace(val);
LocationInGrid locationInGrid4 = val.Grids[0].FindFreeSpace(val2);
if (containedItem2 != null)
{
val.Grids[0].AddItemWithoutRestrictions(val2, locationInGrid4);
val.Grids[0].AddItemWithoutRestrictions(val2, locationInGrid4);
containedItem.Grids[0].AddItemWithoutRestrictions(val, locationInGrid3);
}
}
}
catch (Exception ex)
{
ConsoleScreen.Log("Log: Exception occurred: " + ex.Message);
}
}
private void HandleThiccCaseContents(dynamic thiccCase, ItemFactory itemFactory)
{
if (Main.GameWorld == null)
{
return;
}
dynamic val = thiccCase.Grids[0];
int num = val.GridWidth;
int num2 = val.GridHeight;
string id = (Settings.sicc ? Settings.SICCID : "5aafbde786f774389d0cbc0f");
int num3 = (Settings.sicc ? 1 : 2);
int num4 = 2;
int num5 = num * num2 / (num3 * num4);
for (int i = 0; i < num5; i++)
{
dynamic val2 = itemFactory.CreateItem(id);
if (val2 != null)
{
val2.SpawnedInSession = true;
LocationInGrid locationInGrid = val.FindFreeSpace(val2);
if (locationInGrid != null)
{
val.AddItemWithoutRestrictions(val2, locationInGrid);
ConsoleScreen.Log("Log: Container added to Thicc case.");
FillContainerWithNestedItems(val2, itemidstring, itemFactory);
}
else
{
ConsoleScreen.Log("Log: No free space in Thicc case for container.");
}
}
else
{
ConsoleScreen.Log("Log: Failed to create container.");
}
}
}
public void AddItemsToBackpack()
{
if (Main.GameWorld == null)
{
return;
}
try
{
ItemFactory itemFactory = new ItemFactory();
string id = (Settings.sicc ? Settings.SICCID : "5aafbde786f774389d0cbc0f");
_ = Settings.sicc;
dynamic val = itemFactory.CreateItem(id);
if (val == null)
{
ConsoleScreen.Log("Log: Failed to create container.");
return;
}
val.SpawnedInSession = true;
dynamic containedItem = Main.LocalPlayer.Profile.Inventory.Equipment.GetSlot(EquipmentSlot.Backpack).ContainedItem;
if (GameUtils.IsInventoryItemValid(containedItem))
{
LocationInGrid locationInGrid = containedItem.Grids[0].FindFreeSpace(val);
if (locationInGrid != null)
{
containedItem.Grids[0].AddItemWithoutRestrictions(val, locationInGrid);
ConsoleScreen.Log("Log: Container added to the backpack successfully.");
FillContainerWithNestedItems(val, itemidstring, itemFactory);
}
else
{
ConsoleScreen.Log("Log: No free space in backpack for container.");
}
}
else
{
ConsoleScreen.Log("Log: Backpack is not valid.");
}
}
catch (Exception ex)
{
ConsoleScreen.Log("Log: Exception occurred: " + ex.Message);
}
}
private void FillContainerWithNestedItems(dynamic container, string nestedItemID, ItemFactory itemFactory)
{
if (Main.GameWorld == null)
{
return;
}
dynamic val = container.Grids[0];
int num = val.GridWidth;
int num2 = val.GridHeight;
int num3 = 1;
int num4 = 1;
int num5 = num * num2 / (num3 * num4);
for (int i = 0; i < num5; i++)
{
dynamic val2 = itemFactory.CreateItem(nestedItemID);
if (val2 != null)
{
val2.SpawnedInSession = true;
val2.StackObjectsCount = val2.Template.StackMaxSize;
if (container.GetItemComponent<TagComponent>() is TagComponent tagComponent)
{
string text = val2.Template.ShortName;
tagComponent.Name = "Contains " + text + " ";
tagComponent.Color = 2;
tagComponent.Item.SpawnedInSession = true;
}
if (Settings.componentexploit)
{
ProcessComponents(val2);
}
LocationInGrid locationInGrid = val.FindFreeSpace(val2);
if (!(locationInGrid != null))
{
ConsoleScreen.Log("Log: No free space in container for nested item.");
break;
}
val.AddItemWithoutRestrictions(val2, locationInGrid);
}
else
{
ConsoleScreen.Log("Log: Failed to create nested item with ID: " + nestedItemID + ".");
}
}
}
private void OnKeybindButtonClick(KeybindType keybindType)
{
currentKeybindType = keybindType;
waitingForKey = true;
switch (keybindType)
{
case KeybindType.ClearCache:
clearCacheKeyLabel.text = "Press a key...";
break;
case KeybindType.Skill:
skillKeyLabel.text = "Press a key...";
break;
case KeybindType.Aimbot:
aimbotKeyLabel.text = "Press a key...";
break;
case KeybindType.UnlockDoors:
unlockDoorsKeyLabel.text = "Press a key...";
break;
case KeybindType.teleportitem:
teleportitemlabel.text = "Press a key...";
break;
case KeybindType.killall:
killalllabel.text = "Press a key...";
break;
case KeybindType.tpall:
tpallkeylabel.text = "Press a key...";
break;
case KeybindType.instaheal:
instahealkeylabel.text = "Press a key...";
break;
case KeybindType.flyhack:
flyhacktogglekeylabel1.text = "Press a key...";
break;
case KeybindType.speedhack:
speedhacktogglekeylabel1.text = "Press a key...";
break;
}
}
private void AssignKeybind(KeyCode newKey)
{
switch (currentKeybindType)
{
case KeybindType.ClearCache:
Settings.ClearCache = newKey;
clearCacheKeyLabel.text = "Key: " + newKey;
break;
case KeybindType.Skill:
Settings.tpp = newKey;
skillKeyLabel.text = "Key: " + newKey;
break;
case KeybindType.Aimbot:
Settings.AimbotKey = newKey;
aimbotKeyLabel.text = "Key: " + newKey;
break;
case KeybindType.UnlockDoors:
Settings.UnlockDoors = newKey;
unlockDoorsKeyLabel.text = "Key: " + newKey;
break;
case KeybindType.teleportitem:
Settings.teleportitem = newKey;
teleportitemlabel.text = "Key: " + newKey;
break;
case KeybindType.killall:
Settings.KillAll = newKey;
killalllabel.text = "Key: " + newKey;
break;
case KeybindType.tpall:
Settings.TPall = newKey;
tpallkeylabel.text = "Key: " + newKey;
break;
case KeybindType.instaheal:
Settings.Instahealkey = newKey;
instahealkeylabel.text = "Key: " + newKey;
break;
case KeybindType.flyhack:
Settings.flyhacktoggle = newKey;
flyhacktogglekeylabel1.text = "Key: " + newKey;
break;
case KeybindType.speedhack:
Settings.speedhacktoggle = newKey;
speedhacktogglekeylabel1.text = "Key: " + newKey;
break;
}
}
private void UpdateKeybindLabels()
{
clearCacheKeyLabel.text = "Key: " + Settings.ClearCache;
skillKeyLabel.text = "Key: " + Settings.tpp;
aimbotKeyLabel.text = "Key: " + Settings.AimbotKey;
unlockDoorsKeyLabel.text = "Key: " + Settings.UnlockDoors;
teleportitemlabel.text = "Key: " + Settings.teleportitem;
killalllabel.text = "Key: " + Settings.KillAll;
tpallkeylabel.text = "Key: " + Settings.TPall;
instahealkeylabel.text = "Key: " + Settings.Instahealkey;
speedhacktogglekeylabel1.text = "Key: " + Settings.speedhacktoggle;
flyhacktogglekeylabel1.text = "Key: " + Settings.flyhacktoggle;
}
public void HideAllPanels()
{
aimbotPanel.SetActive(value: false);
playerESPPanel.SetActive(value: false);
itemESPPanel.SetActive(value: false);
miscOptionsPanel.SetActive(value: false);
settingsPanel.SetActive(value: false);
}
public void UpdateAimbotSettingsUI()
{
if (aimbotToggle != null)
{
aimbotToggle.isOn = Settings.Aimbot;
}
if (aimbotSmoothLabel != null)
{
aimbotSmoothLabel.text = $"Aimbot Smooth {(int)Settings.AimbotSmooth}";
}
if (aimbotSmoothSlider != null)
{
aimbotSmoothSlider.value = Settings.AimbotSmooth;
}
if (aimbotDrawFOVToggle != null)
{
aimbotDrawFOVToggle.isOn = Settings.AimbotDrawFOV;
}
if (aimbotFOVLabel != null)
{
aimbotFOVLabel.text = $"Aimbot FOV {(int)Settings.AimbotFOV}";
}
if (aimbotFOVSlider != null)
{
aimbotFOVSlider.value = Settings.AimbotFOV;
}
if (noRecoilToggle != null)
{
noRecoilToggle.isOn = Settings.NoRecoil;
}
if (crosshairToggle != null)
{
crosshairToggle.isOn = Settings.Crosshair;
}
if (silentAimToggle != null)
{
silentAimToggle.isOn = Settings.SilentAim;
}
if (silentTargetLinesToggle != null)
{
silentTargetLinesToggle.isOn = Settings.SilentTargetLines;
}
if (instahitToggle != null)
{
instahitToggle.isOn = Settings.instahit;
}
if (ammodrawToggle != null)
{
ammodrawToggle.isOn = Settings.DrawInfo;
}
if (CheckVisibletoggle != null)
{
CheckVisibletoggle.isOn = Settings.CheckVisible;
}
if (MagicBulletToggle != null)
{
MagicBulletToggle.isOn = Settings.MagicBullet;
}
if (infiniteammo != null)
{
infiniteammo.isOn = Settings.infammo;
}
if (tracers != null)
{
tracers.isOn = Settings.tracers;
}
if (hitmarkers != null)
{
hitmarkers.isOn = Settings.HitMarkers;
}
if (bulletspershotLabel != null)
{
bulletspershotLabel.text = $"Bullets Per Shot {Settings.bulletspershot}";
}
if (bulletspershottoggle != null)
{
bulletspershottoggle.isOn = Settings.bulletspershottoggle;
}
if (bulletspershot != null)
{
bulletspershot.value = Settings.bulletspershot;
}
}
public void ApplyAimbotSettingsUI()
{
Settings.Aimbot = aimbotToggle.isOn;
Settings.AimbotSmooth = aimbotSmoothSlider.value;
Settings.AimbotDrawFOV = aimbotDrawFOVToggle.isOn;
Settings.AimbotFOV = aimbotFOVSlider.value;
Settings.NoRecoil = noRecoilToggle.isOn;
Settings.Crosshair = crosshairToggle.isOn;
Settings.SilentAim = silentAimToggle.isOn;
Settings.SilentTargetLines = silentTargetLinesToggle.isOn;
Settings.instahit = instahitToggle.isOn;
Settings.DrawInfo = ammodrawToggle.isOn;
Settings.CheckVisible = CheckVisibletoggle.isOn;
Settings.MagicBullet = MagicBulletToggle.isOn;
Settings.infammo = infiniteammo.isOn;
Settings.tracers = tracers.isOn;
Settings.HitMarkers = hitmarkers.isOn;
Settings.bulletspershottoggle = bulletspershottoggle.isOn;
Settings.bulletspershot = (int)bulletspershot.value;
SaveSettings();
}
private void InitializeAimboneDropdown()
{
if (aimboneDropdown != null)
{
aimboneDropdown.options.Clear();
aimboneDropdown.options.Add(new TMP_Dropdown.OptionData("Head"));
aimboneDropdown.options.Add(new TMP_Dropdown.OptionData("Neck"));
aimboneDropdown.options.Add(new TMP_Dropdown.OptionData("Body 1"));
aimboneDropdown.options.Add(new TMP_Dropdown.OptionData("Body 2"));
SetDropdownValueFromSettings();
aimboneDropdown.onValueChanged.AddListener(delegate
{
AimboneDropdownValueChanged(aimboneDropdown);
});
}
}
private void SetDropdownValueFromSettings()
{
int key = new Dictionary<int, int>
{
{ 0, 133 },
{ 1, 132 },
{ 2, 36 },
{ 3, 35 }
}.FirstOrDefault((KeyValuePair<int, int> x) => x.Value == Settings.Aimbone).Key;
if (key >= 0 && key < aimboneDropdown.options.Count)
{
aimboneDropdown.value = key;
}
}
private void AimboneDropdownValueChanged(TMP_Dropdown dropdown)
{
Dictionary<int, int> obj = new Dictionary<int, int>
{
{ 0, 133 },
{ 1, 132 },
{ 2, 36 },
{ 3, 35 }
};
int value = dropdown.value;
if (obj.TryGetValue(value, out var value2))
{
Settings.Aimbone = value2;
SaveSettings();
}
}
private void TPItemValueChanged(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
TPItemInputstring = input;
}
}
private void TPItemInputEndEdit(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
TPItemInputstring = input;
}
else
{
UnityEngine.Debug.LogWarning("Input is either null or whitespace.");
}
}
public void UpdatePlayerESPSettingsUI()
{
if (drawPlayersToggle != null)
{
drawPlayersToggle.isOn = Settings.DrawPlayers;
}
if (drawPlayerBoxToggle != null)
{
drawPlayerBoxToggle.isOn = Settings.DrawPlayerBox;
}
if (drawPlayerNameToggle != null)
{
drawPlayerNameToggle.isOn = Settings.DrawPlayerName;
}
if (drawPlayerLineToggle != null)
{
drawPlayerLineToggle.isOn = Settings.DrawPlayerLine;
}
if (drawPlayerHealthToggle != null)
{
drawPlayerHealthToggle.isOn = Settings.DrawPlayerHealth;
}
if (drawWeaponToggle != null)
{
drawWeaponToggle.isOn = Settings.playerWeapon;
}
if (enableSkeletonToggle != null)
{
enableSkeletonToggle.isOn = Settings.EnableSkeleton;
}
if (ChamsToggle != null)
{
ChamsToggle.isOn = Settings.Chams;
}
if (drawRadarToggle != null)
{
drawRadarToggle.isOn = Settings.DrawRadar;
}
if (drawaimpostoggle != null)
{
drawaimpostoggle.isOn = Settings.drawaimpos;
}
if (fullbright != null)
{
fullbright.isOn = Settings.fullbright;
}
if (grenadeesp != null)
{
grenadeesp.isOn = Settings.grenadeesp;
}
if (DrawTripWires != null)
{
DrawTripWires.isOn = Settings.tripwire;
}
if (drawPlayersDistanceSlider != null)
{
drawPlayersDistanceSlider.value = Settings.DrawPlayersDistance;
}
if (drawplayerdistancelabel != null)
{
drawplayerdistancelabel.text = $"Player Distance {(int)Settings.DrawPlayersDistance} m";
}
if (radardistanceslider != null)
{
radardistanceslider.value = Settings.DrawPlayersRadarDistance;
}
if (radardistancelabel != null)
{
radardistancelabel.text = $"Radar Distance {(int)Settings.DrawPlayersRadarDistance} m";
}
if (SkeletonUpdateSlider != null)
{
SkeletonUpdateSlider.value = Settings.cachedelayskelet;
}
float num = 1f / Settings.cachedelayskelet;
if (SkeletonUpdateSliderText != null)
{
SkeletonUpdateSliderText.text = $"Skeleton Update Speed {num:F2} FPS ";
}
if (FONTSIZE != null)
{
FONTSIZE.value = Settings.fontsize;
}
if (FONTSIZETXT != null)
{
FONTSIZETXT.text = $"ESP Font Size : {Settings.fontsize} ";
}
}
public void ApplyPlayerESPSettingsUI()
{
Settings.DrawPlayers = drawPlayersToggle.isOn;
Settings.DrawPlayerBox = drawPlayerBoxToggle.isOn;
Settings.DrawPlayerName = drawPlayerNameToggle.isOn;
Settings.DrawPlayerLine = drawPlayerLineToggle.isOn;
Settings.DrawPlayerHealth = drawPlayerHealthToggle.isOn;
Settings.playerWeapon = drawWeaponToggle.isOn;
Settings.EnableSkeleton = enableSkeletonToggle.isOn;
Settings.DrawRadar = drawRadarToggle.isOn;
Settings.DrawPlayersDistance = drawPlayersDistanceSlider.value;
Settings.DrawPlayersRadarDistance = radardistanceslider.value;
Settings.cachedelayskelet = SkeletonUpdateSlider.value;
Settings.fontsize = (int)FONTSIZE.value;
Settings.Chams = ChamsToggle.isOn;
Settings.drawaimpos = drawaimpostoggle.isOn;
Settings.fullbright = fullbright.isOn;
Settings.grenadeesp = grenadeesp.isOn;
Settings.tripwire = DrawTripWires.isOn;
SaveSettings();
}
public void UpdateItemESPSettingsUI()
{
if (drawLootItemsToggle != null)
{
drawLootItemsToggle.isOn = Settings.DrawLootItems;
}
if (drawLootItemsDistanceSlider != null)
{
drawLootItemsDistanceSlider.value = Settings.DrawLootItemsDistance;
}
if (drawlootitemsdistancelabel != null)
{
drawlootitemsdistancelabel.text = $"Item Distance : {(int)Settings.DrawLootItemsDistance} m";
}
if (superRareItemsToggle != null)
{
superRareItemsToggle.isOn = Settings.superrare;
}
if (kappaItemsToggle != null)
{
kappaItemsToggle.isOn = Settings.kappa;
}
if (questItemsToggle != null)
{
questItemsToggle.isOn = Settings.quest;
}
if (superrareTPToggle != null)
{
superrareTPToggle.isOn = Settings.superrareTP;
}
if (commonItemsToggle != null)
{
commonItemsToggle.isOn = Settings.common;
}
if (stimsItemsToggle != null)
{
stimsItemsToggle.isOn = Settings.stim;
}
if (KappaTPToggle != null)
{
KappaTPToggle.isOn = Settings.kappaTP;
}
if (QuestTPToggle != null)
{
QuestTPToggle.isOn = Settings.questTP;
}
if (SearchTPToggle != null)
{
SearchTPToggle.isOn = Settings.searchTP;
}
if (StimsTPToggle != null)
{
StimsTPToggle.isOn = Settings.StimTP;
}
if (commonItemsDistanceSlider != null)
{
commonItemsDistanceSlider.value = Settings.commonitemdistance;
}
if (commonItemsdistancelabel != null)
{
commonItemsdistancelabel.text = $"Common Item Distance : {(int)Settings.commonitemdistance} m";
}
if (drawLootableContainersToggle != null)
{
drawLootableContainersToggle.isOn = Settings.DrawLootableContainers;
}
if (drawLootableContainersDistanceSlider != null)
{
drawLootableContainersDistanceSlider.value = Settings.DrawLootableContainersDistance;
}
if (drawcontainerdistancelabel != null)
{
drawcontainerdistancelabel.text = $"Container Distance : {(int)Settings.DrawLootableContainersDistance} m";
}
if (bodyESPToggle != null)
{
bodyESPToggle.isOn = Settings.BodyESP;
}
if (playerInventoryESPToggle != null)
{
playerInventoryESPToggle.isOn = Settings.PlayerInventoryESP;
}
if (searchItemToggle != null)
{
searchItemToggle.isOn = Settings.searchItem;
}
if (teleportItemsToggle != null)
{
teleportItemsToggle.isOn = Settings.TeleportItems;
}
if (drawExfiltrationPointsToggle != null)
{
drawExfiltrationPointsToggle.isOn = Settings.DrawExfiltrationPoints;
}
if (ChamsToggle != null)
{
ChamsToggle.isOn = Settings.Chams;
}
if (DrawHideoutItems != null)
{
DrawHideoutItems.isOn = Settings.drawhideoutitems;
}
if (DrawWishlistItems != null)
{
DrawWishlistItems.isOn = Settings.drawwishlistitem;
}
if (ESPfiltervalue != null)
{
ESPfiltervalue.isOn = Settings.ESPFilterbyprice;
}
if (TPWishlistItems != null)
{
TPWishlistItems.isOn = Settings.TPwishlistitem;
}
if (TPHideoutItems != null)
{
TPHideoutItems.isOn = Settings.TPhideoutitem;
}
if (TPHVItems != null)
{
TPHVItems.isOn = Settings.TPHVitem;
}
if (DrawItemValue != null)
{
DrawItemValue.isOn = Settings.drawvalue;
}
if (ESPfiltervalueslider != null)
{
ESPfiltervalueslider.value = Settings.ESPPRICEfiltervalue;
}
if (ESPfiltervaluesliderlabel != null)
{
ESPfiltervaluesliderlabel.text = $"Minimum Item Value : {Settings.ESPPRICEfiltervalue / 1000}K";
}
if (ItemTPRadiusSlider != null)
{
ItemTPRadiusSlider.value = Settings.loottpradius;
}
if (ItemTPRadiusLabel != null)
{
ItemTPRadiusLabel.text = $"Teleport Radius : {(int)Settings.loottpradius} m";
}
}
public void ApplyItemESPSettingsUI()
{
Settings.DrawLootItems = drawLootItemsToggle.isOn;
Settings.DrawLootItemsDistance = drawLootItemsDistanceSlider.value;
Settings.superrare = superRareItemsToggle.isOn;
Settings.kappa = kappaItemsToggle.isOn;
Settings.quest = questItemsToggle.isOn;
Settings.common = commonItemsToggle.isOn;
Settings.commonitemdistance = commonItemsDistanceSlider.value;
Settings.DrawLootableContainers = drawLootableContainersToggle.isOn;
Settings.DrawLootableContainersDistance = drawLootableContainersDistanceSlider.value;
Settings.BodyESP = bodyESPToggle.isOn;
Settings.PlayerInventoryESP = playerInventoryESPToggle.isOn;
Settings.searchItem = searchItemToggle.isOn;
Settings.TeleportItems = teleportItemsToggle.isOn;
Settings.DrawExfiltrationPoints = drawExfiltrationPointsToggle.isOn;
Settings.superrareTP = superrareTPToggle.isOn;
Settings.StimTP = StimsTPToggle.isOn;
Settings.kappaTP = KappaTPToggle.isOn;
Settings.searchTP = SearchTPToggle.isOn;
Settings.questTP = QuestTPToggle.isOn;
Settings.stim = stimsItemsToggle.isOn;
Settings.TPHVitem = TPHVItems.isOn;
Settings.TPhideoutitem = TPHideoutItems.isOn;
Settings.TPwishlistitem = TPWishlistItems.isOn;
Settings.drawhideoutitems = DrawHideoutItems.isOn;
Settings.drawwishlistitem = DrawWishlistItems.isOn;
Settings.ESPFilterbyprice = ESPfiltervalue.isOn;
Settings.drawvalue = DrawItemValue.isOn;
Settings.ESPPRICEfiltervalue = (int)ESPfiltervalueslider.value;
Settings.loottpradius = ItemTPRadiusSlider.value;
SaveSettings();
}
public void UpdateMiscOptionsSettingsUI()
{
if (flyhackToggle != null)
{
flyhackToggle.isOn = Settings.Flyhack;
}
if (speedhackToggle != null)
{
speedhackToggle.isOn = Settings.Speedhack;
}
if (speedSlider != null)
{
speedSlider.value = Settings.Speed;
}
if (maincamfovchanger != null)
{
maincamfovchanger.isOn = Settings.changemaincamfov;
}
if (maincamfov != null)
{
maincamfov.value = Settings.maincamfov;
}
if (xpslider != null)
{
xpslider.value = Settings.expamount;
}
if (xpsliderlabel != null)
{
xpsliderlabel.text = $"XP {(int)Settings.expamount}";
}
if (infStaminaToggle != null)
{
infStaminaToggle.isOn = Settings.Infstamina;
}
if (instaHealToggle != null)
{
instaHealToggle.isOn = Settings.Instaheal;
}
if (thermalVisionToggle != null)
{
thermalVisionToggle.isOn = Settings.Thermal;
}
if (godmodeToggle != null)
{
godmodeToggle.isOn = Settings.Godmode;
}
if (instaSearchToggle != null)
{
instaSearchToggle.isOn = Settings.InstaSearch;
}
if (noVisorToggle != null)
{
noVisorToggle.isOn = Settings.NoVisor;
}
if (flaresToggle != null)
{
flaresToggle.isOn = Settings.flares;
}
if (noJamToggle != null)
{
noJamToggle.isOn = Settings.nojam;
}
if (fireRateToggle != null)
{
fireRateToggle.isOn = Settings.firerate;
}
if (showitemspawnmenu != null)
{
showitemspawnmenu.isOn = Settings.Itemspawnmenu;
}
if (weaponchams != null)
{
weaponchams.isOn = Settings.weaponchams;
}
if (alwayssurvived != null)
{
alwayssurvived.isOn = Settings.alwayssurvived;
}
if (tppmc != null)
{
tppmc.isOn = Settings.tppmc;
}
if (tpboss != null)
{
tpboss.isOn = Settings.tpboss;
}
if (sicc != null)
{
sicc.isOn = Settings.sicc;
}
if (thicc != null)
{
thicc.isOn = Settings.thicc;
}
if (ammobox != null)
{
ammobox.isOn = Settings.ammobox;
}
if (bypassrestrictions != null)
{
bypassrestrictions.isOn = Settings.removefilters;
}
if (fillraidbp != null)
{
fillraidbp.isOn = Settings.fillraidbp;
}
if (autofillslots != null)
{
autofillslots.isOn = Settings.fillslots;
}
if (farreachtoggle != null)
{
farreachtoggle.isOn = Settings.farreach;
}
if (invisibletoggle != null)
{
invisibletoggle.isOn = Settings.invisible;
}
if (QuestESP != null)
{
QuestESP.isOn = Settings.QuestESP;
}
if (QuestDescription != null)
{
QuestDescription.isOn = Settings.DrawDescription;
}
if (SimplifiedStrings != null)
{
SimplifiedStrings.isOn = Settings.DrawSimpleStrings;
}
if (DrawOutline != null)
{
DrawOutline.isOn = Settings.DrawOutline;
}
if (Artillery != null)
{
Artillery.isOn = Settings.artillery;
}
if (DrawWatermark != null)
{
DrawWatermark.isOn = Settings.drawwatermark;
}
if (DurabilityExploit != null)
{
DurabilityExploit.isOn = Settings.componentexploit;
}
if (filtersuperrare != null)
{
filtersuperrare.isOn = Settings.filtersuperrare;
}
if (filterkappa != null)
{
filterkappa.isOn = Settings.filterkappa;
}
if (filterquest != null)
{
filterquest.isOn = Settings.filterquest;
}
if (filterwishlist != null)
{
filterwishlist.isOn = Settings.filterwishlist;
}
if (filterstim != null)
{
filterstim.isOn = Settings.filterstim;
}
if (ShowColorMenu != null)
{
ShowColorMenu.isOn = Settings.ShowColorSettingsMenu;
}
if (disableallinputs != null)
{
disableallinputs.isOn = Settings.allinputdisabled;
}
if (filterhideout != null)
{
filterhideout.isOn = Settings.filterhideout;
}
if (filtervalue != null)
{
filtervalue.isOn = Settings.filtervalue;
}
if (filtervalueslider != null)
{
filtervalueslider.value = Settings.moneyfiltervalue;
}
if (filtervalueslidertext != null)
{
filtervalueslidertext.text = $"Minimum Value : {Settings.moneyfiltervalue / 1000}K ";
}
if (SpoofNicknameToggle != null)
{
SpoofNicknameToggle.isOn = Settings.hidenick;
}
if (bigheadstoggle != null)
{
bigheadstoggle.isOn = Settings.BigHeads;
}
if (showraidsettingsmenu != null)
{
showraidsettingsmenu.isOn = Settings.showraidsettingsmenu;
}
if (modifyraidsettingstoggle != null)
{
modifyraidsettingstoggle.isOn = Settings.modifyraidsettings;
}
if (makeallbotsfriendlytoggle != null)
{
makeallbotsfriendlytoggle.isOn = Settings.makeallbotsfriendly;
}
}
public void ApplyMiscOptionsSettingsUI()
{
Settings.Flyhack = flyhackToggle.isOn;
Settings.Speedhack = speedhackToggle.isOn;
Settings.Speed = speedSlider.value;
Settings.changemaincamfov = maincamfovchanger.isOn;
Settings.maincamfov = maincamfov.value;
Settings.expamount = xpslider.value;
Settings.Infstamina = infStaminaToggle.isOn;
Settings.Instaheal = instaHealToggle.isOn;
Settings.Thermal = thermalVisionToggle.isOn;
Settings.Godmode = godmodeToggle.isOn;
Settings.InstaSearch = instaSearchToggle.isOn;
Settings.NoVisor = noVisorToggle.isOn;
Settings.flares = flaresToggle.isOn;
Settings.nojam = noJamToggle.isOn;
Settings.firerate = fireRateToggle.isOn;
Settings.Itemspawnmenu = showitemspawnmenu.isOn;
Settings.weaponchams = weaponchams.isOn;
Settings.alwayssurvived = alwayssurvived.isOn;
Settings.tppmc = tppmc.isOn;
Settings.tpboss = tpboss.isOn;
Settings.QuestESP = QuestESP.isOn;
Settings.DrawDescription = QuestDescription.isOn;
Settings.DrawSimpleStrings = SimplifiedStrings.isOn;
Settings.DrawOutline = DrawOutline.isOn;
Settings.artillery = Artillery.isOn;
Settings.drawwatermark = DrawWatermark.isOn;
Settings.componentexploit = DurabilityExploit.isOn;
Settings.thicc = thicc.isOn;
Settings.sicc = sicc.isOn;
Settings.ammobox = ammobox.isOn;
Settings.removefilters = bypassrestrictions.isOn;
Settings.fillraidbp = fillraidbp.isOn;
Settings.fillslots = autofillslots.isOn;
Settings.farreach = farreachtoggle.isOn;
Settings.invisible = invisibletoggle.isOn;
Settings.filtersuperrare = filtersuperrare.isOn;
Settings.filterkappa = filterkappa.isOn;
Settings.filterquest = filterquest.isOn;
Settings.filterwishlist = filterwishlist.isOn;
Settings.filterstim = filterstim.isOn;
Settings.ShowColorSettingsMenu = ShowColorMenu.isOn;
Settings.allinputdisabled = disableallinputs.isOn;
Settings.filterhideout = filterhideout.isOn;
Settings.filtervalue = filtervalue.isOn;
Settings.moneyfiltervalue = (int)filtervalueslider.value;
Settings.hidenick = SpoofNicknameToggle.isOn;
Settings.BigHeads = bigheadstoggle.isOn;
Settings.showraidsettingsmenu = showraidsettingsmenu.isOn;
Settings.modifyraidsettings = modifyraidsettingstoggle.isOn;
Settings.makeallbotsfriendly = makeallbotsfriendlytoggle.isOn;
SaveSettings();
}
private void OnSearchItemValueChanged(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
publicSearchString = input;
}
}
private void OnSearchItemInputEndEdit(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
publicSearchString = input;
}
}
private void SpawnItemValueChanged(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
itemidstring = input;
}
}
private void SpawnItemInputEndEdit(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
itemidstring = input;
}
}
private void SpawnAIValueChanged(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
spawnid = input;
}
}
private void SpawnAIInputEndEdit(string input)
{
if (!string.IsNullOrWhiteSpace(input))
{
spawnid = input;
}
}
public void AddToggleListeners()
{
if (aimbotToggle != null)
{
aimbotToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (noRecoilToggle != null)
{
noRecoilToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (crosshairToggle != null)
{
crosshairToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (silentAimToggle != null)
{
silentAimToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (silentTargetLinesToggle != null)
{
silentTargetLinesToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (instahitToggle != null)
{
instahitToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (ammodrawToggle != null)
{
ammodrawToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (CheckVisibletoggle != null)
{
CheckVisibletoggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (MagicBulletToggle != null)
{
MagicBulletToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (infiniteammo != null)
{
infiniteammo.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (aimbotDrawFOVToggle != null)
{
aimbotDrawFOVToggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (tracers != null)
{
tracers.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (hitmarkers != null)
{
hitmarkers.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (drawPlayersToggle != null)
{
drawPlayersToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawPlayerBoxToggle != null)
{
drawPlayerBoxToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawPlayerNameToggle != null)
{
drawPlayerNameToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawPlayerLineToggle != null)
{
drawPlayerLineToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawPlayerHealthToggle != null)
{
drawPlayerHealthToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawWeaponToggle != null)
{
drawWeaponToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (enableSkeletonToggle != null)
{
enableSkeletonToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawRadarToggle != null)
{
drawRadarToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (ChamsToggle != null)
{
ChamsToggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawaimpostoggle != null)
{
drawaimpostoggle.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (fullbright != null)
{
fullbright.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (grenadeesp != null)
{
grenadeesp.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (DrawTripWires != null)
{
DrawTripWires.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawLootItemsToggle != null)
{
drawLootItemsToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (superRareItemsToggle != null)
{
superRareItemsToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (kappaItemsToggle != null)
{
kappaItemsToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (questItemsToggle != null)
{
questItemsToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (commonItemsToggle != null)
{
commonItemsToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (drawLootableContainersToggle != null)
{
drawLootableContainersToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (bodyESPToggle != null)
{
bodyESPToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (playerInventoryESPToggle != null)
{
playerInventoryESPToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (searchItemToggle != null)
{
searchItemToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (teleportItemsToggle != null)
{
teleportItemsToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (drawExfiltrationPointsToggle != null)
{
drawExfiltrationPointsToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (stimsItemsToggle != null)
{
stimsItemsToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (superrareTPToggle != null)
{
superrareTPToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (KappaTPToggle != null)
{
KappaTPToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (QuestTPToggle != null)
{
QuestTPToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (StimsTPToggle != null)
{
StimsTPToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (SearchTPToggle != null)
{
SearchTPToggle.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (flyhackToggle != null)
{
flyhackToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (speedhackToggle != null)
{
speedhackToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (maincamfovchanger != null)
{
maincamfovchanger.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (infStaminaToggle != null)
{
infStaminaToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (instaHealToggle != null)
{
instaHealToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (thermalVisionToggle != null)
{
thermalVisionToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (godmodeToggle != null)
{
godmodeToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (instaSearchToggle != null)
{
instaSearchToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (noVisorToggle != null)
{
noVisorToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (flaresToggle != null)
{
flaresToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (noJamToggle != null)
{
noJamToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (fireRateToggle != null)
{
fireRateToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (farreachtoggle != null)
{
farreachtoggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (invisibletoggle != null)
{
invisibletoggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (showitemspawnmenu != null)
{
showitemspawnmenu.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (thicc != null)
{
thicc.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (sicc != null)
{
sicc.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (autofillslots != null)
{
autofillslots.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (ammobox != null)
{
ammobox.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (bypassrestrictions != null)
{
bypassrestrictions.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (fillraidbp != null)
{
fillraidbp.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (weaponchams != null)
{
weaponchams.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (alwayssurvived != null)
{
alwayssurvived.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (tppmc != null)
{
tppmc.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (tpboss != null)
{
tpboss.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (QuestESP != null)
{
QuestESP.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (QuestDescription != null)
{
QuestDescription.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (SimplifiedStrings != null)
{
SimplifiedStrings.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (DrawOutline != null)
{
DrawOutline.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (Artillery != null)
{
Artillery.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (DrawWatermark != null)
{
DrawWatermark.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (DurabilityExploit != null)
{
DurabilityExploit.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (DrawHideoutItems != null)
{
DrawHideoutItems.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (DrawWishlistItems != null)
{
DrawWishlistItems.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (ESPfiltervalue != null)
{
ESPfiltervalue.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (DrawItemValue != null)
{
DrawItemValue.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (filtersuperrare != null)
{
filtersuperrare.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (filterkappa != null)
{
filterkappa.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (filterquest != null)
{
filterquest.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (filterwishlist != null)
{
filterwishlist.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (filterstim != null)
{
filterstim.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (TPWishlistItems != null)
{
TPWishlistItems.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (TPHideoutItems != null)
{
TPHideoutItems.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (TPHVItems != null)
{
TPHVItems.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (ShowColorMenu != null)
{
ShowColorMenu.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (disableallinputs != null)
{
disableallinputs.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (filterhideout != null)
{
filterhideout.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (filtervalue != null)
{
filtervalue.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (SpoofNicknameToggle != null)
{
SpoofNicknameToggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (bulletspershottoggle != null)
{
bulletspershottoggle.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (bigheadstoggle != null)
{
bigheadstoggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (showraidsettingsmenu != null)
{
showraidsettingsmenu.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (makeallbotsfriendlytoggle != null)
{
makeallbotsfriendlytoggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (modifyraidsettingstoggle != null)
{
modifyraidsettingstoggle.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
SaveSettings();
}
private void AddSliderListeners()
{
if (aimbotSmoothSlider != null)
{
aimbotSmoothSlider.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (aimbotFOVSlider != null)
{
aimbotFOVSlider.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (radardistanceslider != null)
{
radardistanceslider.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (SkeletonUpdateSlider != null)
{
SkeletonUpdateSlider.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (FONTSIZE != null)
{
FONTSIZE.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawPlayersDistanceSlider != null)
{
drawPlayersDistanceSlider.onValueChanged.AddListener(delegate
{
ApplyPlayerESPSettingsUI();
});
}
if (drawLootItemsDistanceSlider != null)
{
drawLootItemsDistanceSlider.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (commonItemsDistanceSlider != null)
{
commonItemsDistanceSlider.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (drawLootableContainersDistanceSlider != null)
{
drawLootableContainersDistanceSlider.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (speedSlider != null)
{
speedSlider.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (maincamfov != null)
{
maincamfov.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (xpslider != null)
{
xpslider.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (filtervalueslider != null)
{
filtervalueslider.onValueChanged.AddListener(delegate
{
ApplyMiscOptionsSettingsUI();
});
}
if (ESPfiltervalueslider != null)
{
ESPfiltervalueslider.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
if (bulletspershot != null)
{
bulletspershot.onValueChanged.AddListener(delegate
{
ApplyAimbotSettingsUI();
});
}
if (ItemTPRadiusSlider != null)
{
ItemTPRadiusSlider.onValueChanged.AddListener(delegate
{
ApplyItemESPSettingsUI();
});
}
}
public void MaxWeaponskill()
{
Player localPlayer = Main.LocalPlayer;
if (!(localPlayer != null))
{
return;
}
foreach (_E9D4 value in localPlayer.Skills.Mastering.Values)
{
value.Current = value.MasteringGroup.Level2 + value.MasteringGroup.Level3;
}
}
private void PopulateRaidSettingsDropdowns()
{
PopulateRaidDropdown(botAmountDropdown, typeof(EBotAmount));
PopulateRaidDropdown(botDifficultyDropdown, typeof(EBotDifficulty));
PopulateRaidDropdown(windTypeDropdown, typeof(EWindSpeed));
PopulateRaidDropdown(timeFlowTypeDropdown, typeof(ETimeFlowType));
PopulateRaidDropdown(cloudinessTypeDropdown, typeof(ECloudinessType));
PopulateRaidDropdown(rainTypeDropdown, typeof(ERainType));
botAmountDropdown.value = 0;
botDifficultyDropdown.value = 0;
windTypeDropdown.value = 0;
timeFlowTypeDropdown.value = 0;
cloudinessTypeDropdown.value = 0;
rainTypeDropdown.value = 0;
}
private void PopulateRaidDropdown(TMP_Dropdown dropdown, Type enumType)
{
dropdown.ClearOptions();
List<string> list = new List<string> { "Default" };
list.AddRange(Enum.GetNames(enumType));
dropdown.AddOptions(list);
}
private void ApplyRaidSettings()
{
if (Settings.modifyraidsettings && !(LocationsFixerV2._tarkovApplication == null) && !(Main.GameWorld != null))
{
RaidSettings currentRaidSettings = LocationsFixerV2._tarkovApplication.CurrentRaidSettings;
if (botAmountDropdown.value != 0)
{
currentRaidSettings.BotSettings.BotAmount = (EBotAmount)(botAmountDropdown.value - 1);
}
if (botDifficultyDropdown.value != 0)
{
currentRaidSettings.WavesSettings.BotDifficulty = (EBotDifficulty)(botDifficultyDropdown.value - 1);
}
currentRaidSettings.WavesSettings.IsTaggedAndCursed = taggedAndCursedToggle.isOn;
currentRaidSettings.MetabolismDisabled = metabolismDisabledToggle.isOn;
currentRaidSettings.BotSettings.IsScavWars = scavwartoggle.isOn;
if (windTypeDropdown.value != 0)
{
currentRaidSettings.TimeAndWeatherSettings.WindType = (EWindSpeed)(windTypeDropdown.value - 1);
}
if (timeFlowTypeDropdown.value != 0)
{
currentRaidSettings.TimeAndWeatherSettings.TimeFlowType = (ETimeFlowType)(timeFlowTypeDropdown.value - 1);
}
if (cloudinessTypeDropdown.value != 0)
{
currentRaidSettings.TimeAndWeatherSettings.CloudinessType = (ECloudinessType)(cloudinessTypeDropdown.value - 1);
}
if (rainTypeDropdown.value != 0)
{
currentRaidSettings.TimeAndWeatherSettings.RainType = (ERainType)(rainTypeDropdown.value - 1);
}
}
}
public void UpdateEntityList()
{
if (entityButtonTemplate == null)
{
return;
}
if (Main.GameWorld == null || Main.GamePlayers.Count < 1)
{
ClearAllEntitiesFromList();
return;
}
HashSet<string> currentEntityIds = new HashSet<string>();
foreach (GamePlayer gamePlayer in Main.GamePlayers)
{
if (gamePlayer != null && !(gamePlayer.Player == null) && !gamePlayer.Player.IsYourPlayer && gamePlayer.Player.Profile?.Info?.Settings != null)
{
string text = gamePlayer.Player.GetInstanceID().ToString();
currentEntityIds.Add(text);
if (!activeEntityButtons.ContainsKey(text))
{
AddEntityToList(gamePlayer, text);
}
}
}
foreach (string item in activeEntityButtons.Keys.Where((string id) => !currentEntityIds.Contains(id)).ToList())
{
UnityEngine.Object.Destroy(activeEntityButtons[item]);
activeEntityButtons.Remove(item);
}
if (activeEntityButtons.Count == 0)
{
noentitiestexttmp.text = "No Entities to List";
}
else
{
noentitiestexttmp.text = " ";
}
if (selectedEntity != null && !selectedEntity.HealthController.IsAlive)
{
selectedEntity = null;
entityInfoText.text = " Please Select an Entity\n From The List !";
}
else if (selectedEntity == null && entityInfoText.text != null)
{
entityInfoText.text = " Please Select an Entity\n From The List !";
}
LayoutRebuilder.ForceRebuildLayoutImmediate(entityButtonContainer.GetComponent<RectTransform>());
Canvas.ForceUpdateCanvases();
}
private void AddEntityToList(GamePlayer player, string id)
{
if (entityButtonTemplate == null)
{
return;
}
GameObject gameObject = UnityEngine.Object.Instantiate(entityButtonTemplate, entityButtonContainer);
if (gameObject == null)
{
return;
}
TMP_Text componentInChildren = gameObject.GetComponentInChildren<TMP_Text>();
var (nickname, color) = EntityManager.GetEntityDisplayInfo(player);
if (componentInChildren != null)
{
componentInChildren.text = nickname;
componentInChildren.color = color;
}
Button component = gameObject.GetComponent<Button>();
if (component != null)
{
GamePlayer capturedPlayer = player;
component.onClick.AddListener(delegate
{
OnEntityButtonClick(capturedPlayer, nickname);
});
}
gameObject.SetActive(value: true);
activeEntityButtons[id] = gameObject;
}
private void ClearAllEntitiesFromList()
{
foreach (Transform item in entityButtonContainer)
{
UnityEngine.Object.Destroy(item.gameObject);
}
activeEntityButtons.Clear();
noentitiestexttmp.text = "No Entities to List";
if (selectedEntity != null)
{
selectedEntity = null;
entityInfoText.text = " Please Select an Entity\n From The List !";
}
}
private void OnEntityButtonClick(GamePlayer entity, string name)
{
if (entity == null)
{
return;
}
foreach (GamePlayer gamePlayer in Main.GamePlayers)
{
if (gamePlayer == entity)
{
gamePlayer.isselected = true;
}
else
{
gamePlayer.isselected = false;
}
}
selectedEntity = entity.Player;
UpdateEntityInfoText(name);
}
public void UpdateEntityInfoText(string name = "", bool disregardstring = false)
{
_E9AD info = selectedEntity.Profile.Info;
string text = "";
if (disregardstring)
{
foreach (GamePlayer gamePlayer in Main.GamePlayers)
{
if (gamePlayer.Player == selectedEntity)
{
string item = EntityManager.GetEntityDisplayInfo(gamePlayer).displayName;
text = item;
}
}
}
else
{
text = name;
}
entityInfoText.text = "Selected Entity:\nESP Name: " + text + "\n" + $"Role: {info.Settings.Role}\n" + $"Side: {info.Side}\n" + $"Is Ally ? : {selectedEntity.AIData.BotOwner.BotsGroup.IsAlly(Main.LocalPlayer)}\n" + $"Health: [{selectedEntity.ActiveHealthController.GetBodyPartHealth(EBodyPart.Common).Current:F0}/{selectedEntity.ActiveHealthController.GetBodyPartHealth(EBodyPart.Common).Maximum:F0}]";
}
public void OnKillEntityClick()
{
EntityManager.KillEntity(selectedEntity);
if (!selectedEntity.HealthController.IsAlive)
{
entityInfoText.text = " Please Select an Entity\n From The List !";
}
else
{
UpdateEntityInfoText(string.Empty, disregardstring: true);
}
}
public void OnHealEntityClick()
{
EntityManager.HealEntity(selectedEntity);
UpdateEntityInfoText(string.Empty, disregardstring: true);
}
public void OnTeleportEntityClick()
{
EntityManager.TeleportEntityToCrosshair(selectedEntity);
UpdateEntityInfoText(string.Empty, disregardstring: true);
}
public void onmakebraindeadclick()
{
EntityManager.ToggleOffEntityObject(selectedEntity);
UpdateEntityInfoText(string.Empty, disregardstring: true);
}
public void ongivebotblickykitclick()
{
EntityManager.GiveBotsBlickyKit(selectedEntity);
UpdateEntityInfoText(string.Empty, disregardstring: true);
}
public void ongiveallbotsblickykitclick()
{
foreach (GamePlayer gamePlayer in Main.GamePlayers)
{
EntityManager.GiveBotsBlickyKit(gamePlayer.Player);
}
}
}
Reference in a new issue View git blame Copy permalink