public static void ShowQuickmenuPage(string pagename)
{
QuickMenu menu = QuickMenu.Instance;
Transform transform = menu.transform.Find(pagename);
if (transform == null)
{
ConSole.Print(ConSoleStatus.Error, "[QuickMenuStuff] Not found menu!");
return;
}
menu._currentMenu = transform.gameObject;
foreach (Transform element in menu.transform)
{
if (element.name.Contains("QuickMenu_NewElements"))
{
continue;
}
if (element.gameObject.active)
{
element.gameObject.SetActive(false);
}
}
transform.gameObject.SetActive(true);
menu.transform.Find("QuickMenu_NewElements/_InfoBar").gameObject.SetActive(false);
}
public static void Start()
{
try
{
IL2Method method = Assemblies.a["Assembly-CSharp"].GetClass("VRC_EventDispatcherRFC").GetMethod("TriggerEvent");
if (method == null)
{
new Exception();
}
pTriggerEvent = IL2Ch.Patch(method, typeof(patch_EventManager).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: EventManager");
}
catch
{
ConSole.Error("Patch: EventManager");
}
try
{
IL2Method method = Assemblies.a["Assembly-CSharp"].GetClass("RoomManagerBase").GetMethod("OnConnectedToMaster");
if (method == null)
{
new Exception();
}
pOnConnectToMaster = IL2Ch.Patch(method, typeof(patch_EventManager).GetMethod("patch_method2", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: EventManager [JoinRoom]");
}
catch
{
ConSole.Error("Patch: EventManager [JoinRoom]");
}
}
public static void Start()
{
try
{
IL2Method method = Assemblies.a["Assembly-CSharp"].GetClass("VRC_EventLog").GetProperties().First(x => x.GetGetMethod().GetReturnType().Name == "System.Boolean" && x.GetGetMethod().HasFlag(IL2BindingFlags.METHOD_STATIC)).GetGetMethod();
pPatch[2] = IL2Ch.Patch(method, typeof(patch_Network).GetMethod("patch_method3", BindingFlags.Static | BindingFlags.NonPublic));
method = Assemblies.a["Assembly-CSharp"].GetClass("SteamNetworkingManager", "VRC.Steam").GetProperties().First(x => x.GetGetMethod().HasFlag(IL2BindingFlags.METHOD_STATIC) && x.GetGetMethod().GetReturnType().Name == "System.Boolean").GetGetMethod();
pPatch[3] = IL2Ch.Patch(method, typeof(patch_Network).GetMethod("patch_method4", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: Network");
}
}
public static void LoadSettings()
{
string src = Path.Combine(Environment.CurrentDirectory, "BlazeEngine");
src += "\\data.json";
if (!File.Exists(src))
{
SaveSettings();
ConSole.Print(ConsoleColor.Red, "[Config] Not found!", "Creating file!");
return;
}
settings = JsonManager.Reader(src);
LoadDefaultSettings();
ConSole.Print(ConsoleColor.Green, "[Config] Found! File loaded!");
}
public static void Start()
{
try
{
IL2Method method = PortalTrigger.Instance_Class.GetMethod("OnTriggerEnter");
if (method == null)
{
throw new Exception();
}
pPortalJoin = IL2Ch.Patch(method, typeof(patch_NoPortal).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: No Portal Join");
}
catch
{
ConSole.Error("Patch: No Portal Join");
}
}
public static void Start()
{
try
{
IL2Method method = Assemblies.a["Photon3Unity3D"].GetClass("EnetPeer", "ExitGames.Client.Photon").GetMethod("EnqueueOperation");
if (method == null)
{
throw new Exception();
}
pPhotonPeer = IL2Ch.Patch(method, typeof(patch_PhotonSerilize).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: Photon Serilize");
}
catch
{
ConSole.Error("Patch: Photon Serilize");
}
}
public static void Start()
{
try
{
IL2Method method = IL2Cmds.GetAssembly("VRCSDKBase").GetClass("VRC_EventHandler", "VRC.SDKBase").GetMethod("InternalTriggerEvent");
if (method == null)
{
throw new Exception();
}
pGlobalEvents = IL2Ch.Patch(method, typeof(patch_GlobalEvents).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: Global Events");
}
catch
{
ConSole.Error("Patch: Global Events");
}
}
public static void Start()
{
try
{
IL2Method method = Assemblies.a["VRCCore-Standalone"].GetClass("API", "VRC.Core").GetMethod("SendRequestInternal");
if (method == null)
{
throw new Exception();
}
pInvisMode = IL2Ch.Patch(method, typeof(patch_InvisAPI).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: InvisAPI");
}
catch
{
ConSole.Error("Patch: InvisAPI");
}
}
public static void Start()
{
try
{
IL2Method method = UiAvatarList.Instance_Class.GetMethod("Update");
if (method == null)
{
new Exception();
}
pUpdate = IL2Ch.Patch(method, typeof(patch_AvatarTools).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: Avatar Tools");
}
catch
{
ConSole.Error("Patch: Avatar Tools");
}
}
public static void Start()
{
IL2Method[] methods = null;
try
{
methods = Assemblies.a["Assembly-CSharp"].GetClass("RoomManagerBase").GetMethods().Where(x => x.GetParameters().Length == 1).Where(x => x.GetParameters()[0].typeName == "PortalInternal").ToArray();
if (methods == null)
{
throw new Exception();
}
foreach (IL2Method method in methods)
{
IL2Ch.Patch(method, typeof(patch_MorePortals).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
}
ConSole.Success("Patch: More Portals [1]");
}
catch
{
ConSole.Error("Patch: More Portals [1]");
}
#if (DEBUG)
try
{
methods = Assemblies.a["Assembly-CSharp"].GetClass("ObjectInstantiator").GetMethods().Where(x => x.GetParameters().Length == 2).Where(x => x.GetParameters()[0].typeName == "VRC.Player" && x.GetParameters()[1].typeName.StartsWith("ObjectInstantiator.")).ToArray();
if (methods == null)
{
throw new Exception();
}
foreach (IL2Method method in methods)
{
IL2Ch.Patch(method, typeof(patch_MorePortals).GetMethod("patch_method_2", BindingFlags.Static | BindingFlags.NonPublic));
}
ConSole.Success("Patch: More Portals [2]");
}
catch
{
ConSole.Error("Patch: More Portals [2]");
}
#endif
}
public static void Start()
{
IL2Method method = null;
try
{
method = Assemblies.a["Assembly-CSharp"].GetClass("UserInteractMenu").GetMethod("Update");
if (method == null)
{
new Exception();
}
pAvatarStealer = IL2Ch.Patch(method, typeof(patch_AvatarSteal).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: Avatar Stealer");
}
catch
{
ConSole.Error("Patch: Avatar Stealer");
}
}
public static void Start()
{
try
{
// ----------------- [ Update ] --------------------------- //
IL2Method method = UdonBehaviour.Instance_Class.GetMethod("Update");
if (method == null)
{
new Exception();
}
pList[0] = IL2Ch.Patch(method, typeof(patch_NoUdon).GetMethod("patch_method_0", BindingFlags.Static | BindingFlags.NonPublic));
// ----------------- [ LateUpdate ] --------------------------- //
method = UdonBehaviour.Instance_Class.GetMethod("LateUpdate");
if (method == null)
{
new Exception();
}
pList[1] = IL2Ch.Patch(method, typeof(patch_NoUdon).GetMethod("patch_method_1", BindingFlags.Static | BindingFlags.NonPublic));
// ----------------- [ FixedUpdate ] --------------------------- //
method = UdonBehaviour.Instance_Class.GetMethod("FixedUpdate");
if (method == null)
{
new Exception();
}
pList[2] = IL2Ch.Patch(method, typeof(patch_NoUdon).GetMethod("patch_method_2", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Success("Patch: NO-Udon");
}
catch
{
ConSole.Error("Patch: NO-Udon");
}
}
internal static void Start()
{
try
{
IL2Method method = Assemblies.a["Assembly-CSharp"].GetClass("LocomotionInputController").GetMethod("Update");
if (method == null)
{
throw new Exception();
}
update = IL2Ch.Patch(method, typeof(Threads).GetMethod("patch_Control_Thread_Update", BindingFlags.Static | BindingFlags.NonPublic));
if (update == null)
{
throw new Exception();
}
ConSole.Debug("Is success patch #1");
}
catch
{
ConSole.Debug("Not working patch #1");
}
try
{
IL2Method method = Assemblies.a["Assembly-CSharp"].GetClass("VRCApplication").GetMethod("OnApplicationQuit");
if (method == null)
{
throw new Exception();
}
IL2Ch.Patch(method, typeof(BlazeManager).GetMethod("OnApplicationQuit", BindingFlags.Static | BindingFlags.NonPublic));
ConSole.Debug("Is success patch #2 [FixFastQuit]");
}
catch
{
ConSole.Debug("Not working patch #2 [FixFastQuit]");
}
}
public static UiAvatarList AddNewList(string title, int index)
{
UiAvatarList[] uiAvatarLists = Resources.FindObjectsOfTypeAll <UiAvatarList>();
if (uiAvatarLists.Length == 0)
{
ConSole.Print(ConsoleColor.Red, "[Error]", "uiAvatarLists == 0!");
return(null);
}
UiAvatarList gameFavList = null;
foreach (UiAvatarList list in uiAvatarLists)
{
if (list.name.Contains("Favorite") && !list.name.Contains("Quest"))
{
gameFavList = list;
break;
}
}
if (gameFavList == null)
{
ConSole.Print(ConsoleColor.Red, "[Error]", "gameFavList not found!");
return(null);
}
UiAvatarList newList = GameObject.Instantiate <UiAvatarList>(gameFavList, gameFavList.transform.parent);
newList.GetComponentInChildren <Button>(true).GetComponentInChildren <Text>().text = title;
newList.gameObject.SetActive(true);
newList.transform.SetSiblingIndex(index);
newList.category = UiAvatarList.Category.SpecificList;
return(newList);
}
public static void Start()
{
IL2Method method;
int iError = 0;
// ~ Analytics [Count: 3]
try
{
method = Assemblies.a["UnityEngine.UnityAnalyticsModule"].GetClass("Analytics", "UnityEngine.Analytics").GetMethods()
.Where(x => x.Name == "CustomEvent" && x.GetParameters().Length == 2)
.First(x => x.GetParameters()[1].Name == "eventData");
pAnalytics[0] = IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_3", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: AntiKick [2]");
iError++;
}
try
{
method = Assemblies.a["Assembly-CSharp"].GetClass("Analytics").GetMethods()
.Where(x => x.GetReturnType().Name == "System.Void" && x.GetParameters().Length == 3)
.Where(x => x.GetParameters()[0].typeName[0] == 'A')
.First(x => x.HasFlag(IL2BindingFlags.METHOD_STATIC));
pAnalytics[1] = IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_4", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: AntiKick [3]");
iError++;
}
try
{
method = Assemblies.a["VRCCore-Standalone"].GetClass("AmplitudeWrapper", "AmplitudeSDKWrapper").GetMethod("CheckedLogEvent");
pAnalytics[2] = IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_5", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: AntiKick [4]");
iError++;
}
try
{
foreach (var m in Assemblies.a["Assembly-CSharp"].GetClass("ModerationManager").GetMethods()
.Where(x => x.GetReturnType().Name == "System.Boolean" && x.GetParameters().Length == 0))
{
//.Where(x => x.HasFlag(IL2BindingFlags.METHOD_STATIC)))
IL2Ch.Patch(m, typeof(patch_AntiKick).GetMethod("patch_method_6", BindingFlags.Static | BindingFlags.NonPublic));
}
}
catch
{
ConSole.Error("Patch: AntiKick [5]");
iError++;
}
try
{
foreach (var m in Assemblies.a["Assembly-CSharp"].GetClass("ModerationManager").GetMethods()
.Where(x => x.GetParameters().Length == 3)
.Where(x => IL2Import.il2cpp_type_get_name(x.GetParameters()[0].ptr) == "System.String")
.Where(x => IL2Import.il2cpp_type_get_name(x.GetParameters()[1].ptr) == "System.String")
.Where(x => IL2Import.il2cpp_type_get_name(x.GetParameters()[2].ptr) == "System.String"))
{
IL2Ch.Patch(m, typeof(patch_AntiKick).GetMethod("patch_method_7", BindingFlags.Static | BindingFlags.NonPublic));
}
}
catch
{
ConSole.Error("Patch: AntiKick [6]");
iError++;
}
try
{
method = Assemblies.a["Assembly-CSharp"].GetClass("ModerationManager").GetMethod("KickUserRPC");
IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_5", BindingFlags.Static | BindingFlags.NonPublic));
method = Assemblies.a["Assembly-CSharp"].GetClass("ModerationManager").GetMethod("WarnUserRPC");
IL2Ch.Patch(method, typeof(patch_AntiKick).GetMethod("patch_method_5", BindingFlags.Static | BindingFlags.NonPublic));
}
catch
{
ConSole.Error("Patch: AntiKick [6]");
iError++;
}
// Debug
if (iError == 0)
{
ConSole.Success("Patch: AntiKick");
}
else
{
ConSole.Error("Patch: AntiKick");
}
}
private static void patch_Control_Thread_Update(IntPtr instance)
{
if (instance == IntPtr.Zero)
{
return;
}
update.InvokeOriginal(instance);
if (!bFirstThreadControl)
{
bFirstThreadControl = true;
Application.targetFrameRate = 101;
BlazeManagerMenu.Main.CreateMenu();
return;
}
if (!bFirstThreadInRoom)
{
bFirstThreadInRoom = true;
NoLocalPickup.ClearObjects();
NoLocalPickup.Update();
return;
}
Avatars.UIAvatar.resfresh = 3;
if (Input.GetKey(KeyCode.LeftControl))
{
if (Input.GetKeyDown(KeyCode.F))
{
FlyMode.Toggle_Enable();
}
if (Input.GetKeyDown(KeyCode.I))
{
InfinityJump.Toggle_Enable();
}
if (Input.GetKeyDown(KeyCode.Mouse2))
{
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out RaycastHit hit))
{
UserUtils.TeleportTo(hit.point);
}
}
if (Input.GetKeyDown(KeyCode.Mouse3))
{
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out RaycastHit hit))
{
GameObject SelectColesion = hit.transform.gameObject;
if (SelectColesion != null)
{
ConSole.Message(SelectColesion.ToString() + " | " + SelectColesion.transform.position);
foreach (var comp in SelectColesion.GetComponents(typeof(Component)))
{
ConSole.Debug(comp.ToString());
}
}
}
}
if (Input.GetKeyDown(KeyCode.J))
{
UserUtils.RemoveInstiatorObjects();
}
/*
* if (Input.GetKeyDown(KeyCode.G))
* {
* Avatars.UIAvatar.AddFavorite("avtr_e1a33684-acc2-426d-8058-3ee6de630715");
* Avatars.UIAvatar.AddFavorite("avtr_7c480631-b8c8-434d-8430-de8ca01ae250");
* }
*/
if (Input.GetKey(KeyCode.T))
{
Vector3 position = VRC.Player.Instance.transform.position;
UserUtils.SpawnPortal(position);
}
#if DEBUG
if (Input.GetKey(KeyCode.Y))
{
for (int i = 0; i <= 50; i++)
{
BlazeAttack.PortalSploit.Start();
}
// VRCPlayer.Instance.Refresh_Properties();
}
if (Input.GetKey(KeyCode.O))
{
GameObject gameObject = VRC.Player.Instance.uSpeaker.gameObject;
for (int i = 0; i <= 50; i++)
{
BlazeAttack.PortalSploit.Test(gameObject);
}
}
#endif
if (Input.GetKeyDown(KeyCode.P))
{
Console.WriteLine(VRCApplicationSetup.Instance.appVersion);
//ConSole.Debug(VRC.Player.Instance.photonPlayer.hashtable.ToString());
//ConSole.Debug(((IntPtr)VRC.Player.Instance.photonPlayer.hashtable["showSocialRank"]).MonoCast<bool>().ToString());
/*
* foreach(var player in UnityEngine.Object.FindObjectsOfType<VRCPlayer>())
* {
* player.TeleportRPC(new Vector3(0, 0, 0), new Quaternion(0, 0, 0, 0), VRC.SDKBase.VRC_SceneDescriptor.SpawnOrientation.AlignRoomWithSpawnPoint);
* }
*/
}
}
if (InfinityJump.isEnabled)
{
if (Input.GetKeyDown(KeyCode.Space))
{
InfinityJump.EventJump();
}
}
// For UpdateMods
FlyMode.Update();
}
public static void Start()
{
IL2Method method = VRC.Player.Instance_Class.GetMethod("OnNetworkReady");
try
{
unsafe
{
var disasm = new Disassembler(*(IntPtr *)method.ptr, 16, ArchitectureMode.x86_64, unchecked ((ulong)(*(IntPtr *)method.ptr).ToInt64()), true, Vendor.Intel);
var instruction = disasm.Disassemble().First(x => x.ToString().StartsWith("jmp "));
IntPtr addr = new IntPtr((long)instruction.Offset + instruction.Length + instruction.Operands[0].LvalSDWord);
VRC.Player.methodUpdateModeration = VRC.Player.Instance_Class.GetMethods().First(x => *(IntPtr *)x.ptr == addr);
if (VRC.Player.methodUpdateModeration == null)
{
throw new Exception();
}
// UpdateModeration()
disasm = new Disassembler(*(IntPtr *)VRC.Player.methodUpdateModeration.ptr, 0x1000, ArchitectureMode.x86_64, unchecked ((ulong)(*(IntPtr *)VRC.Player.methodUpdateModeration.ptr).ToInt64()), true, Vendor.Intel);
// disasm.Disassemble().ToList().ForEach(x => { Console.WriteLine(x.ToString()); });
var instructions = disasm.Disassemble().TakeWhile(x => x.Mnemonic != ud_mnemonic_code.UD_Iint3);
foreach (var instruction1 in instructions)
{
if (!instruction1.ToString().StartsWith("call "))
{
continue;
}
try
{
addr = new IntPtr((long)instruction1.Offset + instruction1.Length + instruction1.Operands[0].LvalSDWord);
method = ModerationManager.Instance_Class.GetMethods().First(x => *(IntPtr *)x.ptr == addr);
if (method.GetParameters().Length != 1 || method.GetReturnType().Name != "System.Boolean")
{
continue;
}
if (method.GetParameters()[0].typeName != "System.String")
{
continue;
}
pAntiBlock = IL2Ch.Patch(method, typeof(patch_AntiBlock).GetMethod("patch_method", BindingFlags.Static | BindingFlags.NonPublic));
break;
}
catch { continue; }
}
}
foreach (var ass in BlazeSDK.Main.listAssembly)
{
ConSole.Debug(ass.FullName);
}
if (pAntiBlock == null)
{
throw new Exception();
}
ConSole.Success("Patch: Anti-Block");
}
catch
{
ConSole.Error("Patch: Anti-Block");
}
}
public static void Start()
{
string srcYoutubeDL = Application.streamingAssetsPath + "/youtube-dl.exe";
if (File.Exists(srcYoutubeDL))
{
currentVersion = FileVersionInfo.GetVersionInfo(srcYoutubeDL).ProductVersion;
}
Uri uri = new Uri(apiGitHub);
ServicePointManager.SecurityProtocol = WebTools.SecureProtocol.SSL;
using (WebClient webClient = new WebClient())
{
webClient.Headers.Add("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-GB; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12");
webClient.Headers.Add("Accept", "*/*");
webClient.Headers.Add("Accept-Language", "en-gb,en;q=0.5");
webClient.Headers.Add("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
Stream stream = webClient.OpenRead(uri);
StreamReader streamReader = new StreamReader(stream);
try
{
string _result = streamReader.ReadToEnd();
string[] args = _result.Split('\n').Where(x => x.Contains("\"tag_name\"")).ToArray();
if (args.Length > 0)
{
foreach (string arg in args)
{
string[] templist = arg.Split(new char[] { ':' }, 2);
if (templist.Length == 2)
{
string[] temparg = templist[1].Split('"');
if (temparg.Length == 3)
{
apiVersion = temparg[1];
if (apiVersion == currentVersion)
{
ConSole.Success("You use last version Youtube-dl! [" + apiVersion + "]");
return;
}
}
}
}
}
else
{
throw new Exception("Not found a tag_name");
}
}
catch
{
ConSole.Error("Patch: Youtube-dl");
}
finally
{
streamReader.Close();
stream.Close();
}
}
ServicePointManager.SecurityProtocol = WebTools.SecureProtocol.SSL;
using (WebClient webClient = new WebClient())
{
webClient.Headers.Add("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 6.1; en-GB; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12");
webClient.Headers.Add("Accept", "*/*");
webClient.Headers.Add("Accept-Language", "en-gb,en;q=0.5");
webClient.Headers.Add("Accept-Charset", "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
try
{
webClient.DownloadFile("https://github.com/ytdl-org/youtube-dl/releases/download/" + apiVersion + "/youtube-dl.exe", srcYoutubeDL);
ConSole.Success("Downloaded! You are installed last version Youtube-dl! [" + apiVersion + "]");
}
catch
{
ConSole.Error("Patch: Bad download!");
}
}
}
