Full Remotekill

Posts 1–6 of 6 · Page 1 of 1

Full Remotekill

Remotekill.h

Code:

#ifndef _REMOTE_KILL_H_
#define _REMOTE_KILL_H_

#pragma once

#include "Stdafx.h"

typedef bool(WINAPIV *m_pIntersectSegment)(IntersectQuery& m_Query, IntersectInfo *m_Info);
extern m_pIntersectSegment g_pIntersectSegment;

namespace cRemotekill
{
    void VectorTargetID(void);
    void DrawClientID(void);
    int PriorityIDSetup(void);
    void StartRemoteFov(void);
    int PriorityCustomTargetPlayer(void);
    int PriorityHighestKillPlayer(void);
    int PriorityLowestKillPlayer(void);
    int GetNearestByTargetPlayer(void);
    int PriorityCustomTargetZombie(void);
    int PriorityHighestKillZombie(void);
    int PriorityLowestKillZombie(void);
    int GetNearestByTargetZombie(void);
    void EnableRemote(void);
    void DisableRemote(void);
    void InitializeRemote(void);
}

#endif

Remotekill.cpp

Code:

#include "Remotekill.h"

#define PI2 6.283185307179586

m_pIntersectSegment g_pIntersectSegment = 0;

bool FilterObjs(cObject *m_Object, void *user)
{
    for (int i = 0; i < Engine->GetMaxPlayer(); i++)
    {
        CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
        if (m_Object == TargetPlayer->m_Object)
            return false;
    }
    return true;
}

void cRemotekill::VectorTargetID(void)
{
    if (!Engine->IsGameReadyForHook()) return;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsValidPointer(TargetPlayer->m_Object))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            if (TargetPlayer != LocalPlayer)
            {
                std::vector<int>::iterator it = std::find(Enemy_DB.begin(), Enemy_DB.end(), i);
                if (it != Enemy_DB.end());
                else
                {
                    Enemy_DB.push_back(i);
                }
            }
        }
    }
}

void cRemotekill::DrawClientID(void)
{
    if (!Engine->IsGameReadyForHook()) return;

    int32_t MaxEnemyCount = Enemy_DB.size();
    if (MaxEnemyCount > 0)
    {
        if (GetAsyncKeyState(VK_LEFT) & 1)
        {
            if (RemoteEnemyID != 0)
            {
                RemoteEnemyID -= 1;
            }
            else
            {
                RemoteEnemyID = 0;
            }
        }
    }
    if (MaxEnemyCount > 0)
    {
        if (GetAsyncKeyState(VK_RIGHT) & 1)
        {
            if (RemoteEnemyID != MaxEnemyCount - 1)
            {
                RemoteEnemyID += 1;
            }
            else
            {
                RemoteEnemyID = MaxEnemyCount - 1;
            }
        }
    }
    if (MaxEnemyCount > 0)
    {
        RemoteClientID = Enemy_DB[RemoteEnemyID];
        CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
        CPlayer* TargetPlayer = Engine->GetPlayerByIndex(RemoteClientID);
        if (Engine->IsValidPointer(LocalPlayer) && Engine->IsValidPointer(TargetPlayer))
        {
            char* ArrowLeft = "<-- ";
            char* ArrowRight = " -->";
            char* Name = TargetPlayer->Name;
            char* Show = (char*)malloc(1 + strlen(ArrowLeft) + strlen(Name) + strlen(ArrowRight));

            strcpy(Show, ArrowLeft); strcat(Show, Name); strcat(Show, ArrowRight);
            Esp->lWriteText(120, 50, Red, Show);
            RemotePriorityTargetID = RemoteClientID;
        }
    }
    Esp->lWriteText(120, 75, Red, Crossfire->WriteLogChar(RemotePriorityTargetID, "ID : "));
}

int cRemotekill::PriorityIDSetup(void)
{
    int32_t i = RemotePriorityTargetID;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

    if (!Engine->IsValidClient(TargetPlayer))
        return -1;

    if (Engine->IsTM(LocalPlayer, TargetPlayer))
        return -1;

    //if (!Engine->IsVisible(Engine->GetBonePosition(LocalPlayer->Object, 6), Engine->GetBonePosition(TargetPlayer->Object, 6)) && Var_RemoteVisibleCheck == 1)
        //return -1;

    if (TargetPlayer->CharacterFx->SpawnShield())
        return -1;

    if (TargetPlayer->CharacterFx->IsDead())
        return -1;

    //D3DXVECTOR3 Head = Engine->GetBonePosition(TargetPlayer->Object, 6);
        //if (!Engine->WorldToScreen(g_pDevice, &Head) && Var_RemoteMode != 0)
        //return -1;

    return i;
}

void cRemotekill::StartRemoteFov(void)
{
    if (!Engine->IsGameReadyForHook()) return;
    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    switch (Var_RemoteFov)
    {
        case 1: RemoteFirstView = 2.50f; break; // 10.0f
        case 2: RemoteFirstView = 6.50f; break; // 30.0f
        case 3: RemoteFirstView = 9.50f; break; // 45.0f
        case 4: RemoteFirstView = 12.50f; break; // 60.0f
        case 5: RemoteFirstView = 16.50f; break; // 80.0f
        case 6: RemoteFirstView = 18.50f; break; // 90.0f
        case 7: RemoteFirstView = 32.50f; break; // 180.0f
        case 8: RemoteFirstView = 64.5f; break; // 360.0f
        default: RemoteFirstView = 6.50f;
    }

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        if (!LocalPlayer->CharacterFx->IsDead())
        {
            if (Var_Remotekill)
            {
                if (Var_RemoteMode != 0)
                {
                    DirectX->DrawCircle(ScreenX, ScreenY, (RemoteFirstView * 5.0f) * PI2, Yellow, g_pDevice);
                }
            }
        }
    }
}

