-- Advanced Resolver Helper for GameSense.

pub

-- Define resolver settings in the menu

local resolver_enabled = ui.new_checkbox("Rage", "Other", "Enable Enhanced
Resolver")
local resolver_debug = ui.new_checkbox("Rage", "Other", "Enhanced Resolver Debug")
local resolver_mode = ui.new_combobox("Rage", "Other", "Enhanced Resolver Mode",
"Standard", "Adaptive", "Experimental", "Advanced", "Predictive", "State",
"Custom")
local resolver_iterations = ui.new_slider("Rage", "Other", "Enhanced Resolver
Iterations", 1, 10, 1, true, "", 1)
local resolver_backtrack = ui.new_checkbox("Rage", "Other", "Enable Enhanced
Backtracking")
local resolver_predictive = ui.new_checkbox("Rage", "Other", "Enable Enhanced
Predictive Adjustments")
local resolver_spin = ui.new_checkbox("Rage", "Other", "Enable Spin Resolver")
local resolver_fakelag = ui.new_checkbox("Rage", "Other", "Enable Fake Lag
Resolver")
local resolver_desync = ui.new_checkbox("Rage", "Other", "Enable Desync Resolver")
local resolver_delay = ui.new_slider("Rage", "Other", "Resolver Delay (ms)", 0,
1000, 0, true, "ms", 1)
local resolver_complexity = ui.new_slider("Rage", "Other", "Resolver Complexity",
1, 100, 50, true, "", 1)

-- Cached data for resolver logic

local cached_yaw = {}
local cached_lby = {}
local player_states = {}
local shot_history = {}
local desync_cache = {}
local last_resolved_time = {}
local last_shot_time = {}
local last_hit_time = {}
local last_miss_time = {}
local last_desync_time = {}
local last_spin_time = {}
local last_fakelag_time = {}
local last_backtrack_time = {}
local last_predictive_time = {}
local last_complex_time = {}
local last_custom_time = {}

-- Utility functions
local function normalize_angle(angle)
while angle > 180 do angle = angle - 360 end
while angle < -180 do angle = angle + 360 end
return angle
end

local function calculate_delta(angle1, angle2)

if angle1 == nil or angle2 == nil then
return 0
end
return [Link](normalize_angle(angle1 - angle2))
end

local function get_max_desync_delta(player)

return (entity.get_prop(player, "m_flPoseParameter", 11) * 58) + 0.5
end
local function update_player_state(player)
if not player_states[player] then
player_states[player] = { shots_fired = 0, hits = 0, misses = 0,
desync_detected = false, last_yaw = nil }
end
end

local function log_debug(message)

if [Link](resolver_debug) then
[Link](message)
end
end

local function log_resolver(player, mode, yaw)

if [Link](resolver_debug) then
log_debug("Resolved Player: " .. player .. " Yaw: " .. yaw .. " Mode: " ..
mode)
end
end

local function get_random_factor()

return [Link]() * [Link](resolver_complexity) / 100
end

-- Resolver logic
local function resolve_standard(player)
local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")

local yaw_delta = calculate_delta(player_yaw, cached_yaw[player])

local lby_delta = calculate_delta(player_lby, cached_lby[player])

if yaw_delta > 35 then

local new_yaw = normalize_angle(player_yaw + get_max_desync_delta(player))
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
else
entity.set_prop(player, "m_angEyeAngles[1]", player_lby)
end

cached_yaw[player] = player_yaw
cached_lby[player] = player_lby

log_resolver(player, "Standard", player_yaw)

end

local function resolve_adaptive(player)

local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")
local velocity = {entity.get_prop(player, "m_vecVelocity[0]"),
entity.get_prop(player, "m_vecVelocity[1]")}
local speed = [Link](velocity[1]^2 + velocity[2]^2)
local max_desync = get_max_desync_delta(player)

if speed > 5 then

local movement_angle = math.atan2(velocity[2], velocity[1]) * (180 /
[Link])
local new_yaw = normalize_angle(movement_angle + max_desync * 0.6)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
 elseif calculate_delta(player_yaw, player_lby) > 35 then
local new_yaw = normalize_angle(player_yaw + max_desync * 0.75)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
else
entity.set_prop(player, "m_angEyeAngles[1]", player_lby)
end

cached_yaw[player] = player_yaw
cached_lby[player] = player_lby
end

local function resolve_experimental(player)

local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")

local yaw_delta = calculate_delta(player_yaw, cached_yaw[player])

local lby_delta = calculate_delta(player_lby, cached_lby[player])

if yaw_delta > 35 then

local max_desync = get_max_desync_delta(player)
local iterations = [Link](resolver_iterations)

for i = 1, iterations do
local new_yaw = normalize_angle(player_yaw + (i * (max_desync /
iterations)))
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
end
else
entity.set_prop(player, "m_angEyeAngles[1]", player_lby)
end

cached_yaw[player] = player_yaw
cached_lby[player] = player_lby

log_resolver(player, "Experimental", player_yaw)

end

local function resolve_advanced(player)

local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")
local max_desync = get_max_desync_delta(player)
local yaw_delta = calculate_delta(player_yaw, cached_yaw[player])
local lby_delta = calculate_delta(player_lby, cached_lby[player])

if yaw_delta > 35 then

local new_yaw = normalize_angle(player_yaw + max_desync * 0.75)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
elseif lby_delta > 35 then
local new_yaw = normalize_angle(player_lby + max_desync * 0.75)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
else
entity.set_prop(player, "m_angEyeAngles[1]", player_lby)
end

cached_yaw[player] = player_yaw
cached_lby[player] = player_lby

log_resolver(player, "Advanced", player_yaw)

end
local function resolve_predictive(player)
local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]") or 0
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget") or 0
local velocity_x, velocity_y = entity.get_prop(player, "m_vecVelocity[0]"),
entity.get_prop(player, "m_vecVelocity[1]")
local speed = [Link](velocity_x^2 + velocity_y^2)
local max_desync = get_max_desync_delta(player)

if speed > 0.1 then

-- Расчет направления движения
local movement_angle = math.atan2(velocity_y, velocity_x) * (180 / [Link])
local predicted_angle = normalize_angle(movement_angle + (speed * 0.1)) --
Добавляем компенсацию за движение
local new_yaw = normalize_angle(predicted_angle + (max_desync * 0.5)) --
Применяем часть десинка
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)

elseif calculate_delta(player_yaw, player_lby) > 45 then

-- Обработка большого дельты между Yaw и LBY
local predicted_yaw = normalize_angle(player_yaw + ((player_yaw -
(cached_yaw[player] or player_yaw)) * 0.7))
local new_yaw = normalize_angle(predicted_yaw + (max_desync * 0.6)) --
Применяем больше десинка
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)

else
-- Возвращаем к нижней части тела, если нет движения и небольшой дельта
local new_yaw = normalize_angle(player_lby + (max_desync * 0.3)) --
Небольшая компенсация десинка
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
end

-- Кеширование значений для следующего расчета

cached_yaw[player] = player_yaw
cached_lby[player] = player_lby
end

local function resolve_complex(player)

local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")
local max_desync = get_max_desync_delta(player)
local yaw_delta = calculate_delta(player_yaw, cached_yaw[player])
local lby_delta = calculate_delta(player_lby, cached_lby[player])
local random_factor = get_random_factor()

if yaw_delta > 35 then

local new_yaw = normalize_angle(player_yaw + max_desync * random_factor)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
elseif lby_delta > 35 then
local new_yaw = normalize_angle(player_lby + max_desync * random_factor)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
else
entity.set_prop(player, "m_angEyeAngles[1]", player_lby)
end

cached_yaw[player] = player_yaw
cached_lby[player] = player_lby
 log_resolver(player, "Complex", player_yaw)
end

-- Continued from previous script...

-- Custom Resolver
local function resolve_custom(player)
local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")
local max_desync = get_max_desync_delta(player)
local yaw_delta = calculate_delta(player_yaw, cached_yaw[player])
local lby_delta = calculate_delta(player_lby, cached_lby[player])
local random_factor = get_random_factor()

if yaw_delta > 35 then

local new_yaw = normalize_angle(player_yaw + max_desync * random_factor)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
elseif lby_delta > 35 then
local new_yaw = normalize_angle(player_lby + max_desync * random_factor)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
else
local new_yaw = normalize_angle(player_yaw + (max_desync * random_factor /
2))
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
end

cached_yaw[player] = player_yaw
cached_lby[player] = player_lby

log_resolver(player, "Custom", player_yaw)

end

-- Main resolver function

local function resolver(player)
local resolver_type = [Link](resolver_mode)

if resolver_type == "Standard" then

resolve_standard(player)
elseif resolver_type == "Adaptive" then
resolve_adaptive(player)
elseif resolver_type == "Experimental" then
resolve_experimental(player)
elseif resolver_type == "Advanced" then
resolve_advanced(player)
elseif resolver_type == "Predictive" then
resolve_predictive(player)
elseif resolver_type == "State" then
resolve_complex(player)
elseif resolver_type == "Custom" then
resolve_custom(player)
end
end

local backtrack_cache = {}

-- Backtrack Resolver
local function backtrack_enemy(player)
if not backtrack_cache[player] then
backtrack_cache[player] = {}
 end

-- Add the current simulation time to the backtrack cache

[Link](backtrack_cache[player], entity.get_prop(player,
"m_flSimulationTime"))

-- Limit the size of the cache (for example, keep the last 5 records)
if #backtrack_cache[player] > 5 then
[Link](backtrack_cache[player], 1)
end

-- Implement your backtracking logic here

local last_record = backtrack_cache[player][#backtrack_cache[player]]
if last_record then
entity.set_prop(player, "m_flSimulationTime", last_record)
end
end

-- Predictive Resolver
local function predictive_resolver(player)
local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")
local velocity = { entity.get_prop(player, "m_vecVelocity[0]"),
entity.get_prop(player, "m_vecVelocity[1]") }
local velocity_length = [Link](velocity[1]^2 + velocity[2]^2)

if velocity_length > 0.1 then

local new_yaw = normalize_angle(player_yaw + (velocity_length / 10))
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
else
entity.set_prop(player, "m_angEyeAngles[1]", player_lby)
end
end

-- Spin Resolver
local function spin_resolver(player)
local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local spin_angle = ([Link]() % 360)
local new_yaw = normalize_angle(player_yaw + spin_angle)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
end

-- Fake Lag Resolver

local function fakelag_resolver(player)
local player_velocity = { entity.get_prop(player, "m_vecVelocity[0]"),
entity.get_prop(player, "m_vecVelocity[1]") }
local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local velocity_length = [Link](player_velocity[1]^2 + player_velocity[2]^2)

if velocity_length < 5 then

local new_yaw = normalize_angle(player_yaw + get_max_desync_delta(player))
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
end
end

-- Desync Resolver
local function desync_resolver(player)
local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local desync_delta = get_max_desync_delta(player)
 if desync_cache[player] then
local previous_desync = desync_cache[player]
local desync_change = [Link](desync_delta - previous_desync)

if desync_change > 10 then

local new_yaw = normalize_angle(player_yaw + desync_change)
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
end
end

desync_cache[player] = desync_delta
end

-- Advanced Anti-Aim Handling

local function resolve_advanced_aim(player)
local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")
local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")

local max_desync = get_max_desync_delta(player)

local random_factor = get_random_factor()

if calculate_delta(player_yaw, player_lby) > 35 then

local new_yaw = normalize_angle(player_yaw + (max_desync * random_factor))
entity.set_prop(player, "m_angEyeAngles[1]", new_yaw)
else
entity.set_prop(player, "m_angEyeAngles[1]", player_lby)
end

cached_yaw[player] = player_yaw
cached_lby[player] = player_lby

log_resolver(player, "Advanced Aim", player_yaw)

end

-- Event to trigger advanced anti-aim handling

client.set_event_callback("paint", function()
if [Link](resolver_enabled) then
local players = entity.get_players(true)
for i = 1, #players do
local player = players[i]
resolver(player)
resolve_advanced_aim(player) -- Call the advanced aim resolver
if [Link](resolver_backtrack) then
backtrack_enemy(player)
end
if [Link](resolver_predictive) then
predictive_resolver(player)
end
if [Link](resolver_spin) then
spin_resolver(player)
end
if [Link](resolver_fakelag) then
fakelag_resolver(player)
end
if [Link](resolver_desync) then
desync_resolver(player)
end
end
 end
end)

-- Log initialization
[Link]("Advanced Anti-Aim and Lag Compensation Resolver initialized.")
[Link]("Enhanced Resolver script running.")

-- Additional features and debugging

-- Function to track shots fired, hits, and misses

local function track_shots(player, event_type)
if not player_states[player] then
update_player_state(player)
end

if event_type == "fire" then

player_states[player].shots_fired = player_states[player].shots_fired + 1
last_shot_time[player] = [Link]()
log_debug("Shot fired by player: " .. player .. " Total shots: " ..
player_states[player].shots_fired)
elseif event_type == "hit" then
player_states[player].hits = player_states[player].hits + 1
last_hit_time[player] = [Link]()
log_debug("Shot hit by player: " .. player .. " Total hits: " ..
player_states[player].hits)
elseif event_type == "miss" then
player_states[player].misses = player_states[player].misses + 1
last_miss_time[player] = [Link]()
log_debug("Shot missed by player: " .. player .. " Total misses: " ..
player_states[player].misses)
end
end

client.set_event_callback("weapon_fire", function(event)
local player = client.userid_to_entindex([Link])
if player then
track_shots(player, "fire")
end
end)

client.set_event_callback("player_hurt", function(event)
local player = client.userid_to_entindex([Link])
if player then
track_shots(player, "hit")
end
end)

client.set_event_callback("player_death", function(event)
local player = client.userid_to_entindex([Link])
if player then
track_shots(player, "miss")
end
end)

-- Function to track desync

local function track_desync(player)
if not player_states[player] then
update_player_state(player)
end
 local desync_delta = get_max_desync_delta(player)
if desync_delta > 10 then
player_states[player].desync_detected = true
last_desync_time[player] = [Link]()
log_debug("Desync detected for player: " .. player .. " Desync delta: " ..
desync_delta)
else
player_states[player].desync_detected = false
end
end

local function track_spin(player)

if not player_states[player] then
update_player_state(player)
end

local spin_angle = ([Link]() % 360)

if spin_angle > 180 then
player_states[player].spin_detected = true
last_spin_time[player] = [Link]()
log_debug("Spin detected for player: " .. player .. " Spin angle: " ..
spin_angle)
else
player_states[player].spin_detected = false
end
end

local function track_fakelag(player)

if not player_states[player] then
update_player_state(player)
end

local player_velocity = { entity.get_prop(player, "m_vecVelocity[0]"),

entity.get_prop(player, "m_vecVelocity[1]") }
local velocity_length = [Link](player_velocity[1]^2 + player_velocity[2]^2)

if velocity_length < 5 then

player_states[player].fakelag_detected = true
last_fakelag_time[player] = [Link]()
log_debug("Fake lag detected for player: " .. player .. " Velocity length:
" .. velocity_length)
else
player_states[player].fakelag_detected = false
end
end

local function track_backtrack(player)

if not player_states[player] then
update_player_state(player)
end

if backtrack_cache[player] and #backtrack_cache[player] > 0 then

player_states[player].backtrack_detected = true
last_backtrack_time[player] = [Link]()
log_debug("Backtrack detected for player: " .. player .. " Backtrack
records: " .. #backtrack_cache[player])
else
 player_states[player].backtrack_detected = false
end
end

-- Function to track predictive

local function track_predictive(player)
if not player_states[player] then
update_player_state(player)
end

local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")

local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")
local velocity = { entity.get_prop(player, "m_vecVelocity[0]"),
entity.get_prop(player, "m_vecVelocity[1]") }
local velocity_length = [Link](velocity[1]^2 + velocity[2]^2)

if velocity_length > 0.1 then

player_states[player].predictive_detected = true
last_predictive_time[player] = [Link]()
log_debug("Predictive detected for player: " .. player .. " Velocity
length: " .. velocity_length)
else
player_states[player].predictive_detected = false
end
end

local function track_complex(player)

if not player_states[player] then
update_player_state(player)
end

local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")

local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")
local max_desync = get_max_desync_delta(player)
local yaw_delta = calculate_delta(player_yaw, cached_yaw[player])
local lby_delta = calculate_delta(player_lby, cached_lby[player])
local random_factor = get_random_factor()

if yaw_delta > 35 or lby_delta > 35 then

player_states[player].complex_detected = true
last_complex_time[player] = [Link]()
log_debug("Complex detected for player: " .. player .. " Yaw delta: " ..
yaw_delta .. " LBY delta: " .. lby_delta)
else
player_states[player].complex_detected = false
end
end

-- Function to track custom

local function track_custom(player)
if not player_states[player] then
update_player_state(player)
end

local player_yaw = entity.get_prop(player, "m_angEyeAngles[1]")

local player_lby = entity.get_prop(player, "m_flLowerBodyYawTarget")
local max_desync = get_max_desync_delta(player)
local yaw_delta = calculate_delta(player_yaw, cached_yaw[player])
 local lby_delta = calculate_delta(player_lby, cached_lby[player])
local random_factor = get_random_factor()

if yaw_delta > 35 or lby_delta > 35 then

player_states[player].custom_detected = true
last_custom_time[player] = [Link]()
log_debug("Custom detected for player: " .. player .. " Yaw delta: " ..
yaw_delta .. " LBY delta: " .. lby_delta)
else
player_states[player].custom_detected = false
end
end

-- Event to track all features

client.set_event_callback("paint", function()
if [Link](resolver_enabled) then
local players = entity.get_players(true)
for i = 1, #players do
local player = players[i]
track_desync(player)
track_spin(player)
track_fakelag(player)
track_backtrack(player)
track_predictive(player)
track_complex(player)
track_custom(player)
end
end
end)

local ref = {
aimbot = [Link]('RAGE', 'Aimbot', 'Enabled'),
doubletap = {
main = { [Link]('RAGE', 'Aimbot', 'Double tap') },
fakelag_limit = [Link]('RAGE', 'Aimbot', 'Double tap fake lag limit')
}
}

local local_player, callback_reg, dt_charged = nil, false, false

local function check_charge()

local m_nTickBase = entity.get_prop(local_player, 'm_nTickBase')
local client_latency = [Link]()
local shift = [Link](m_nTickBase - [Link]() - 3 -
toticks(client_latency) * .5 + .5 * (client_latency * 10))

local wanted = -14 + ([Link]([Link].fakelag_limit) - 1) + 3 --error

margin

dt_charged = shift <= wanted

end

client.set_event_callback('setup_command', function()
if not [Link]([Link][2]) or not [Link]([Link][1]) then
[Link]([Link], true)

if callback_reg then
client.unset_event_callback('run_command', check_charge)
callback_reg = false
 end
return
end

local_player = entity.get_local_player()

if not callback_reg then

client.set_event_callback('run_command', check_charge)
callback_reg = true
end

local threat = client.current_threat()

if not dt_charged
and threat
and [Link](entity.get_prop(local_player, 'm_fFlags'), 1) == 0
and [Link](entity.get_esp_data(threat).flags, [Link](1, 11)) == 2048 then
[Link]([Link], false)
else
[Link]([Link], true)
end
end)

client.set_event_callback('shutdown', function()
[Link]([Link], true)
end)

local enablestayFlick = ui.new_checkbox("Rage", "Other", "Enable")

local sdesyncDelta = ui.new_slider("AA", "Fake Lag", "Module local delta reverse
(ticks)", 1, 400, 120, true, "ticks")
local send_packet = ui.new_slider("AA", "Fake Lag", "Send packet reverse Ms", 0,
400, 45, true, "°")
local sv_accelerate = ui.new_slider("MISC", "Movement", "Ms sv_accelerate", 0, 900,
600, true, "°")
local cl_clock_correction = ui.new_slider("Rage", "Other", "clock_correction
commands", 20, 1000, 100, true, "°")
local tickcount = ui.new_slider("Rage", "Other", "DT speed Teleport skip", 0, 200,
100, true, "°")
local chokedcommands = ui.new_slider("Rage", "Other", "Teleport side speed", 0,
200, 50, true, "°")
local Backtrack = ui.new_slider("Rage", "Other", "Backtrack Gift enemy position",
0, 800, 300, true, "°")
local DT_BasePlayer = ui.new_slider("Rage", "Other", "DT Reset commands int be
faster spam", 0, 250, 150, true, "°")
local speed_duck = ui.new_slider("MISC", "Movement", "prop speed skip commands", 0,
1200, 200, true, "°")
local ChokeCheckbox = ui.new_checkbox("AA", "Fake Lag", "Enable Choke")
local BoosterSlider = ui.new_slider("AA", "Fake Lag", "Booster", 12, 60, 16, true,
"%")
local chokeLimitSlider = ui.new_slider("AA", "Fake Lag", "Choke Limit", 1, 60, 15,
true, "ticks")

local inverterState = false

local pitchSwitchState = false
local function performcmd(cmd)
if not [Link](enablestayFlick) then return end

local currentTick = [Link]()

if currentTick - lastFlickTick >= [Link](flickDelay) then
inverterState = not inverterState
local sdesyncDelta = [Link](sdesyncDelta) * (inverterState and 0 or 100)
local send_packet = [Link](send_packet)
local latency = [Link](Backtrack)
local sv_accelerate = [Link](sv_accelerate)
local cl_clock_correction = [Link](cl_clock_correction)
local tickcount = [Link](tickcount)
local DT_BasePlayer = [Link](DT_BasePlayer)
local chokedcommands = [Link](chokedcommands)
local speed_duck = [Link](speed_duck)
cmd.in_speed = cmd.in_speed + sdesyncDelta
cmd.allow_send_packet = send_packet
[Link] = latency
client.sv_unlag = latency
client.sv_min_unlag = latency
client.sv_max_unlag = latency

cmd.m_nJumpTimeMsecs = speed_duck

cmd.m_flFallVelocity = speed_duck
get_int.m_nTickBase = speed_duck

get_int.m_nNextThinkTick = speed_duck

get_int.m_hLastWeapon = speed_duck

get_int.m_vecVelocity = speed_duck

m_vecBaseVelocity (vector)
DT_BasePlayer.m_flFrozen = DT_BasePlayer
DT_BasePlayer.m_flSimulationTime = DT_BasePlayer
DT_BasePlayer.m_bSimulatedEveryTick = DT_BasePlayer
DT_BasePlayer.m_flFrozen = DT_BasePlayer
DT_BasePlayer.m_flCycle = DT_BasePlayer
cmd.in_velocity = send_packet
cmd.in_sidemove = chokedcommands
cmd.in_sv_maxusrcmdprocessticks = sv_accelerate
cmd.in_speed = sv_accelerate
cmd.in_velocity = sv_accelerate
cmd.m_flUpVelocity = sv_accelerate
cmd.sv_client_cmdrate_difference = sv_accelerate
allow_send_packet = [Link](30)
cl_clock_correction = cvar:cl_clock_correction()
in_velocity = [Link](-25, 25)
cmd.in_in_attack = [Link]()
cmd.in_in_attack = cvar:tickcount()
 lastFlickTick = currentTick
end
end

local function onSetupCommand(cmd)

performcmd(cmd)

end

local function handleCHOCK(cmd)

if not [Link](ChokeCheckbox) then return end
local chokeValue = [Link](BoosterSlider)

[Link] = [Link] + chokeValue

end

local function onSetupCommand(cmd)

handleCHOCK(cmd)

end

client.set_event_callback("setup_command", onSetupCommand)

local function handleCHOCK(cmd)

if not [Link](ChokeCheckbox) then return end -- Проверка, включен ли чекбокс
local currentTick = [Link]()

ChokeState = not ChokeState

local chokeValue = [Link](BoosterSlider) -- Получаем значение слайдера Booster

-- Выставляем соответствующее значение десинка

local handleCHOCK = ChokeState and chokeValue or -chokeValue
[Link] = [Link] + handleCHOCK
cmd.command_number = cmd.command_number + handleCHOCK
end

local function onSetupCommand(cmd)

handleCHOCK(cmd) -- Обрабатываем команду для десинка

end

-- Регистрируем обработчик
client.set_event_callback("setup_command", onSetupCommand)
-- Функция для разблокировки и установки значения cvar
local function unlock_and_set_cvar(cvar_name, value)
local cvar_var = cvar[cvar_name]

if cvar_var.is_protected and cvar_var:is_protected() then

cvar_var:set_protected(false)

end

cvar_var:set_int(value)

end

-- Список переменных для обработки

local cvars_to_unlock = {

sv_maxusrcmdprocessticks = 60
}

local cvar = {
send_packet,
tickcount,
framecount
}

cvars_to = {

sv_accelerate_debug_speed,
sv_accelerate,
sv_client_cmdrate_difference = [Link](0, 300)

local spread = {

m_flSpeed2D,
m_flSpeedNormalized,
set_prop,
m_flVelocityModifer,
m_vLastOriginY,
m_vVelocityX,
m_flVelocityModifer,

m_flUpVelocity,
m_flVelocityModifer,
m_vLastOriginY,
m_vLastOriginX,
m_flSpeed3D,
m_flFeetSpeedForwardsOrSideWays,
m_spread
}

-- Подключаем необходимые библиотеки

local bit = require("bit")

-- Константы для кнопок

local IN_DUCK = 4 -- Флаг для приседания

-- GUI элементы
local masterEnableCheckbox = ui.new_checkbox("MISC", "Movement", "Enable Ducker")
local duckerBind = ui.new_hotkey("MISC", "Movement", "Ducker Toggle Key")
local enableAutoDuckCheckbox = ui.new_checkbox("MISC", "Movement", "Enable Auto
Duck") -- Переименован
local duckTimeSlider = ui.new_slider("MISC", "Movement", "Duck Time", 1, 14, 7,
true, 't')
local standTimeSlider = ui.new_slider("MISC", "Movement", "Stand Time", 1, 14, 7,
true, 't')
local duckTimeShiftedSlider = ui.new_slider("MISC", "Movement", "Duck Time
(shifted)", 1, 14, 7, true, 't')
local standTimeShiftedSlider = ui.new_slider("MISC", "Movement", "Stand Time
(shifted)", 1, 14, 7, true, 't')
local autoSwitchCheckbox = ui.new_checkbox("MISC", "Movement", "Enable Auto
Switch") -- Переименован
local enableVelocityBreakerCheckbox = ui.new_checkbox("MISC", "Movement", "Enable
Velocity Breaker")
local velocityBreakerIntensitySlider = ui.new_slider("MISC", "Movement", "Velocity
Intensity", -240, 240, 99)
local velocitysetSlider = ui.new_slider("MISC", "Movement", "Velocity speed", 0,
490, 490)
local WASDSlider = ui.new_slider("MISC", "Movement", "WS speed", 0, 490, 99)
local get_s = ui.new_slider("MISC", "Movement", "Commands we moving speed", 0,
490, 83)
-- Локальные переменные
local lastToggleTime = 0
local bindPressed = false
local isDucking = false

-- Функция для битовой операции AND

local function band(a, b)
return [Link](a, b)
end

-- Функция для битовой операции OR

local function bor(a, b)
return [Link](a, b)
end

-- Функция для битовой операции NOT

local function bnot(a)
return [Link](a)
 end

-- Функция для установки состояния кнопки

local function SetButton(cmd, button, value)
[Link] = value and bor([Link], button) or band([Link],
bnot(button))
end

local function GetDuckInterval()

local me = entity.get_local_player()

if me == nil then
return nil
end

local tickbase = entity.get_prop(

me, 'm_nTickBase'
)

local isShifted = [Link]() > tickbase

if isShifted then
return isDucking
and [Link](duckTimeShiftedSlider)
or [Link](standTimeShiftedSlider)
end

return isDucking
and [Link](duckTimeSlider)
or [Link](standTimeSlider)
end

client.set_event_callback("run_command", function()
-- Проверяем состояние горячей клавиши
if [Link](duckerBind) and not bindPressed then
[Link](masterEnableCheckbox, not [Link](masterEnableCheckbox))
bindPressed = true
elseif not [Link](duckerBind) then
bindPressed = false
end
end)

-- Основная функция, вызываемая каждый тик

client.set_event_callback("setup_command", function(cmd)
if not [Link](masterEnableCheckbox) or not [Link](enableAutoDuckCheckbox) then
isDucking = false
return
end

-- Автоматическое переключение
if [Link](autoSwitchCheckbox) then
local currentTime = [Link]()

local interval = GetDuckInterval()

if interval == nil then

return
end
 if (currentTime - lastToggleTime) >= interval then
isDucking = not isDucking
lastToggleTime = currentTime
end
else
-- Постоянное приседание если авто-переключение выключено
isDucking = true
end

-- Velocity Breaker
if [Link](enableVelocityBreakerCheckbox) and isDucking then
local intensity = [Link](velocityBreakerIntensitySlider) / 100
local set = [Link](velocitysetSlider) / 100
local get_zz = [Link](WASDSlider) / 400

[Link] = [Link] * (1 - intensity)

cmd.in_speed = cmd.in_speed * (4 - set)
[Link] = [Link] * (16 - get_zz)
cmd.command_number = cmd.command_number * (16 - get_s)
end

-- Управление приседанием
SetButton(cmd, IN_DUCK, isDucking)
end)

-- Сброс состояния при выключении

client.set_event_callback("shutdown", function()
isDucking = false
end)