Grenade Prediction CSGOSimple?

[r01yt]

собсна, как сделатб?
жду ответов не по теме (), но лучше по теме

 

[Yorenevann]

можешь попробовать на c++

 

[Dreammm]

ну берешь аврору (извиняюсь, если она не на симпле) или писькавар (dickware) там по ip вычисляешь grenade tracer пастишь его в свой чит, если что-то выдает ошибку то переходи в писькавар/аврору, и на той функции (или не функции) нажми пкм и показать определение, и это пасти (есть шанс что в общем это войдет в бесконечный круг где фикся одну ошибку ты будешь получать по 50 (у меня так было, незабываемый опыт) не советую пастить с ху0 в симпл;))

 

[r01yt]

можешь попробовать на c++

благодарю

 

[r01yt]

ну берешь аврору (извиняюсь, если она не на симпле) или писькавар (dickware) там по ip вычисляешь grenade tracer пастишь его в свой чит, если что-то выдает ошибку то переходи в писькавар/аврору, и на той функции (или не функции) нажми пкм и показать определение, и это пасти (есть шанс что в общем это войдет в бесконечный круг где фикся одну ошибку ты будешь получать по 50 (у меня так было, незабываемый опыт) не советую пастить с ху0 в симпл;))

ну-ка интересненька, пасиба

 

[Qunion]

собсна, как сделатб?
жду ответов не по теме (), но лучше по теме

В мунеонееее(говно чит) есть grenade helper, в исходнике. Но у меня топовый granadehelper который показывает куда встать и куда кинуть гранату, причем показывает броски только на ту гранату которую держишь в руке. И показывает трасер на гранату

 

[alex96]

Берешь спуфаешь команду которая была не давно добавлена а название ее забыл но ты можешь в локах апдейто кс почекать

 

[r01yt]

В мунеонееее(говно чит) есть grenade helper, в исходнике. Но у меня топовый granadehelper который показывает куда встать и куда кинуть гранату, причем показывает броски только на ту гранату которую держишь в руке. И показывает трасер на гранату

мне и трасера хватит, но всё равно спасибо

 

[r01yt]

Берешь спуфаешь команду которая была не давно добавлена а название ее забыл но ты можешь в локах апдейто кс почекать

спасибо, посмотрю

 

[Frzguy]

вот сматри эта писькавр:

Спойлер: GrenadeTrajectory.h

#pragma once
#include "..\singleton.hpp"
#include "..\valve_sdk\csgostructs.hpp"
#include "..\valve_sdk\sdk.hpp"

enum ACT
{
    ACT_NONE,
    ACT_THROW,
    ACT_LOB,
    ACT_DROP,
};

class GrenadeHint : public Singleton<GrenadeHint>
{
public:
    void Tick(int buttons);
    void View();
    void Paint();

private:
    void Setup(C_BasePlayer* pl, Vector& vecSrc, Vector& vecThrow, const QAngle& angEyeAngles);
    void Simulate(QAngle& Angles, C_BasePlayer* pLocal);
    int Step(Vector& vecSrc, Vector& vecThrow, int tick, float interval);
    bool CheckDetonate(const Vector& vecThrow, const trace_t& tr, int tick, float interval);
    void TraceHull(Vector& src, Vector& end, trace_t& tr);
    void AddGravityMove(Vector& move, Vector& vel, float frametime, bool onground);
    void PushEntity(Vector& src, const Vector& move, trace_t& tr);
    void ResolveFlyCollisionCustom(trace_t& tr, Vector& vecVelocity, float interval);
    int PhysicsClipVelocity(const Vector& in, const Vector& normal, Vector& out, float overbounce);
    void Draw3dCube(float scalar, QAngle angles, Vector middle_origin, Color outline);

    enum
    {
        ACT_NONE,
        ACT_LOB,
        ACT_DROP,
        ACT_THROW
    };

    int act = 0;
    int type = 0;
    std::vector<Vector> path;
    std::vector<std::pair<Vector, QAngle>> OtherCollisions;
    Color TracerColor = Color(105, 158, 244, 255);
    bool firegrenade_didnt_hit = false;
};

А вот

Спойлер: GrenadeTrajectory.cpp

#include "GrenadeTrajectory.h"

#include "visuals.hpp"
#include "../Settings.h"
#include "../options.hpp"
#include "../valve_sdk/csgostructs.hpp"
#include "../helpers/math.hpp"
#include "../helpers/utils.hpp"
#include "../valve_sdk/sdk.hpp"
#include <iostream>
#include <iomanip>
#include <cmath>
#include <limits>
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#endif

#define Assert( _exp ) ((void)0)