int cRemotekill::PriorityCustomTargetPlayer(void)
{
    int BestTarget = -1;

    float MaxDistance = INFINITE;

    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    // ==================== [ Custom Target Player ] ==================== //
    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        int SetTarget = cRemotekill::PriorityIDSetup();
        if (SetTarget > -1)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(SetTarget);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);
            if (Engine->IsValidClient(TargetPlayer))
            {
                if (Engine->IsCheckPlayer(TargetPlayer))
                {
                    if (!Engine->IsTM(LocalPlayer, TargetPlayer))
                    {
                        // ==================== [ Get Nearest By 360 ] ==================== //
                        if (Var_RemoteMode == 0)
                        {
                            float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                            if (Tmp < MaxDistance)
                            {
                                MaxDistance = Tmp;
                                BestTarget = SetTarget;
                            }
                        }
                        // ==================== [ Get Nearest By Crosshair ] ==================== //
                        if (Var_RemoteMode == 1)
                        {
                            if (Engine->WorldToScreen(g_pDevice, &Pos))
                            {
                                float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                                float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                                float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                                if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                                {
                                    if (Tmp < MaxDistance)
                                    {
                                        MaxDistance = Tmp;
                                        BestTarget = SetTarget;
                                    }
                                }
                            }
                        }
                        // ==================== [ Get Nearest By Distance ] ==================== //
                        if (Var_RemoteMode == 2)
                        {
                            if (Engine->WorldToScreen(g_pDevice, &Pos))
                            {
                                float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                                float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                                if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                                {
                                    if (Tmp < MaxDistance)
                                    {
                                        MaxDistance = Tmp;
                                        BestTarget = SetTarget;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return BestTarget;
        }
    }
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckPlayer(TargetPlayer))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By 360 ] ==================== //
            if (Var_RemoteMode == 0)
            {
                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                if (Tmp < MaxDistance)
                {
                    MaxDistance = Tmp;
                    BestTarget = i;
                }
            }
            // ==================== [ Get Nearest By Crosshair ] ==================== //
            if (Var_RemoteMode == 1)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
            // ==================== [ Get Nearest By Distance ] ==================== //
            if (Var_RemoteMode == 2)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityHighestKillPlayer(void)
{
    int MaxKills = -50;
    int BestTarget = -1;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckPlayer(TargetPlayer))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            if (TargetPlayer->Kills >= MaxKills)
            {
                MaxKills = TargetPlayer->Kills;
                BestTarget = i;
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityLowestKillPlayer(void)
{
    int MinKills = 50;
    int BestTarget = -1;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckPlayer(TargetPlayer))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By Lowest Kill ] ==================== //
            if (TargetPlayer->Kills <= MinKills)
            {
                MinKills = TargetPlayer->Kills;
                BestTarget = i;
            }
        }
    }
    return BestTarget;
}

int cRemotekill::GetNearestByTargetPlayer(void)
{
    int BestTarget = -1;

    float MaxDistance = INFINITE;

    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckPlayer(TargetPlayer))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By 360 ] ==================== //
            if (Var_RemoteMode == 0)
            {
                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                if (Tmp < MaxDistance)
                {
                    MaxDistance = Tmp;
                    BestTarget = i;
                }
            }
            // ==================== [ Get Nearest By Crosshair ] ==================== //
            if (Var_RemoteMode == 1)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
            // ==================== [ Get Nearest By Distance ] ==================== //
            if (Var_RemoteMode == 2)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityCustomTargetZombie(void)
{
    int BestTarget = -1;

    float MaxDistance = INFINITE;

    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    // ==================== [ Custom Target Player ] ==================== //
    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        int SetTarget = cRemotekill::PriorityIDSetup();
        if (SetTarget > -1)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(SetTarget);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);
            if (Engine->IsValidClient(TargetPlayer))
            {
                if (Engine->IsCheckZombie(TargetPlayer))
                {
                    if (!Engine->IsZM(LocalPlayer, TargetPlayer))
                    {
                        // ==================== [ Get Nearest By 360 ] ==================== //
                        if (Var_RemoteMode == 0)
                        {
                            float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                            if (Tmp < MaxDistance)
                            {
                                MaxDistance = Tmp;
                                BestTarget = SetTarget;
                            }
                        }
                        // ==================== [ Get Nearest By Crosshair ] ==================== //
                        if (Var_RemoteMode == 1)
                        {
                            if (Engine->WorldToScreen(g_pDevice, &Pos))
                            {
                                float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                                float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                                float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                                if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                                {
                                    if (Tmp < MaxDistance)
                                    {
                                        MaxDistance = Tmp;
                                        BestTarget = SetTarget;
                                    }
                                }
                            }
                        }
                        // ==================== [ Get Nearest By Distance ] ==================== //
                        if (Var_RemoteMode == 2)
                        {
                            if (Engine->WorldToScreen(g_pDevice, &Pos))
                            {
                                float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                                float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                                if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                                {
                                    if (Tmp < MaxDistance)
                                    {
                                        MaxDistance = Tmp;
                                        BestTarget = SetTarget;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return BestTarget;
        }
    }
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckZombie(TargetPlayer))
                continue;

            if (Engine->IsZM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By 360 ] ==================== //
            if (Var_RemoteMode == 0)
            {
                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                if (Tmp < MaxDistance)
                {
                    MaxDistance = Tmp;
                    BestTarget = i;
                }
            }
            // ==================== [ Get Nearest By Crosshair ] ==================== //
            if (Var_RemoteMode == 1)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
            // ==================== [ Get Nearest By Distance ] ==================== //
            if (Var_RemoteMode == 2)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityHighestKillZombie(void)
{
    int MaxKills = -50;
    int BestTarget = -1;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckZombie(TargetPlayer))
                continue;

            if (Engine->IsZM(LocalPlayer, TargetPlayer))
                continue;

            if (TargetPlayer->Kills >= MaxKills)
            {
                MaxKills = TargetPlayer->Kills;
                BestTarget = i;
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityLowestKillZombie(void)
{
    int MinKills = 50;
    int BestTarget = -1;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckZombie(TargetPlayer))
                continue;

            if (Engine->IsZM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By Lowest Kill ] ==================== //
            if (TargetPlayer->Kills <= MinKills)
            {
                MinKills = TargetPlayer->Kills;
                BestTarget = i;
            }
        }
    }
    return BestTarget;
}

int cRemotekill::GetNearestByTargetZombie(void)
{
    int BestTarget = -1;

    float MaxDistance = INFINITE;

    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckZombie(TargetPlayer))
                continue;

            if (Engine->IsZM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By 360 ] ==================== //
            if (Var_RemoteMode == 0)
            {
                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                if (Tmp < MaxDistance)
                {
                    MaxDistance = Tmp;
                    BestTarget = i;
                }
            }
            // ==================== [ Get Nearest By Crosshair ] ==================== //
            if (Var_RemoteMode == 1)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
            // ==================== [ Get Nearest By Distance ] ==================== //
            if (Var_RemoteMode == 2)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
        }
    }
    return BestTarget;
}

