#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:

rocess_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;
}