void GrenadeHint::Tick(int buttons)
{
//if (!g_Options.GrenadeTra)
// return;

bool in_attack = (buttons & IN_ATTACK);
bool in_attack2 = (buttons & IN_ATTACK2);

act = (in_attack && in_attack2) ? ACT_DROP :
(in_attack2) ? ACT_THROW :
(in_attack) ? ACT_LOB :
ACT_NONE;
}

void GrenadeHint::View()
{
if (!Settings::Visual::NadeTracerEnabled)
return;

if (!g_LocalPlayer)
return;

auto weapon = g_LocalPlayer->m_hActiveWeapon().Get();
if (!weapon)
return;

if ((weapon->IsGrenade()) && act != ACT_NONE)
{
QAngle Angles;
g_EngineClient->GetViewAngles(Angles);

ClientClass* pWeaponClass = weapon->GetClientClass();
if (!pWeaponClass)
{
type = -1;
Simulate(Angles, g_LocalPlayer);
}
else
{
type = static_cast<int>(pWeaponClass->m_ClassID);
Simulate(Angles, g_LocalPlayer);
}
}
else
{
type = -1;
}
}

inline float CSGO_Armor(float flDamage, int ArmorValue) {
float flArmorRatio = 0.5f;
float flArmorBonus = 0.5f;
if (ArmorValue > 0) {
float flNew = flDamage * flArmorRatio;
float flArmor = (flDamage - flNew) * flArmorBonus;

if (flArmor > static_cast<float>(ArmorValue)) {
flArmor = static_cast<float>(ArmorValue) * (1.f / flArmorBonus);
flNew = flDamage - flArmor;
}

flDamage = flNew;
}
return flDamage;
}

void GrenadeHint::Paint()
{
if (!Settings::Visual::NadeTracerEnabled)
return;

if (!g_LocalPlayer)
return;

auto weapon = g_LocalPlayer->m_hActiveWeapon().Get();
if (!weapon)
return;

if ((type) && path.size() > 1 && act != ACT_NONE && weapon->IsGrenade())
{
Vector ab, cd;
Vector prev = path[0];
for (auto it = path.begin(), end = path.end(); it != end; ++it)
{
if (Math::WorldToScreen(prev, ab) && Math::WorldToScreen(*it, cd))
{
g_VGuiSurface->DrawSetColor(TracerColor);
g_VGuiSurface->DrawLine(ab[0], ab[1], cd[0], cd[1]);
}
prev = *it;
}

for (auto it = OtherCollisions.begin(), end = OtherCollisions.end(); it != end; ++it)
{
GrenadeHint::Draw3dCube(2.f, it->second, it->first, Color(0, 255, 0, 200));
}

GrenadeHint::Draw3dCube(2.f, OtherCollisions.rbegin()->second, OtherCollisions.rbegin()->first, Color(255, 0, 0, 200));

std::string EntName;
auto bestdmg = 0;
static Color redcol = { 255, 0, 0, 255 };
static Color greencol = { 25, 255, 25, 255 };
static Color yellowgreencol = { 177, 253, 2, 255 };
static Color yellowcol = { 255, 255, 0, 255 };
static Color orangecol = { 255, 128, 0, 255 };
static Color white = { 255,2555,255 };
Color *BestColor = &redcol;

Vector endpos = path[path.size() - 1];
Vector absendpos = endpos;

float totaladded = 0.0f;

while (totaladded < 30.0f) {
if (g_EngineTrace->GetPointContents(endpos) == CONTENTS_EMPTY)
break;

totaladded += 2.0f;
endpos.z += 2.0f;
}

C_BaseCombatWeapon* pWeapon = g_LocalPlayer->m_hActiveWeapon().Get();
auto weapon = g_LocalPlayer->m_hActiveWeapon();
int weap_id = weapon->m_Item().m_iItemDefinitionIndex();

if (pWeapon &&
weap_id == WEAPON_HEGRENADE ||
weap_id == WEAPON_MOLOTOV ||
weap_id == WEAPON_INC) {
for (int i = 1; i < 64; i++) {
C_BasePlayer *pEntity = (C_BasePlayer*)g_EntityList->GetClientEntity(i);


if (!pEntity || pEntity->m_iTeamNum() == g_LocalPlayer->m_iTeamNum())
continue;

float dist = (pEntity->m_vecOrigin() - endpos).Length();

if (dist < 350.0f) {
CTraceFilter filter;
filter.pSkip = g_LocalPlayer;
Ray_t ray;
Vector NadeScreen;
Math::WorldToScreen(endpos, NadeScreen);

Vector vPelvis = pEntity->GetBonePos(HITBOX_PELVIS);
ray.Init(endpos, vPelvis);
trace_t ptr;
g_EngineTrace->TraceRay(ray, MASK_SHOT, &filter, &ptr);

if (ptr.hit_entity == pEntity) {
Vector PelvisScreen;

Math::WorldToScreen(vPelvis, PelvisScreen);

static float a = 105.0f;
static float b = 25.0f;
static float c = 140.0f;

float d = ((((pEntity->m_vecOrigin()) - prev).Length() - b) / c);
float flDamage = a * exp(-d * d);
auto dmg = max(static_cast<int>(ceilf(CSGO_Armor(flDamage, pEntity->m_ArmorValue()))), 0);

Color *destcolor = dmg >= 65 ? &redcol : dmg >= 40 ? &orangecol : dmg >= 20 ? &white : &greencol;

if (dmg > bestdmg)
{
EntName = pEntity->GetName();
BestColor = destcolor;
bestdmg = dmg;
}
}
}
}
}

if (bestdmg > 0.f) {
if (weap_id != WEAPON_HEGRENADE || WEAPON_MOLOTOV || WEAPON_INC)
{
if (Math::WorldToScreen(prev, cd))
VGSHelper::Get().DrawText(firegrenade_didnt_hit ? "No collisions" : (EntName + " will be burnt."), cd.x, cd.y - 10, *BestColor);
//Visuals::DrawString(esp_font, cd[0], cd[1] - 10, *BestColor, FONT_CENTER, firegrenade_didnt_hit ? "No collisions" : (EntName + " will be burnt.").c_str());
}
else
{
if (Math::WorldToScreen(*path.begin(), cd))
VGSHelper::Get().DrawText(("Most damage dealt to: " + EntName + " -" + std::to_string(bestdmg)), cd.x, cd.y - 10, *BestColor);
//Visuals::DrawString(esp_font, cd[0], cd[1] - 10, *BestColor, FONT_CENTER, ("Most damage dealt to: " + EntName + " -" + std::to_string(bestdmg)).c_str());
}
}
}
}