bool m_Remotekill(IntersectQuery* g_pQuery, IntersectInfo* g_pInfo)
{
    VIRTUALIZER_FISH_BLACK_START
    int BONE_ID = 6;

    switch (Var_RemoteBone)
    {
        case 1: BONE_ID = 5; break; // Neck
        case 2: BONE_ID = 2; break; // Body
        case 3: BONE_ID = 10; break; // Left Hand
        case 4: BONE_ID = 17; break; // Right Hand
        case 5: BONE_ID = 23; break; // Left Foot
        case 6: BONE_ID = 28; break; // Right Foot
        default: BONE_ID = 6; // Head
    }

    if (!Engine->IsRoomInfoZmMode())
    {
        CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
        if (Engine->IsValidPointer(LocalPlayer))
        {
            int TargetIndex = cRemotekill::GetNearestByTargetPlayer();
            switch (Var_PriorityType)
            {
                case 1: TargetIndex = cRemotekill::PriorityCustomTargetPlayer(); break;
                case 2: TargetIndex = cRemotekill::PriorityHighestKillPlayer(); break;
                case 3: TargetIndex = cRemotekill::PriorityLowestKillPlayer(); break;
                default: TargetIndex = cRemotekill::GetNearestByTargetPlayer();
            }
            if (TargetIndex != -1)
            {
                CPlayer* TargetPlayer = Engine->GetPlayerByIndex(TargetIndex);
                if (Engine->IsValidPointer(TargetPlayer))
                {
                    if (TargetPlayer != LocalPlayer)
                    {
                        D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, BONE_ID);
                        if (Var_RemoteVisibleCheck == 0)
                        {
                            g_pQuery->m_From = Pos + D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                            g_pQuery->m_To = Pos - D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                            g_pQuery->m_Flags = PObjects::CHECK_FROM_POINT_INSIDE_OBJECTS | PObjects::INTERSECT_OBJECTS | PObjects::INTERSECT_HPOLY | PObjects::IGNORE_NONSOLID;
                            g_pQuery->m_FilterFn = FilterObjs;

                            bool Result = g_pIntersectSegment(*g_pQuery, g_pInfo);
                            if (Result)
                            {
                                g_pInfo->g_pObject = TargetPlayer->m_Object;
                                g_pInfo->m_PlayerPos = Pos;
                            }
                            return g_pIntersectSegment(*g_pQuery, g_pInfo);
                        }
                        else if (Var_RemoteVisibleCheck == 1)
                        {
                            if (Engine->IsVisible(Engine->GetBonePosition(LocalPlayer->m_Object, 6), Engine->GetBonePosition(TargetPlayer->m_Object, BONE_ID)))
                            {
                                g_pQuery->m_From = Pos + D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                                g_pQuery->m_To = Pos - D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                                g_pQuery->m_Flags = PObjects::CHECK_FROM_POINT_INSIDE_OBJECTS | PObjects::INTERSECT_OBJECTS | PObjects::INTERSECT_HPOLY | PObjects::IGNORE_NONSOLID;
                                g_pQuery->m_FilterFn = FilterObjs;
                            }
                            bool Result = g_pIntersectSegment(*g_pQuery, g_pInfo);
                            if (Result)
                            {
                                g_pInfo->g_pObject = TargetPlayer->m_Object;
                                g_pInfo->m_PlayerPos = Pos;
                            }
                            return g_pIntersectSegment(*g_pQuery, g_pInfo);
                        }
                    }
                }
            }
        }
    }
    else if (Engine->IsRoomInfoZmMode())
    {
        CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
        if (Engine->IsValidPointer(LocalPlayer))
        {
            int TargetIndex = cRemotekill::GetNearestByTargetZombie();
            switch (Var_PriorityType)
            {
                case 1: TargetIndex = cRemotekill::PriorityCustomTargetZombie(); break;
                case 2: TargetIndex = cRemotekill::PriorityHighestKillZombie(); break;
                case 3: TargetIndex = cRemotekill::PriorityLowestKillZombie(); break;
                default: TargetIndex = cRemotekill::GetNearestByTargetZombie();
            }

            CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
            if (TargetIndex != -1)
            {
                CPlayer* TargetPlayer = Engine->GetPlayerByIndex(TargetIndex);
                if (Engine->IsValidPointer(TargetPlayer))
                {
                    if (TargetPlayer->CharacterFx->IsMutant() != LocalPlayer->CharacterFx->IsMutant())
                    {
                        D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, BONE_ID);
                        if (Var_RemoteVisibleCheck == 0)
                        {
                            g_pQuery->m_From = Pos + D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                            g_pQuery->m_To = Pos - D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                            g_pQuery->m_Flags = PObjects::CHECK_FROM_POINT_INSIDE_OBJECTS | PObjects::INTERSECT_OBJECTS | PObjects::INTERSECT_HPOLY | PObjects::IGNORE_NONSOLID;
                            g_pQuery->m_FilterFn = FilterObjs;

                            bool Result = g_pIntersectSegment(*g_pQuery, g_pInfo);
                            if (Result)
                            {
                                g_pInfo->g_pObject = TargetPlayer->m_Object;
                                g_pInfo->m_PlayerPos = Pos;
                            }
                            return g_pIntersectSegment(*g_pQuery, g_pInfo);
                        }
                        else if (Var_RemoteVisibleCheck == 1)
                        {
                            if (Engine->IsVisible(Engine->GetBonePosition(LocalPlayer->m_Object, 6), Engine->GetBonePosition(TargetPlayer->m_Object, BONE_ID)))
                            {
                                g_pQuery->m_From = Pos + D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                                g_pQuery->m_To = Pos - D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                                g_pQuery->m_Flags = PObjects::CHECK_FROM_POINT_INSIDE_OBJECTS | PObjects::INTERSECT_OBJECTS | PObjects::INTERSECT_HPOLY | PObjects::IGNORE_NONSOLID;
                                g_pQuery->m_FilterFn = FilterObjs;
                            }
                            bool Result = g_pIntersectSegment(*g_pQuery, g_pInfo);
                            if (Result)
                            {
                                g_pInfo->g_pObject = TargetPlayer->m_Object;
                                g_pInfo->m_PlayerPos = Pos;
                            }
                            return g_pIntersectSegment(*g_pQuery, g_pInfo);
                        }
                    }
                }
            }
        }
    }
    return g_pIntersectSegment(*g_pQuery, g_pInfo);
    VIRTUALIZER_FISH_BLACK_END
}

