-- Weapon cover tilt script
-- Makes weapon go up when near obstacle to emulate weapon dimensions 
-- Written by demonized

-- Current version
VERSION = 14

--Protected function call to prevent crashes to desktop
--Prints error in console if occured, otherwise proceed normally
--Use for test only, slower than usual
local try = try or function(func, ...)
	local status, error_or_result = pcall(func, ...)
	if not status then
		printf(error_or_result)
		return false, status, error_or_result
	else
		return error_or_result, status
	end
end

local dte = demonized_time_events

local normalize = normalize
local clamp = clamp

local abs = math.abs
local min = math.min
local max = math.max
local sqrt = math.sqrt

local actor_weapon_lowered = game.actor_weapon_lowered

local get_target_dist = level.get_target_dist
local get_target_obj = level.get_target_obj

--EMA smoothing for changing values, frame independent
local default_smoothing = 11.5
local smoothed_values = {}

local function ema(key, value, def, steps, delta)
	local steps = steps or default_smoothing
	local delta = delta or steps
	local smoothing_alpha = 2.0 / (steps + 1)

	smoothed_values[key] = smoothed_values[key] and smoothed_values[key] + min(smoothing_alpha * (delta / steps), 1) * (value - smoothed_values[key]) or def or value

	--printf("EMA fired, key %s, target %s, current %s, going %s", key, value, smoothed_values[key], (value > smoothed_values[key] and "up" or "down"))
	return smoothed_values[key]
end

-- Linear inter/extrapolation
local function lerp(a, b, f)
	if a and b and f then
		return a + f * (b - a)
	else
		return a or b or 0
	end
end

local intercepts = {
	["actor_on_weapon_before_tilt"] = {}, -- Params: weapon_object, flags
	["actor_on_weapon_tilt_start"] = {}, -- Params: weapon_object
	["actor_on_weapon_tilt_end"] = {}, -- Params: weapon_object
	["actor_on_weapon_tilting"] = {}, -- Params: weapon_object, coeff
	["actor_on_weapon_tilting_back"] = {}, -- Params: weapon_object, coeff
}

function add_intercept(name)
	if intercepts[name] then return end
	intercepts[name] = {}
end

function add_callback(name, func)
	if not (name and func and intercepts[name]) then return end
	intercepts[name][func] = true
end

function remove_callback(name, func)
	if not (name and func and intercepts[name]) then return end
	intercepts[name][func] = nil 
end

function callback(name, ...)
	if not (name and intercepts[name]) then return end
	for func, _ in pairs(intercepts[name]) do
		func(...)
	end
end

-- MCM
-- Load the defaults
local function load_defaults()
	local t = {}
	local op = weapon_cover_tilt_mcm.op
	for i, v in ipairs(op.gr) do
		if v.def ~= nil then
			t[v.id] = v.def
		end
	end
	return t
end

local settings = load_defaults()

local function load_settings()
	settings = load_defaults()
	if ui_mcm then
		for k, v in pairs(settings) do
			settings[k] = ui_mcm.get("weapon_cover_tilt/" .. k)
		end
	end
end

function get_setting(key)
	return settings[key]
end

function debug_enabled()
	return DEV_DEBUG or DEV_DEBUG_DEV
end