void GrenadeHint::Setup(C_BasePlayer* pl, Vector& vecSrc, Vector& vecThrow, const QAngle& angEyeAngles)
{
QAngle angThrow = angEyeAngles;
float pitch = angThrow.pitch;

if (pitch <= 90.0f)
{
if (pitch < -90.0f)
{
pitch += 360.0f;
}
}
else
{
pitch -= 360.0f;
}
float a = pitch - (90.0f - fabs(pitch)) * 10.0f / 90.0f;
angThrow.pitch = a;

// Gets ThrowVelocity from weapon files
// Clamped to [15,750]
float flVel = 750.0f * 0.9f;

// Do magic on member of grenade object [esi+9E4h]
// m1=1 m1+m2=0.5 m2=0
static const float power[] = { 1.0f, 1.0f, 0.5f, 0.0f };
float b = power[act];
// Clamped to [0,1]
b = b * 0.7f;
b = b + 0.3f;
flVel *= b;

Vector vForward, vRight, vUp;
Math::AngleVectors(angThrow, vForward, vRight, vUp);

vecSrc = pl->m_vecOrigin();
vecSrc += pl->m_vecViewOffset();
float off = (power[act] * 12.0f) - 12.0f;
vecSrc.z += off;

// Game calls UTIL_TraceHull here with hull and assigns vecSrc tr.endpos
trace_t tr;
Vector vecDest = vecSrc;
vecDest.MulAdd(vecDest, vForward, 22.0f);
TraceHull(vecSrc, vecDest, tr);

// After the hull trace it moves 6 units back along vForward
// vecSrc = tr.endpos - vForward * 6
Vector vecBack = vForward; vecBack *= 6.0f;
vecSrc = tr.endpos;
vecSrc -= vecBack;

// Finally calculate velocity
vecThrow = pl->m_vecVelocity(); vecThrow *= 1.25f;
vecThrow.MulAdd(vecThrow, vForward, flVel);
}

void GrenadeHint::Simulate(QAngle& Angles, C_BasePlayer* pLocal)
{
Vector vecSrc, vecThrow;
Setup(pLocal, vecSrc, vecThrow, Angles);

float interval = g_GlobalVars->interval_per_tick;

// Log positions 20 times per sec
int logstep = static_cast<int>(0.05f / interval);
int logtimer = 0;

path.clear();
OtherCollisions.clear();
TracerColor = Settings::Visual::NadeTracerColor;
for (unsigned int i = 0; i < path.max_size() - 1; ++i)
{
if (!logtimer)
path.push_back(vecSrc);

int s = Step(vecSrc, vecThrow, i, interval);
if ((s & 1) || vecThrow == Vector(0, 0, 0))
break;

// Reset the log timer every logstep OR we bounced
if ((s & 2) || logtimer >= logstep) logtimer = 0;
else ++logtimer;
}
path.push_back(vecSrc);
}