void cRemotekill::EnableRemote(void)
{
    VIRTUALIZER_FISH_BLACK_START
    if (!Engine->IsGameReadyForHook()) return;
    static uint32_t CShell = (uint32_t)GetModuleHandleA(eCShell);
    // ==================== [ Modified Hook Function ] ==================== //
    uint32_t aILTClient = *(uint32_t*)(CShell + NetVars::PHacks::ADDR_LTClient);
    if (aILTClient != NULL)
    {
        g_pIntersectSegment = (m_pIntersectSegment)(*(uint32_t*)(aILTClient + 0x7C));
        *(uint32_t*)(aILTClient + 0x7C) = (uint32_t)m_Remotekill;
    }
    VIRTUALIZER_FISH_BLACK_END
}

void cRemotekill::DisableRemote(void)
{
    VIRTUALIZER_FISH_BLACK_START
    if (!Engine->IsGameReadyForHook()) return;
    static uint32_t CShell = (uint32_t)GetModuleHandleA(eCShell);
    // ==================== [ Backup Hook Function ] ==================== //
    uint32_t aILTClient = *(uint32_t*)(CShell + NetVars::PHacks::ADDR_LTClient);
    if (aILTClient != NULL)
    {
        *(uint32_t*)(aILTClient + 0x7C) = (uint32_t)g_pIntersectSegment;
    }
    VIRTUALIZER_FISH_BLACK_END
}

void cRemotekill::InitializeRemote(void)
{
    VIRTUALIZER_FISH_BLACK_START
    cRemotekill::VectorTargetID();

    if (!Engine->InGame() && !Engine->IsValidPlayer())
    {
        RemoteEnemyID = 0;
        Enemy_DB.erase(Enemy_DB.begin(), Enemy_DB.begin() + Enemy_DB.size());
        return;
    }

    if (!Engine->InGame() && !Engine->IsValidPlayer())
    {
        if (!DoItOnce)
        {
            cRemotekill::DisableRemote();
            DoItOnce = true;
        }
    }
    else if (Engine->InGame() && Engine->IsValidPlayer())
    {
        if (!Var_MenuVisible)
        {
            if (Var_PriorityType == 1)
            {
                cRemotekill::DrawClientID();
            }
        }

        int ActivateRemoteKeys = (GetAsyncKeyState(VK_LBUTTON));

        switch (Var_RemoteKeys)
        {
            case 1: ActivateRemoteKeys = (GetAsyncKeyState(VK_RBUTTON)); break;
            case 2:    ActivateRemoteKeys = (GetAsyncKeyState(VK_SHIFT)); break;
            case 3:    ActivateRemoteKeys = (GetAsyncKeyState(VK_MENU)); break;
            default: ActivateRemoteKeys = (GetAsyncKeyState(VK_LBUTTON));
        }

        if (Var_Remotekill && ActivateRemoteKeys && Engine->GetLocalPlayer()->CharacterFx->GetWeaponPlayer()->isWeapon())
        {
            if (DoItOnce)
            {
                cRemotekill::EnableRemote();
                DoItOnce = false;
            }
        }
        else
        {
            if (!DoItOnce)
            {
                cRemotekill::DisableRemote();
                DoItOnce = true;
            }
        }
        return;
    }
    VIRTUALIZER_FISH_BLACK_END
}

Credits:
@MemoryThePast
@davinci Junior the MXVIII
@vaisefud3
@dreek1
@~FALLEN~
@MiNT
@gellin
@giniyat101
@zNova
@Geopulse
@RazerXJosh
@ACEOFEAGLE
@xmikan09

btw its already detected by sig scan. so you shall need to do a something to make it undetected goodluck

have you found bypass measure for this hook?
looks their(remotekill hook,superkill head) checks from same address

- - - Updated - - -

have you found bypass measure for this hook?
looks their(remotekill hook,superkill head) checks from same address

Originally Posted by MemoryThePast

Code:

#ifndef _REMOTE_KILL_H_
#define _REMOTE_KILL_H_

#pragma once

#include "Stdafx.h"

typedef bool(WINAPIV *m_pIntersectSegment)(IntersectQuery& m_Query, IntersectInfo *m_Info);
extern m_pIntersectSegment g_pIntersectSegment;

namespace cRemotekill
{
    void VectorTargetID(void);
    void DrawClientID(void);
    int PriorityIDSetup(void);
    void StartRemoteFov(void);
    int PriorityCustomTargetPlayer(void);
    int PriorityHighestKillPlayer(void);
    int PriorityLowestKillPlayer(void);
    int GetNearestByTargetPlayer(void);
    int PriorityCustomTargetZombie(void);
    int PriorityHighestKillZombie(void);
    int PriorityLowestKillZombie(void);
    int GetNearestByTargetZombie(void);
    void EnableRemote(void);
    void DisableRemote(void);
    void InitializeRemote(void);
}