local parameters = {
-- Type: 0 = string | 1 = number | 2 = 3d vector | 3 = 4d vector | 
	["hands_position"]		            = { name = "Hands Position",         typ = 2, def = {0,0,0}, indx = 1,  min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 0,  hud = true },
	["hands_orientation"]	            = { name = "Hands Orientation",      typ = 2, def = {0,0,0}, indx = 2,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 0,  hud = true },
	["aim_hud_offset_pos"]		        = { name = "Aim Position",           typ = 2, def = {0,0,0}, indx = 3,  min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 1,  hud = true },
	["aim_hud_offset_rot"]	            = { name = "Aim Orientation",        typ = 2, def = {0,0,0}, indx = 4,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 1,  hud = true },
	["gl_hud_offset_pos"]		        = { name = "GL Position",            typ = 2, def = {0,0,0}, indx = 5,  min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 2,  hud = true },
	["gl_hud_offset_rot"]		        = { name = "GL Orientation",         typ = 2, def = {0,0,0}, indx = 6,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 2,  hud = true },
	["aim_hud_offset_alt_pos"]	        = { name = "Alt Position",           typ = 2, def = {0,0,0}, indx = 7,  min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 3,  hud = true },
	["aim_hud_offset_alt_rot"]			= { name = "Alt Orientation",        typ = 2, def = {0,0,0}, indx = 8,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 3,  hud = true },
	["lowered_hud_offset_pos"]			= { name = "Lowered Position",       typ = 2, def = {0,0,0}, indx = 9,  min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 4,  hud = true },
	["lowered_hud_offset_rot"]			= { name = "Lowered Orientation",    typ = 2, def = {0,0,0}, indx = 10, min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 4,  hud = true },
	["fire_point"]	        			= { name = "Fire Point",           	 typ = 2, def = {0,0,0}, indx = 11, min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 10, hud = true, no_16x9 = true },
	["fire_point2"]	       				= { name = "Fire Point 2",           typ = 2, def = {0,0,0}, indx = 12, min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 11, hud = true, no_16x9 = true },
	["fire_direction"]					= { name = "Fire Direction",         typ = 2, def = {0,0,1}, indx = 13, min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 10, hud = true, no_16x9 = true },
	["shell_point"]						= { name = "Shell Point",        	 typ = 2, def = {0,0,0}, indx = 14, min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 11, hud = true, no_16x9 = true },
	["custom_ui_pos"]	       		 	= { name = "UI Position",            typ = 2, def = {0,0,0}, indx = 15, min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 20 }, --idxb 20 is reserved for device ui
	["custom_ui_rot"]					= { name = "UI Orientation",         typ = 2, def = {0,0,0}, indx = 16, min = -180,   max = 180, step = 1, 		 idxa = 1, idxb = 20 },
	["item_position"]	        		= { name = "Item Position",          typ = 2, def = {0,0,0}, indx = 17, min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 12, hud = true, no_16x9 = true },
	["item_orientation"]	       		= { name = "Item Orientation",       typ = 2, def = {0,0,0}, indx = 18, min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 12, hud = true, no_16x9 = true },
	["scope_zoom_factor"]				= { name = "Zoom Factor",        	 typ = 1, def = 0, 		 indx = 19, min = 0,  	  max = 120, step = 0.1 },
	["gl_zoom_factor"]					= { name = "GL Zoom Factor",         typ = 1, def = 0, 		 indx = 20, min = 0,  	  max = 120, step = 0.1 },
	["scope_zoom_factor_alt"]			= { name = "Alt Zoom Factor",        typ = 1, def = 0, 		 indx = 21, min = 0,  	  max = 120, step = 0.1 }, 
}

function reset_wpn_hud(sec)
	local hud_sec = SYS_GetParam(0, sec, "hud")
	if not hud_sec then return end

	hud_adjust.enabled(true)
	for k, v in pairs(parameters) do
		if v.typ == 1 then
			local p = SYS_GetParam(2, hud_sec, k, v.def)
			if p then
				hud_adjust.set_value(k, p)
			end
		elseif v.typ == 2 then
			local function res(str)
				local str = str or ""
				local p = SYS_GetParam(0, hud_sec, v.no_16x9 and k or (k .. str))

				if not p then
					p = table.concat(v.def, ",")
				end

				if p then
					p = str_explode(p, ",")
					for i, d in ipairs(v.def) do
						p[i] = p[i] and tonumber(p[i]) or d
					end
					hud_adjust.set_vector(v.idxa, v.idxb, p[1] or 0, p[2] or 0, p[3] or 0)
				end
			end
			res(utils_xml.is_widescreen() and "_16x9")
		end
	end
	hud_adjust.enabled(false)
end

function IsBinoc(sec)
	return 	SYS_GetParam(0, sec, "ammo_class", "") == "ammo_binoc"
	or 		SYS_GetParam(0, sec, "class", "") == "WP_BINOC"
end

function IsThrowable(wpn)
	return IsBolt(wpn) or SYS_GetParam(0, wpn:section(), "class", "") == "II_BOLT"
end 

local scoped_weapon_zoomed = false
function isScopedWeapon(wpn)
	if not wpn then return false end

	local has_scopes_sect = SYS_GetParam(0, wpn:section(), "scopes_sect", "") ~= ""
	local has_texture = SYS_GetParam(0, wpn:section(), "scope_texture", "") ~= ""

	local cobj = wpn:cast_Weapon()

	-- If old scopes system
	if has_scopes_sect then
		if cobj and cobj:IsScopeAttached() or wpn:weapon_is_scope() then
			return true
		end
	else
		-- If there is fixed scope or no scope defined, but also if there is a scope texture, it will use the texture for zoomin and considered a scoped weapon
		if  (wpn:weapon_scope_status() == 1 or wpn:weapon_scope_status() == 0) and has_texture then
			return true
		end

		-- Usual check
		if  (cobj and cobj:IsScopeAttached() or wpn:weapon_is_scope()) and has_texture then
			return true
		end
	end

	return false
end

function isSilencedWeapon(wpn)
	if not wpn then return false end

	local cobj = wpn:cast_Weapon()
	return 	wpn:weapon_silencer_status() == 2
	and 	(cobj and cobj:IsSilencerAttached() or wpn:weapon_is_silencer() or utils_item.addon_attached(wpn, "sl"))
end

local random_funcs = demonized_randomizing_functions
local wpn_positions = weapon_cover_tilt_positions or {}
local wpn_radii = weapon_cover_tilt_gun_trigger_radii and weapon_cover_tilt_gun_trigger_radii.weapon_trigger_radii or {}

