patate/DevourClient
1
1
Fork 0
Code Issues 7 Pull Requests 1 Actions Packages Projects Releases 24 Wiki Activity

various header files added/updated

Browse Source 
- Created a header file called players. added a helper function to get the gameobject of all players, the gameobject of the local player and the NolanBehaviour component
- Added UnityCore file to make it easier for us to use unity functions
- Misc file fully updated
- Added Wrapper class to make it easier to use il2cpp functions
- ClientHelper updated
- color.hpp library was included in the project to make the console colorful
This commit is contained in:
Jadis0x
2024-05-16 21:37:01 +03:00
parent 17df650819
commit f69767f794
13 changed files with 1593 additions and 292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

280
lib/ClientHelper.cpp
View File

@@ -1,10 +1,10 @@
#include "pch-il2cpp.h"
#include "helpers.h"
#include <iostream>
#include <helpers.h>
#include "ClientHelper.h"
#include "wrapper.h"
#include "players/players.h"
#include "UnityCore.h"
bool IsSinglePlayer()
{
@@ -21,226 +21,92 @@ bool IsHost()
return app::BoltNetwork_get_IsServer(NULL);
}
app::Menu* get_HorrorMenu() {
Wrapper wrapper;
const Il2CppImage* image = wrapper.GetImage("Assembly-CSharp.dll");
// DO_APP_FUNC(0x0065B240, void, Menu_OnLobbyStartButtonClick, (Menu * __this, MethodInfo * method));
// menu.OnLobbyStartButtonClick();
Il2CppObject* object = wrapper.GetObjectFromClass(image, "Horror", "Menu");
if (object != nullptr) {
app::Object_1* Horror_MenuObject = app::Object_1_FindObjectOfType(reinterpret_cast<app::Type*>(object), nullptr);
if (Horror_MenuObject) {
app::Menu* HorrorMenu = reinterpret_cast<app::Menu*>(Horror_MenuObject);
if (HorrorMenu) {
return HorrorMenu;
}
}
}
return nullptr;
}
std::string get_SceneName()
bool IsLocalPlayer(app::NolanBehaviour* player)
{
app::SaveHelpers* SaveHelper = app::SaveHelpers_get_singleton(nullptr);
auto boltEntity = app::EntityBehaviour_get_entity((app::EntityBehaviour*)player, NULL);
if (SaveHelper) {
if (not boltEntity
|| not app::BoltEntity_get_IsAttached(boltEntity, NULL)
|| not app::BoltEntity_get_IsOwner(boltEntity, NULL))
return false;
std::string str = il2cppi_to_string(SaveHelper->fields.sceneName);
return str;
}
return std::string("unknown");
return true;
}
void BurnRitualObj(bool burnAll)
bool IsPlayerCrawling()
{
// Devour: SurvivalObjectBurnController
// Molly: SurvivalMollyAltarController
// Inn: InnMapController
// Town: SurvivalTownAltarController
// Slaughterhouse: SlaughterhouseAltarController
if (!Player::GetLocalPlayer())
return false;
/* MAP: TOWN, DEVOUR
DO_APP_FUNC(0x00562320, void, SurvivalObjectBurnController_BurnGoat, (SurvivalObjectBurnController * __this, MethodInfo * method));
DO_APP_FUNC(0x00562590, void, SurvivalObjectBurnController_SkipToGoat, (SurvivalObjectBurnController * __this, int32_t number, MethodInfo * method));
*/
if (!IsHost()) {
return;
}
Wrapper wrapper;
const Il2CppImage* image = wrapper.GetImage("Assembly-CSharp.dll");
std::string sceneName = get_SceneName();
std::cout << "call..\n";
// !!!!Check if Azazel is awake.
BurnManager(sceneName, wrapper, image, burnAll);
return app::NolanBehaviour_IsCrawling(Player::GetNolan(), nullptr);
}
void BurnManager(std::string& sceneName, Wrapper& wrapper, const Il2CppImage* image, bool burnAll)
bool IsPlayerCrawling(app::GameObject* go)
{
int32_t num = 10;
if (go == NULL)
return false;
if (sceneName == std::string("Devour")) {
app::String* str = reinterpret_cast<app::String*>(il2cpp_string_new("NolanBehaviour"));
Il2CppObject* object = wrapper.GetObjectFromClass(image, "", "SurvivalObjectBurnController");
if (app::GameObject_GetComponentByName != NULL) {
app::Component* nbComponent = app::GameObject_GetComponentByName(go, str, nullptr);
if (object != nullptr) {
auto SurvivalObjectBurnController_Object = app::Object_1_FindObjectOfType(reinterpret_cast<app::Type*>(object), nullptr);
if (nbComponent) {
app::NolanBehaviour* nb = reinterpret_cast<app::NolanBehaviour*>(nbComponent);
if (SurvivalObjectBurnController_Object) {
auto SurvivalObjectBurnController = reinterpret_cast<app::SurvivalObjectBurnController*>(SurvivalObjectBurnController_Object);
if (SurvivalObjectBurnController) {
if (burnAll) {
if (app::SurvivalObjectBurnController_SkipToGoat) {
app::SurvivalObjectBurnController_SkipToGoat(SurvivalObjectBurnController, num, nullptr);
}
}
else {
if (app::SurvivalObjectBurnController_BurnGoat) {
app::SurvivalObjectBurnController_BurnGoat(SurvivalObjectBurnController, nullptr);
}
}
}
if (nb) {
return app::NolanBehaviour_IsCrawling(nb, nullptr);
}
}
}
else if (sceneName == std::string("Molly")) {
/*
MAP: MOLLY
DO_APP_FUNC(0x0055C100, void, SurvivalMollyAltarController_SkipToGoat, (SurvivalMollyAltarController * __this, int32_t number, MethodInfo * method));
DO_APP_FUNC(0x0055C8E0, void, SurvivalMollyAltarController_OnGoat, (SurvivalMollyAltarController * __this, MethodInfo * method));
*/
Il2CppObject* object = wrapper.GetObjectFromClass(image, "", "SurvivalMollyAltarController");
if (object != nullptr) {
auto MollyAltarController_Object = app::Object_1_FindObjectOfType(reinterpret_cast<app::Type*>(object), nullptr);
if (MollyAltarController_Object) {
auto SurvivalMollyAltarController = reinterpret_cast<app::SurvivalMollyAltarController*>(MollyAltarController_Object);
if (SurvivalMollyAltarController) {
if (burnAll) {
if (app::SurvivalMollyAltarController_SkipToGoat) {
app::SurvivalMollyAltarController_SkipToGoat(SurvivalMollyAltarController, num, nullptr);
}
}
else {
if (app::SurvivalMollyAltarController_OnGoat) {
app::SurvivalMollyAltarController_OnGoat(SurvivalMollyAltarController, nullptr);
}
}
}
}
}
}
else if (sceneName == std::string("Inn")) {
/* MAP: INN
DO_APP_FUNC(0x00930CD0, void, MapController_SetProgressTo, (MapController * __this, int32_t progress, MethodInfo * method));
DO_APP_FUNC(0x00930EA0, void, MapController_IncreaseProgress, (MapController * __this, MethodInfo * method));
*/
Il2CppObject* object = wrapper.GetObjectFromClass(image, "", "SurvivalMollyAltarController");
if (object != nullptr) {
auto MapController_Object = app::Object_1_FindObjectOfType(reinterpret_cast<app::Type*>(object), nullptr);
if (MapController_Object) {
auto MapController = reinterpret_cast<app::MapController*>(MapController_Object);
if (MapController) {
if (burnAll) {
if (app::MapController_SetProgressTo) {
app::MapController_SetProgressTo(MapController, num, nullptr);
}
}
else {
if (app::MapController_IncreaseProgress) {
app::MapController_IncreaseProgress(MapController, nullptr);
}
}
}
}
}
}
else if (sceneName == std::string("Town")) {
/* MAP: TOWN, DEVOUR
DO_APP_FUNC(0x00562320, void, SurvivalObjectBurnController_BurnGoat, (SurvivalObjectBurnController * __this, MethodInfo * method));
DO_APP_FUNC(0x00562590, void, SurvivalObjectBurnController_SkipToGoat, (SurvivalObjectBurnController * __this, int32_t number, MethodInfo * method));
*/
Il2CppObject* object = wrapper.GetObjectFromClass(image, "", "SurvivalMollyAltarController");
if (object != nullptr) {
auto MapController_Object = app::Object_1_FindObjectOfType(reinterpret_cast<app::Type*>(object), nullptr);
if (MapController_Object) {
auto MapController = reinterpret_cast<app::MapController*>(MapController_Object);
if (MapController) {
if (burnAll) {
if (app::MapController_SetProgressTo) {
app::MapController_SetProgressTo(MapController, num, nullptr);
}
}
else {
if (app::MapController_IncreaseProgress) {
app::MapController_IncreaseProgress(MapController, nullptr);
}
}
}
}
}
}
else if (sceneName == std::string("Slaughterhouse")) {
/* MAP: Slaughterhouse
DO_APP_FUNC(0x0050DEB0, void, SlaughterhouseAltarController_SkipToGoat, (SlaughterhouseAltarController * __this, int32_t number, MethodInfo * method));
*/
Il2CppObject* object = wrapper.GetObjectFromClass(image, "", "SlaughterhouseAltarController");
if (object != nullptr) {
auto SlaughterhouseAltarController_Object = app::Object_1_FindObjectOfType(reinterpret_cast<app::Type*>(object), nullptr);
if (SlaughterhouseAltarController_Object) {
auto SlaughterhouseAltarController = reinterpret_cast<app::SlaughterhouseAltarController*>(SlaughterhouseAltarController_Object);
if (SlaughterhouseAltarController) {
if (burnAll) {
if (app::SlaughterhouseAltarController_SkipToGoat) {
app::SlaughterhouseAltarController_SkipToGoat(SlaughterhouseAltarController, num, nullptr);
}
}
else {
return;
}
}
}
}
}
else {
return;
}
return app::NolanBehaviour_IsCrawling(Player::GetNolan(), nullptr);
}
bool IsInGame()
{
app::OptionsHelpers* optionsHelpers = UnityCore::Object<app::OptionsHelpers>::FindObjectOfType("OptionsHelpers");
if (optionsHelpers)
return optionsHelpers->fields._inGame_k__BackingField;
return false;
}
app::GameObject* GetAzazel(app::Survival* survival)
{
app::GameObject* ai = app::Survival_GetAzazel(survival, nullptr);
if (ai) {
return ai;
}
return NULL;
}
std::string SceneName()
{
if (app::SaveHelpers_get_singleton != nullptr) {
app::SaveHelpers* SaveHelper = app::SaveHelpers_get_singleton(nullptr);
if (SaveHelper) {
std::string str = il2cppi_to_string(SaveHelper->fields.sceneName);
return str;
}
}
return std::string("");
}
float Time_DeltaTime()
{
if (app::Time_1_get_deltaTime) {
return app::Time_1_get_deltaTime(nullptr);
}
return 0.0f;
}

14
lib/ClientHelper.h
View File

@@ -1,15 +1,15 @@
#pragma once
#include <string>
class Wrapper;
bool IsSinglePlayer();
bool IsOnline();
bool IsHost();
bool IsLocalPlayer(app::NolanBehaviour* player);
bool IsPlayerCrawling();
bool IsPlayerCrawling(app::GameObject* go);
bool IsInGame();
app::Menu* get_HorrorMenu();
std::string get_SceneName();
app::GameObject* GetAzazel(app::Survival* survival);
void BurnRitualObj(bool burnAll);
void BurnManager(std::string& sceneName, Wrapper& wrapper, const Il2CppImage* image, bool burnAll);
std::string SceneName();
float Time_DeltaTime();

18
lib/UnityCore.cpp Normal file
View File

@@ -0,0 +1,18 @@
#include "pch-il2cpp.h"
#include "UnityCore.h"
app::Component* Unity::GameObject::GetComponentByName(app::GameObject* go, const char* type)
{
app::String* str = reinterpret_cast<app::String*>(il2cpp_string_new(type));
if (str != nullptr) {
app::Component* component = app::GameObject_GetComponentByName(go, str, nullptr);
if (component != nullptr) {
return component;
}
}
return nullptr;
}

44
lib/UnityCore.h Normal file
View File

@@ -0,0 +1,44 @@
#pragma once
#include "Wrapper.h"
#include <vector>
namespace Unity {
namespace GameObject {
// DO_APP_FUNC(0x02D34DA0, Component *, GameObject_GetComponentByName, (GameObject * __this, String * type, MethodInfo * method));
app::Component* GetComponentByName(app::GameObject* go, const char* type);
}
}
namespace UnityCore {
template<typename T>
class Object {
public:
Object() = default;
static T* FindObjectOfType(const char* className, const char* classNamespace = "");
};
template<typename T>
inline T* Object<T>::FindObjectOfType(const char* className, const char* classNamespace)
{
Wrapper obj("Assembly-CSharp.dll");
Il2CppObject* object = obj.find_class(classNamespace, className).get_class();
if (object) {
if (app::Object_1_FindObjectOfType == nullptr) return nullptr;
app::Object_1* obj_1 = app::Object_1_FindObjectOfType(reinterpret_cast<app::Type*>(object), nullptr);
if (obj_1) {
T* foundObject = reinterpret_cast<T*>(obj_1);
if (foundObject) {
return foundObject;
}
}
}
return nullptr;
}
}

136
lib/wrapper.cpp
View File

@@ -1,64 +1,98 @@
#include "pch-il2cpp.h"
#include "wrapper.h"
#include "Wrapper.h"
#include <iostream>
#include <string.h>
Wrapper::Wrapper()
Wrapper::Wrapper(const char* imageName) : image(GetImage(imageName)), obj(nullptr) {}
const Il2CppImage* Wrapper::GetImage(const char* imageName)
{
const Il2CppDomain* domain = il2cpp_domain_get();
if (image)
return image;
const Il2CppAssembly** assemblies;
size_t size;
const Il2CppDomain* domain = il2cpp_domain_get();
size_t size;
const Il2CppAssembly** assemblies = il2cpp_domain_get_assemblies(domain, &size);
assemblies = il2cpp_domain_get_assemblies(domain, &size);
assemblyMap.clear();
for (size_t i = 0; i < size; ++i) {
const Il2CppAssembly* assembly = assemblies[i];
if (assembly) {
const char* assemblyName = il2cpp_image_get_name(assembly->image);
assemblyMap[assemblyName] = assembly;
}
}
for (size_t i = 0; i < size; ++i) {
const Il2CppAssembly* assembly = assemblies[i];
if (assembly) {
const char* assemblyName = il2cpp_image_get_name(assembly->image);
if (std::string(assemblyName) == imageName) {
return assembly->image;
}
}
}
return nullptr;
}
const Il2CppAssembly* Wrapper::GetAssembly(const char* _assembly) {
for (const auto& entry : assemblyMap) {
if (strcmp(entry.first, _assembly) == 0) {
return entry.second;
}
}
return nullptr;
}
const Il2CppImage* Wrapper::GetImage(const char* _assembly) {
for (const auto& entry : assemblyMap) {
if (strcmp(entry.first, _assembly) == 0) {
return entry.second->image;
}
}
return nullptr;
}
Il2CppObject* Wrapper::GetObjectFromClass(const Il2CppImage* _image, const char* _namespaze, const char* _name)
Wrapper& Wrapper::find_class(const char* classNamespace, const char* className)
{
Il2CppClass* _class = il2cpp_class_from_name(_image, _namespaze, _name);
Il2CppClass* _class = il2cpp_class_from_name(image, classNamespace, className);
if (_class) {
const Il2CppType* _type = il2cpp_class_get_type(_class);
if (_type) {
obj = il2cpp_type_get_object(_type);
}
}
if (_class) {
const Il2CppType* _type = il2cpp_class_get_type(_class);
if (_type) {
Il2CppObject* _object = il2cpp_type_get_object(_type);
if (_object) {
return _object;
}
}
}
return nullptr;
return *this;
}
void Wrapper::get_fields(const char* classNamespace, const char* className)
{
}
void Wrapper::method_info(const char* classNamespace, const char* className)
{
}
void Wrapper::classList()
{
size_t classCount = il2cpp_image_get_class_count(image);
std::cout << "{\n";
for (size_t i = 0; i < classCount; ++i) {
const Il2CppClass* _klass = il2cpp_image_get_class(image, i);
if (_klass) {
char* _name = const_cast<char*>(il2cpp_class_get_name(const_cast<Il2CppClass*>(_klass)));
char* _namespace = const_cast<char*>(il2cpp_class_get_namespace(const_cast<Il2CppClass*>(_klass)));
std::cout << " [\n";
std::cout << "\tName: " << _name << "\n";
std::cout << "\tNamespace: " << _namespace << "\n";
std::cout << " ],\n";
}
}
std::cout << "\n}\n";
}
Il2CppObject* Wrapper::get_class()
{
return obj;
}
const char* Wrapper::GetImageName()
{
if (image)
return il2cpp_image_get_name(image);
return nullptr;
}
const Il2CppImage* Wrapper::get_image()
{
if (image)
return image;
return nullptr;
}

21
lib/wrapper.h
View File

@@ -1,15 +1,20 @@
#pragma once
#include <map>
struct Il2CppObject;
struct Il2CppImage;
class Wrapper {
public:
Wrapper();
const Il2CppAssembly* GetAssembly(const char* _assembly);
const Il2CppImage* GetImage(const char* _assembly);
Il2CppObject* GetObjectFromClass(const Il2CppImage* _image, const char* _namespaze, const char* _name);
Wrapper(const char* imageName);
Wrapper& find_class(const char* classNamespace, const char* className);
void get_fields(const char* classNamespace, const char* className);
void method_info(const char* classNamespace, const char* className);
void classList();
Il2CppObject* get_class();
const char* GetImageName();
const Il2CppImage* get_image();
private:
std::map<const char*, const Il2CppAssembly*> assemblyMap;
const Il2CppImage* GetImage(const char* image);
const Il2CppImage* image;
Il2CppObject* obj;
};