#endif

Remotekill.cpp

Code:

#include "Remotekill.h"

#define PI2 6.283185307179586

m_pIntersectSegment g_pIntersectSegment = 0;

bool FilterObjs(cObject *m_Object, void *user)
{
    for (int i = 0; i < Engine->GetMaxPlayer(); i++)
    {
        CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
        if (m_Object == TargetPlayer->m_Object)
            return false;
    }
    return true;
}

void cRemotekill::VectorTargetID(void)
{
    if (!Engine->IsGameReadyForHook()) return;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsValidPointer(TargetPlayer->m_Object))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            if (TargetPlayer != LocalPlayer)
            {
                std::vector<int>::iterator it = std::find(Enemy_DB.begin(), Enemy_DB.end(), i);
                if (it != Enemy_DB.end());
                else
                {
                    Enemy_DB.push_back(i);
                }
            }
        }
    }
}

void cRemotekill::DrawClientID(void)
{
    if (!Engine->IsGameReadyForHook()) return;

    int32_t MaxEnemyCount = Enemy_DB.size();
    if (MaxEnemyCount > 0)
    {
        if (GetAsyncKeyState(VK_LEFT) & 1)
        {
            if (RemoteEnemyID != 0)
            {
                RemoteEnemyID -= 1;
            }
            else
            {
                RemoteEnemyID = 0;
            }
        }
    }
    if (MaxEnemyCount > 0)
    {
        if (GetAsyncKeyState(VK_RIGHT) & 1)
        {
            if (RemoteEnemyID != MaxEnemyCount - 1)
            {
                RemoteEnemyID += 1;
            }
            else
            {
                RemoteEnemyID = MaxEnemyCount - 1;
            }
        }
    }
    if (MaxEnemyCount > 0)
    {
        RemoteClientID = Enemy_DB[RemoteEnemyID];
        CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
        CPlayer* TargetPlayer = Engine->GetPlayerByIndex(RemoteClientID);
        if (Engine->IsValidPointer(LocalPlayer) && Engine->IsValidPointer(TargetPlayer))
        {
            char* ArrowLeft = "<-- ";
            char* ArrowRight = " -->";
            char* Name = TargetPlayer->Name;
            char* Show = (char*)malloc(1 + strlen(ArrowLeft) + strlen(Name) + strlen(ArrowRight));

            strcpy(Show, ArrowLeft); strcat(Show, Name); strcat(Show, ArrowRight);
            Esp->lWriteText(120, 50, Red, Show);
            RemotePriorityTargetID = RemoteClientID;
        }
    }
    Esp->lWriteText(120, 75, Red, Crossfire->WriteLogChar(RemotePriorityTargetID, "ID : "));
}

int cRemotekill::PriorityIDSetup(void)
{
    int32_t i = RemotePriorityTargetID;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

    if (!Engine->IsValidClient(TargetPlayer))
        return -1;

    if (Engine->IsTM(LocalPlayer, TargetPlayer))
        return -1;

    //if (!Engine->IsVisible(Engine->GetBonePosition(LocalPlayer->Object, 6), Engine->GetBonePosition(TargetPlayer->Object, 6)) && Var_RemoteVisibleCheck == 1)
        //return -1;

    if (TargetPlayer->CharacterFx->SpawnShield())
        return -1;

    if (TargetPlayer->CharacterFx->IsDead())
        return -1;

    //D3DXVECTOR3 Head = Engine->GetBonePosition(TargetPlayer->Object, 6);
        //if (!Engine->WorldToScreen(g_pDevice, &Head) && Var_RemoteMode != 0)
        //return -1;

    return i;
}

void cRemotekill::StartRemoteFov(void)
{
    if (!Engine->IsGameReadyForHook()) return;
    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    switch (Var_RemoteFov)
    {
        case 1: RemoteFirstView = 2.50f; break; // 10.0f
        case 2: RemoteFirstView = 6.50f; break; // 30.0f
        case 3: RemoteFirstView = 9.50f; break; // 45.0f
        case 4: RemoteFirstView = 12.50f; break; // 60.0f
        case 5: RemoteFirstView = 16.50f; break; // 80.0f
        case 6: RemoteFirstView = 18.50f; break; // 90.0f
        case 7: RemoteFirstView = 32.50f; break; // 180.0f
        case 8: RemoteFirstView = 64.5f; break; // 360.0f
        default: RemoteFirstView = 6.50f;
    }

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        if (!LocalPlayer->CharacterFx->IsDead())
        {
            if (Var_Remotekill)
            {
                if (Var_RemoteMode != 0)
                {
                    DirectX->DrawCircle(ScreenX, ScreenY, (RemoteFirstView * 5.0f) * PI2, Yellow, g_pDevice);
                }
            }
        }
    }
}