function getBestMatch(sec)
	local best_match, best_match_l = nil, 0
	local function getMatch(k, s1, s2)
		local a, b = s1:find(s2)
		if a and b then
			local l = b - a + 1
			if l > best_match_l then
				best_match = k
				best_match_l = l
			end
		end
	end
	for k, v in pairs(wpn_radii) do
		getMatch(k, sec, k)
		-- getMatch(k, k, sec)
	end
	return best_match
end

-- Test of is material of static geometry is shootable, engine edit required
--[[
			
	Material List
	flBreakable = (1ul << 0ul),
	flBounceable = (1ul << 2ul),
	flSkidmark = (1ul << 3ul),
	flBloodmark = (1ul << 4ul),
	flClimable = (1ul << 5ul),
	flPassable = (1ul << 7ul),
	flDynamic = (1ul << 8ul),
	flLiquid = (1ul << 9ul),
	flSuppressShadows = (1ul << 10ul),
	flSuppressWallmarks = (1ul << 11ul),
	flActorObstacle = (1ul << 12ul),
	flNoRicoshet = (1ul << 13ul),

	flInjurious = (1ul << 28ul),
	flShootable = (1ul << 29ul),
	flTransparent = (1ul << 30ul),
	flSlowDown = (1ul << 31ul)

	// material exports
	.def_readonly("material_name", &script_rq_result::pMaterialName)
	.def_readonly("material_flags", &script_rq_result::pMaterialFlags)
	.def_readonly("material_phfriction", &script_rq_result::fPHFriction)
	.def_readonly("material_phdamping", &script_rq_result::fPHDamping)
	.def_readonly("material_phspring", &script_rq_result::fPHSpring)
	.def_readonly("material_phbounce_start_velocity", &script_rq_result::fPHBounceStartVelocity)
	.def_readonly("material_phbouncing", &script_rq_result::fPHBouncing)
	.def_readonly("material_flotation_factor", &script_rq_result::fFlotationFactor)
	.def_readonly("material_shoot_factor", &script_rq_result::fShootFactor)
	.def_readonly("material_shoot_factor_mp", &script_rq_result::fShootFactorMP)
	.def_readonly("material_bounce_damage_factor", &script_rq_result::fBounceDamageFactor)
	.def_readonly("material_injurious_speed", &script_rq_result::fInjuriousSpeed)
	.def_readonly("material_vis_transparency_factor", &script_rq_result::fVisTransparencyFactor)
	.def_readonly("material_snd_occlusion_factor", &script_rq_result::fSndOcclusionFactor)
	.def_readonly("material_density_factor", &script_rq_result::fDensityFactor)

--]]
local function lshift(x, by)
	return x * 2 ^ by
end

local function test(x, mask)
	return bit_and(x, mask) == mask
end

local flags_test = {
	-- {"flBreakable", lshift(1, 0)},
	-- {"flBounceable", lshift(1, 2)},
	-- {"flSkidmark", lshift(1, 3)},
	-- {"flBloodmark", lshift(1, 4)},
	-- {"flClimable", lshift(1, 5)},
	-- {"flPassable", lshift(1, 7)},
	-- {"flDynamic", lshift(1, 8)},
	-- {"flLiquid", lshift(1, 9)},
	-- {"flSuppressShadows", lshift(1, 10)},
	-- {"flSuppressWallmarks", lshift(1, 11)},
	-- {"flActorObstacle", lshift(1, 12)},
	-- {"flNoRicoshet", lshift(1, 13)},

	-- {"flInjurious", lshift(1, 28)},
	{"flShootable", lshift(1, 29)},
	-- {"flTransparent", lshift(1, 30)},
	-- {"flSlowDown", lshift(1, 31)},
}

function isShootableMaterial(max_dist)
	local max_dist = max_dist or 10
	local ray = ray_pick()
	ray:set_flags(3)
	ray:set_range(max_dist)
	ray:set_position(device().cam_pos)
	ray:set_direction(device().cam_dir)
	ray:set_ignore_object(db.actor)

	local res = ray:query()

	-- Return false if failed query
	if not res then
		return false
	end

	-- Return false if game object
	if ray:get_object() then
		return false
	end

	local result = ray:get_result()

	-- Return false if engine doesnt have material exports or unknown material
	if not (
		result
	and result.material_name
	and result.material_flags
	and result.material_shoot_factor
	)
	then
		return false
	end

	local flags = result.material_flags
	local name = result.material_name
	local shoot_factor = result.material_shoot_factor

	-- Test material flags	
	local flags_test_result = {}
	for i, v in ipairs(flags_test) do
		if test(flags, v[2]) then
			flags_test_result[v[1]] = true
		end
		-- printf("%s, %s test, %s, %s, %s", name, v[1], flags, v[2], test(flags, v[2]))
	end

	-- printf("%s, material_shoot_factor %s", name, shoot_factor)

	-- If name contains "bush" or material is shootable and low shoot_factor - true 
	if string.find(name, "bush") then
		return true
	end

	if string.find(name, "water") then
		return false
	end

	if false
	-- or (flags_test_result.flShootable and shoot_factor <= 0.01)
	then
		return true
	end

	return false
end

