ClassDump.h

#pragma once
#include <Cyrus/shared.h>
#include <Windows.h>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <nlohmann/json.hpp>
#include <ostream>
#include <string>
 
using namespace nlohmann;
 
class ClassTypeStorage {
public:
  uint8_t pad[0x30];    // 0x8
  std::string typeName; // 0x38
  uint8_t pad1[0x30];   // 0x58
  bool isPointer;       // 0x88
 
  virtual ~ClassTypeStorage() = default;
};
 
class ClassContainerStorage {
public:
  virtual void *constructor();     // 0x0
  virtual char *getStorage();      // 0x8
  virtual int getElements(bool a); // 0x10
  virtual void unk1();             // 0x18
  virtual bool isDynamic();        // 0x20
};
 
class ClassDescriptor;
 
class ClassEnumVal {
public:
  std::string value;
  void *pad;
  std::string name;
};
 
class ClassProperty {
public:
  uint8_t pad[0x30];                       // 0x8
  ClassDescriptor *descriptor;             // 0x38
  ClassContainerStorage *containerStorage; // 0x40
  uint8_t paddd[0x2];                      // 0x48
  uintptr_t propertyID;                    // 0x50
  char *name;                              // 0x58
  void *pad3;                              // 0x60
  uint32_t offset;                         // 0x68
  uint32_t pad2;                           // 0x6C
  ClassTypeStorage *storage;               // 0x70
  void *pad4;                              // 0x78
  uintptr_t flags;                         // 0x80
  char *note;                              // 0x88
  void *pad22;                             // 0x90
  uintptr_t enumStart;                     // 0x98
  uintptr_t enumEnd;                       // 0xA0
 
  char *getName() { return name; }
 
  uint32_t getPropertyID() { return propertyID; }
 
  std::string getType() { return storage->typeName; }
 
  bool isPointer() { return storage->isPointer; }
 
  virtual ~ClassProperty() = default;
 
  json serialize() {
    json j;
    std::string note = std::string(this->note);
    auto name = getName();
    if (note != name) {
      j["note"] = note;
    }
    j["name"] = name;
    j["type"] = getType();
    j["container"] = containerStorage->getStorage();
    j["offset"] = offset;
    auto dynamic = containerStorage->isDynamic();
    j["dynamic"] = dynamic;
    j["pointer"] = isPointer();
    if (!dynamic) {
      j["elements"] = containerStorage->getElements(false);
    }
 
    auto enumItemCount = (enumEnd - enumStart) / 0x48;
    j["enumValueCount"] = enumItemCount;
    for (auto i = enumStart; i < enumEnd; i += 0x48) {
      auto enumVal = reinterpret_cast<ClassEnumVal *>(i);
      j["enumValues"].push_back(
          json({{"name", enumVal->name}, {"value", enumVal->value}}));
    }
    return j;
  }
};
 
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, pad, 0x8);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, descriptor, 0x38);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, containerStorage, 0x40);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, propertyID, 0x50);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, name, 0x58);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, pad3, 0x60);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, offset, 0x68);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, pad2, 0x6C);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, storage, 0x70);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, pad4, 0x78);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, flags, 0x80);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassProperty, note, 0x88);
 
struct ArgStuff {
  uintptr_t start;
  uintptr_t end;
  uintptr_t WTF;
};
 
class ClassFunctionTypeStorage {
public:
  uint8_t pad[0x28];  // 0x8
  uintptr_t fnAdress; // 0x30
 
  virtual ClassTypeStorage *getReturnType() = 0;
  virtual bool getArgsData(ArgStuff *out) = 0;
};
 
class ClassFunction {
  uint8_t pad[0x30];                      // 0x8
  std::string name;                       // 0x38
  ClassFunctionTypeStorage *functionData; // 0x58
public:
  virtual ~ClassFunction() = default;
 
  json serialize(std::string parentType) {
    json j;
    j["name"] = name;
 
    if (!functionData) {
      return j;
    }
 
    auto ret = functionData->getReturnType();
    if (ret) {
      j["returnType"] = ret->typeName;
    } else {
      j["returnType"] = "void";
    }
 
    ArgStuff *args = new ArgStuff;
    args->start = 0;
    args->end = 0;
    args->WTF = 0;
    if (functionData->getArgsData(args)) {
      j["argCount"] = (args->end - args->start) / 0x8;
    }
 
    j["args"].push_back(parentType + " *self");
    for (auto i = args->start; i < args->end; i += 0x8) {
      auto arg = *reinterpret_cast<ClassTypeStorage **>(i);
      j["args"].push_back(arg->typeName + " a" +
                          std::to_string((i - args->start) / 0x8));
    }
 
    j["rva"] = functionData->fnAdress -
               reinterpret_cast<uintptr_t>(GetModuleHandleA(0));
    return j;
  }
};
 