int cRemotekill::PriorityCustomTargetPlayer(void)
{
    int BestTarget = -1;

    float MaxDistance = INFINITE;

    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    // ==================== [ Custom Target Player ] ==================== //
    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        int SetTarget = cRemotekill::PriorityIDSetup();
        if (SetTarget > -1)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(SetTarget);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);
            if (Engine->IsValidClient(TargetPlayer))
            {
                if (Engine->IsCheckPlayer(TargetPlayer))
                {
                    if (!Engine->IsTM(LocalPlayer, TargetPlayer))
                    {
                        // ==================== [ Get Nearest By 360 ] ==================== //
                        if (Var_RemoteMode == 0)
                        {
                            float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                            if (Tmp < MaxDistance)
                            {
                                MaxDistance = Tmp;
                                BestTarget = SetTarget;
                            }
                        }
                        // ==================== [ Get Nearest By Crosshair ] ==================== //
                        if (Var_RemoteMode == 1)
                        {
                            if (Engine->WorldToScreen(g_pDevice, &Pos))
                            {
                                float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                                float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                                float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                                if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                                {
                                    if (Tmp < MaxDistance)
                                    {
                                        MaxDistance = Tmp;
                                        BestTarget = SetTarget;
                                    }
                                }
                            }
                        }
                        // ==================== [ Get Nearest By Distance ] ==================== //
                        if (Var_RemoteMode == 2)
                        {
                            if (Engine->WorldToScreen(g_pDevice, &Pos))
                            {
                                float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                                float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                                if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                                {
                                    if (Tmp < MaxDistance)
                                    {
                                        MaxDistance = Tmp;
                                        BestTarget = SetTarget;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return BestTarget;
        }
    }
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckPlayer(TargetPlayer))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By 360 ] ==================== //
            if (Var_RemoteMode == 0)
            {
                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                if (Tmp < MaxDistance)
                {
                    MaxDistance = Tmp;
                    BestTarget = i;
                }
            }
            // ==================== [ Get Nearest By Crosshair ] ==================== //
            if (Var_RemoteMode == 1)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
            // ==================== [ Get Nearest By Distance ] ==================== //
            if (Var_RemoteMode == 2)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityHighestKillPlayer(void)
{
    int MaxKills = -50;
    int BestTarget = -1;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckPlayer(TargetPlayer))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            if (TargetPlayer->Kills >= MaxKills)
            {
                MaxKills = TargetPlayer->Kills;
                BestTarget = i;
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityLowestKillPlayer(void)
{
    int MinKills = 50;
    int BestTarget = -1;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckPlayer(TargetPlayer))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By Lowest Kill ] ==================== //
            if (TargetPlayer->Kills <= MinKills)
            {
                MinKills = TargetPlayer->Kills;
                BestTarget = i;
            }
        }
    }
    return BestTarget;
}

int cRemotekill::GetNearestByTargetPlayer(void)
{
    int BestTarget = -1;

    float MaxDistance = INFINITE;

    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckPlayer(TargetPlayer))
                continue;

            if (Engine->IsTM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By 360 ] ==================== //
            if (Var_RemoteMode == 0)
            {
                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                if (Tmp < MaxDistance)
                {
                    MaxDistance = Tmp;
                    BestTarget = i;
                }
            }
            // ==================== [ Get Nearest By Crosshair ] ==================== //
            if (Var_RemoteMode == 1)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
            // ==================== [ Get Nearest By Distance ] ==================== //
            if (Var_RemoteMode == 2)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityCustomTargetZombie(void)
{
    int BestTarget = -1;

    float MaxDistance = INFINITE;

    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    // ==================== [ Custom Target Player ] ==================== //
    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        int SetTarget = cRemotekill::PriorityIDSetup();
        if (SetTarget > -1)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(SetTarget);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);
            if (Engine->IsValidClient(TargetPlayer))
            {
                if (Engine->IsCheckZombie(TargetPlayer))
                {
                    if (!Engine->IsZM(LocalPlayer, TargetPlayer))
                    {
                        // ==================== [ Get Nearest By 360 ] ==================== //
                        if (Var_RemoteMode == 0)
                        {
                            float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                            if (Tmp < MaxDistance)
                            {
                                MaxDistance = Tmp;
                                BestTarget = SetTarget;
                            }
                        }
                        // ==================== [ Get Nearest By Crosshair ] ==================== //
                        if (Var_RemoteMode == 1)
                        {
                            if (Engine->WorldToScreen(g_pDevice, &Pos))
                            {
                                float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                                float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                                float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                                if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                                {
                                    if (Tmp < MaxDistance)
                                    {
                                        MaxDistance = Tmp;
                                        BestTarget = SetTarget;
                                    }
                                }
                            }
                        }
                        // ==================== [ Get Nearest By Distance ] ==================== //
                        if (Var_RemoteMode == 2)
                        {
                            if (Engine->WorldToScreen(g_pDevice, &Pos))
                            {
                                float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                                float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                                if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                                {
                                    if (Tmp < MaxDistance)
                                    {
                                        MaxDistance = Tmp;
                                        BestTarget = SetTarget;
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return BestTarget;
        }
    }
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckZombie(TargetPlayer))
                continue;

            if (Engine->IsZM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By 360 ] ==================== //
            if (Var_RemoteMode == 0)
            {
                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                if (Tmp < MaxDistance)
                {
                    MaxDistance = Tmp;
                    BestTarget = i;
                }
            }
            // ==================== [ Get Nearest By Crosshair ] ==================== //
            if (Var_RemoteMode == 1)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
            // ==================== [ Get Nearest By Distance ] ==================== //
            if (Var_RemoteMode == 2)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityHighestKillZombie(void)
{
    int MaxKills = -50;
    int BestTarget = -1;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckZombie(TargetPlayer))
                continue;

            if (Engine->IsZM(LocalPlayer, TargetPlayer))
                continue;

            if (TargetPlayer->Kills >= MaxKills)
            {
                MaxKills = TargetPlayer->Kills;
                BestTarget = i;
            }
        }
    }
    return BestTarget;
}

int cRemotekill::PriorityLowestKillZombie(void)
{
    int MinKills = 50;
    int BestTarget = -1;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckZombie(TargetPlayer))
                continue;

            if (Engine->IsZM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By Lowest Kill ] ==================== //
            if (TargetPlayer->Kills <= MinKills)
            {
                MinKills = TargetPlayer->Kills;
                BestTarget = i;
            }
        }
    }
    return BestTarget;
}