-- Sections of weapons that have kind "pistol" but they arent pistols
not_pistol_sec = {
	wpn_svt40_short = true,
	wpn_avt40_short = true,
	wpn_aek919k = true,
}

-- Adjust gun radii by kind if cant find section in radii table
wpn_kind_adjustment_table = {
	w_pistol = -0.3,
	w_smg = -0.12,
	w_sniper = 0.12,
	w_shotgun = -0.05,
	w_rifle = 0,
}

local weapon_table = {}
function add_to_weapon_table(sec, force)
	if weapon_table[sec] and not force then return end
	weapon_table[sec] = {
		hands_position = (function()
			local hud_sec = SYS_GetParam(0, sec, "hud")
			local c = str_explode(utils_xml.is_widescreen() and SYS_GetParam(0, hud_sec, "hands_position_16x9") or SYS_GetParam(0, hud_sec, "hands_position") or "0,0,0", ",")
			return {
				[0] = tonumber(c[1]) or 0,
				[1] = tonumber(c[2]) or 0,
				[2] = tonumber(c[3]) or 0,
			}
		end)(),
		hands_orientation = (function()
			local hud_sec = SYS_GetParam(0, sec, "hud")
			local c = str_explode(utils_xml.is_widescreen() and SYS_GetParam(0, hud_sec, "hands_orientation_16x9") or SYS_GetParam(0, hud_sec, "hands_orientation") or "0,0,0", ",")
			return {
				[0] = tonumber(c[1]) or 0,
				[1] = tonumber(c[2]) or 0,
				[2] = tonumber(c[3]) or 0,
			}
		end)(),
		inv_weight = SYS_GetParam(2, sec, "inv_weight", 0),
		zoom_rotate_time = SYS_GetParam(2, sec, "zoom_rotate_time", 0.25),
	}
end

local target_pos = {
	hands_position_pistol = {
		[0] = -0.050912,
		[1] = -0.646908,
		[2] = 0.280633,
	},
	hands_position_rifle = {
		[0] = 0.055224,
		[1] = -0.6,
		[2] = 0.202598,
	}
}

local custom_offsets = {
	[0] = 0,
	[1] = 0,
	[2] = 0,
}

function set_custom_offsets(x, y, z)
	custom_offsets[0] = x or 0
	custom_offsets[1] = y or 0
	custom_offsets[2] = z or 0
end

local tilt_enabled = false
local tilt_key_pressed = false
local firepos_state = 0
local yaw
local roll
local max_deg = 75
local grace_threshold = 75
local grace_time = 0

function set_yaw(deg)
	yaw = deg
end

function set_roll(deg)
	roll = deg
end

function is_tilt_enabled()
	return tilt_enabled
end

function is_tilt_key_pressed()
	return tilt_key_pressed
end

function randomize_roll_yaw()
	if not yaw then
		local max_yaw = settings.yaw_variation
		yaw = random_float(-max_yaw, max_yaw)
	end

	if not roll then
		local max_roll = settings.roll_variation
		roll = random_float(-max_roll, max_roll * 0.33)
	end
end

function remove_roll_yaw()
	yaw = nil
	roll = nil
end

function enable_tilt(sec, wpn)
	if scoped_weapon_zoomed then
		if (get_console():get_bool("wpn_aim_toggle")) then
			level.press_action(bind_to_dik(key_bindings.kWPN_ZOOM))
		else
			level.release_action(bind_to_dik(key_bindings.kWPN_ZOOM))
		end
	end

	if not tilt_enabled then
		-- Dirty AF hack to reset position (unused)
		-- local wpn_hud = ui_debug_wpn_hud.WpnHudEditor(nil, sec)
		-- if wpn_hud then
		-- 	wpn_hud:Reset(true)
		-- 	wpn_hud:Close()
		-- end
		reset_wpn_hud(sec)

		hud_adjust.enabled(true)
		set_weapon_position(sec, weapon_table[sec].hands_position, weapon_table[sec].hands_orientation)
		
		if debug_enabled() then
			exec_console_cmd("g_firepos 1")
		end

		tilt_enabled = true
		callback("actor_on_weapon_tilt_start", wpn)
	end
end

function reset(sec)
	if tilt_enabled then
		if sec and weapon_table[sec] then reset_wpn_hud(sec) end
		hud_adjust.enabled(false)
		
		if debug_enabled() then
			exec_console_cmd("g_firepos " .. (firepos_state or 0))
		end

		smoothed_values.hands_position_x = nil
		smoothed_values.hands_position_y = nil
		smoothed_values.hands_position_z = nil
		smoothed_values.hands_orientation_x = nil
		smoothed_values.hands_orientation_y = nil
		smoothed_values.hands_orientation_z = nil
		smoothed_values.coeff = nil
		tilt_enabled = false
		tilt_key_pressed = false
		grace_time = 0
		callback("actor_on_weapon_tilt_end", wpn)
	end
end

