Untitled

// in my DataRead.cpp

std::vector<PlayerData> batchReadAllPlayerData() {
    inGame = in_game();

    if (inGame) {
        if (!hasCachedData) {
            ReadOnce();
        }

        std::vector<PlayerData> playersData;

        uintptr_t cameraBasePointer = cameraBase;
        vec3_t cameraPosition;
        vec2_t cameraAngles;
        size_t localPlayerIndex = local_index();

        int playerCount = driver::read<int>(sdk::module_base + offsets::BO6::game_mode);

        playersData.resize(playerCount);
        auto sizeOfPlayersData = playersData.size();


        if (cameraBasePointer) {
            uintptr_t cameraPositionAddress = cameraBasePointer + offsets::BO6::camera_pos;
            uintptr_t cameraAnglesAddress = cameraPositionAddress + 0xC;

            cameraPosition = get_cam_affected();
            cameraAngles = driver::read<vec2_t>(cameraAnglesAddress);
        }

        std::vector<vec3_t> positions(sizeOfPlayersData);
        std::vector<uintptr_t> positionPointers(sizeOfPlayersData);
        std::vector<NameEntry> nameEntryBuffer(sizeOfPlayersData);
        std::vector<Scoreboard> scoreboardBuffer(sizeOfPlayersData);

        for (size_t i = 0; i < sizeOfPlayersData; ++i) {
            playersData[i].isLocalPlayer = (i == localPlayerIndex);
            uintptr_t baseAddress = sdk::client_info_base + (i * offsets::BO6::player::size);

            positionPointers[i] = driver::read<uintptr_t>(baseAddress + offsets::BO6::player::pos);
            playersData[i].teamId = driver::read<uint8_t>(baseAddress + offsets::BO6::player::team);
            playersData[i].stance = driver::read<int>(baseAddress + offsets::BO6::player::stance);
            nameEntryBuffer[i] = driver::read<NameEntry>(baseNameListAddress + (i * offsets::BO6::name_size));
            scoreboardBuffer[i] = driver::read<Scoreboard>(baseScoreboardAddress + (i * offsets::BO6::scoreboard_size));
        }

        for (size_t i = 0; i < positionPointers.size(); ++i) {
            if (positionPointers[i] != 0) {
                if (i == 9 && settings::settingsSettings::indexNineFix) {
                    positions[i] = driver::read<vec3_t>(positionPointers[i] + 0x50);
                }
                else {
                    positions[i] = driver::read<vec3_t>(positionPointers[i] + 0x50);
                }
            }
        }

        for (size_t i = 0; i < playersData.size(); ++i) {
            if (positionPointers[i] != 0) {
                playersData[i].position = positions[i];
            }

            const auto& nameEntry = nameEntryBuffer[i];
            const auto& scoreboard = scoreboardBuffer[i];

            std::memcpy(playersData[i].name, nameEntry.name, sizeof(nameEntry.name) - 1);
            playersData[i].name[sizeof(nameEntry.name) - 1] = '\0';
            playersData[i].health = nameEntry.health;
            playersData[i].isVisible = is_player_visible(sdk::client_info, i);
            playersData[i].scoreboard = scoreboard;

            bool isHealthZero = (nameEntry.health <= 0);
            bool isStatusDead = (scoreboard.status == 2);
            bool isPingZero = (!settings::settingsSettings::inPrivateMatch && scoreboard.ping == 0);
            bool isActiveTeam = (scoreboard.team == 0);

            if (playersData[i].health < 1 && !playersData[i].isVisible) {
                continue;
            }

            playersData[i].isDead = isHealthZero || isStatusDead || isPingZero || isActiveTeam;
        }

        // Set Camera Data
        if (cameraBasePointer) {
            for (auto& player : playersData) {
                player.cameraPosition = cameraPosition;
                player.cameraAngles = cameraAngles;
            }
        }

        return playersData;
    }
    else {
        hasCachedData = false;
    }
}