int cRemotekill::GetNearestByTargetZombie(void)
{
    int BestTarget = -1;

    float MaxDistance = INFINITE;

    D3DVIEWPORT9 ViewP;
    g_pDevice->GetViewport(&ViewP);
    float ScreenX = ViewP.Width / 2;
    float ScreenY = ViewP.Height / 2;

    CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
    if (Engine->IsValidClient(LocalPlayer))
    {
        for (int i = 0; i < Engine->GetMaxPlayer(); i++)
        {
            CPlayer* TargetPlayer = Engine->GetPlayerByIndex(i);
            D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, 6);

            if (!Engine->IsValidClient(TargetPlayer))
                continue;

            if (!Engine->IsCheckZombie(TargetPlayer))
                continue;

            if (Engine->IsZM(LocalPlayer, TargetPlayer))
                continue;

            // ==================== [ Get Nearest By 360 ] ==================== //
            if (Var_RemoteMode == 0)
            {
                float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                if (Tmp < MaxDistance)
                {
                    MaxDistance = Tmp;
                    BestTarget = i;
                }
            }
            // ==================== [ Get Nearest By Crosshair ] ==================== //
            if (Var_RemoteMode == 1)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->GetDistance(Pos.x, Pos.y, ScreenX, ScreenY);

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
            // ==================== [ Get Nearest By Distance ] ==================== //
            if (Var_RemoteMode == 2)
            {
                if (Engine->WorldToScreen(g_pDevice, &Pos))
                {
                    float radiusx = (RemoteFirstView * 5.0f) * (ScreenX / 100.0f);
                    float radiusy = (RemoteFirstView * 5.0f) * (ScreenY / 100.0f);

                    float Tmp = Esp->CalculateDistance(LocalPlayer->m_Object->Body, TargetPlayer->m_Object->Body) / 100;

                    if (Pos.x >= ScreenX - radiusx && Pos.x <= ScreenX + radiusx && Pos.y >= ScreenY - radiusy && Pos.y <= ScreenY + radiusy)
                    {
                        if (Tmp < MaxDistance)
                        {
                            MaxDistance = Tmp;
                            BestTarget = i;
                        }
                    }
                }
            }
        }
    }
    return BestTarget;
}

bool m_Remotekill(IntersectQuery* g_pQuery, IntersectInfo* g_pInfo)
{
    VIRTUALIZER_FISH_BLACK_START
    int BONE_ID = 6;

    switch (Var_RemoteBone)
    {
        case 1: BONE_ID = 5; break; // Neck
        case 2: BONE_ID = 2; break; // Body
        case 3: BONE_ID = 10; break; // Left Hand
        case 4: BONE_ID = 17; break; // Right Hand
        case 5: BONE_ID = 23; break; // Left Foot
        case 6: BONE_ID = 28; break; // Right Foot
        default: BONE_ID = 6; // Head
    }

    if (!Engine->IsRoomInfoZmMode())
    {
        CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
        if (Engine->IsValidPointer(LocalPlayer))
        {
            int TargetIndex = cRemotekill::GetNearestByTargetPlayer();
            switch (Var_PriorityType)
            {
                case 1: TargetIndex = cRemotekill::PriorityCustomTargetPlayer(); break;
                case 2: TargetIndex = cRemotekill::PriorityHighestKillPlayer(); break;
                case 3: TargetIndex = cRemotekill::PriorityLowestKillPlayer(); break;
                default: TargetIndex = cRemotekill::GetNearestByTargetPlayer();
            }
            if (TargetIndex != -1)
            {
                CPlayer* TargetPlayer = Engine->GetPlayerByIndex(TargetIndex);
                if (Engine->IsValidPointer(TargetPlayer))
                {
                    if (TargetPlayer != LocalPlayer)
                    {
                        D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, BONE_ID);
                        if (Var_RemoteVisibleCheck == 0)
                        {
                            g_pQuery->m_From = Pos + D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                            g_pQuery->m_To = Pos - D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                            g_pQuery->m_Flags = PObjects::CHECK_FROM_POINT_INSIDE_OBJECTS | PObjects::INTERSECT_OBJECTS | PObjects::INTERSECT_HPOLY | PObjects::IGNORE_NONSOLID;
                            g_pQuery->m_FilterFn = FilterObjs;

                            bool Result = g_pIntersectSegment(*g_pQuery, g_pInfo);
                            if (Result)
                            {
                                g_pInfo->g_pObject = TargetPlayer->m_Object;
                                g_pInfo->m_PlayerPos = Pos;
                            }
                            return g_pIntersectSegment(*g_pQuery, g_pInfo);
                        }
                        else if (Var_RemoteVisibleCheck == 1)
                        {
                            if (Engine->IsVisible(Engine->GetBonePosition(LocalPlayer->m_Object, 6), Engine->GetBonePosition(TargetPlayer->m_Object, BONE_ID)))
                            {
                                g_pQuery->m_From = Pos + D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                                g_pQuery->m_To = Pos - D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                                g_pQuery->m_Flags = PObjects::CHECK_FROM_POINT_INSIDE_OBJECTS | PObjects::INTERSECT_OBJECTS | PObjects::INTERSECT_HPOLY | PObjects::IGNORE_NONSOLID;
                                g_pQuery->m_FilterFn = FilterObjs;
                            }
                            bool Result = g_pIntersectSegment(*g_pQuery, g_pInfo);
                            if (Result)
                            {
                                g_pInfo->g_pObject = TargetPlayer->m_Object;
                                g_pInfo->m_PlayerPos = Pos;
                            }
                            return g_pIntersectSegment(*g_pQuery, g_pInfo);
                        }
                    }
                }
            }
        }
    }
    else if (Engine->IsRoomInfoZmMode())
    {
        CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
        if (Engine->IsValidPointer(LocalPlayer))
        {
            int TargetIndex = cRemotekill::GetNearestByTargetZombie();
            switch (Var_PriorityType)
            {
                case 1: TargetIndex = cRemotekill::PriorityCustomTargetZombie(); break;
                case 2: TargetIndex = cRemotekill::PriorityHighestKillZombie(); break;
                case 3: TargetIndex = cRemotekill::PriorityLowestKillZombie(); break;
                default: TargetIndex = cRemotekill::GetNearestByTargetZombie();
            }

            CPlayer* LocalPlayer = Engine->GetPlayerByIndex(Engine->GetMyIndex());
            if (TargetIndex != -1)
            {
                CPlayer* TargetPlayer = Engine->GetPlayerByIndex(TargetIndex);
                if (Engine->IsValidPointer(TargetPlayer))
                {
                    if (TargetPlayer->CharacterFx->IsMutant() != LocalPlayer->CharacterFx->IsMutant())
                    {
                        D3DXVECTOR3 Pos = Engine->GetBonePosition(TargetPlayer->m_Object, BONE_ID);
                        if (Var_RemoteVisibleCheck == 0)
                        {
                            g_pQuery->m_From = Pos + D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                            g_pQuery->m_To = Pos - D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                            g_pQuery->m_Flags = PObjects::CHECK_FROM_POINT_INSIDE_OBJECTS | PObjects::INTERSECT_OBJECTS | PObjects::INTERSECT_HPOLY | PObjects::IGNORE_NONSOLID;
                            g_pQuery->m_FilterFn = FilterObjs;

                            bool Result = g_pIntersectSegment(*g_pQuery, g_pInfo);
                            if (Result)
                            {
                                g_pInfo->g_pObject = TargetPlayer->m_Object;
                                g_pInfo->m_PlayerPos = Pos;
                            }
                            return g_pIntersectSegment(*g_pQuery, g_pInfo);
                        }
                        else if (Var_RemoteVisibleCheck == 1)
                        {
                            if (Engine->IsVisible(Engine->GetBonePosition(LocalPlayer->m_Object, 6), Engine->GetBonePosition(TargetPlayer->m_Object, BONE_ID)))
                            {
                                g_pQuery->m_From = Pos + D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                                g_pQuery->m_To = Pos - D3DXVECTOR3(0.0f, 50.0f, 0.0f);
                                g_pQuery->m_Flags = PObjects::CHECK_FROM_POINT_INSIDE_OBJECTS | PObjects::INTERSECT_OBJECTS | PObjects::INTERSECT_HPOLY | PObjects::IGNORE_NONSOLID;
                                g_pQuery->m_FilterFn = FilterObjs;
                            }
                            bool Result = g_pIntersectSegment(*g_pQuery, g_pInfo);
                            if (Result)
                            {
                                g_pInfo->g_pObject = TargetPlayer->m_Object;
                                g_pInfo->m_PlayerPos = Pos;
                            }
                            return g_pIntersectSegment(*g_pQuery, g_pInfo);
                        }
                    }
                }
            }
        }
    }
    return g_pIntersectSegment(*g_pQuery, g_pInfo);
    VIRTUALIZER_FISH_BLACK_END
}