-- Get steps depending on inv_weight, heavier guns have less movement speed
function get_weapon_weight(wpn, sec)
	local cobj = wpn and wpn:cast_Weapon()
	local weight = clamp(cobj and cobj:Weight() or (weapon_table[sec] and weapon_table[sec].inv_weight or 0), 0, 20)
	return weight
end

function get_weapon_steps(wpn, sec)
	return settings.animation_speed * (1 + get_weapon_weight(wpn, sec) * settings.animation_weight_coeff * 0.07)
end

function set_weapon_position(sec, new_pos, new_ori)
	-- printf("old_pos for %s: %s, %s, %s", sec, weapon_table[sec].hands_position[0], weapon_table[sec].hands_position[1], weapon_table[sec].hands_position[2])
	-- printf("new_pos for %s: %s, %s, %s", sec, new_pos[0], new_pos[1], new_pos[2])
	-- printf("old_ori for %s: %s, %s, %s", sec, weapon_table[sec].hands_orientation[0], weapon_table[sec].hands_orientation[1], weapon_table[sec].hands_orientation[2])
	-- printf("new_pri for %s: %s, %s, %s", sec, new_ori[0], new_ori[1], new_ori[2])

	hud_adjust.set_vector(0, 0, new_pos[0] or 0, new_pos[1] or 0, new_pos[2] or 0)
	hud_adjust.set_vector(1, 0, new_ori[0] or 0, new_ori[1] or 0, new_ori[2] or 0)
	-- hud_adjust.set_vector(parameters[parent].idxa, parameters[parent].idxb, value_1, value_2, value_3)
end

function soft_reset(wpn, sec, delta)
	if not weapon_table[sec] then return reset(sec) end
	local delta = delta or device().time_delta

	if tilt_enabled then
		-- k is modifier for ema steps to have more inertia in the beginning of movement
		local k = max(1, 1.5 - (1 - normalize(smoothed_values.hands_orientation_y or max_deg, weapon_table[sec].hands_orientation[1], max_deg)))

		-- Increase speed of return to position when closer to it for zoomed weapons
		local is_scoped = isScopedWeapon(wpn)
		local scope_magnitude = 0.105
		k = k * (is_scoped and normalize(smoothed_values.hands_orientation_y, weapon_table[sec].hands_orientation[1], max_deg) ^ scope_magnitude or 1)

		-- printf("cur %s, min %s, max %s, %s", smoothed_values.hands_orientation_y, weapon_table[sec].hands_orientation[1], max_deg, k)
		local steps = get_weapon_steps(wpn, sec) * k

		-- Smooth the coeff
		local coeff_smoothing = steps * 0.5
		local coeff = ema("coeff", 0, 0, coeff_smoothing, delta)

		-- Remove random roll and yaw if close to end
		if coeff < 0.5 then
			remove_roll_yaw()
		end

		local new_pos = {
			[0] = ema("hands_position_x", lerp(weapon_table[sec].hands_position[0], smoothed_values.hands_position_x, coeff), weapon_table[sec].hands_position[0], steps, delta),
			[1] = ema("hands_position_y", lerp(weapon_table[sec].hands_position[1], smoothed_values.hands_position_y, coeff), weapon_table[sec].hands_position[1], steps, delta),
			[2] = ema("hands_position_z", lerp(weapon_table[sec].hands_position[2], smoothed_values.hands_position_z, coeff), weapon_table[sec].hands_position[2], steps, delta),
		}

		local new_ori = {
			[0] = ema("hands_orientation_x", lerp(weapon_table[sec].hands_orientation[0], smoothed_values.hands_orientation_x, coeff), weapon_table[sec].hands_orientation[0], steps, delta),
			[1] = ema("hands_orientation_y", lerp(weapon_table[sec].hands_orientation[1], smoothed_values.hands_orientation_y, coeff), weapon_table[sec].hands_orientation[1], steps, delta),
			[2] = ema("hands_orientation_z", lerp(weapon_table[sec].hands_orientation[2], smoothed_values.hands_orientation_z, coeff), weapon_table[sec].hands_orientation[2], steps, delta),
		}

		local animation_progress = normalize(new_ori[1], weapon_table[sec].hands_orientation[1], max_deg)
		callback("actor_on_weapon_tilting_back", wpn, animation_progress)

		set_weapon_position(sec, new_pos, new_ori)

		if scoped_weapon_zoomed then

			-- Calculate remaining time for scope aiming
			local ms = delta / 1000
			local t = 0
			local threshold = 0.0007
			smoothed_values.t = animation_progress

			while t < weapon_table[sec].zoom_rotate_time and smoothed_values.t > threshold do
				local k = smoothed_values.t ^ scope_magnitude
				local steps = get_weapon_steps(wpn, sec) * k
				local old = smoothed_values.t
				smoothed_values.t = ema("t", 0, 0, steps, delta)
				t = t + ms
			end

			local res = smoothed_values.t
			smoothed_values.t = nil

			if res > threshold then
				if (get_console():get_bool("wpn_aim_toggle")) then
					level.press_action(bind_to_dik(key_bindings.kWPN_ZOOM))
				else
					level.release_action(bind_to_dik(key_bindings.kWPN_ZOOM))
				end
			end
		end

		for i = 0, 2, 1 do
			if 	abs(new_pos[i] - weapon_table[sec].hands_position[i]) > 0.055
			or 	abs(new_ori[i] - weapon_table[sec].hands_orientation[i]) > 0.055
			then
				return
			end
		end

		-- printf("soft reset complete")
		-- printf("animation_progress %s", animation_progress)
		reset(sec)
	end
