Что нового?

Исходник Schema Manager & Parser

notGLadiator
notGLadiator
Участник
Статус
Оффлайн
Регистрация
21 Сен 2019
Сообщения
594
Реакции[?]
250
Поинты[?]
23K
credits:
Пожалуйста, авторизуйтесь для просмотра ссылки.
&
Пожалуйста, авторизуйтесь для просмотра ссылки.
&
Пожалуйста, авторизуйтесь для просмотра ссылки.


I spent a little time and made a parser of all schemes, it in "wok-csgo" style, but you can edit it.

Пожалуйста, авторизуйтесь для просмотра ссылки.

Пожалуйста, авторизуйтесь для просмотра ссылки.


schemes.hpp
C++: 
#pragma once

namespace fw {
namespace sdk {
class c_schemes {
public:
  c_schemes();

  template <typename t> t get(std::uint32_t hash) {
    return m_data.m_list[hash];
  }

private:
  struct {
    std::unordered_map<std::uint32_t, std::int16_t> m_list;
  } m_data;
};
inline std::unique_ptr<c_schemes> schemes;
} // namespace sdk
} // namespace fw

#define SCHEMA(type, func, name)                                               \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::schemes->get<std::ptrdiff_t>(FNV1A(name));                    \
    return *reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +  \
                                     offset);                                  \
  }

#define ASCHEMA(type, size, func, name)                                        \
  ALWAYS_INLINE std::array<type, size> &func {                                 \
    static const auto offset =                                                 \
        fw::sdk::schemes->get<std::ptrdiff_t>(FNV1A(name));                    \
    return *reinterpret_cast<std::array<type, size> *>(                        \
        reinterpret_cast<std::uintptr_t>(this) + offset);                      \
  }

#define PSCHEMA(type, func, name)                                              \
  ALWAYS_INLINE type *func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::schemes->get<std::ptrdiff_t>(FNV1A(name));                    \
    return reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +   \
                                    offset);                                   \
  }

#define SCHEMA_OFFSET(type, func, name, add)                                   \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::schemes->get<std::ptrdiff_t>(FNV1A(name));                    \
    return *reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +  \
                                     offset + add);                            \
  }

#define ASCHEMA_OFFSET(type, size, func, name, add)                            \
  ALWAYS_INLINE std::array<type, size> &func {                                 \
    static const auto offset =                                                 \
        fw::sdk::schemes->get<std::ptrdiff_t>(FNV1A(name));                    \
    return *reinterpret_cast<std::array<type, size> *>(                        \
        reinterpret_cast<std::uintptr_t>(this) + offset + add);                \
  }

#define PSCHEMA_OFFSET(type, func, name, add)                                  \
  ALWAYS_INLINE type *func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::schemes->get<std::ptrdiff_t>(FNV1A(name));                    \
    return reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +   \
                                    offset + add);                             \
  }

#define MSCHEMA(type, func, name, modifier)                                    \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::schemes->get<std::ptrdiff_t>(FNV1A(name));                    \
    return reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +   \
                                    offset * modifier);                        \
  }

#define OFFSET(type, func, offset)                                             \
  ALWAYS_INLINE type &func {                                                   \
    return *reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +  \
                                     offset);                                  \
  }

#define POFFSET(type, func, offset)                                            \
  ALWAYS_INLINE type *func {                                                   \
    return reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +   \
                                    offset);                                   \
  }

#define PPOFFSET(type, func, offset)                                           \
  ALWAYS_INLINE type &func {                                                   \
    return **reinterpret_cast<type **>(                                        \
        reinterpret_cast<std::uintptr_t>(this) + offset);                      \
  }

#define MOFFSET(type, func, offset, modifier)                                  \
  ALWAYS_INLINE type &func {                                                   \
    return **reinterpret_cast<type **>(                                        \
        reinterpret_cast<std::uintptr_t>(this) + offset * modifier);           \
  }
schemes.cpp
C++: 
#include "../../../framework.hpp"

