Welcome to hackvshack.net Forum!
Download Free HvH CS2/CS:GO Cheats, CFG, LUA/JS Scripts, and More!
Register

C++ Cheat neverlose dumped extrapolation

this should be the code
double_tap.cpp:
#include "double_tap.h"
#include <cmath>
#include <algorithm>
extern uintptr_t get_netvar_offset(const char* table, const char* prop);
extern uint32_t get_weapon_data_ptr(void* weapon);
extern float read_float(uintptr_t address);
extern int32_t read_int32(uintptr_t address);
extern uint8_t read_uint8(uintptr_t address);
extern void* get_active_weapon(void* player);
extern float get_server_time(void* player);
static uintptr_t m_nTickBase = 0;
static uintptr_t m_nNextPrimaryAttackTick = 0;
static uintptr_t m_flNextPrimaryAttackTickRatio = 0;
static uintptr_t m_iClip1 = 0;
static uintptr_t m_bInReload = 0;
static uintptr_t m_flCycleTime = 0;
constexpr int32_t MAX_SHIFT_TICKS = 16;
constexpr float TICK_BASE_SCALAR = 1.0f / TICK_INTERVAL;
void init_netvars() {
if (m_nTickBase == 0) {
m_nTickBase = get_netvar_offset("C_BasePlayer", "m_nTickBase");
m_nNextPrimaryAttackTick = get_netvar_offset("C_BasePlayerWeapon", "m_nNextPrimaryAttackTick");
m_flNextPrimaryAttackTickRatio = get_netvar_offset("C_BasePlayerWeapon", "m_flNextPrimaryAttackTickRatio");
m_iClip1 = get_netvar_offset("C_BaseCombatWeapon", "m_iClip1");
m_bInReload = get_netvar_offset("C_BaseCombatWeapon", "m_bInReload");
}
}
void CDoubleTap::update_state(void* player, void* weapon) {
init_netvars();

if (!player || !weapon) {
state_.ready = false;
return;
}

if (!config_.enabled) {
state_.ready = false;
state_.charging = false;
return;
}

int32_t tickbase = read_int32((uintptr_t)player + m_nTickBase);
int32_t next_attack_tick = read_int32((uintptr_t)weapon + m_nNextPrimaryAttackTick);
float next_attack_ratio = read_float((uintptr_t)weapon + m_flNextPrimaryAttackTickRatio);

float server_time = get_server_time(player);
float next_attack_time = (float)next_attack_tick * TICK_INTERVAL + next_attack_ratio * TICK_INTERVAL;

state_.current_time = server_time;
state_.next_attack_time = next_attack_time;

bool can_attack_now = server_time >= next_attack_time;
bool has_bullets = has_ammo(weapon);
bool not_reloading = !is_reloading(weapon);

if (!can_attack_now || !has_bullets || !not_reloading) {
if (state_.charge_available > 0 && can_attack_now) {
state_.charging = false;
state_.ready = true;
} else {
state_.ready = false;
if (config_.auto_recharge) {
state_.charging = true;
}
}
return;
}

calculate_shift(player, weapon);

int32_t tick_diff = next_attack_tick - tickbase;

if (tick_diff >= config_.shift_ticks) {
if (state_.charge_available < config_.shift_ticks) {
state_.charging = true;
state_.charge_available++;
} else {
state_.charging = false;
state_.ready = true;
}
} else if (tick_diff > 1) {
state_.charging = true;
if (state_.charge_available < tick_diff - 1) {
state_.charge_available++;
}
}

state_.can_shift = (state_.charge_available >= config_.shift_ticks);
}
bool CDoubleTap::has_ammo(void* weapon) const {
if (!weapon) return false;
int32_t clip = read_int32((uintptr_t)weapon + m_iClip1);
return clip > 1;
}
bool CDoubleTap::is_reloading(void* weapon) const {
if (!weapon) return false;
return read_uint8((uintptr_t)weapon + m_bInReload) != 0;
}
void CDoubleTap::calculate_shift(void* player, void* weapon) {
if (!player || !weapon) {
state_.shift_amount = 0;
state_.can_shift = false;
return;
}

uint32_t weapon_data = get_weapon_data_ptr(weapon);
if (weapon_data == 0) {
state_.shift_amount = 0;
state_.can_shift = false;
return;
}

int32_t tickbase = read_int32((uintptr_t)player + m_nTickBase);
int32_t next_attack_tick = read_int32((uintptr_t)weapon + m_nNextPrimaryAttackTick);

int32_t ticks_until_can_fire = next_attack_tick - tickbase;

int32_t desired_shift = std::min(config_.shift_ticks, MAX_SHIFT_TICKS);

if (ticks_until_can_fire >= desired_shift) {
state_.shift_amount = desired_shift;
state_.max_charge = desired_shift;
} else if (ticks_until_can_fire > 0) {
state_.shift_amount = ticks_until_can_fire;
state_.max_charge = ticks_until_can_fire;
} else {
state_.shift_amount = 0;
state_.max_charge = desired_shift;
}
}
bool CDoubleTap::can_double_tap() const {
return config_.enabled &&
state_.ready &&
state_.can_shift &&
state_.charge_available >= config_.shift_ticks;
}
bool CDoubleTap::should_shift_tickbase() const {
return can_double_tap();
}
int32_t CDoubleTap::get_shift_amount() const {
if (!should_shift_tickbase()) return 0;
return std::min(state_.shift_amount, state_.charge_available);
}
void CDoubleTap::process_command(UserCmd* cmd, void* player, void* weapon) {
if (!cmd || !player || !weapon) return;

update_state(player, weapon);

if (cmd->command_number != last_command_number_) {
command_history_.push_back(cmd->command_number);
if (command_history_.size() > 150) {
command_history_.erase(command_history_.begin());
}
last_command_number_ = cmd->command_number;
}

if (should_shift_tickbase() && (cmd->buttons & (1 << 0))) {
int32_t shift = get_shift_amount();

state_.charge_available = 0;
state_.ready = false;
state_.charging = true;
state_.recharging = true;

shift_tickbase_by(cmd, shift);
}
}
void CDoubleTap::shift_tickbase_by(UserCmd* cmd, int32_t shift_amount) {
if (!cmd || shift_amount <= 0) return;
cmd->tick_count -= shift_amount;
}
void CDoubleTap::reset_charge() {
state_.charge_available = 0;
state_.ready = false;
state_.charging = true;
state_.recharging = true;
}
double_tap.h
#pragma once
#include "types.h"
#include <vector>
struct TickbaseShiftState {
bool ready;
bool charging;
bool recharging;
int32_t shift_amount;
int32_t charge_available;
int32_t max_charge;
float next_attack_time;
float current_time;
int32_t weapon_mode;
bool can_shift;
bool permission_granted;
};
struct DoubleTapConfig {
bool enabled;
int32_t shift_ticks;
bool auto_recharge;
bool defensive_mode;
bool wait_for_peek;
};
class CDoubleTap {
public:
void update_state(void* player, void* weapon);
bool can_double_tap() const;
bool should_shift_tickbase() const;
int32_t get_shift_amount() const;
void process_command(UserCmd* cmd, void* player, void* weapon);
void reset_charge();
bool is_ready() const { return state_.ready; }
bool is_charging() const { return state_.charging; }
int32_t get_charge() const { return state_.charge_available; }

void set_config(const DoubleTapConfig& cfg) { config_ = cfg; }
const DoubleTapConfig& get_config() const { return config_; }
const TickbaseShiftState& get_state() const { return state_; }
private:
bool has_ammo(void* weapon) const;
bool is_reloading(void* weapon) const;
void calculate_shift(void* player, void* weapon);
void shift_tickbase_by(UserCmd* cmd, int32_t shift_amount);

TickbaseShiftState state_;
DoubleTapConfig config_;
int32_t last_command_number_;
std::vector<int32_t> command_history_;
};
void angle_to_vector(const QAngle& angles, Vec3* forward);
void calculate_spread_angle(void* weapon, int32_t seed, float* x, float* y);
int32_t calculate_server_seed(int32_t client_command);
 
I don't know why, but whenever it's a tickbase shift type double tap, it’s always useless for me and I can never get the second shot off.
prob ur attack button getting cleared after u shift or ur using player->m_nTickBase instead of server tick which desyncs. also make sure weapon is already past m_nNextPrimaryAttackTick before u shift and nothing else in ur hook is touching the cmd after. most failed dt is just the button not being set when command actually sends or shifting before weapon is ready
 
so im currently decompiling features from neverlose free and posting here for pasters or sum , anyways , some shit might be wrong , im using claude to reverse it.
theres no neverlose free its a velocity with ported features
 
so im currently decompiling features from neverlose free and posting here for pasters or sum , anyways , some shit might be wrong , im using claude to reverse it.
Coud u decomp the movement and skinchager mainly the airstrafe bc it works on nixware maps
 
prob ur attack button getting cleared after u shift or ur using player->m_nTickBase instead of server tick which desyncs. also make sure weapon is already past m_nNextPrimaryAttackTick before u shift and nothing else in ur hook is touching the cmd after. most failed dt is just the button not being set when command actually sends or shifting before weapon is ready
i am use DEEPSEEK to dump neverwin all source. maybe it can 100% source
 

Who has read this thread (Total: 1) in last 1 hours View details