I found a class that allows me to try implementing ESP and other functions, but it doesn't have static fields or methods that return its instance. However, it inherits from LazySingleton, which has a static field that returns T. Here are the two classes:
I'm trying to do this only through pointers and the il2cpp API, and this is the code I have so far, but it causes the application to crash when calling the static method, and when outputting the arguments of the generic class, it shows that there are no arguments.
Code:
public abstract class LazySingleton<T> : MonoBehaviour, IDisposable // TypeDefIndex: 11
{
// Fields
private static MonoBehaviourRef<T> CFEDGEHEGEFGBFH; // 0x0
private bool ECCFBBBEFCBHAFA; // 0x0
// Properties
public static T DBACHHHDDBACGAC { get; }
// Methods
// RVA: -1 Offset: -1 Slot: 4
public void Dispose() { }
/* GenericInstMethod :
|
|-RVA: 0x32CA204 Offset: 0x32C9204 VA: 0x32CA204
|-LazySingleton<object>.Dispose
*/
// RVA: -1 Offset: -1
protected void .ctor() { }
/* GenericInstMethod :
|
|-RVA: 0x32CA21C Offset: 0x32C921C VA: 0x32CA21C
|-LazySingleton<object>..ctor
*/
// RVA: -1 Offset: -1 Slot: 5
protected virtual void EHDAHAGEBDCDHAA() { }
/* GenericInstMethod :
|
|-RVA: 0x32CA224 Offset: 0x32C9224 VA: 0x32CA224
|-LazySingleton<object>.EHDAHAGEBDCDHAA
*/
// RVA: -1 Offset: -1
public static bool FEFCCAAFDBBGCHD() { }
/* GenericInstMethod :
|
|-RVA: 0x32CA2A0 Offset: 0x32C92A0 VA: 0x32CA2A0
|-LazySingleton<object>.FEFCCAAFDBBGCHD
*/
// RVA: -1 Offset: -1
private void OnDestroy() { }
/* GenericInstMethod :
|
|-RVA: 0x32CA2F0 Offset: 0x32C92F0 VA: 0x32CA2F0
|-LazySingleton<object>.OnDestroy
*/
// RVA: -1 Offset: -1 Slot: 6
protected virtual void GHGDGBHGEFGGHDA() { }
/* GenericInstMethod :
|
|-RVA: 0x32CA308 Offset: 0x32C9308 VA: 0x32CA308
|-LazySingleton<object>.GHGDGBHGEFGGHDA
*/
// RVA: -1 Offset: -1
public static T BDBDAACEEHHGAEG() { }
/* GenericInstMethod :
|
|-RVA: 0x32CA3B8 Offset: 0x32C93B8 VA: 0x32CA3B8
|-LazySingleton<object>.BDBDAACEEHHGAEG
*/
}
Code:
public class PlayerManager : LazySingleton<PlayerManager> // TypeDefIndex: 5025
{
// Fields
private static ILogger CCHFDDAAGHAFBAF; // 0x0
private int BAFDHGHGEEFBCDH; // 0x24
private readonly Dictionary<int, PlayerController> FABHCCGHCCCEEDA; // 0x28
private readonly HashSet<PlayerController> ADDEABCBEEFDHCF; // 0x30
private readonly Dictionary<string, Material> BEEDACAAAACEDGC; // 0x38
private readonly HashSet<AFFHFDECAHFDCFD> FHCDCGFBGHHHDCH; // 0x40
[CompilerGenerated]
private PlayerManager.FBEBAEADDGAGBEH FHAFEGAFFACHAGG; // 0x48
[CompilerGenerated]
private PlayerManager.FBEBAEADDGAGBEH BBHDGFFFCDEHGBD; // 0x50
[CompilerGenerated]
private Action<PlayerController, EDHFCGGAGFEDCAF> FFGCEHCDFDECBCH; // 0x58
private readonly List<Type> BFABGCAGFEGHDEE; // 0x60
private bool CHABHCEACCGEHCC; // 0x68
[CompilerGenerated]
private PlayerController <BBGDEBGCGEFAEDF>k__BackingField; // 0x70
[CompilerGenerated]
private PlayerController <FCGBEHEBADDFEHG>k__BackingField; // 0x78
public Dictionary<string, FDGBHADBCHECHEC> Pools; // 0x80
// Properties
private static ILogger CAFCBADGEGACHCB { get; }
public HashSet<PlayerController> AAGECHGBGHEAHCH { get; }
internal PlayerController GHCCGDHDCAAFBCG { get; set; }
public PlayerController DCCADEEACEDEFHH { get; set; }
private bool CGEEEHHDGHAEBGA { get; }
// Methods
// RVA: 0x232E5E4 Offset: 0x232D5E4 VA: 0x232E5E4
public void FGGHFHBHEDDFFHA(GameObject DAFAGCHFCDDGEGF) { }
// RVA: 0x232E9A8 Offset: 0x232D9A8 VA: 0x232E9A8
public void FEBFDDCGGFFEEFD(PlayerController GBCCAEGGHEDFHDB) { }
// RVA: 0x232EDE0 Offset: 0x232DDE0 VA: 0x232EDE0
public Material CHABDECGDGBGGBH(CharacterSkinnedMeshLodGroupBase GEGFCEFGHHBGGDG, Material FACHHAEBEHHHDCD) { }
// RVA: 0x232EF50 Offset: 0x232DF50 VA: 0x232EF50
internal void AABBFBBBGGDFBBC(PlayerController GBCCAEGGHEDFHDB, int DGHFHDBHHADHFBD) { }
// RVA: 0x232F1E4 Offset: 0x232E1E4 VA: 0x232F1E4
public List<string> DDCEGHFAGDECABA() { }
// RVA: 0x232F4A0 Offset: 0x232E4A0 VA: 0x232F4A0
public void BHCCGFAABAFDBCH(Team FABHHAEEBHAABBD, string DCDCCBEHFHDGHAF, Vector3 CCEGFABBDCGBDFH, Quaternion AAABFFECGDGHAEF, int BHBBHDDGCACGEAF = 100, int BCFDACFADHEEHHB = 100, bool EAHCACGEAFCBDBE = True, bool DCDDCGFGEFHHAEA = False, float GCCGHBBGBBDDAGD = 3,4028235E+38) { }
// RVA: 0x232F758 Offset: 0x232E758 VA: 0x232F758
public void HFDAEBEFHDCFHAD(AFFHFDECAHFDCFD AECGGCAFFCCGEBC) { }
// RVA: 0x232F7B0 Offset: 0x232E7B0 VA: 0x232F7B0
private void FDHHAEACBECBBGD() { }
// RVA: 0x232F920 Offset: 0x232E920 VA: 0x232F920
public HashSet<PlayerController> CEFCEABBFCGBGFG() { }
// RVA: 0x232F928 Offset: 0x232E928 VA: 0x232F928
public void BFDAEEHDGBDCHFG(Team FABHHAEEBHAABBD, PlayerArms ABDEGEDHBGFADAB, PlayerCharacters AACHDECGFABBBAB, int AEFFEACGBGCFADA, Type[] DACCAHBGDGEHEAF, string CHBHCAGABGCGCEE, string ABDFDAGGHGABHHC, string DCDCCBEHFHDGHAF) { }
// RVA: 0x232FB64 Offset: 0x232EB64 VA: 0x232FB64
public PlayerController DAGBFHDCBFBBEHG(GameObject FAHCBHDGABFADHD) { }
// RVA: 0x232FD2C Offset: 0x232ED2C VA: 0x232FD2C
private bool GDCDFDEGGEEGAHF() { }
// RVA: 0x232FDF8 Offset: 0x232EDF8 VA: 0x232FDF8
public bool FGEEEGAFEGHBDAH(int DDCHHGGEDAAFABA) { }
// RVA: 0x232FE50 Offset: 0x232EE50 VA: 0x232FE50
public void .ctor() { }
[CompilerGenerated]
// RVA: 0x2330080 Offset: 0x232F080 VA: 0x2330080
public void CHBHBDFHHGECAHC(Action<PlayerController, EDHFCGGAGFEDCAF> ACHHCFBEEFHCBEA) { }
// RVA: 0x2330130 Offset: 0x232F130 VA: 0x2330130
public string FGHACDEGCDDHFHA(Team FABHHAEEBHAABBD) { }
// RVA: 0x233029C Offset: 0x232F29C VA: 0x233029C
public void AEBDFCEBBECGHFD(PlayerController FGFABHEFBFCBDFD, EDHFCGGAGFEDCAF ABFHABCCDGHHGFA) { }
// RVA: 0x2330420 Offset: 0x232F420 VA: 0x2330420
internal void FHGAGHBGABFBCGH(PlayerController FGFABHEFBFCBDFD) { }
[CompilerGenerated]
// RVA: 0x2330A14 Offset: 0x232FA14 VA: 0x2330A14
internal PlayerController CDGAECHDHHGFFHB() { }
// RVA: 0x2330A1C Offset: 0x232FA1C VA: 0x2330A1C Slot: 5
protected override void EHDAHAGEBDCDHAA() { }
// RVA: 0x2330C1C Offset: 0x232FC1C VA: 0x2330C1C
public void DBFABDDDAAAGFHB(Team FABHHAEEBHAABBD, Vector3 CCEGFABBDCGBDFH, Quaternion AAABFFECGDGHAEF, int BHBBHDDGCACGEAF = 100, int BCFDACFADHEEHHB = 100, bool EAHCACGEAFCBDBE = True, bool DCDDCGFGEFHHAEA = False, float GCCGHBBGBBDDAGD = 3,4028235E+38) { }
[CompilerGenerated]
// RVA: 0x2330E28 Offset: 0x232FE28 VA: 0x2330E28
public void DEFECDEEBCGHBHG(Action<PlayerController, EDHFCGGAGFEDCAF> ACHHCFBEEFHCBEA) { }
// RVA: 0x2330ED8 Offset: 0x232FED8 VA: 0x2330ED8
private void DDDGHEBECCGDDDF() { }
// RVA: 0x2331034 Offset: 0x2330034 VA: 0x2331034
public Material HECGHGHBHEFBCDH(CharacterLodGroup GEGFCEFGHHBGGDG, Material FACHHAEBEHHHDCD) { }
[CompilerGenerated]
// RVA: 0x23311EC Offset: 0x23301EC VA: 0x23311EC
private void BDFHBGAGCCHECHD(PlayerController ACHHCFBEEFHCBEA) { }
[CanBeNull]
// RVA: 0x23311F4 Offset: 0x23301F4 VA: 0x23311F4
public PlayerController AACCDDCHDDEHCAB(int DDCHHGGEDAAFABA) { }
// RVA: 0x232E8C8 Offset: 0x232D8C8 VA: 0x232E8C8
private FDGBHADBCHECHEC EEDDAGCEBBADDHD(string DCDCCBEHFHDGHAF) { }
// RVA: 0x23312A0 Offset: 0x23302A0 VA: 0x23312A0
public void AFFFFEAFCBEAFAG(Type DCEGEDAHAGHAHAE) { }
[CompilerGenerated]
// RVA: 0x23313C0 Offset: 0x23303C0 VA: 0x23313C0
public void HHDEAHGBCDFHAEE(PlayerManager.FBEBAEADDGAGBEH ACHHCFBEEFHCBEA) { }
[CompilerGenerated]
// RVA: 0x233145C Offset: 0x233045C VA: 0x233145C
public void FCHCDGCFFAAEFBF(PlayerManager.FBEBAEADDGAGBEH ACHHCFBEEFHCBEA) { }
// RVA: 0x23314F8 Offset: 0x23304F8 VA: 0x23314F8
public GameObject CCCABCFGBDADBBH(string DGHFHDBHHADHFBD, Vector3 CCEGFABBDCGBDFH, Quaternion AAABFFECGDGHAEF) { }
// RVA: 0x23301B4 Offset: 0x232F1B4 VA: 0x23301B4
private FDGBHADBCHECHEC EEDDAGCEBBADDHD(Team FABHHAEEBHAABBD) { }
// RVA: 0x2331674 Offset: 0x2330674 VA: 0x2331674
public void CFBFCCEACHEDCDC(PlayerController GBCCAEGGHEDFHDB) { }
// RVA: 0x2331E94 Offset: 0x2330E94 VA: 0x2331E94
public void ADFCBECBADHFCGB(string EEBHBBFFHBFGFDE) { }
[CompilerGenerated]
// RVA: 0x2331FFC Offset: 0x2330FFC VA: 0x2331FFC
public PlayerController FBFFHBBGFAFBBCH() { }
// RVA: 0x2332004 Offset: 0x2331004 VA: 0x2332004
public void GHFACDBEAAAFFBD(AFFHFDECAHFDCFD AECGGCAFFCCGEBC) { }
[CompilerGenerated]
// RVA: 0x233205C Offset: 0x233105C VA: 0x233205C
public void CEDCCCEHBDDCHCD(PlayerManager.FBEBAEADDGAGBEH ACHHCFBEEFHCBEA) { }
[CompilerGenerated]
// RVA: 0x23320F8 Offset: 0x23310F8 VA: 0x23320F8
public void DDHAAHDABEDGBHH(PlayerManager.FBEBAEADDGAGBEH ACHHCFBEEFHCBEA) { }
// RVA: 0x2332194 Offset: 0x2331194 VA: 0x2332194
public void OnPhotonInstantiate(PlayerController GBCCAEGGHEDFHDB) { }
// RVA: 0x2331BA4 Offset: 0x2330BA4 VA: 0x2331BA4
private void CFBFCCEACHEDCDC() { }
[CompilerGenerated]
// RVA: 0x2332334 Offset: 0x2331334 VA: 0x2332334
private void DDAACAHBBHBHDCB(PlayerController ACHHCFBEEFHCBEA) { }
// RVA: 0x232EC48 Offset: 0x232DC48 VA: 0x232EC48
private void BCBCBBFAABACBHG(Action BGEECBHEGCDCHEA) { }
// RVA: 0x232E82C Offset: 0x232D82C VA: 0x232E82C
private static ILogger BGGADGEACFFHCEG() { }
}I'm trying to do this only through pointers and the il2cpp API, and this is the code I have so far, but it causes the application to crash when calling the static method, and when outputting the arguments of the generic class, it shows that there are no arguments.
Code:
void Test(){
void* (*get_appDomain)() = (void* (*)())(il2cpp_base + string2Offset("0x3cefbcc"));
monoString*(*TypeName)(void*type) = (monoString*(*)(void*))(il2cpp_base + string2Offset("0x3ceca10"));
monoArray2<void*>* (*Get_asses)(void* domain) = (monoArray2<void*>* (*)(void*))(il2cpp_base + string2Offset("0x3cefbd8"));
void* (*get_assNameObject)(void* assembly) = (void* (*)(void*))(il2cpp_base + string2Offset("0x3be9370"));
monoString* (*get_assName)(void* assembly_name_object) = (monoString* (*)(void*))(il2cpp_base + string2Offset("0x3bea070"));
void*(*GetTypeFromName)(void*assembly, Il2CppString*name, bool throwError, bool ignore_case) = (void*(*)(void*, Il2CppString*, bool, bool))(il2cpp_base + string2Offset("0x3bec46c"));
void*(*MakeGenericType)(void*type, void*generic_type) = (void*(*)(void*, void*))(il2cpp_base + string2Offset("0x3ce8e04"));
void*(*CreateInstance_Array)(void* type, int len) = (void*(*)(void*, int))(il2cpp_base + string2Offset("0x3cd0cec"));
void*(*GetType_Object)(void*object) = (void*(*)(void*))(il2cpp_base + string2Offset("0x3cede78"));
void*(*Load_Assembly)(Il2CppString*name) = (void*(*)(Il2CppString*))(il2cpp_base + string2Offset("0x3be94ac"));
void(*SetValue_Array)(void*array, void*Object, int index) = (void(*)(void*,void*,int))(il2cpp_base + string2Offset("0x3ccd68c"));
long(*get_LongLength_Array)(void*array) = (long(*)(void*))(il2cpp_base + string2Offset("0x3cced6c"));
void*(*GetValue_Array)(void*array,long index) = (void*(*)(void*,long))(il2cpp_base + string2Offset("0x3ccede8"));
void*(*GetBase_Type)(void*type) = (void*(*)(void*))(il2cpp_base + string2Offset("0x3ce7d78"));
monoArray2<void*>*(*GetMethods)(void* type, int flag) = (monoArray2<void*>*(*)(void*,int))(il2cpp_base + string2Offset("0x3ce65fc"));
monoString*(*MethodName)(void*method) = (monoString*(*)(void*))(il2cpp_base + string2Offset("0x3beeca8"));
void*(*GetRuntimeHandle)(void*method) = (void*(*)(void*))(il2cpp_base + string2Offset("0x3bef394"));
void*(*RuntimeHandle_GetValue)(void*runHandle) = (void*(*)(void*))(il2cpp_base + string2Offset("0x3cfbdf0"));
Il2CppClass* playerManager = get_class("Game.Player", "PlayerManager", assembly_main);
Il2CppClass* sigleton = get_class("Game.Core", "LazySingleton`1", assembly_main);
void* domik = get_appDomain();
if (domik) {
LOGI("domain is getting");
}
LOGI("try get assemblies");
monoArray2<void*>* assemblies = Get_asses(domik);
if (assemblies) {
LOGI("assemblies is getting");
}
void** ass_pointer = assemblies->getPointer();
for (int p = 0; p < assemblies->getCapacity(); ++p) {
void* assembled = ass_pointer[p];
if (assembled) {
const char* ass_name = get_assName(get_assNameObject(assembled))->getChars();
if (strcmp(ass_name, "Assembly-CSharp.dll") == 0 || strcmp(ass_name, "Assembly-CSharp") == 0) {
void* corlib = Load_Assembly(il2cpp_string_new("mscorlib"));
LOGI("Getting type...");
void* PlayerManager = GetTypeFromName(assembled, il2cpp_string_new("Game.Player.PlayerManager"), false, true);
void* Lazy = GetTypeFromName(assembled, il2cpp_string_new("Game.Core.LazySingleton`1"), false, true);
void* SystemType = GetTypeFromName(corlib, il2cpp_string_new("System.Type"), false, true);
Il2CppClass* SystemType_klass = il2cpp_class_from_name(il2cpp_get_corlib(), "System", "Type");
Il2CppClass* PlayerManager_klass = get_class("Game.Player", "PlayerManager", assembly_main);
Il2CppClass* Lazy_klass = get_class("Game.Core", "LazySingleton`1", assembly_main);
Il2CppClass* Int64Type = il2cpp_class_from_name(il2cpp_get_corlib(), "System", "Int64");
if(PlayerManager){
LOGI("PlayerManager is get");
LOGI("Name [%s]", TypeName(PlayerManager)->getChars());
}
if(Lazy){
LOGI("Lazy is get");
LOGI("Name [%s]", TypeName(Lazy)->getChars());
}
if(SystemType){
LOGI("SystemType is get");
LOGI("Name [%s]", TypeName(SystemType)->getChars());
}
if(Int64Type){
LOGI("Int64Type is get");
LOGI("Name [%s]", Int64Type->name);
}
if(PlayerManager_klass){
LOGI("PlayerManager_klass is get");
LOGI("Name [%s], size [%i]", PlayerManager_klass->name, (int)PlayerManager_klass->instance_size);
}
if(SystemType_klass){
LOGI("SystemType_klass is get");
LOGI("Name [%s]", SystemType_klass->name);
}
LOGI("Try get base type...");
void* base = GetBase_Type(PlayerManager);
LOGI("BAse getting");
void* TypeArray = CreateInstance_Array(SystemType, 1);
LOGI("Type array creating");
SetValue_Array(TypeArray, PlayerManager, 0);
LOGI("Value setted");
void* generic_type = MakeGenericType(Lazy, TypeArray);
LOGI("Generic type is created");
if(generic_type){
LOGI("generic_type is creating good");
LOGI("Type name [%s], generic arg [%s]", TypeName(generic_type)->getChars(), GenericType((Il2CppClass*)generic_type).c_str());
}
}
}
}
}