end

function calculate_new_position(wpn, sec, coeff, delta, steps)
	-- Calculate new position
	local position_coeff_y = -0.445
	local position_coeff_z = 0.565
	local delta = delta or device().time_delta

	-- Get steps depending on inv_weight, heavier guns have less movement speed
	-- k is modifier for ema steps to have more inertia in the beginning of movement
	if not steps then
		local k = max(1, 1.5 - sqrt(normalize(smoothed_values.hands_orientation_y or weapon_table[sec].hands_orientation[1], weapon_table[sec].hands_orientation[1], max_deg)))
		steps = get_weapon_steps(wpn, sec) * k
	end

	-- Smooth the coeff
	local coeff_smoothing = steps * 0.5
	coeff = ema("coeff", coeff, 0, coeff_smoothing, delta)
	
	local is_pistol = SYS_GetParam(0, sec, "kind", "") == "w_pistol" and not not_pistol_sec[sec]
	local new_pos
	if wpn_positions.weapon_positions[sec] then
		local p = wpn_positions.weapon_positions[sec]
		new_pos = {
			[0] = lerp(weapon_table[sec].hands_position[0], p.x or weapon_table[sec].hands_position[0], coeff),
			[1] = lerp(weapon_table[sec].hands_position[1], p.y or weapon_table[sec].hands_position[1], coeff),
			[2] = lerp(weapon_table[sec].hands_position[2], p.z or weapon_table[sec].hands_position[2], coeff ^ 3.5),
		}
	else
		-- Check for scopes on weapons
		if not wpn_positions.weapon_offsets[sec] then
			local parent = SYS_GetParam(0, sec, "parent_section", sec)
			local scopes = str_explode(SYS_GetParam(0, parent, "scopes", ""), ",")
			for k, v in pairs(scopes) do
				if (parent .. "_" .. v) == sec then
					wpn_positions.weapon_offsets[sec] = wpn_positions.weapon_offsets[parent]
					break
				end
			end

			-- Add table with 0 offsets if no weapon offset found
			if not wpn_positions.weapon_offsets[sec] then
				wpn_positions.weapon_offsets[sec] = {
					x = 0,
					y = 0,
					z = 0
				}
			end
		end

		local o = {
			[0] = wpn_positions.weapon_offsets[sec].x or 0,
			[1] = wpn_positions.weapon_offsets[sec].y or 0,
			[2] = wpn_positions.weapon_offsets[sec].z or 0,
		}

		-- Interpolate between offseted position and desirable closer to obstacle, looks better, mostly
		-- Different calculations for pistols
		if is_pistol then
			local target_pos = {
				[0] = weapon_table[sec].hands_position[0] + settings.offset_x + custom_offsets[0],
				[1] = target_pos.hands_position_pistol[1] + settings.offset_y + custom_offsets[1],
				[2] = target_pos.hands_position_pistol[2] + settings.offset_z + custom_offsets[2],
			}

			-- local a = {
			-- 	[0] = weapon_table[sec].hands_position[0] + o[0] * coeff,
			-- 	[1] = weapon_table[sec].hands_position[1] + (o[1] + position_coeff_y) * coeff,
			-- 	[2] = weapon_table[sec].hands_position[2] + (o[2] + position_coeff_z) * coeff >= 1 and coeff or coeff ^ 2,
			-- }

			local b = {
				[0] = lerp(weapon_table[sec].hands_position[0], (o[0] + target_pos[0]), coeff),
				[1] = lerp(weapon_table[sec].hands_position[1], (o[1] + target_pos[1]), coeff),
				[2] = lerp(weapon_table[sec].hands_position[2], (o[2] + target_pos[2]), coeff >= 1 and coeff or coeff ^ 2),
			}

			-- local c = {
			-- 	[0] = lerp(b[0], b[0], coeff),
			-- 	[1] = lerp(b[1], b[1], coeff),
			-- 	[2] = lerp(b[2], b[2], coeff ^ 2),
			-- }

			new_pos = b
		else
			local target_pos = {
				[0] = weapon_table[sec].hands_position[0] + settings.offset_x + custom_offsets[0],
				[1] = target_pos.hands_position_rifle[1] + settings.offset_y + custom_offsets[1],
				[2] = target_pos.hands_position_rifle[2] + settings.offset_z + custom_offsets[2],
			}

			local a = {
				[0] = weapon_table[sec].hands_position[0] + o[0] * coeff,
				[1] = weapon_table[sec].hands_position[1] + (o[1] + position_coeff_y) * coeff,
				[2] = weapon_table[sec].hands_position[2] + (o[2] + position_coeff_z) * (coeff >= 1 and coeff or coeff ^ 3.5),
			}

			local b = {
				[0] = lerp(weapon_table[sec].hands_position[0], (o[0] + target_pos[0]), coeff),
				[1] = lerp(weapon_table[sec].hands_position[1], (o[1] + target_pos[1]), coeff),
				[2] = lerp(weapon_table[sec].hands_position[2], (o[2] + target_pos[2]), coeff >= 1 and coeff or coeff ^ 3.5),
			}

			local c = {
				[0] = lerp(a[0], b[0], coeff),
				[1] = lerp(a[1], b[1], coeff),
				[2] = lerp(a[2], b[2], coeff >= 1 and coeff or coeff ^ 3.5),
			}

			new_pos = c
		end
	end

	-- Smooth new position
	new_pos = {
		[0] = ema("hands_position_x", new_pos[0], weapon_table[sec].hands_position[0], steps, delta),
		[1] = ema("hands_position_y", new_pos[1], weapon_table[sec].hands_position[1], steps, delta),
		[2] = ema("hands_position_z", new_pos[2], weapon_table[sec].hands_position[2], steps, delta),
	}

	-- Randomize roll and yaw
	randomize_roll_yaw()
	local new_ori = {
		[0] = ema("hands_orientation_x", weapon_table[sec].hands_orientation[0] + yaw * coeff, weapon_table[sec].hands_orientation[0], steps, delta),
		[1] = ema("hands_orientation_y", weapon_table[sec].hands_orientation[1] + max_deg * coeff, weapon_table[sec].hands_orientation[1], steps, delta),
		[2] = ema("hands_orientation_z", weapon_table[sec].hands_orientation[2] + roll * coeff, weapon_table[sec].hands_orientation[2], steps, delta),
	}
	return new_pos, new_ori