// in my esp.cpp
void RenderEsp(const std::vector<PlayerData>& playersData, PlayerData localPlayer, ref_def_t ref_def) {
    const float halfScreenWidth = ref_def.width / 2;
    const float halfScreenHeight = ref_def.height / 2;  

    static int pGM = -1;
    int cGM = driver::read<int>(sdk::module_base + offsets::BO6::game_mode);

    /*if (cGM != pGM) {
        pGM = cGM;
        return;
    }*/

    if (cGM <= 1) {
        return;
    }

    if (settings::aimSettings::DrawCircleFOV) {
        ImGui::GetOverlayDrawList()->AddCircle(ImVec2(halfScreenWidth, halfScreenHeight), settings::fov, settings::visualsSettings::FovColor, 100);
    }

    if (settings::aimSettings::crosshair) {
        ImVec2 center(halfScreenWidth, halfScreenHeight);
        ImVec2 horizontalLineStart(center.x - 12, center.y);
        ImVec2 horizontalLineEnd(center.x + 12, center.y);
        ImVec2 verticalLineStart(center.x, center.y - 12);
        ImVec2 verticalLineEnd(center.x, center.y + 12);

        auto drawList = ImGui::GetBackgroundDrawList();
        drawList->AddLine(horizontalLineStart, horizontalLineEnd, settings::visualsSettings::crosshaircolor, 1.0f);
        drawList->AddLine(verticalLineStart, verticalLineEnd, settings::visualsSettings::crosshaircolor, 1.0f);
    }

    /*if (settings::visualsSettings::enableLootEsp) {
        auto draw = ImGui::GetForegroundDrawList();
        auto lootList = BO6::get_all_loot();

        for (const auto& loot : lootList) {
            if (!loot.is_valid()) {
                continue; // Skip invalid loot
            }

            vec3_t lootPos = loot.get_position();
            vec2_t screenPos;

            if (espw2s(lootPos, screenPos)) {
                float dist = units_to_m(localPlayer.position.distance_to(lootPos));

                if (dist > 1.0f && dist < settings::visualsSettings::lootDist) {
                    std::string lootName = loot.get_name();
                    ImU32 lootColor = loot.is_supply()
                        ? ImGui::GetColorU32(ImVec4(1.0f, 0.5f, 0.0f, 1.0f)) // Supply loot (orange)
                        : ImGui::GetColorU32(ImVec4(0.0f, 1.0f, 0.0f, 1.0f)); // Regular loot (green)

                    // Draw loot name
                    draw->AddText(ImVec2(screenPos.x, screenPos.y), lootColor, lootName.c_str());

                    // Optionally draw distance
                    if (settings::visualsSettings::lootDist) {
                        char distanceText[32];
                        snprintf(distanceText, sizeof(distanceText), "[%.1f m]", dist);
                        draw->AddText(ImVec2(screenPos.x, screenPos.y + 12), lootColor, distanceText);
                    }
                }
            }
        }
    }*/

    if (settings::visualsSettings::enableEsp) {
        auto draw = ImGui::GetForegroundDrawList();

        for (size_t i = 0; i < playersData.size(); ++i) {
            esp_t esp(sdk::client_info_base + (i * offsets::BO6::player::size));
            auto player = playersData[i];
            auto sizeOfPlayersData = playersData.size();
            std::vector<Scoreboard> scoreboardBuffer(sizeOfPlayersData);
            const auto bone_index = offsets::BO6::decrypt_bone_index(i, sdk::module_base);
            const auto bone_ptr = BO6::get_bone_ptr(sdk::bone_base, bone_index);

            const auto& scoreboard = scoreboardBuffer[i];


            if (player.health < 1 && !player.isVisible) {
                continue;
            }

            if ((!settings::reddot && player.teamId == localPlayer.teamId) || player.isDead || scoreboard.status == 2 ||
                (settings::visualsSettings::legitEsp && !player.isVisible)) {
                continue;
            }

            vec2_t screen;
            vec3_t pos = player.position;
            if (w2s(pos, screen, player)) {
                auto dist = units_to_m(localPlayer.position.distance_to(player.position));

                if (dist > 1.0f && dist < settings::visualsSettings::maxespdist) {
                    vec2_t screenHead;
                    vec3_t headPos = pos;
                    headPos.z += 66.f;

                    if (w2s(headPos, screenHead, player)) {
                        float height = screen.y - screenHead.y;
                        float width = height * 0.25f;
                        ImVec2 boxUpperLeft(screenHead.x - width, screenHead.y);
                        ImVec2 boxLowerRight(screenHead.x + width, screen.y);

                        VisualParams params = CalculateVisualParams(dist, settings::visualsSettings::maxespdist, CLOSE_DISTANCE, 0.1f, 2.5f);

                        if (settings::visualsSettings::boxes) {
                            vec2_t headScreen, feetScreen;
                            vec3_t headPos = pos;
                            headPos.z += 66.f;
                            vec3_t feetPos = pos;

                            if (espw2s(headPos, headScreen) && espw2s(feetPos, feetScreen)) {
                                float height = abs(headScreen.y - feetScreen.y);
                                float width = height * 0.65f;

                                if (height > 0 && width > 0) {
                                    ImU32 boxColor = player.isVisible
                                        ? ImGui::GetColorU32(ImVec4(settings::visualsSettings::boxColorVisible[0],
                                            settings::visualsSettings::boxColorVisible[1],
                                            settings::visualsSettings::boxColorVisible[2],
                                            params.alpha))
                                        : ImGui::GetColorU32(ImVec4(settings::visualsSettings::boxColorNotVisible[0],
                                            settings::visualsSettings::boxColorNotVisible[1],
                                            settings::visualsSettings::boxColorNotVisible[2],
                                            params.alpha));

                                    if (settings::boxStyles == 0) {
                                        DrawBox(headScreen.x - width / 2, headScreen.y, width, height, player.isVisible, boxColor, settings::boxThickness, params);
                                    }
                                    else if (settings::boxStyles == 1) {
                                        DrawPlayerCorneredBox(headScreen.x - width / 2, headScreen.y, width, height, player.isVisible, boxColor, settings::boxThickness, params);
                                    }
                                }
                            }
                        }

                        if (settings::healthbars) {
                            DrawHealthBar(draw, player.health, 127.0f, boxUpperLeft, boxLowerRight, params);
                        }
                        if (settings::visualsSettings::nameesp) {
                            DrawPlayerName(draw, player.name, ImVec2(screenHead.x, boxUpperLeft.y + 10), params);
                        }
                        /*if (settings::visualsSettings::killsEsp) {
                            DrawPlayerKills(draw, player.scoreboard.kills, ImVec2(screenHead.x, boxLowerRight.y + 20), params);
                        }*/
                        if (settings::visualsSettings::distanceesp) {
                            DrawDistance(draw, dist, ImVec2(screen.x, screen.y - 20));
                        }
                        /// TODO: refactor for other games maybe.
                        if (settings::visualsSettings::boneesp) {
                            DrawBones(draw, player, i, params);
                        }
                        if (settings::visualsSettings::drawlines) {
                            ImVec2 startPoint = ImVec2(halfScreenWidth, settings::visualsSettings::linetype == 1 ? ref_def.height : halfScreenHeight);
                            ImVec2 endPoint = ImVec2(screen.x, screen.y);
                            DrawLines(draw, startPoint, endPoint, player.isVisible, params);
                        }
                    }
                }
            }
        }
    }
}