void cRemotekill::EnableRemote(void)
{
    VIRTUALIZER_FISH_BLACK_START
    if (!Engine->IsGameReadyForHook()) return;
    static uint32_t CShell = (uint32_t)GetModuleHandleA(eCShell);
    // ==================== [ Modified Hook Function ] ==================== //
    uint32_t aILTClient = *(uint32_t*)(CShell + NetVars::PHacks::ADDR_LTClient);
    if (aILTClient != NULL)
    {
        g_pIntersectSegment = (m_pIntersectSegment)(*(uint32_t*)(aILTClient + 0x7C));
        *(uint32_t*)(aILTClient + 0x7C) = (uint32_t)m_Remotekill;
    }
    VIRTUALIZER_FISH_BLACK_END
}

void cRemotekill::DisableRemote(void)
{
    VIRTUALIZER_FISH_BLACK_START
    if (!Engine->IsGameReadyForHook()) return;
    static uint32_t CShell = (uint32_t)GetModuleHandleA(eCShell);
    // ==================== [ Backup Hook Function ] ==================== //
    uint32_t aILTClient = *(uint32_t*)(CShell + NetVars::PHacks::ADDR_LTClient);
    if (aILTClient != NULL)
    {
        *(uint32_t*)(aILTClient + 0x7C) = (uint32_t)g_pIntersectSegment;
    }
    VIRTUALIZER_FISH_BLACK_END
}

void cRemotekill::InitializeRemote(void)
{
    VIRTUALIZER_FISH_BLACK_START
    cRemotekill::VectorTargetID();

    if (!Engine->InGame() && !Engine->IsValidPlayer())
    {
        RemoteEnemyID = 0;
        Enemy_DB.erase(Enemy_DB.begin(), Enemy_DB.begin() + Enemy_DB.size());
        return;
    }

    if (!Engine->InGame() && !Engine->IsValidPlayer())
    {
        if (!DoItOnce)
        {
            cRemotekill::DisableRemote();
            DoItOnce = true;
        }
    }
    else if (Engine->InGame() && Engine->IsValidPlayer())
    {
        if (!Var_MenuVisible)
        {
            if (Var_PriorityType == 1)
            {
                cRemotekill::DrawClientID();
            }
        }

        int ActivateRemoteKeys = (GetAsyncKeyState(VK_LBUTTON));

        switch (Var_RemoteKeys)
        {
            case 1: ActivateRemoteKeys = (GetAsyncKeyState(VK_RBUTTON)); break;
            case 2:    ActivateRemoteKeys = (GetAsyncKeyState(VK_SHIFT)); break;
            case 3:    ActivateRemoteKeys = (GetAsyncKeyState(VK_MENU)); break;
            default: ActivateRemoteKeys = (GetAsyncKeyState(VK_LBUTTON));
        }

        if (Var_Remotekill && ActivateRemoteKeys && Engine->GetLocalPlayer()->CharacterFx->GetWeaponPlayer()->isWeapon())
        {
            if (DoItOnce)
            {
                cRemotekill::EnableRemote();
                DoItOnce = false;
            }
        }
        else
        {
            if (!DoItOnce)
            {
                cRemotekill::DisableRemote();
                DoItOnce = true;
            }
        }
        return;
    }
    VIRTUALIZER_FISH_BLACK_END
}

Credits:
@MemoryThePast
@davinci Junior the MXVIII
@vaisefud3
@dreek1
@~FALLEN~
@MiNT
@gellin
@giniyat101
@zNova
@Geopulse
@RazerXJosh
@ACEOFEAGLE

btw its already detected by sig scan. so you shall need to do a something to make it undetected goodluck

Nice, but as I told u before, there are better methods to hook it

Originally Posted by vaisefud3

Nice, but as I told u before, there are better methods to hook it

yup i have another way to hook it and its still undetected ^_^

I removed the advertising part of your post, mind the less that you bypassed the word filter. Consider this as a non-official warning. Please keep your posts within the rules & guidelines of MPGH. You know them better from the copypasta site of MPGH you have there.