#include "esp.h"
#include "../../enhance.h"
#include "../../globals/globals.h"
#include "../../gui/GUI.h"
#include "../module_keybind.h"
#include <sdk/minecraft/minecraft.h>
#include <sdk/minecraft/world/world.h>
#include <sdk/minecraft/entity/entity.h>
#include <sdk/minecraft/util/box.h>
#include <sdk/classloader.h>
#include <sdk/mappings/mappings.hpp>
#include <algorithm>
#include <cfloat>
#include <cmath>
#include <cstdio>
#include <mutex>
#include <vector>
static std::vector<esp_player_data> g_players;
static esp_camera_data g_camera;
static std::mutex g_players_mutex;
static bool g_esp_toggled = false;
static bool g_esp_was_pressed = false;
struct esp_render_matrices
{
float modelview[16]{};
float projection[16]{};
int viewport_width = 0;
int viewport_height = 0;
bool valid = false;
};
static esp_render_matrices g_matrices;
static std::mutex g_matrices_mutex;
namespace
{
jmethodID get_method_by_names(JNIEnv* env, jclass clazz, const char* const* names, int count, const char* sig)
{
for (int i = 0; i < count; ++i)
{
jmethodID mid = env->GetMethodID(clazz, names, sig);
if (mid && !env->ExceptionCheck())
{
return mid;
}
env->ExceptionClear();
}
return nullptr;
}
bool read_text_to_utf8(JNIEnv* env, jobject text_obj, std::string& out)
{
if (!env || !text_obj)
{
return false;
}
jclass text_class = env->GetObjectClass(text_obj);
if (!text_class)
{
env->ExceptionClear();
return false;
}
const char* get_string_names[] = {"method_10851", "getString", "asString", "func_150260_c", "m_130791_"};
jmethodID get_string = get_method_by_names(env, text_class, get_string_names, 5, "()Ljava/lang/String;");
if (!get_string)
{
env->DeleteLocalRef(text_class);
return false;
}
jstring s = static_cast<jstring>(env->CallObjectMethod(text_obj, get_string));
if (!s || env->ExceptionCheck())
{
env->ExceptionClear();
if (s) env->DeleteLocalRef(s);
env->DeleteLocalRef(text_class);
return false;
}
const char* utf = env->GetStringUTFChars(s, nullptr);
if (!utf)
{
env->DeleteLocalRef(s);
env->DeleteLocalRef(text_class);
return false;
}
out = utf;
env->ReleaseStringUTFChars(s, utf);
env->DeleteLocalRef(s);
env->DeleteLocalRef(text_class);
return !out.empty();
}
void mul4(const float* m, float x, float y, float z, float w, float& ox, float& oy, float& oz, float& ow)
{
ox = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
oy = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
oz = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
ow = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
}
bool project_point(const esp_render_matrices& mtx, float x, float y, float z, float& sx, float& sy)
{
if (!mtx.valid || mtx.viewport_width <= 0 || mtx.viewport_height <= 0)
{
return false;
}
float vx = 0.0f, vy = 0.0f, vz = 0.0f, vw = 0.0f;
float cx = 0.0f, cy = 0.0f, cz = 0.0f, cw = 0.0f;
mul4(mtx.modelview, x, y, z, 1.0f, vx, vy, vz, vw);
mul4(mtx.projection, vx, vy, vz, vw, cx, cy, cz, cw);
if (cw <= 0.0001f)
{
return false;
}
const float ndc_x = cx / cw;
const float ndc_y = cy / cw;
sx = (ndc_x + 1.0f) * 0.5f * static_cast<float>(mtx.viewport_width);
sy = (1.0f - ndc_y) * 0.5f * static_cast<float>(mtx.viewport_height);
return std::isfinite(sx) && std::isfinite(sy);
}
bool project_point_camera(const esp_camera_data& cam, int screen_w, int screen_h, float x, float y, float z, float& sx, float& sy)
{
const float pi = 3.14159265358979323846f;
if (screen_w <= 0 || screen_h <= 0)
{
return false;
}
const float dx = x - static_cast<float>(cam.cam_x);
const float dy = y - static_cast<float>(cam.cam_y);
const float dz = z - static_cast<float>(cam.cam_z);
// Minecraft yaw convention compensation.
const float yaw = (cam.yaw + 90.0f) * (pi / 180.0f);
const float pitch = cam.pitch * (pi / 180.0f);
const float cos_y = cosf(yaw);
const float sin_y = sinf(yaw);
const float cos_p = cosf(pitch);
const float sin_p = sinf(pitch);
const float rx = dx * cos_y + dz * sin_y;
const float rz = dz * cos_y - dx * sin_y;
const float ry = dy * cos_p - rz * sin_p;
const float rz2 = rz * cos_p + dy * sin_p;
if (rz2 <= 0.01f)
{
return false;
}
const float fov = (std::max)(30.0f, (std::min)(170.0f, cam.fov > 1.0f ? cam.fov : 70.0f));
const float f = 1.0f / tanf((fov * 0.5f) * (pi / 180.0f));
const float aspect = static_cast<float>(screen_w) / static_cast<float>(screen_h);
const float ndc_x = (rx * f / aspect) / rz2;
const float ndc_y = (ry * f) / rz2;
sx = (ndc_x + 1.0f) * 0.5f * static_cast<float>(screen_w);
sy = (1.0f - ndc_y) * 0.5f * static_cast<float>(screen_h);
return std::isfinite(sx) && std::isfinite(sy);
}
void draw_box_2d(ImDrawList* dl, float min_x, float min_y, float max_x, float max_y, ImU32 color)
{
const ImU32 outline = IM_COL32(0, 0, 0, 255);
dl->AddRect(ImVec2(min_x - 1.0f, min_y - 1.0f), ImVec2(max_x + 1.0f, max_y + 1.0f), outline, 0.0f, 0, 2.0f);
dl->AddRect(ImVec2(min_x, min_y), ImVec2(max_x, max_y), color, 0.0f, 0, 1.5f);
dl->AddRect(ImVec2(min_x + 1.0f, min_y + 1.0f), ImVec2(max_x - 1.0f, max_y - 1.0f), outline, 0.0f, 0, 1.0f);
}
void draw_corner_box(ImDrawList* dl, float min_x, float min_y, float max_x, float max_y, ImU32 color)
{
const float w = max_x - min_x;
const float h = max_y - min_y;
const float cs = (std::min)(w, h) * 0.25f;
const bool outline_on = globals::esp_corner_outline;
const ImU32 outline = IM_COL32(0, 0, 0, 200);
auto seg = [&](const ImVec2& a, const ImVec2& b)
{
if (outline_on)
{
dl->AddLine(ImVec2(a.x - 1.0f, a.y - 1.0f), ImVec2(b.x - 1.0f, b.y - 1.0f), outline, 3.0f);
dl->AddLine(ImVec2(a.x + 1.0f, a.y + 1.0f), ImVec2(b.x + 1.0f, b.y + 1.0f), outline, 3.0f);
}
dl->AddLine(a, b, color, 2.0f);
};
seg(ImVec2(min_x, min_y), ImVec2(min_x + cs, min_y));
seg(ImVec2(min_x, min_y), ImVec2(min_x, min_y + cs));
seg(ImVec2(max_x, min_y), ImVec2(max_x - cs, min_y));
seg(ImVec2(max_x, min_y), ImVec2(max_x, min_y + cs));
seg(ImVec2(min_x, max_y), ImVec2(min_x + cs, max_y));
seg(ImVec2(min_x, max_y), ImVec2(min_x, max_y - cs));
seg(ImVec2(max_x, max_y), ImVec2(max_x - cs, max_y));
seg(ImVec2(max_x, max_y), ImVec2(max_x, max_y - cs));
}
void draw_3d_edges(ImDrawList* dl, const float pts[8][2], ImU32 color)
{
const ImU32 outline = IM_COL32(0, 0, 0, 200);
const int edges[12][2] = {
{0,1},{1,2},{2,3},{3,0},
{4,5},{5,6},{6,7},{7,4},
{0,4},{1,5},{2,6},{3,7}
};
for (const auto& e : edges)
{
const ImVec2 a(pts[e[0]][0], pts[e[0]][1]);
const ImVec2 b(pts[e[1]][0], pts[e[1]][1]);
dl->AddLine(ImVec2(a.x - 1.0f, a.y - 1.0f), ImVec2(b.x - 1.0f, b.y - 1.0f), outline, 3.0f);
dl->AddLine(a, b, color, 1.6f);
}
}
void draw_center_text(ImDrawList* dl, const char* text, float x, float y, ImU32 color)
{
const ImVec2 sz = ImGui::CalcTextSize(text);
const ImVec2 p(x - sz.x * 0.5f, y);
dl->AddText(ImVec2(p.x + 1.0f, p.y + 1.0f), IM_COL32(0, 0, 0, 200), text);
dl->AddText(p, color, text);
}
}
void enhance::modules::esp::run()
{
const bool active = globals::esp_enabled && (globals::esp_box || globals::esp_health_bar || globals::esp_name || globals::esp_distance);
if (!enhance::modules::module_keybind::is_active(active, globals::esp_keybind, globals::esp_mode, g_esp_toggled, g_esp_was_pressed))
{
std::lock_guard<std::mutex> lock(g_players_mutex);
g_players.clear();
return;
}
auto env = enhance::instance->get_env();
if (!env)
{
return;
}
jobject world = sdk::instance->get_world();
jobject local_player = sdk::instance->get_player();
if (!world || !local_player)
{
if (world) env->DeleteLocalRef(world);
if (local_player) env->DeleteLocalRef(local_player);
return;
}
sdk::world_client world_client(world);
std::vector<jobject> players = world_client.get_players();
sdk::camera_data cam = sdk::instance->get_camera();
if (!cam.valid)
{
sdk::entity_client self(local_player);
cam.x = self.get_x();
cam.y = self.get_y() + 1.62;
cam.z = self.get_z();
cam.yaw = self.get_yaw();
cam.pitch = self.get_pitch();
cam.fov = 70.0f;
cam.valid = true;
}
std::vector<esp_player_data> out;
out.reserve(players.size());
jclass living_cls = sdk::classloader::find_class(env, sdk::mappings::living_entity_class_sig);
jmethodID get_health_mid = nullptr;
jmethodID get_max_health_mid = nullptr;
if (living_cls)
{
get_health_mid = env->GetMethodID(living_cls, sdk::mappings::living_entity_get_health_name, sdk::mappings::living_entity_get_health_sig);
if (env->ExceptionCheck())
{
env->ExceptionClear();
get_health_mid = nullptr;
}
get_max_health_mid = env->GetMethodID(living_cls, sdk::mappings::living_entity_get_max_health_name, sdk::mappings::living_entity_get_max_health_sig);
if (env->ExceptionCheck())
{
env->ExceptionClear();
get_max_health_mid = nullptr;
}
}
for (jobject p : players)
{
if (!p) continue;
sdk::entity_client ent(p);
if (ent.is_same_object(local_player)) continue;
esp_player_data d{};
d.is_player = true;
d.name = "Unknown";
d.x = ent.get_x();
d.y = ent.get_y();
d.z = ent.get_z();
d.prev_x = d.x;
d.prev_y = d.y;
d.prev_z = d.z;
jclass ent_cls = env->GetObjectClass(p);
if (ent_cls)
{
jfieldID xo = env->GetFieldID(ent_cls, "xo", "D");
jfieldID yo = env->GetFieldID(ent_cls, "yo", "D");
jfieldID zo = env->GetFieldID(ent_cls, "zo", "D");
if (xo && yo && zo && !env->ExceptionCheck())
{
d.prev_x = env->GetDoubleField(p, xo);
d.prev_y = env->GetDoubleField(p, yo);
d.prev_z = env->GetDoubleField(p, zo);
if (env->ExceptionCheck())
{
env->ExceptionClear();
d.prev_x = d.x;
d.prev_y = d.y;
d.prev_z = d.z;
}
}
else
{
env->ExceptionClear();
}
bool got_name = false;
const char* display_name_names[] = {"method_5476", "getDisplayName", "func_145748_c_", "m_7755_"};
jmethodID get_display_name = get_method_by_names(env, ent_cls, display_name_names, 4, "()Lnet/minecraft/class_2561;");
if (get_display_name)
{
jobject t = env->CallObjectMethod(p, get_display_name);
if (t && !env->ExceptionCheck())
{
got_name = read_text_to_utf8(env, t, d.name);
env->DeleteLocalRef(t);
}
else
{
env->ExceptionClear();
}
}
if (!got_name)
{
const char* get_name_names[] = {"method_5477", "getName", "func_70005_c_", "m_5446_"};
jmethodID get_name = get_method_by_names(env, ent_cls, get_name_names, 4, "()Lnet/minecraft/class_2561;");
if (get_name)
{
jobject t = env->CallObjectMethod(p, get_name);
if (t && !env->ExceptionCheck())
{
got_name = read_text_to_utf8(env, t, d.name);
env->DeleteLocalRef(t);
}
else
{
env->ExceptionClear();
}
}
}
if (!got_name)
{
const char* gp_names[] = {"method_7334", "getGameProfile", "func_146103_bH", "m_21223_"};
jmethodID gp_mid = get_method_by_names(env, ent_cls, gp_names, 4, "()Lcom/mojang/authlib/GameProfile;");
if (gp_mid)
{
jobject gp = env->CallObjectMethod(p, gp_mid);
if (gp && !env->ExceptionCheck())
{
jclass gp_cls = env->GetObjectClass(gp);
const char* gn[] = {"getName"};
jmethodID gn_mid = get_method_by_names(env, gp_cls, gn, 1, "()Ljava/lang/String;");
if (gn_mid)
{
jstring s = static_cast<jstring>(env->CallObjectMethod(gp, gn_mid));
if (s && !env->ExceptionCheck())
{
const char* u = env->GetStringUTFChars(s, nullptr);
if (u)
{
d.name = u;
env->ReleaseStringUTFChars(s, u);
}
env->DeleteLocalRef(s);
}
else
{
env->ExceptionClear();
}
}
env->DeleteLocalRef(gp_cls);
env->DeleteLocalRef(gp);
}
else
{
env->ExceptionClear();
}
}
}
env->DeleteLocalRef(ent_cls);
}
if (d.name.rfind("Ghost_", 0) == 0)
{
continue;
}
jobject bb_obj = ent.get_bounding_box();
if (!bb_obj) continue;
sdk::box_client bb(bb_obj);
d.bb_min_x = bb.get_min_x();
d.bb_min_y = bb.get_min_y();
d.bb_min_z = bb.get_min_z();
d.bb_max_x = bb.get_max_x();
d.bb_max_y = bb.get_max_y();
d.bb_max_z = bb.get_max_z();
env->DeleteLocalRef(bb_obj);
d.width = static_cast<float>(d.bb_max_x - d.bb_min_x);
d.height = static_cast<float>(d.bb_max_y - d.bb_min_y);
if (d.width < 0.05f || d.width > 4.0f || d.height < 0.3f || d.height > 5.0f)
{
continue;
}
d.health = 20.0f;
d.max_health = 20.0f;
if (get_health_mid && get_max_health_mid)
{
d.health = env->CallFloatMethod(p, get_health_mid);
if (env->ExceptionCheck())
{
env->ExceptionClear();
d.health = 20.0f;
}
d.max_health = env->CallFloatMethod(p, get_max_health_mid);
if (env->ExceptionCheck())
{
env->ExceptionClear();
d.max_health = 20.0f;
}
}
const double dx = d.x - cam.x;
const double dy = d.y - cam.y;
const double dz = d.z - cam.z;
d.distance = static_cast<float>(sqrt(dx * dx + dy * dy + dz * dz));
out.push_back(d);
}
if (living_cls) env->DeleteLocalRef(living_cls);
for (jobject p : players)
{
if (p) env->DeleteLocalRef(p);
}
env->DeleteLocalRef(world);
env->DeleteLocalRef(local_player);
{
std::lock_guard<std::mutex> lock(g_players_mutex);
g_players = std::move(out);
g_camera.cam_x = cam.x;
g_camera.cam_y = cam.y;
g_camera.cam_z = cam.z;
g_camera.yaw = cam.yaw;
g_camera.pitch = cam.pitch;
g_camera.fov = cam.fov;
}
}
void enhance::modules::esp::draw_boxes()
{
if (!globals::esp_enabled || (!globals::esp_box && !globals::esp_health_bar && !globals::esp_name && !globals::esp_distance))
{
return;
}
if (!GUI::get_is_init())
{
return;
}
ImGuiIO& io = ImGui::GetIO();
const int screen_w = static_cast<int>(io.DisplaySize.x);
const int screen_h = static_cast<int>(io.DisplaySize.y);
if (screen_w <= 0 || screen_h <= 0)
{
return;
}
ImDrawList* dl = ImGui::GetBackgroundDrawList();
if (!dl)
{
return;
}
std::vector<esp_player_data> players;
esp_camera_data cam{};
{
std::lock_guard<std::mutex> lock(g_players_mutex);
if (g_players.empty()) return;
players = g_players;
cam = g_camera;
}
esp_render_matrices mtx{};
{
std::lock_guard<std::mutex> lock(g_matrices_mutex);
mtx = g_matrices;
}
const ImU32 box_color = ImGui::ColorConvertFloat4ToU32(globals::esp_box_color);
const ImU32 name_color = ImGui::ColorConvertFloat4ToU32(globals::esp_name_color);
const ImU32 dist_color = ImGui::ColorConvertFloat4ToU32(globals::esp_distance_color);
for (const auto& p : players)
{
if (!p.is_player) continue;
if (globals::esp_max_distance > 0.0f && p.distance > globals::esp_max_distance) continue;
const float ex = 0.03f;
const float corners_world[8][3] = {
{static_cast<float>(p.bb_min_x - ex), static_cast<float>(p.bb_min_y - ex), static_cast<float>(p.bb_min_z - ex)},
{static_cast<float>(p.bb_max_x + ex), static_cast<float>(p.bb_min_y - ex), static_cast<float>(p.bb_min_z - ex)},
{static_cast<float>(p.bb_max_x + ex), static_cast<float>(p.bb_min_y - ex), static_cast<float>(p.bb_max_z + ex)},
{static_cast<float>(p.bb_min_x - ex), static_cast<float>(p.bb_min_y - ex), static_cast<float>(p.bb_max_z + ex)},
{static_cast<float>(p.bb_min_x - ex), static_cast<float>(p.bb_max_y + ex), static_cast<float>(p.bb_min_z - ex)},
{static_cast<float>(p.bb_max_x + ex), static_cast<float>(p.bb_max_y + ex), static_cast<float>(p.bb_min_z - ex)},
{static_cast<float>(p.bb_max_x + ex), static_cast<float>(p.bb_max_y + ex), static_cast<float>(p.bb_max_z + ex)},
{static_cast<float>(p.bb_min_x - ex), static_cast<float>(p.bb_max_y + ex), static_cast<float>(p.bb_max_z + ex)}
};
float corners_rel[8][3]{};
for (int i = 0; i < 8; ++i)
{
corners_rel[0] = corners_world[0] - static_cast<float>(cam.cam_x);
corners_rel[1] = corners_world[1] - static_cast<float>(cam.cam_y);
corners_rel[2] = corners_world[2] - static_cast<float>(cam.cam_z);
}
float pts[8][2]{};
auto project_all = [&](const float corners[8][3], float out_pts[8][2], float& min_x, float& min_y, float& max_x, float& max_y, int& valid) -> bool
{
min_x = FLT_MAX;
min_y = FLT_MAX;
max_x = -FLT_MAX;
max_y = -FLT_MAX;
valid = 0;
for (int i = 0; i < 8; ++i)
{
float sx = 0.0f, sy = 0.0f;
if (!project_point(mtx, corners[0], corners[1], corners[2], sx, sy))
{
continue;
}
out_pts[0] = sx;
out_pts[1] = sy;
min_x = (std::min)(min_x, sx);
min_y = (std::min)(min_y, sy);
max_x = (std::max)(max_x, sx);
max_y = (std::max)(max_y, sy);
++valid;
}
return valid >= 2 && std::isfinite(min_x) && std::isfinite(min_y) && std::isfinite(max_x) && std::isfinite(max_y) && max_x > min_x && max_y > min_y;
};
auto project_all_camera = [&](const float corners[8][3], float out_pts[8][2], float& min_x, float& min_y, float& max_x, float& max_y, int& valid) -> bool
{
min_x = FLT_MAX;
min_y = FLT_MAX;
max_x = -FLT_MAX;
max_y = -FLT_MAX;
valid = 0;
for (int i = 0; i < 8; ++i)
{
float sx = 0.0f, sy = 0.0f;
if (!project_point_camera(cam, screen_w, screen_h, corners[0], corners[1], corners[2], sx, sy))
{
continue;
}
out_pts[0] = sx;
out_pts[1] = sy;
min_x = (std::min)(min_x, sx);
min_y = (std::min)(min_y, sy);
max_x = (std::max)(max_x, sx);
max_y = (std::max)(max_y, sy);
++valid;
}
return valid >= 2 && std::isfinite(min_x) && std::isfinite(min_y) && std::isfinite(max_x) && std::isfinite(max_y) && max_x > min_x && max_y > min_y;
};
float min_x = 0.0f, min_y = 0.0f, max_x = 0.0f, max_y = 0.0f;
int valid = 0;
bool ok = false;
if (mtx.valid && mtx.viewport_width > 0 && mtx.viewport_height > 0)
{
ok = project_all(corners_world, pts, min_x, min_y, max_x, max_y, valid);
if (!ok)
{
ok = project_all(corners_rel, pts, min_x, min_y, max_x, max_y, valid);
}
}
if (!ok)
{
ok = project_all_camera(corners_world, pts, min_x, min_y, max_x, max_y, valid);
}
if (!ok) continue;
const float bw = max_x - min_x;
const float bh = max_y - min_y;
if (bw > screen_w * 0.8f || bh > screen_h * 0.9f) continue;
if (bw < 1.0f || bh < 2.0f) continue;
if (globals::esp_box)
{
if (globals::esp_box_style == 2)
{
draw_3d_edges(dl, pts, box_color);
}
else if (globals::esp_box_style == 1)
{
draw_corner_box(dl, min_x, min_y, max_x, max_y, box_color);
}
else
{
draw_box_2d(dl, min_x, min_y, max_x, max_y, box_color);
}
}
if (globals::esp_health_bar && p.max_health > 0.0f)
{
float hp = p.health / p.max_health;
hp = (std::max)(0.0f, (std::min)(1.0f, hp));
const float bar_w = 3.0f;
const float bar_h = max_y - min_y;
const float bar_x = min_x - bar_w - 3.0f;
const float fill_h = bar_h * hp;
ImU32 hc = IM_COL32(0, 255, 0, 255);
if (hp <= 0.75f) hc = IM_COL32(255, 255, 0, 255);
if (hp <= 0.50f) hc = IM_COL32(255, 165, 0, 255);
if (hp <= 0.25f) hc = IM_COL32(255, 0, 0, 255);
dl->AddRectFilled(ImVec2(bar_x - 1.0f, min_y - 1.0f), ImVec2(bar_x + bar_w + 1.0f, max_y + 1.0f), IM_COL32(0, 0, 0, 255));
dl->AddRectFilled(ImVec2(bar_x, min_y), ImVec2(bar_x + bar_w, max_y), IM_COL32(50, 50, 50, 200));
dl->AddRectFilled(ImVec2(bar_x, max_y - fill_h), ImVec2(bar_x + bar_w, max_y), hc);
}
if (globals::esp_name)
{
const char* n = globals::esp_stream_safe ? "Player" : p.name.c_str();
draw_center_text(dl, n, (min_x + max_x) * 0.5f, min_y - 15.0f, name_color);
}
if (globals::esp_distance)
{
char b[32];
sprintf_s(b, "%.0fm", p.distance);
draw_center_text(dl, b, (min_x + max_x) * 0.5f, max_y + 5.0f, dist_color);
}
}
}
void enhance::modules::esp::set_render_matrices(const float* modelview, const float* projection, int viewport_width, int viewport_height)
{
std::lock_guard<std::mutex> lock(g_matrices_mutex);
if (!modelview || !projection || viewport_width <= 0 || viewport_height <= 0)
{
g_matrices.valid = false;
return;
}
for (int i = 0; i < 16; ++i)
{
g_matrices.modelview = modelview;
g_matrices.projection = projection;
}
g_matrices.viewport_width = viewport_width;
g_matrices.viewport_height = viewport_height;
g_matrices.valid = true;
}
