[Source / CS:GO] Backtrack do ayyware

#include "Backtrack.h"
#include "RageBot.h"

#define TIME_TO_TICKS( dt )    ( ( int )( 0.5f + ( float )( dt ) / Interfaces::Globals->interval_per_tick ) )

void BackTrack::Update(int tick_count)
{
        if (Menu::Window.RageBotTab.RagePositionAdjustment.GetState())
        return;

    latest_tick = tick_count;
    for (int i = 0; i < 64; i++)
    {
        UpdateRecord(i);
    }
}

bool BackTrack::IsTickValid(int tick)
{
    int delta = latest_tick - tick;
    float deltaTime = delta * Interfaces::Globals->interval_per_tick;
    return (fabs(deltaTime) <= 0.2f);
}

void BackTrack::UpdateRecord(int i)
{
    IClientEntity* pEntity = Interfaces::EntList->GetClientEntity(i);
    if (pEntity && pEntity->IsAlive() && !pEntity->IsDormant())
    {
        float lby = pEntity->GetLowerBodyYaw();
        if (lby != records.lby)
        {
            records.tick_count = latest_tick;
            records.lby = lby;
            records.headPosition = GetHitboxPosition(pEntity, 0);
        }
    }
    else
    {
        records.tick_count = 0;
    }
}

bool BackTrack::RunLBYBackTrack(int i, CUserCmd* pCmd, Vector& aimPoint)
{
    if (IsTickValid(records.tick_count))
    {
        aimPoint = records.headPosition;
        pCmd->tick_count = records.tick_count;
        return true;
    }
    return false;
}

void BackTrack::legitBackTrack(CUserCmd* pCmd, IClientEntity* pLocal)
{
    if (Menu::Window.LegitBotTab.LegitPositionAdjustment.GetState())
    {
        int bestTargetIndex = -1;
        float bestFov = FLT_MAX;
        player_info_t info;
        if (!pLocal->IsAlive())
            return;

        for (int i = 0; i < Interfaces::Engine->GetMaxClients(); i++)
        {
            auto pEntity = (IClientEntity*)Interfaces::EntList->GetClientEntity(i);

            if (!pEntity || !pLocal)
                continue;

            if (pEntity == pLocal)
                continue;

            if (!Interfaces::Engine->GetPlayerInfo(i, &info))
                continue;

            if (pEntity->IsDormant())
                continue;

            if (pEntity->GetTeamNum() == pLocal->GetTeamNum())
                continue;

            if (pEntity->IsAlive())
            {

                float simtime = pEntity->GetSimulationTime();
                Vector hitboxPos = GetHitboxPosition(pEntity, 0);

                headPositions[pCmd->command_number % 13] = backtrackData{ simtime, hitboxPos };
                Vector ViewDir = angle_vector(pCmd->viewangles + (pLocal->localPlayerExclusive()->GetAimPunchAngle() * 2.f));
                float FOVDistance = distance_point_to_line(hitboxPos, pLocal->GetEyePosition(), ViewDir);

                if (bestFov > FOVDistance)
                {
                    bestFov = FOVDistance;
                    bestTargetIndex = i;
                }
            }
        }

        float bestTargetSimTime;
        if (bestTargetIndex != -1)
        {
            float tempFloat = FLT_MAX;
            Vector ViewDir = angle_vector(pCmd->viewangles + (pLocal->localPlayerExclusive()->GetAimPunchAngle() * 2.f));
            for (int t = 0; t < 12; ++t)
            {
                float tempFOVDistance = distance_point_to_line(headPositions[bestTargetIndex][t].hitboxPos, pLocal->GetEyePosition(), ViewDir);
                if (tempFloat > tempFOVDistance && headPositions[bestTargetIndex][t].simtime > pLocal->GetSimulationTime() - 1)
                {
                    tempFloat = tempFOVDistance;
                    bestTargetSimTime = headPositions[bestTargetIndex][t].simtime;
                }
            }
            if (pCmd->buttons & IN_ATTACK)
            {
                pCmd->tick_count = TIME_TO_TICKS(bestTargetSimTime);
            }
        }
    }
}

BackTrack* backtracking = new BackTrack();
backtrackData headPositions[64][12];

#pragma once
#include "SDK.h"

struct lbyRecords
{
    int tick_count;
    float lby;
    Vector headPosition;
};
struct backtrackData
{
    float simtime;
    Vector hitboxPos;
};

class BackTrack
{
    int latest_tick;
    bool IsTickValid(int tick);
    void UpdateRecord(int i);
public:
    lbyRecords records[64];
    bool RunLBYBackTrack(int i, CUserCmd* pCmd, Vector& aimPoint);
    void Update(int tick_count);
    void legitBackTrack(CUserCmd* pCmd, IClientEntity* pLocal);
};

extern backtrackData headPositions[64][12];

extern BackTrack* backtracking;
 

    if (Interfaces::Engine->GetPlayerInfo(i, &pinfo) && !pEntity->IsAlive())
            {
                if (Menu::Window.LegitBotTab.LegitPositionAdjustment..GetState())
                {
                    if (pLocal->IsAlive())
                    {
                        for (int t = 0; t < 12; ++t)
                        {
                            Vector screenbacktrack[64][12];

                            if (headPositions[t].simtime && headPositions[t].simtime + 1 > pLocal->GetSimulationTime())
                            {
                                if (Render::WorldToScreen(headPositions[t].hitboxPos, screenbacktrack[t]))
                                {

                                    Interfaces::Surface->DrawSetColor(Color::Red());
                                    Interfaces::Surface->DrawOutlinedRect(screenbacktrack[t].x, screenbacktrack[t].y, screenbacktrack[t].x + 2, screenbacktrack[t].y + 2);

                                }
                            }
                        }
                    }
                    else
                    {
                        memset(&headPositions[0][0], 0, sizeof(headPositions));
                    }
                }
            }
        }
    }
}

backtracking->legitBackTrack(pCmd, pLocal);

backtracking->Update(g_Globals->tickcount);