int GrenadeHint::Step(Vector& vecSrc, Vector& vecThrow, int tick, float interval)
{
// Apply gravity
Vector move;
AddGravityMove(move, vecThrow, interval, false);

// Push entity
trace_t tr;
PushEntity(vecSrc, move, tr);

int result = 0;
// Check ending conditions
if (CheckDetonate(vecThrow, tr, tick, interval))
{
result |= 1;
}

// Resolve collisions
if (tr.fraction != 1.0f)
{
result |= 2; // Collision!
ResolveFlyCollisionCustom(tr, vecThrow, interval);
}

if (tr.hit_entity && ((C_BasePlayer*)tr.hit_entity)->IsPlayer())
{
TracerColor = Color(255, 0, 0, 255);
}

if ((result & 1) || vecThrow == Vector(0, 0, 0) || tr.fraction != 1.0f)
{
QAngle angles;
Math::VectorAngles((tr.endpos - tr.startpos).Normalized(), angles);
OtherCollisions.push_back(std::make_pair(tr.endpos, angles));
}

// Set new position
vecSrc = tr.endpos;

return result;
}

bool GrenadeHint::CheckDetonate(const Vector& vecThrow, const trace_t& tr, int tick, float interval)
{
firegrenade_didnt_hit = false;
switch (type)
{
case (int)ClassId::CSmokeGrenade:
case (int)ClassId::CDecoyGrenade:
// Velocity must be <0.1, this is only checked every 0.2s
if (vecThrow.Length() < 0.1f)
{
int det_tick_mod = static_cast<int>(0.2f / interval);
return !(tick%det_tick_mod);
}
return false;

/* TIMES AREN'T COMPLETELY RIGHT FROM WHAT I'VE SEEN ! ! ! */
case (int)ClassId::CMolotovGrenade:
case (int)ClassId::CIncendiaryGrenade:
// Detonate when hitting the floor
if (tr.fraction != 1.0f && tr.plane.normal.z > 0.7f)
return true;
// OR we've been flying for too long

case (int)ClassId::CFlashbang:
case (int)ClassId::CHEGrenade:
{
// Pure timer based, detonate at 1.5s, checked every 0.2s
firegrenade_didnt_hit = static_cast<float>(tick)*interval > 1.5f && !(tick%static_cast<int>(0.2f / interval));
return firegrenade_didnt_hit;
}
default:
Assert(false);
return false;
}
}

void GrenadeHint::TraceHull(Vector& src, Vector& end, trace_t& tr)
{
// Setup grenade hull
static const Vector hull[2] = { Vector(-2.0f, -2.0f, -2.0f), Vector(2.0f, 2.0f, 2.0f) };

CTraceFilter filter;
filter.SetIgnoreClass("BaseCSGrenadeProjectile");
filter.pSkip = g_EntityList->GetClientEntity(g_EngineClient->GetLocalPlayer());

Ray_t ray;
ray.Init(src, end, hull[0], hull[1]);

const unsigned int mask = 0x200400B;
g_EngineTrace->TraceRay(ray, mask, &filter, &tr);
}

void GrenadeHint::AddGravityMove(Vector& move, Vector& vel, float frametime, bool onground)
{
Vector basevel(0.0f, 0.0f, 0.0f);

move.x = (vel.x + basevel.x) * frametime;
move.y = (vel.y + basevel.y) * frametime;

if (onground)
{
move.z = (vel.z + basevel.z) * frametime;
}
else
{
// Game calls GetActualGravity( this );
float gravity = 800.0f * 0.4f;

float newZ = vel.z - (gravity * frametime);
move.z = ((vel.z + newZ) / 2.0f + basevel.z) * frametime;

vel.z = newZ;
}
}

void GrenadeHint::PushEntity(Vector& src, const Vector& move, trace_t& tr)
{
Vector vecAbsEnd = src;
vecAbsEnd += move;

// Trace through world
TraceHull(src, vecAbsEnd, tr);
}