namespace fw {
namespace sdk {
c_schemes::c_schemes() {
  // Get schema modules
  const auto type_scopes = interfaces::m_schema_system->get_type_scopes();

  // Iterate through modules
  for (auto i = 0; i < type_scopes.Count(); ++i) {
    // Get current module
    const auto current = type_scopes.m_pElements[i];

    // Current module invalid(?) or it's server module, so we skip.
    if (!current || current->get_scope_name() == "server.dll")
      continue;

    // iterate through schema module classes
    for (const auto schema_class_binding :
         current->get_classes().GetElements()) {
      // Get current class information
      const auto class_info =
          current->find_declared_class(schema_class_binding->m_binary_name);

      // Class info invalid(?), so we skip.
      if (!class_info)
        continue;

      // Iterate through class fields
      for (int i = 0; i < class_info->m_align; ++i) {
        // Get current class field
        const auto &current_field = class_info->m_fields[i];

        // Build schema name (class name + field name)
        std::string schema_name = schema_class_binding->m_binary_name;
        schema_name.append("->");
        schema_name.append(current_field.m_name);

        // Add schema to list
        m_data.m_list[FNV1A_RT(schema_name.c_str())] =
            current_field.m_single_inheritance_offset;
      }
    }
  }
}
} // namespace sdk
} // namespace fw
example:
// init
fw::sdk::schemes = std::make_unique<fw::sdk::c_schemes>();
// use
SCHEMA(std::uint8_t, m_iTeamNum(), "C_BaseEntity->m_iTeamNum");

 
Последнее редактирование:
canubanmeagainfuckas
C
Забаненный
Статус
Оффлайн
Регистрация
20 Мар 2023
Сообщения
19
Реакции[?]
22
Поинты[?]
1K
Обратите внимание, пользователь заблокирован на форуме. Не рекомендуется проводить сделки.
notGLadiator написал(а):
credits:
Пожалуйста, авторизуйтесь для просмотра ссылки.
&
Пожалуйста, авторизуйтесь для просмотра ссылки.
&
Пожалуйста, авторизуйтесь для просмотра ссылки.


I spent a little time and made a parser of all netvars, it in "wok-csgo" style, but you can edit it.

netvars.hpp
C++: 
#pragma once

namespace fw {
namespace sdk {
class c_netvars {
public:
  c_netvars();

  template <typename t> t get(std::uint32_t hash) {
    return m_data.m_list[hash];
  }

private:
  struct {
    std::unordered_map<std::uint32_t, std::int16_t> m_list;
  } m_data;
};
inline c_netvars *netvars = nullptr;
} // namespace sdk
} // namespace fw

#define NETVAR(type, func, name)                                               \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::netvars->get<std::uintptr_t>(FNV1A(name));                    \
    return *reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +  \
                                     offset);                                  \
  }

#define ANETVAR(type, size, func, name)                                        \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::netvars->get<std::uintptr_t>(FNV1A(name));                    \
    return *reinterpret_cast<std::array<type, size> *>(                        \
        reinterpret_cast<std::uintptr_t>(this) + offset);                      \
  }

#define PNETVAR(type, func, name)                                              \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::netvars->get<std::uintptr_t>(FNV1A(name));                    \
    return reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +   \
                                    offset);                                   \
  }

#define NETVAR_OFFSET(type, func, name, add)                                   \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::netvars->get<std::uintptr_t>(FNV1A(name));                    \
    return *reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +  \
                                     offset + add);                            \
  }

#define ANETVAR_OFFSET(type, size, func, name, add)                            \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::netvars->get<std::uintptr_t>(FNV1A(name));                    \
    return *reinterpret_cast<std::array<type, size> *>(                        \
        reinterpret_cast<std::uintptr_t>(this) + offset + add);                \
  }

#define PNETVAR_OFFSET(type, func, name, add)                                  \
  ALWAYS_INLINE type &func {                                                   \
    static const auto offset =                                                 \
        fw::sdk::netvars->get<std::uintptr_t>(FNV1A(name));                    \
    return reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +   \
                                    offset + add);                             \
  }