end

local force_disabled = false
function set_force_disabled(v)
	force_disabled = v or v == nil
end

local reset_on_show_done = false
function actor_on_update(binder, delta)
	if force_disabled then return end

	local actor = db.actor

	-- Cancel if PDA is active
	if actor:active_slot() == 8 or actor:active_slot() == 14 then
		return reset()
	end

	local wpn = actor:active_item()

	-- printf("%s", delta)

	-- Reset if no wpn
	if not wpn then
		return reset()
	end

	local sec = wpn:section()
	local hud_sec = SYS_GetParam(0, sec, "hud")

	-- Reset when no hud sec
	if not hud_sec then
		return reset(sec)
	end

	-- Reset if melee weapon or binocs
	if IsMelee(wpn) or IsItem("fake_ammo_wpn", sec) or IsBinoc(sec) then
		return reset(sec)
	end

	-- Reset if throwable weapon (grenade, bolt)
	if IsBolt(wpn) or IsGrenade(wpn) or IsThrowable(wpn) then
		return reset(sec)
	end

	-- Add to weapon table
	if not weapon_table[sec] then
		add_to_weapon_table(sec)
	end

	-- Reset HUD once on weapon raise
	local state = wpn:get_state()
	if state == 1 then
		if not reset_on_show_done then
			-- printf("reset on show for %s", sec)
			reset_on_show_done = true
			reset(sec)
		end
	else
		reset_on_show_done = false
	end

	-- Reset if callback function set enabled to false
	local flags = {
		enabled = true
	}
	callback("actor_on_weapon_before_tilt", wpn, flags)
	if not flags.enabled then
		return reset(sec)
	end

	-- Soft reset if weapon is lowered
	if actor_weapon_lowered() then
		return soft_reset(wpn, sec, delta)
	end

	-- Cancel if detector is active
	if actor:active_detector() then
		return soft_reset(wpn, sec, delta)
	end

	-- Soft reset if hiding weapon or reloading
	if state == 2 or state == 7 then
		return soft_reset(wpn, sec, delta)
	end

	local new_pos, new_ori
	if tilt_key_pressed then
		new_pos, new_ori = calculate_new_position(wpn, sec, 1, delta)
	else
		-- Get max dist based on weapon
		-- Check for scopes on weapons
		if not wpn_radii[sec] then
			local parent = SYS_GetParam(0, sec, "parent_section", sec)
			local scopes = str_explode(SYS_GetParam(0, parent, "scopes", ""), ",")
			for k, v in pairs(scopes) do
				if (parent .. "_" .. v) == sec then
					wpn_radii[sec] = wpn_radii[parent]
					break
				end
			end

			if not wpn_radii[sec] then
				local best_match = getBestMatch(sec)
				if best_match then
					wpn_radii[sec] = wpn_radii[best_match]
				end
			end

			-- Adjust by weapon kind
			if not wpn_radii[sec] then
				local wpn_kind = SYS_GetParam(0, sec, "kind", "")
				local wpn_kind_adjustment = wpn_kind_adjustment_table[wpn_kind] or 0
				wpn_radii[sec] = wpn_kind_adjustment
			end

			if not wpn_radii[sec] then
				wpn_radii[sec] = 0
			end
		end

		local max_dist = settings.trigger_radius

		-- Adjust distance
		local dist_adjustment = (
			-- Adjust distance based on wpn_radii table
			(wpn_radii[sec] or 0)

			-- Adjust distance based on silenced weapon
			+ (settings.consider_silencer and isSilencedWeapon(wpn) and 0.12 or 0)
		)
			-- Magnify the adjustment
			* settings.trigger_radius_magnitude

		-- Adjust the distance
		max_dist = max_dist + dist_adjustment

		-- Get target dist
		local dist = max(0, get_target_dist() - 0.5)
		-- printf("target_dist %s", dist)

		-- Soft reset if distance is more than max_dist
		if dist > max_dist then
			return soft_reset(wpn, sec, delta)
		end

		-- Soft reset if target is enemy stalker or monster
		local target_obj = get_target_obj()
		if target_obj and (IsMonster(target_obj) or (IsStalker(target_obj) and xr_combat_ignore.is_enemy(target_obj, actor, true))) then
			return soft_reset(wpn, sec, delta)
		end

		-- Soft reset is material is shootable, engine edit required
		if isShootableMaterial() then
			return soft_reset(wpn, sec, delta)
		end

		-- Don't raise before grace time expired
		-- if grace_time < grace_threshold then
		-- 	grace_time = grace_time + device().time_delta
		-- 	return
		-- end

		-- Apply non linear coefficient
		local coeff = random_funcs.CircularEaseOutPowered(1 - dist / max_dist, 0.65)

		-- Calculate new position
		new_pos, new_ori = calculate_new_position(wpn, sec, coeff, delta)
	end

	-- Adjust hud
	enable_tilt(sec, wpn)
	local animation_progress = normalize(new_ori[1], weapon_table[sec].hands_orientation[1], max_deg)
	if animation_progress > 0 then
		callback("actor_on_weapon_tilting", wpn, animation_progress)
	end
	set_weapon_position(sec, new_pos, new_ori)
	