void GrenadeHint::ResolveFlyCollisionCustom(trace_t& tr, Vector& vecVelocity, float interval)
{
// Calculate elasticity
float flSurfaceElasticity = 1.0; // Assume all surfaces have the same elasticity
float flGrenadeElasticity = 0.45f; // GetGrenadeElasticity()
float flTotalElasticity = flGrenadeElasticity * flSurfaceElasticity;
if (flTotalElasticity > 0.9f) flTotalElasticity = 0.9f;
if (flTotalElasticity < 0.0f) flTotalElasticity = 0.0f;

// Calculate bounce
Vector vecAbsVelocity;
PhysicsClipVelocity(vecVelocity, tr.plane.normal, vecAbsVelocity, 2.0f);
vecAbsVelocity *= flTotalElasticity;

// Stop completely once we move too slow
float flSpeedSqr = vecAbsVelocity.LengthSqr();
static const float flMinSpeedSqr = 20.0f * 20.0f; // 30.0f * 30.0f in CSS
if (flSpeedSqr < flMinSpeedSqr)
vecAbsVelocity.Zero();

// Stop if on ground
if (tr.plane.normal.z > 0.7f)
{
vecVelocity = vecAbsVelocity;
vecAbsVelocity.Mul((1.0f - tr.fraction) * interval);
PushEntity(tr.endpos, vecAbsVelocity, tr);
}
else
{
vecVelocity = vecAbsVelocity;
}
}

int GrenadeHint::PhysicsClipVelocity(const Vector& in, const Vector& normal, Vector& out, float overbounce)
{
static const float STOP_EPSILON = 0.1f;

float backoff;
float change;
float angle;
int i, blocked;

blocked = 0;

angle = normal[2];

if (angle > 0)
{
blocked |= 1; // floor
}
if (!angle)
{
blocked |= 2; // step
}

backoff = in.Dot(normal) * overbounce;

for (i = 0; i < 3; i++)
{
change = normal * backoff;
out = in - change;
if (out > -STOP_EPSILON && out < STOP_EPSILON)
{
out = 0;
}
}

return blocked;
}

void GrenadeHint::Draw3dCube(float scalar, QAngle angles, Vector middle_origin, Color outline)
{
Vector forward, right, up;
Math::AngleVectors(angles, forward, right, up);

Vector points[8];
points[0] = middle_origin - (right * scalar) + (up * scalar) - (forward * scalar); // BLT
points[1] = middle_origin + (right * scalar) + (up * scalar) - (forward * scalar); // BRT
points[2] = middle_origin - (right * scalar) - (up * scalar) - (forward * scalar); // BLB
points[3] = middle_origin + (right * scalar) - (up * scalar) - (forward * scalar); // BRB

points[4] = middle_origin - (right * scalar) + (up * scalar) + (forward * scalar); // FLT
points[5] = middle_origin + (right * scalar) + (up * scalar) + (forward * scalar); // FRT
points[6] = middle_origin - (right * scalar) - (up * scalar) + (forward * scalar); // FLB
points[7] = middle_origin + (right * scalar) - (up * scalar) + (forward * scalar); // FRB

Vector points_screen[8];
for (int i = 0; i < 8; i++)
if (!Math::WorldToScreen(points, points_screen))
return;

g_VGuiSurface->DrawSetColor(outline);

// Back frame
g_VGuiSurface->DrawLine(points_screen[0].x, points_screen[0].y, points_screen[1].x, points_screen[1].y);
g_VGuiSurface->DrawLine(points_screen[0].x, points_screen[0].y, points_screen[2].x, points_screen[2].y);
g_VGuiSurface->DrawLine(points_screen[3].x, points_screen[3].y, points_screen[1].x, points_screen[1].y);
g_VGuiSurface->DrawLine(points_screen[3].x, points_screen[3].y, points_screen[2].x, points_screen[2].y);

// Frame connector
g_VGuiSurface->DrawLine(points_screen[0].x, points_screen[0].y, points_screen[4].x, points_screen[4].y);
g_VGuiSurface->DrawLine(points_screen[1].x, points_screen[1].y, points_screen[5].x, points_screen[5].y);
g_VGuiSurface->DrawLine(points_screen[2].x, points_screen[2].y, points_screen[6].x, points_screen[6].y);
g_VGuiSurface->DrawLine(points_screen[3].x, points_screen[3].y, points_screen[7].x, points_screen[7].y);

// Front frame
g_VGuiSurface->DrawLine(points_screen[4].x, points_screen[4].y, points_screen[5].x, points_screen[5].y);
g_VGuiSurface->DrawLine(points_screen[4].x, points_screen[4].y, points_screen[6].x, points_screen[6].y);
g_VGuiSurface->DrawLine(points_screen[7].x, points_screen[7].y, points_screen[5].x, points_screen[5].y);
g_VGuiSurface->DrawLine(points_screen[7].x, points_screen[7].y, points_screen[6].x, points_screen[6].y);
}

 

[Сutie]

1. Берёшь сурс grenade prediction например от саблима
2. Меняешь под своё sdk.