class ClassDescriptor {
public:
  uintptr_t unk1;                          // 0x8
  uint32_t m_offset;                       // 0x10
  uint32_t unk2;                           // 0x14
  ClassDescriptor *super;                  // 0x18; super class descriptor
  ClassTypeStorage *classTypeStorage;      // 0x20
  uint8_t padd[0x30];                      // 0x28
  std::vector<ClassProperty *> properties; // 0x58
  std::vector<ClassFunction *> functions;  // 0x70
 
public:
  virtual ~ClassDescriptor() = default;
 
  json serialize() {
    json j;
    j["offset"] = m_offset;
    if (!classTypeStorage) {
      return j;
    }
    j["name"] = classTypeStorage->typeName;
 
    if (!super) {
      return j;
    }
 
    auto cSupper = super;
    j["super"] = super->classTypeStorage->typeName;
    while (cSupper) {
      j["allSuperClasses"].push_back(cSupper->classTypeStorage->typeName);
      cSupper = cSupper->super;
    }
 
    for (auto i = 0; i < properties.size(); i += 2) {
      auto prop = properties[i];
      j["properties"].push_back(prop->serialize());
    }
 
    for (auto i = 0; i < functions.size(); i += 2) {
      auto f = functions[i];
      j["functions"].push_back(f->serialize(classTypeStorage->typeName));
    }
    return j;
  }
};
 
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassDescriptor, unk1, 0x8);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassDescriptor, m_offset, 0x10);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassDescriptor, unk2, 0x14);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassDescriptor, super, 0x18);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassDescriptor, classTypeStorage, 0x20);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassDescriptor, padd, 0x28);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassDescriptor, properties, 0x58);
DEFINE_OFFSET_AND_STATIC_ASSERT(ClassDescriptor, functions, 0x70);
 
void dumpClasses() {
  std::vector<ClassDescriptor *> wizClasses;
  uintptr_t base = reinterpret_cast<uintptr_t>(GetModuleHandleA(nullptr));
  uintptr_t superClassDescriptor =
      *reinterpret_cast<uintptr_t *>(base + 0x347F018);
 
  const auto wizClassDescriptorEnd =
      *reinterpret_cast<uintptr_t *>(superClassDescriptor);
  auto currentClassDescriptor =
      *reinterpret_cast<uintptr_t *>(wizClassDescriptorEnd);
 
  auto count = 0;
  while (currentClassDescriptor != wizClassDescriptorEnd) {
    auto classDataPointer =
        *reinterpret_cast<uintptr_t *>(currentClassDescriptor + 0x28);
    auto classAttributePointer =
        *reinterpret_cast<uintptr_t *>(currentClassDescriptor + 0x10);
    if (*reinterpret_cast<uint8_t *>(classAttributePointer + 0x19)) {
      auto linkedDescriptor =
          *reinterpret_cast<uintptr_t *>(currentClassDescriptor + 0x8);
      for (; !*reinterpret_cast<uint8_t *>(linkedDescriptor + 0x19);
           linkedDescriptor =
               *reinterpret_cast<uintptr_t *>(linkedDescriptor + 0x8)) {
        if (currentClassDescriptor !=
            *reinterpret_cast<uintptr_t *>(linkedDescriptor + 0x10)) {
          break;
        }
        currentClassDescriptor = linkedDescriptor;
      }
      currentClassDescriptor = linkedDescriptor;
    } else {
      currentClassDescriptor =
          *reinterpret_cast<uintptr_t *>(currentClassDescriptor + 0x10);
      for (auto linkedDescriptor =
               *reinterpret_cast<uintptr_t *>(classAttributePointer);
           !*reinterpret_cast<uint8_t *>(linkedDescriptor + 0x19);
           linkedDescriptor =
               *reinterpret_cast<uintptr_t *>(linkedDescriptor)) {
        currentClassDescriptor = linkedDescriptor;
      }
    }
    auto currentClass = *reinterpret_cast<uintptr_t *>(classDataPointer + 0x90);
    if (currentClass &&
        !*reinterpret_cast<uint8_t *>(classDataPointer + 0x88)) {
      wizClasses.push_back(reinterpret_cast<ClassDescriptor *>(currentClass));
      count++;
    }
  }
 
  json classes;
  for (auto wizClass : wizClasses) {
    if (wizClass == nullptr) {
      continue;
    }
    classes.push_back(wizClass->serialize());
  }
  std::ofstream file("classes.json");
  if (file.is_open()) {
    auto classesJson = classes.dump(4);
    file << classesJson;
    file.close();
  } else {
    std::cout << "Unable to open classes file for writing" << std::endl;
  }
}