end

function actor_on_weapon_zoom_in(obj)
	scoped_weapon_zoomed = isScopedWeapon(obj)
end

function actor_on_weapon_zoom_out(obj)
	scoped_weapon_zoomed = false
end

function on_key_press(dik)
	if dik == settings.manual_tilt_key_bind then
		tilt_key_pressed = not tilt_key_pressed
	else
		local bind = dik_to_bind(dik)
		local kb = key_bindings

		if bind == kb.kWPN_ZOOM
		or bind == kb.kWPN_FIRE
		then
			-- Postpone on next tick, needed to not fire on raised state
			dte.CreateTimeEvent("tilt_key_pressed_postpone", 0, 0, function()
				tilt_key_pressed = false
				return true
			end)
		end
	end
end

function actor_on_weapon_before_fire(flags)
	if tilt_key_pressed then
		tilt_key_pressed = false
		flags.ret_value = false
	end
end

function reset_settings()
	load_settings()

	if settings.enable_manual_tilt then
		RegisterScriptCallback("on_key_press", on_key_press)
	else
		tilt_key_pressed = false
		UnregisterScriptCallback("on_key_press", on_key_press)
	end

	if settings.enabled then
		RegisterScriptCallback("actor_on_update", actor_on_update)
	else
		local sec
		if db.actor then
			local wpn = db.actor:active_item()
			sec = wpn and wpn:section()
		end
		reset(sec)
		UnregisterScriptCallback("actor_on_update", actor_on_update)
	end
end

function actor_on_first_update()
	-- firepos_state = debug_enabled() and get_console_cmd(0, "g_firepos") or 0
	firepos_state = 0
	reset_settings()
end

-- Reset without parameter, for callbacks
function reset_func()
	reset()
end

function on_game_start()
	RegisterScriptCallback("on_option_change", reset_settings)
	RegisterScriptCallback("actor_on_before_death", reset_func)
	RegisterScriptCallback("actor_on_net_destroy", reset_func)
	RegisterScriptCallback("on_before_level_changing", reset_func)
	RegisterScriptCallback("actor_on_first_update", actor_on_first_update)
	RegisterScriptCallback("actor_on_update", actor_on_update)
	RegisterScriptCallback("actor_on_weapon_zoom_in", actor_on_weapon_zoom_in)
	RegisterScriptCallback("actor_on_weapon_zoom_out", actor_on_weapon_zoom_out)
	RegisterScriptCallback("actor_on_weapon_before_fire", actor_on_weapon_before_fire)
	RegisterScriptCallback("on_key_press", on_key_press)
end

-- Patches
-- Safemode when weapon is raised manually
actor_is_safemode = xr_conditions.actor_is_safemode
xr_conditions.actor_is_safemode = function(actor, npc)
	return actor_is_safemode(actor, npc) or (tilt_enabled and tilt_key_pressed)
end

function muzzle_pos()
	local item = db.actor:active_item()
	if not item then return end
	local pos = utils_obj.safe_bone_pos(item, "muzzle")
	return game.world2ui(pos, true)
end