#define OFFSET(type, func, offset)                                             \
  ALWAYS_INLINE type &func {                                                   \
    return *reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +  \
                                     offset);                                  \
  }

#define POFFSET(type, func, offset)                                            \
  ALWAYS_INLINE type &func {                                                   \
    return reinterpret_cast<type *>(reinterpret_cast<std::uintptr_t>(this) +   \
                                    offset);                                   \
  }

#define PPOFFSET(type, func, offset)                                           \
  ALWAYS_INLINE type &func {                                                   \
    return **reinterpret_cast<type **>(                                        \
        reinterpret_cast<std::uintptr_t>(this) + offset);                      \
  }

#define MPOFFSET(type, func, offset, modifier)                                 \
  ALWAYS_INLINE type &func {                                                   \
    return **reinterpret_cast<type **>(                                        \
        reinterpret_cast<std::uintptr_t>(this) + offset * modifier);           \
  }
netvars.cpp
C++: 
#include "../../../framework.hpp"

namespace fw {
namespace sdk {
c_netvars::c_netvars() {
  const auto type_scopes = interfaces::m_schema_system->get_type_scopes();

  for (auto i = 0; i < type_scopes.Count(); ++i) {
    const auto current = type_scopes.m_pElements[i];

    for (const auto schema_class_binding :
         current->get_classes().GetElements()) {
      const auto class_info =
          current->find_declared_class(schema_class_binding->m_binary_name);

      short field_size = class_info->get_field_size();
      sdk::schema_class_field_data_t *fields = class_info->get_fields();

      for (int i = 0; i < field_size; ++i) {
        sdk::schema_class_field_data_t &field = fields[i];

        char name[256];

        strcpy_s(name, schema_class_binding->m_binary_name);
        strcat_s(name, xr("->"));
        strcat_s(name, field.m_name);

        m_data.m_list[FNV1A_RT(name)] = field.m_offset;

        fw::console->print(xr("Found netvar {}"), name);
      }
    }
  }
}
} // namespace sdk
} // namespace fw
example:
// init
fw::sdk::netvars = new fw::sdk::c_netvars();
// use
NETVAR(std::uint8_t, m_iTeamNum(), "C_BaseEntity->m_iTeamNum");

Нажмите для раскрытия...
+rep but you can change name[ 256 ] to name[ 260 ] max number of namings is 260
 
notGLadiator
notGLadiator
Участник
Статус
Оффлайн
Регистрация
21 Сен 2019
Сообщения
594
Реакции[?]
250
Поинты[?]
23K
notGLadiator
notGLadiator
Участник
Статус
Оффлайн
Регистрация
21 Сен 2019
Сообщения
594
Реакции[?]
250
Поинты[?]
23K
Update: Small refactoring, fixed some macros, comments added (sorry for bad English), now it's "Schema Manager".
 
notGLadiator
notGLadiator
Участник
Статус
Оффлайн
Регистрация
21 Сен 2019
Сообщения
594
Реакции[?]
250
Поинты[?]
23K
Minor update: redesigned to fit the schema system style from "source2gen", some pointer validation checks. I also updated the format of the schemes dump, it's much better now.
 
notGLadiator
notGLadiator
Участник
Статус
Оффлайн
Регистрация
21 Сен 2019
Сообщения
594
Реакции[?]
250
Поинты[?]
23K
Minor update: Some fixes, removed schemes parsing from server.dll, I added to the comments (?) which means this should normally never happen, and something is probably wrong with your cheat. I also updated schemes dump a bit and added enumes dump.
 
Войдите или зарегистрируйтесь для ответа.
Немного о главном
Полезные мелочи
О нас

Проект предоставляет различный материал, относящийся к сфере киберспорта, программирования, ПО для игр, а также позволяет его участникам общаться на многие другие темы. Почта для жалоб: admin@yougame.biz

Поделиться страницей
Сверху Снизу