-- Draggable Hud Editor by demonized
-- Possibility to set hud values by mouse dragging
-- Adjusting world model position and orientation for strapped/unstrapped poses
-- 2023

--[[
	Script by Tronex
	Engine edits by Rezy
	2019/9/15
	Weapon HUD editor
	
	Weapon HUD editor allows you to change Weapon HUD position and orientation in real-time.
	The GUI is interactive and easy to use, with ability to save adjusted pos in a temp file "temp_hud.ltx".
	Edited values are temporarly cached for the weapons you worked on. You can return to them in case you turned off the editor (Avoid exiting or reloading when you have unsaved values).
	Keybinds:
	• Up Arrow: 		select previous parameter.
	• Down Arrow: 		select next parameter.
	• Left Arrow: 		reduce\rotate value of selected parameter.
	• Right Arrow: 		increase\rotate value of selected parameter.
	• LShift (hold): 	x10 value step.
	• LAlt (hold): 		x50 value step.
	• C: 				copy current section settings.
	• V: 				paste/apply current section settings.
	• Delete: 			clean temp cache.
	• H: 				toggle hint window.
	• Esc or Home: 		turn off editor.
--]]

local EPS = 0.0000100
local function fsimilar(value, to, eps)
	return math.abs(value - to) < eps
end

local function generate_orthonormal_basis_normalized(d)
	local dir = vector():set(d):normalize()
	local up = vector():set(0,0,0)
	local right = vector():set(0,0,0)
	local fInvLength
	if (fsimilar(dir.y, 1.0, EPS)) then
		up:set(0, 0, 1)
		fInvLength = 1 / math.sqrt(dir.x * dir.x + dir.y * dir.y)
		right.x = -dir.y * fInvLength
		right.y = dir.x * fInvLength
		right.z = 0
		up.x = -dir.z * right.y
		up.y = dir.z * right.x
		up.z = dir.x * right.y - dir.y * right.x
	else
		up:set(0, 1, 0)
		fInvLength = 1 / math.sqrt(dir.x * dir.x + dir.z * dir.z)
		right.x = dir.z * fInvLength
		right.y = 0
		right.z = -dir.x * fInvLength
		up.x = dir.y * right.z
		up.y = dir.z * right.x - dir.x * right.z
		up.z = -dir.y * right.x
	end
	return dir, up, right
end

local precision = 6 -- allowed number of zeros
local t_dir = "items\\weapons\\"
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 (GL)",           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 }, 
}

local third_person_parameters = {
	["position"]		            = { name = "Position",         typ = 2, def = {0,0,0}, indx = 1,  min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 0,  hud = false, no_16x9 = true },
	["orientation"]	            = { name = "Orientation",      typ = 2, def = {0,0,0}, indx = 2,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 0,  hud = false, no_16x9 = true },
	["strap_position"]		        = { name = "Strap Position",           typ = 2, def = {0,0,0}, indx = 3,  min = -180,   max = 180, step = 0.0001, idxa = 0, idxb = 1,  hud = false, no_16x9 = true },
	["strap_orientation"]	            = { name = "Strap Orientation",        typ = 2, def = {0,0,0}, indx = 4,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 1,  hud = false, no_16x9 = true },
	["fire_point"]	            = { name = "Fire Point",        typ = 2, def = {0,0,0}, indx = 5,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 1,  hud = false, no_16x9 = true },
	["fire_point2"]	            = { name = "Fire Point 2 (GL)",        typ = 2, def = {0,0,0}, indx = 6,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 1,  hud = false, no_16x9 = true },
	["shell_point"]	            = { name = "Shell Point",        typ = 2, def = {0,0,0}, indx = 7,  min = -180,   max = 180, step = 0.0001, idxa = 1, idxb = 1,  hud = false, no_16x9 = true },
}

local adjust_active = nil

local is_wide = utils_xml.is_widescreen()
local _width = (device().width)-400
local _hight = (device().height)
local msg_width = is_wide and (_width*0.8) or _width

-- general values cache
local _memo = {} 	-- _memo[section] = {...}
local _memo_i = {}  -- _memo_i[section] = {...}

-- cache current values
local _cache = {}
local _cache_i = {}
local _selected = {}
local _selected_group = {}

local key_timer = 0
local jump_1 = 1
local jump_2 = 10
local jump_3 = 50
local jump = jump_1

local dummy_npc

local enable_debug = false
function print_dbg(...)
	if enable_debug then
		printf(...)
	end
end


-------------------------------------------------------------------
GUI = nil -- instance, don't touch
function start(owner)
	-- Hide the owner
	if owner then
		if (owner:IsShown()) then
			print_dbg("~ hide owner: %s", owner.name or "?")
			owner:HideDialog()
			owner:Show(false)
		end
	else
		hide_hud_inventory()
	end
	
	local wpn = db.actor:active_item()
	local det = db.actor:active_detector()
	if wpn or det then
	
		if (not GUI) then
			GUI = WpnHudEditor(owner, wpn and wpn:section() or det:section())
		end
	
		
		if (GUI) and (not GUI:IsShown()) then
		
			-- Enable hud adjust mode
			if (not adjust_active) then
				adjust_active = true
				hud_adjust.enabled(true)
				print_dbg("~ Enabled hud adjust mode")
			end
	
			GUI:ShowDialog(true)
			GUI.section = wpn and wpn:section() or det:section()
			GUI:Reset()
			GUI:Send_MSG("Press H for info")
			
			RegisterScriptCallback("on_key_release",on_key_release)
			RegisterScriptCallback("on_key_hold",on_key_hold)
			
			Register_UI("WpnHudEditor","ui_debug_wpn_hud")
		else
			ui_debug_launcher.resume()
			printe("! Ok... Something is fucked...")
		end
	else
		ui_debug_launcher.resume()
		actor_menu.set_msg(1, "Hold the weapon you want to edit in your hands first!",5)
	end
end

function on_key_release(key)
	-- jump = jump_1
end

function on_key_hold(key)
	-- if GUI then
	-- 	if (key == DIK_keys["DIK_LSHIFT"]) then
	-- 		jump = jump_2
	-- 		key_timer = time_global() + 200
	-- 	elseif (key == DIK_keys["DIK_LMENU"]) then
	-- 		jump = jump_3
	-- 		key_timer = time_global() + 200
	-- 	end
	-- end
end

-------------------------------------------------------------------
class "WpnHudEditor" (CUIScriptWnd)

function WpnHudEditor:__init(owner,section) super()
	self.owner = owner
	self.section = section

	self.data = {}

	self.tables = {parameters, third_person_parameters}
	
	for i, v in ipairs(self.tables) do
		_selected[v] = _selected[v] or 1
		_selected_group[v] = _selected_group[v] or 1

		self.data[v] = {}
		self.data[v].selected = _selected[v]
		self.data[v].selected_group = _selected_group[v]
		self.data[v].cnt = 0 		 -- parameters counter / index
		self.data[v].cnt_group = {} -- parameters counter / index per parent parameter
		self.data[v].cnt_to_group = {} -- parameters counter to group relation
		
		self.data[v].name = {} 		 -- parameters name (by index)
		self.data[v].typ = {} 	 	 -- parameter type (by index)
		self.data[v].value = {}  	 -- parameter value (by index)
		self.data[v].value_i = {}  	 -- parameter value (by parent)
		self.data[v].parent = {} 	 -- parameter parent, useful for dealing with vector values (by index)
		self.data[v].index = {}		 -- list parameter index, to trace list value
		
		self.data[v].par = {}        -- parameter element (by index)
		self.data[v].par_cap = {}    -- parameter cap (by index)
		self.data[v].par_hl = {}     -- parameter hightlighting (by index)
		self.data[v].par_list = {}	 -- parameter list for lists (by index)
		self.data[v].par_list_n = {} -- parameter numbered list for lists (by index)
	end

	self.active_table = parameters
	self.third_person_mode = false
	self:ResetNpcCam()
	
	self:InitControls()
	self:InitCallBacks()
	
	self:Reset(true)
	
	self:Send_MSG("Press H for info")
end

function WpnHudEditor:__finalize()
end

function WpnHudEditor:InitControls()
	self:SetWndRect			(Frect():set(0,0,1024,768))
	self:SetAutoDelete(true)
	
	if self.owner then
		self.xml = self.owner.xml
	else
		self.xml = CScriptXmlInit()
	end
	
	local xml = self.xml
	if (not self.owner) then
		xml:ParseFile			("ui_debug_launcher.xml")
	end
	
	-- Guides
	local width = device().width
	local hight = device().height
	local w_fac = (1024/width)
	local h_fac = (768/hight)
	local thic = 2
	
	self._w = xml:InitStatic("dbg_wpn_hud_editor:align", self)
	--self._w:SetWndPos(vector2():set( 			0 								, 		((hight/2 * h_fac) - (thic/2)) 		))
	--self._w:SetWndSize(vector2():set( 			(width * w_fac) 				, 		(thic * h_fac) 						))
	self._w:Show(false)
	
	self._h = xml:InitStatic("dbg_wpn_hud_editor:align", self)
	--self._h:SetWndPos(vector2():set( 			((width/2 * w_fac) - (thic/2)) 	, 		0 									))
	--self._h:SetWndSize(vector2():set( 			(thic * w_fac) 					, 		(hight * h_fac) 					))
	self._h:Show(false)
	
	local pos_w = self._w:GetWndPos()
	--printf("_W | x=%s y=%s w=%s h=%s", pos_w.x, pos_w.y, self._w:GetWidth(), self._w:GetHeight())
	
	local pos_h = self._h:GetWndPos()
	--printf("_H | x=%s y=%s w=%s h=%s", pos_h.x, pos_h.y, self._h:GetWidth(), self._h:GetHeight())
	
	-- Dialog
	self.dialog	= xml:InitStatic("dbg_wpn_hud_editor", self)
	
	xml:InitFrame("dbg_wpn_hud_editor:frame", self.dialog)
	xml:InitStatic("dbg_wpn_hud_editor:cap",self.dialog)
	
	self.txt_section = xml:InitTextWnd("dbg_wpn_hud_editor:section",self.dialog)
	
	-- Ratio saving
	xml:InitStatic("dbg_wpn_hud_editor:cap_ratio", self.dialog)
	
	self.btn_ratio = xml:InitCheck("dbg_wpn_hud_editor:check_ratio", self.dialog)
	self:Register(self.btn_ratio, "btn_ratio")
	self.btn_ratio:SetCheck(true)
	
	-- Show alignment
	self.btn_align = xml:Init3tButton("dbg_wpn_hud_editor:btn_alignment", self.dialog)
	self:Register(self.btn_align, "btn_align")

	-- Third person switch
	self.btn_third_person = xml:Init3tButton("dbg_wpn_hud_editor:btn_third_person", self.dialog)
	self:Register(self.btn_third_person, "btn_third_person")
	
	-- Copy section settings
	self.btn_ini_copy = xml:Init3tButton("dbg_wpn_hud_editor:btn_ini_copy", self.dialog)
	self:Register(self.btn_ini_copy, "btn_copy")
	
	-- Paste section settings
	self.btn_ini_paste = xml:Init3tButton("dbg_wpn_hud_editor:btn_ini_paste", self.dialog)
	self:Register(self.btn_ini_paste, "btn_paste")
	
	-- Save file
	self.btn_save = xml:Init3tButton("dbg_wpn_hud_editor:btn_save", self.dialog)
	self:Register(self.btn_save, "btn_save")
	
	-- Reload hud values
	self.btn_reload = xml:Init3tButton("dbg_wpn_hud_editor:btn_reload", self.dialog)
	self:Register(self.btn_reload, "btn_reload")

	self:ResetSelects()
	
	-- Parameters
	for i, v in ipairs(self.tables) do
		self.data[v].scroll_par = xml:InitScrollView("dbg_wpn_hud_editor:scroll_par", self.dialog)
		self.data[v].scroll_par:Clear()
		
		local functor = function(t,a,b) return t[a].indx < t[b].indx end
		local v1 = v
		for par,v in spairs(v,functor) do
			local _st = xml:InitStatic("dbg_wpn_hud_editor:tmp_par", nil)
			
			-- Parameter cap
			local n = #self.data[v1].par_cap + 1
			self.data[v1].par_cap[n] = xml:InitTextWnd("dbg_wpn_hud_editor:op_par:cap", _st)
			self.data[v1].par_cap[n]:SetText(v.name)
			
			-- Multi boxes for vectors
			local par_i = ((v.typ == 2) and 3) or ((v.typ == 3) and 4) or 1
			for i=1,par_i do
			
				-- Tracers
				local ext = self:GetStringByType(i,v.typ)
				local str = par .. ext
				self.data[v1].cnt = self.data[v1].cnt + 1
				self.data[v1].name[self.data[v1].cnt] = str
				self.data[v1].typ[self.data[v1].cnt] = v.typ
				self.data[v1].parent[self.data[v1].cnt] = par
				
				self.data[v1].cnt_group[n] = self.data[v1].cnt_group[n] or {}
				local size_cg = #self.data[v1].cnt_group[n] + 1
				self.data[v1].cnt_group[n][size_cg] = self.data[v1].cnt
				self.data[v1].cnt_to_group[self.data[v1].cnt] = n
				
				-- Parameter element and hightlight texture
				if v.typ == 0 then
					self.data[v1].par[self.data[v1].cnt] = xml:InitComboBox("dbg_wpn_hud_editor:op_par:list", _st)
					self:Register(self.data[v1].par[self.data[v1].cnt],tostring(v1) .. "par_" .. self.data[v1].cnt)
					
					self.data[v1].par_hl[self.data[v1].cnt] = xml:InitStatic("dbg_wpn_hud_editor:op_par:hl_list", _st)
				else
					self.data[v1].par[self.data[v1].cnt] = xml:InitEditBox("dbg_wpn_hud_editor:op_par:input" .. ext, _st)
					self:Register(self.data[v1].par[self.data[v1].cnt],tostring(v1) .. "par_" .. self.data[v1].cnt)
					
					if v.typ == 1 then
						self.data[v1].par[self.data[v1].cnt]:SetText(v.def)
					else
						self.data[v1].par[self.data[v1].cnt]:SetText(v.def[i])
					end
					
					self.data[v1].par_hl[self.data[v1].cnt] = xml:InitStatic("dbg_wpn_hud_editor:op_par:hl" .. ext, _st)
				end
				
				-- Hightlight last selected parameter
				if (self.data[v1].cnt ~= _selected[v1]) then
					self.data[v1].par_hl[self.data[v1].cnt]:Show(false)
				end
			end
			
			self.data[v1].scroll_par:AddWindow(_st, true)
			_st:SetAutoDelete(false)
		end
		if i > 1 then
			self.data[v].scroll_par:Show(false)
		end
	end
	
	
	-- Lines
	xml:InitStatic("dbg_wpn_hud_editor:line_1",self.dialog)
	xml:InitStatic("dbg_wpn_hud_editor:line_2",self.dialog)
	
	
	-- Message Window 
	self.msg_wnd = xml:InitFrame("hint_wnd:background",self)
	self.msg_wnd:SetAutoDelete(false)
	self.msg_wnd_text = xml:InitTextWnd("hint_wnd:text",self.msg_wnd)
	self.msg_wnd_text:SetTextAlignment(2)
	
	self.msg_wnd:Show(false)
	self.msg_wnd:SetColor(GetARGB(255,0,0,0))
	
	-- Hint Window 
	self.hint_wnd = xml:InitFrame("help_wnd:background",self)
	self.hint_wnd:SetAutoDelete(false)
	self.hint_wnd_text = xml:InitTextWnd("help_wnd:text",self.hint_wnd)
	--self.hint_wnd_text:SetTextAlignment(2)
	self.hint_wnd_text:SetText(game.translate_string("st_ui_dbg_hud_about"))
	self.hint_wnd_text:AdjustHeightToText()
	self.hint_wnd_text:SetWndSize(vector2():set(msg_width, self.hint_wnd_text:GetHeight()+10))
	self.hint_wnd_text:SetWndPos(vector2():set(20,10))
	
	self.hint_wnd:Show(false)
	self.hint_wnd:SetWndSize(vector2():set(msg_width, 700))
	self.hint_wnd:SetWndPos(vector2():set( self.dialog:GetWidth() , 1 ))
	self.hint_wnd:SetColor(GetARGB(255,0,0,0))

	self.disable_drag = true
	self.pos = nil
	self.mouse_hold = nil
	self.save_mode = true
end

function WpnHudEditor:ResetSelects(state_only)
	local xml = self.xml

	-- State Select
	self.dummy_npc_states = {
		{"Unstrapped", "guard_na"},
		{"Strapped", "wait_na"},
		{"Threat", "threat"},
		{"Fire", "threat_fire"},
	}
	self.list_dummy_npc_state = self.list_dummy_npc_state or xml:InitComboBox("dbg_wpn_hud_editor:list_dummy_npc_state", self.dialog)
	self.list_dummy_npc_state:ClearList()
	for i = 1, #self.dummy_npc_states do
		self.list_dummy_npc_state:AddItem(self.dummy_npc_states[i][1], i)
	end
	self.list_dummy_npc_state:enable_id(1)
	self.list_dummy_npc_state:SetText(self.dummy_npc_states[1][1])
	self.dummy_npc_state = self.dummy_npc_states[1][2]
	if dummy_npc then
		db.storage[dummy_npc.id].ui_debug_wpn_hud_dummy.state = self.dummy_npc_state
	end

	if state_only then return end

	-- Time Factor Select
	self.tf = {
		{"TF Normal (1)", 1},
		{"TF Slow-mo (0.1)", 0.1},
		{"TF Freeze (0.01)", 0.01},
	}
	self.tf_select = self.tf_select or xml:InitComboBox("dbg_wpn_hud_editor:list_tf", self.dialog)
	self.tf_select:ClearList()
	for i = 1, #self.tf do
		self.tf_select:AddItem(self.tf[i][1], i)
	end
	self.tf_select:enable_id(1)
	self.tf_select:SetText(self.tf[1][1])
	exec_console_cmd("time_factor " .. 1)

	-- Drag Mode Select (Persistent)
	if not self.select_registered then
		self.drag_modes = {
			{"Drag per-group", true},
			{"Drag per-value", false},
		}
		self.list_drag_mode = self.list_drag_mode or xml:InitComboBox("dbg_wpn_hud_editor:list_drag_mode", self.dialog)
		self.list_drag_mode:ClearList()
		for i = 1, #self.drag_modes do
			self.list_drag_mode:AddItem(self.drag_modes[i][1], i)
		end
		self.list_drag_mode:enable_id(1)
		self.list_drag_mode:SetText(self.drag_modes[1][1])
		self.drag_mode = self.drag_modes[1][2]		
	end

	if not self.select_registered then
		self.select_registered = true
		self:Register(self.tf_select, "tf_select")
		self:Register(self.list_dummy_npc_state, "list_dummy_npc_state")
		self:Register(self.list_drag_mode, "list_drag_mode")
	end
end

function WpnHudEditor:InitCallBacks()
	self:AddCallback("btn_copy", ui_events.BUTTON_CLICKED, self.OnButtonCopy, self)
	self:AddCallback("btn_paste", ui_events.BUTTON_CLICKED, self.OnButtonPaste, self)
	self:AddCallback("btn_save", ui_events.BUTTON_CLICKED, self.OnButtonSave, self)
	self:AddCallback("btn_reload", ui_events.BUTTON_CLICKED, self.OnButtonResume, self)
	self:AddCallback("btn_align", ui_events.BUTTON_CLICKED, self.OnButtonAlign, self)
	self:AddCallback("btn_third_person", ui_events.BUTTON_CLICKED, self.OnButtonThirdPerson, self)

	self:AddCallback("tf_select", ui_events.LIST_ITEM_SELECT, self.OnTfSelect, self)
	self:AddCallback("list_dummy_npc_state", ui_events.LIST_ITEM_SELECT, self.OnDummyNpcStateChange, self)
	self:AddCallback("list_drag_mode", ui_events.LIST_ITEM_SELECT, self.OnDragModeChange, self)
	--self:AddCallback("btn_ratio", ui_events.BUTTON_CLICKED, self.OnButtonRatio, self)

	for i, v in ipairs(self.tables) do
		for i=1,self.data[v].cnt do
			local f = tostring(v).."OnInput_" .. i
			self[f] = function(self)
				self:OnInput(i)
				local group = self.data[v].cnt_to_group[i]
				self:SwitchParamByIndex(group, i)
			end
			self:AddCallback(tostring(v) .. "par_" .. i, ui_events.EDIT_TEXT_COMMIT, self[f], self)
		end
	end
end

function WpnHudEditor:OnTfSelect()
	local id = self.tf_select:CurrentID()
	local tf = self.tf[id][2]
	exec_console_cmd("time_factor " .. tf)
end

function WpnHudEditor:OnDummyNpcStateChange()
	local id = self.list_dummy_npc_state:CurrentID()
	local state = self.dummy_npc_states[id][2]
	self.dummy_npc_state = state
	if dummy_npc then
		db.storage[dummy_npc.id].ui_debug_wpn_hud_dummy.state = self.dummy_npc_state
	end
end

function WpnHudEditor:OnDragModeChange()
	local id = self.list_drag_mode:CurrentID()
	local state = self.drag_modes[id][2]
	self.drag_mode = state
end

function WpnHudEditor:ResetNpcCam()
	self.dummy_npc_cam_offset = {
		heading = 0,
		pitch = 0,
		height = 1.2,
		zoom = 1.5,
		move = -0.2,
	}
	self:SetCam()
end

function WpnHudEditor:SetCam()
	if dummy_npc then
		local obj = level.object_by_id(dummy_npc.id)
		if obj then
			local pos = obj:position():add(vector():set(0, self.dummy_npc_cam_offset.height, 0))
			local obj_pos = vector():set(pos)
			local dir = vector():setHP(utils_data.deg2rad(self.dummy_npc_cam_offset.heading), self.dummy_npc_cam_offset.pitch):normalize()

			pos = pos:mad(dir, self.dummy_npc_cam_offset.zoom)
			dir = vector():set(obj_pos):sub(pos):normalize()
			
			-- dir = vector_rotate_y(dir, 15)
			local d, u, r = generate_orthonormal_basis_normalized(dir)
			pos:mad(r, self.dummy_npc_cam_offset.move)

			dir = vector():set(
				dir:getH(),
				dir:getP(),
				0
			)

			level.set_cam_custom_position_direction(pos, dir)
		end
	end
end

function WpnHudEditor:ChangeNpcCam(heading, height, zoom, move, pitch)
	if heading then
		self.dummy_npc_cam_offset.heading = self.dummy_npc_cam_offset.heading + heading
	end
	if pitch then
		self.dummy_npc_cam_offset.pitch = clamp(self.dummy_npc_cam_offset.pitch + pitch,
			-math.pi / 2.6, math.pi / 2.05)
	end
	if height then
		self.dummy_npc_cam_offset.height = clamp(self.dummy_npc_cam_offset.height + height, 0.2, 2)
	end
	if zoom then
		self.dummy_npc_cam_offset.zoom = clamp(self.dummy_npc_cam_offset.zoom + zoom, 0.2, 2.5)
	end
	if move then
		self.dummy_npc_cam_offset.move = clamp(self.dummy_npc_cam_offset.move + move, -1.5, 1.5)
	end
	self:SetCam()
end

function WpnHudEditor:StopCam()
	if dummy_npc then
		alife():release(dummy_npc)
		dummy_npc = nil
	end
	if level.remove_cam_custom_position_direction then level.remove_cam_custom_position_direction() end
	RemoveTimeEvent("ui_debug_wpn_hud_dummy", "ui_debug_wpn_hud_dummy_npc")
	RemoveTimeEvent("ui_debug_wpn_hud_dummy", "ui_debug_wpn_hud_dummy_weapon")
	self.dummy_npc_state = self.dummy_npc_states[1][2]
end

function WpnHudEditor:DisableWCT(v)
	if weapon_cover_tilt and weapon_cover_tilt.set_force_disabled then
		weapon_cover_tilt.set_force_disabled(v)
	end
end

function WpnHudEditor:Reset(force,use_cache)
	local _use_cache = use_cache and is_not_empty(_cache) and is_not_empty(_cache_i) and true

	self:DisableWCT(true)
		
	local section = self.section
	local hud_section = ini_sys:r_string_ex(section,"hud")
	local str = utils_xml.is_widescreen() and "_16x9" or ""
	local ltx = ini_file("temp_hud.ltx")
	local section_found = ltx and ltx:section_exist(hud_section)
	
	self.txt_section:SetText(section)

	for i, v in ipairs(self.tables) do
		empty_table(self.data[v].index)

		local _use_cache = use_cache and is_not_empty(_cache) and is_not_empty(_cache[v]) and is_not_empty(_cache_i) and is_not_empty(_cache_i[v]) and true
		
		-- Read values and convert to numbers if needed
		if _use_cache then 
			--print_dbg("/ WpnHudEditor:Reset | use cache")
			copy_table(self.data[v].value_i, _cache_i[v])
			
			if not _memo_i[v] then _memo_i[v] = {} end
			if (not _memo_i[v][section]) then _memo_i[v][section] = {} end
			copy_table(_memo_i[v][section], _cache_i[v])
		elseif _memo_i[v] and _memo_i[v][section] then
			--print_dbg("/ WpnHudEditor:Reset | use memo | file: %s - hour: %s", file, hour)
			copy_table(self.data[v].value_i, _memo_i[v][section])
		else
			local v1 = v
			for par,v in pairs(v1) do
				local t = {}
				if (v.hud) then
					local par_str = v.no_16x9 and par or (par..str)
					if section_found and ltx:r_string_ex(hud_section,(par_str)) then
						t = parse_list(ltx, hud_section, (par_str))
					else
						t = parse_list(ini_sys, hud_section, (par_str))
					end
				else
					if ltx:r_string_ex(section, par) then
						t = parse_list(ltx, section, par)
					else
						t = parse_list(ini_sys, section, par)
					end
				end
				
				self.data[v1].value_i[par] = {}
				for i=1,#t do
					if (v.typ ~= 0) then
						self.data[v1].value_i[par][i] = tonumber(t[i])
					end
				end
				
				-- use default values if nothing is found
				if (#self.data[v1].value_i[par] == 0) then
					if (v.typ == 1) then
						self.data[v1].value_i[par][1] = v.def
					else
						copy_table(self.data[v1].value_i[par], v.def)
					end
				end
			end
		end
		
		-- Fill current values
		for i=1,self.data[v].cnt do
			local value
			if _use_cache then
				value = _cache[v][i]
				
				if (not _memo[v]) then _memo[v] = {} end
				if (not _memo[v][section]) then _memo[v][section] = {} end
				_memo[v][section][i] = _cache[v][i]
			elseif _memo[v] and _memo[v][section] then
				value = _memo[v][section][i]
			else
				value = self:GetParameterValue(i, v)
			end
			-- print_dbg("/ WpnHudEditor:Reset | Filler | self.value[%s] (%s) = %s", i, self.parent[i], value)
			
			self.data[v].value[i] = value
			self.data[v].par[i]:SetText(value)
		end
	end

	
	-- Apply values in-game
	for i, t in ipairs(self.tables) do
		if t == third_person_parameters then
			self:ApplyThirdPersonParameterValue()
		else
			for par,v in pairs(t) do
				self:ApplyParameterValue(v.typ, par, t)
			end
		end
	end
	
	-- Crosshair state
	self.crosshair = get_console_cmd(1,"hud_crosshair")
	if self._w:IsShown() then
		exec_console_cmd("hud_crosshair on")
	end

	self.disable_drag = true
	self.pos = nil
	self.mouse_hold = nil
	-- self.drag_mode = true
end


---------------< Utility >---------------
local indx_str = {
	[1] = "_x",
	[2] = "_y",
	[3] = "_z",
	[4] = "_a",
}
function WpnHudEditor:GetStringByType(indx,typ)
	if (typ == 0) or (typ == 1) then
		return ""
	else
		return indx_str[indx]
	end
end

function WpnHudEditor:GetParameterValue(cnt, v)
	local str = self.data[v].name[cnt]
	local parent = self.data[v].parent[cnt]
	local typ = self.data[v].typ[cnt]
	
	print_dbg("/ WpnHudEditor:GetParameterValue | str: %s - parent: %s - typ: %s", str, parent, typ)
	if (typ == 0) or (typ == 1) then
		return self.data[v].value_i[parent][1]
	end
	
	if (string.sub(str,-2) == "_x") then return self.data[v].value_i[parent][1]
	elseif (string.sub(str,-2) == "_y") then return self.data[v].value_i[parent][2]
	elseif (string.sub(str,-2) == "_z") then return self.data[v].value_i[parent][3]
	elseif (string.sub(str,-2) == "_a") then return self.data[v].value_i[parent][4]
	end
	printe("!ERROR no returned value for %s!", parent)
end

function WpnHudEditor:SetParameterValue(cnt,value)
	local v = self.active_table
	local str = self.data[v].name[cnt]
	local parent = self.data[v].parent[cnt]
	local typ = self.data[v].typ[cnt]
	
	if self:IsInvalidValue(cnt,typ,value) then
		self:Send_MSG("!ERROR nil value found for parameter [%s]", str)
		return
	end
	
	if (typ == 1) then
		self.data[v].value_i[parent][1] = value
	elseif (string.sub(str,-2) == "_x") then self.data[v].value_i[parent][1] = value
	elseif (string.sub(str,-2) == "_y") then self.data[v].value_i[parent][2] = value
	elseif (string.sub(str,-2) == "_z") then self.data[v].value_i[parent][3] = value
	elseif (string.sub(str,-2) == "_a") then self.data[v].value_i[parent][4] = value
	end
	
	local section = self.section
	if not _memo[v] then _memo[v] = {} end
	if not _memo_i[v] then _memo_i[v] = {} end

	if (not _memo[v][section]) then _memo[v][section] = {} end
	copy_table(_memo[v][section], self.data[v].value)
	
	if (not _memo_i[v][section]) then _memo_i[v][section] = {} end
	copy_table(_memo_i[v][section], self.data[v].value_i)
end

function WpnHudEditor:ApplyParameterValue(typ, parent, v)
	v = v or self.active_table
	print_dbg("# Setting now: %s",parent)
	
	if v == third_person_parameters then
		self:ApplyThirdPersonParameterValue()
	else
		if (typ == 1) then
			local value = self.data[v].value_i[parent][1]
			if value and (type(value) == "number") then
				hud_adjust.set_value(parent, value)
				print_dbg("-hud_adjust.set_value(%s,%s)",parent,value)
			else
				printe("! MISSING VALUE: WpnHudEditor:ApplyParameterValue(%s, %s)", typ ,parent)
			end
		elseif (typ == 2) then
			local value_1 = self.data[v].value_i[parent][1]
			local value_2 = self.data[v].value_i[parent][2]
			local value_3 = self.data[v].value_i[parent][3]
			if value_1 and (type(value_1) == "number")
			and value_2 and (type(value_2) == "number")
			and value_3 and (type(value_3) == "number")
			then
				hud_adjust.set_vector(v[parent].idxa, v[parent].idxb, value_1, value_2, value_3)
				print_dbg("-hud_adjust.set_vector[%s]([%s][%s]: %s,%s,%s)", parent, v[parent].idxa, v[parent].idxb, value_1, value_2, value_3)
			else
				printe("! MISSING VALUE: WpnHudEditor:ApplyParameterValue(%s, %s)", typ ,parent)
			end
		elseif (typ == 3) then
			local value_1 = self.data[v].value_i[parent][1]
			local value_2 = self.data[v].value_i[parent][2]
			local value_3 = self.data[v].value_i[parent][3]
			local value_4 = self.data[v].value_i[parent][4]
			if value_1 and (type(value_1) == "number")
			and value_2 and (type(value_2) == "number")
			and value_3 and (type(value_3) == "number")
			and value_4 and (type(value_4) == "number")
			then
				--weather.set_value_vector(parent,value_1,value_2,value_3,value_4)
				print_dbg("-weather.set_value_vector2(%s,%s,%s,%s,%s)",parent,value_1,value_2,value_3,value_4)
			else
				printe("! MISSING VALUE: WpnHudEditor:ApplyParameterValue(%s, %s)", typ ,parent)
			end
		end
	end
end

function WpnHudEditor:ApplyThirdPersonParameterValue()
	if not self.weapon_cobj then
		print_dbg("no active weapon to set")
		return
	end

	if not (
		self.weapon_cobj.Set_mOffset 
		and self.weapon_cobj.Set_mStrapOffset
		and self.weapon_cobj.Set_mFirePoint
		and self.weapon_cobj.Set_mFirePoint2
		and self.weapon_cobj.Set_mShellPoint
	) then
		self:Print(nil, "Modded exes not installed, third person editor is unavailable")
		return
	end

	local params = {}
	for par,v in pairs(third_person_parameters) do
		local typ = v.typ
		local parent = par
		if (typ == 1) then
			local value = self.data[third_person_parameters].value_i[parent][1]
			if value and (type(value) == "number") then
				params[parent] = value
				print_dbg("-third_person_value(%s,%s)",parent,value)
			else
				printe("! MISSING VALUE: third_person_value(%s,%s)", typ ,parent)
			end
		elseif (typ == 2) then
			local value_1 = self.data[third_person_parameters].value_i[parent][1]
			local value_2 = self.data[third_person_parameters].value_i[parent][2]
			local value_3 = self.data[third_person_parameters].value_i[parent][3]
			if value_1 and (type(value_1) == "number")
			and value_2 and (type(value_2) == "number")
			and value_3 and (type(value_3) == "number")
			then
				params[parent] = vector():set(value_1, value_2, value_3)
				print_dbg("-third_person_value(%s,%s,%s,%s)",parent,value_1, value_2, value_3)
			else
				printe("! MISSING VALUE: third_person_value(%s, %s)", typ ,parent)
			end
		end
	end

	if params.position and params.orientation then
		self.weapon_cobj:Set_mOffset(params.position, params.orientation)
	end

	if params.strap_position and params.strap_orientation then
		self.weapon_cobj:Set_mStrapOffset(params.strap_position, params.strap_orientation)
	end

	if params.fire_point then
		self.weapon_cobj:Set_mFirePoint(params.fire_point)
	end

	if params.fire_point2 then
		self.weapon_cobj:Set_mFirePoint2(params.fire_point2)
	end

	if params.shell_point then
		self.weapon_cobj:Set_mShellPoint(params.shell_point)
	end
end

function WpnHudEditor:IsInvalidValue(cnt,typ,value)
	
	-- Numbers
	if not (value and value ~= "" and tonumber(value)) then
		return true
	end
	
	return false
end

function WpnHudEditor:Send_MSG(text,...)
	printf(text, ...)
	self:Print(nil, strformat(text,...))
	-- local str = strformat(text,...)
	
	-- self.msg_wnd:Show(true)
	-- self.msg_wnd_text:SetText(str)
	-- self.msg_wnd_text:AdjustHeightToText()
	-- self.msg_wnd_text:SetWndSize(vector2():set(msg_width, self.msg_wnd_text:GetHeight()+10))
	-- self.msg_wnd_text:SetWndPos(vector2():set(0,20))
	
	-- self.msg_wnd:SetWndSize(vector2():set(msg_width, self.msg_wnd_text:GetHeight()+44))
	-- self.msg_wnd:SetWndPos(vector2():set( self.dialog:GetWidth() , (_hight - self.msg_wnd:GetHeight()) ))
	
	-- self.msg_wnd_timer = time_global() + 4000
end

local toggle_hint = false
function WpnHudEditor:ShowHint()
	toggle_hint = not toggle_hint

	self.hint_wnd_show = toggle_hint
end

function WpnHudEditor:Update()
	CUIScriptWnd.Update(self)

	if key_state(DIK_keys.DIK_LSHIFT) == 1 then
		jump = jump_2
	elseif key_state(DIK_keys.DIK_LMENU) == 1 then
		jump = jump_3
	else
		jump = jump_1
	end

	self:SetCam()
	self:On_Drag()

	if self.third_person_mode then
		if key_state(bind_to_dik(key_bindings.kFWD)) == 1 then
			self:ChangeNpcCam(nil, nil, -0.003)
		elseif key_state(bind_to_dik(key_bindings.kBACK)) == 1 then
			self:ChangeNpcCam(nil, nil, 0.003)
		end

		if key_state(bind_to_dik(key_bindings.kL_STRAFE)) == 1 then
			self:ChangeNpcCam(nil, nil, nil, -0.003)
		elseif key_state(bind_to_dik(key_bindings.kR_STRAFE)) == 1 then
			self:ChangeNpcCam(nil, nil, nil, 0.003)
		end

		-- Lock condition and ammo count in TP
		if self.weapon_cobj then
			self.weapon_cobj:SetAmmoElapsed(30)
			self.weapon:set_condition(1)
		end
	end
	
	if (self.msg_wnd_timer and time_global() > self.msg_wnd_timer) then 
		self.msg_wnd_timer = nil
		self.msg_wnd:Show(false)
	end
	
	if (self.hint_wnd_show) then 
		self.hint_wnd:Show(true)
	else
		self.hint_wnd:Show(false)
	end
end

function WpnHudEditor:Print(s, str, ...)
	actor_menu.set_msg(1, string.format(str, ...), 2)
end

local tg = 0
local tg_interval = 20
local tg_print = 0
function WpnHudEditor:On_Drag()

	if (self.disable_drag) then
		return
	end

	-- local t = time_global()
	-- if t < tg then return end
	-- tg = t + tg_interval
	
	if not self.pos then self.pos = GetCursorPosition() end

	local pos = GetCursorPosition()
	local diff_y = pos.y - self.pos.y
	local diff_x = pos.x - self.pos.x
	local rounded_diff_y = math.abs(round_idp(diff_y, 4)) * device().width / 1920
	local rounded_diff_x = math.abs(round_idp(diff_x, 4)) * device().width / 1920

	-- if time_global() - tg_print > 100 then
	-- 	printf("ratio %s", device().width / 1920)
	-- 	printf("%s, %s", rounded_diff_x, rounded_diff_y)
	-- 	self:Print(nil, rounded_diff_x .. ", " .. rounded_diff_y)
	-- 	tg_print = time_global()
	-- end

	if self.mouse_hold and self.mouse_hold == DIK_keys.MOUSE_3 and self.third_person_mode then
		if key_state(DIK_keys.DIK_LCONTROL) == 1 then
			if diff_y < 0 then
				self:ChangeNpcCam(nil, nil, 0.003 * -rounded_diff_y)
			elseif diff_y > 0 then
				self:ChangeNpcCam(nil, nil, 0.003 * rounded_diff_y)
			end
		elseif key_state(DIK_keys.DIK_LSHIFT) == 1 then
			if diff_x < 0 then
				self:ChangeNpcCam(nil, nil, nil, 0.0015 * rounded_diff_x)
			elseif diff_x > 0 then
				self:ChangeNpcCam(nil, nil, nil, 0.0015 * -rounded_diff_x)
			end
			if diff_y < 0 then
				self:ChangeNpcCam(nil, 0.0015 * -rounded_diff_y)
			elseif diff_y > 0 then
				self:ChangeNpcCam(nil, 0.0015 * rounded_diff_y)
			end
		else
			if diff_x < 0 then
				self:ChangeNpcCam(0.15 * rounded_diff_x)
			elseif diff_x > 0 then
				self:ChangeNpcCam(0.15 * -rounded_diff_x)
			end
			if diff_y < 0 then
				self:ChangeNpcCam(nil, nil, nil, nil, 0.0015 * -rounded_diff_y)
			elseif diff_y > 0 then
				self:ChangeNpcCam(nil, nil, nil, nil, 0.0015 * rounded_diff_y)
			end
		end
	end

	local v = self.active_table
	if self.drag_mode == true then
		local group = self.data[v].cnt_group[self.data[v].selected_group]
		if self.mouse_hold and self.mouse_hold == DIK_keys.MOUSE_1 then
			if self.data[v].selected_group == 2 then -- Hands orientation
				if diff_y < 0 then
					self:SwitchValue(true, group[2], 8 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[2], 8 * rounded_diff_y)
				end
				if diff_x < 0 then
					self:SwitchValue(true, group[1], 8 * rounded_diff_x)
				elseif diff_x > 0 then
					self:SwitchValue(false, group[1], 8 * rounded_diff_x)
				end
			elseif self.data[v].selected_group == 4 and v == third_person_parameters then -- TP Strapped Orientation
				if diff_y > 0 then
					self:SwitchValue(true, group[1], 8 * rounded_diff_y)
				elseif diff_y < 0 then
					self:SwitchValue(false, group[1], 8 * rounded_diff_y)
				end
				if diff_x > 0 then
					self:SwitchValue(true, group[2], 8 * rounded_diff_x)
				elseif diff_x < 0 then
					self:SwitchValue(false, group[2], 8 * rounded_diff_x)
				end
			elseif self.data[v].selected_group == 4 then -- Aim orientation
				if diff_y > 0 then
					self:SwitchValue(true, group[1], 1 * rounded_diff_y)
				elseif diff_y < 0 then
					self:SwitchValue(false, group[1], 1 * rounded_diff_y)
				end
				if diff_x > 0 then
					self:SwitchValue(true, group[2], 1 * rounded_diff_x)
				elseif diff_x < 0 then
					self:SwitchValue(false, group[2], 1 * rounded_diff_x)
				end
			elseif self.data[v].selected_group == 6 and v ~= third_person_parameters then -- GL orientation
				if diff_y > 0 then
					self:SwitchValue(true, group[1], 1 * rounded_diff_y)
				elseif diff_y < 0 then
					self:SwitchValue(false, group[1], 1 * rounded_diff_y)
				end
				if diff_x > 0 then
					self:SwitchValue(true, group[2], 1 * rounded_diff_x)
				elseif diff_x < 0 then
					self:SwitchValue(false, group[2], 1 * rounded_diff_x)
				end
			elseif self.data[v].selected_group == 8 then -- Alt orientation
				if diff_y > 0 then
					self:SwitchValue(true, group[1], 1 * rounded_diff_y)
				elseif diff_y < 0 then
					self:SwitchValue(false, group[1], 1 * rounded_diff_y)
				end
				if diff_x > 0 then
					self:SwitchValue(true, group[2], 1 * rounded_diff_x)
				elseif diff_x < 0 then
					self:SwitchValue(false, group[2], 1 * rounded_diff_x)
				end
			elseif self.data[v].selected_group == 17 then -- Item Position
				if diff_y < 0 then
					self:SwitchValue(true, group[2], rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[2], rounded_diff_y)
				end
				if diff_x > 0 then
					self:SwitchValue(true, group[1], rounded_diff_x)
				elseif diff_x < 0 then
					self:SwitchValue(false, group[1], rounded_diff_x)
				end
			elseif self.data[v].selected_group == 18 then -- Item Orientation
				if diff_y < 0 then
					self:SwitchValue(true, group[2], 8 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[2], 8 * rounded_diff_y)
				end
				if diff_x < 0 then
					self:SwitchValue(true, group[1], 8 * rounded_diff_x)
				elseif diff_x > 0 then
					self:SwitchValue(false, group[1], 8 * rounded_diff_x)
				end
			elseif self.data[v].selected_group == 16 then -- UI orientation
				if diff_y > 0 then
					self:SwitchValue(true, group[1], round_idp(0.02 * rounded_diff_y, 4))
				elseif diff_y < 0 then
					self:SwitchValue(false, group[1], round_idp(0.02 * rounded_diff_y, 4))
				end
				if diff_x > 0 then
					self:SwitchValue(true, group[2], round_idp(0.02 * rounded_diff_x, 4))
				elseif diff_x < 0 then
					self:SwitchValue(false, group[2], round_idp(0.02 * rounded_diff_x, 4))
				end
			elseif self.data[v].selected_group == 10 then -- Lowered orientation
				if diff_y > 0 then
					self:SwitchValue(true, group[1], 1 * rounded_diff_y)
				elseif diff_y < 0 then
					self:SwitchValue(false, group[1], 1 * rounded_diff_y)
				end
				if diff_x > 0 then
					self:SwitchValue(true, group[2], 1 * rounded_diff_x)
				elseif diff_x < 0 then
					self:SwitchValue(false, group[2], 1 * rounded_diff_x)
				end
			elseif 	self.data[v].selected_group == 21 or 
					self.data[v].selected_group == 20 or 
					self.data[v].selected_group == 19 then  -- Last 3 groups with single value
				if diff_y < 0 then
					self:SwitchValue(true, group[1], round_idp(0.2 * rounded_diff_y, 4))
				elseif diff_y > 0 then
					self:SwitchValue(false, group[1], round_idp(0.2 * rounded_diff_y, 4))
				end
			else  -- Everything else
				if diff_y < 0 then
					self:SwitchValue(true, group[2], 1 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[2], 1 * rounded_diff_y)
				end
				if diff_x > 0 then
					self:SwitchValue(true, group[1], 1 * rounded_diff_x)
				elseif diff_x < 0 then
					self:SwitchValue(false, group[1], 1 * rounded_diff_x)
				end
			end
		elseif self.mouse_hold and self.mouse_hold == DIK_keys.MOUSE_2 then
			if self.data[v].selected_group == 2 then -- Hands orientation
				if diff_y < 0 then
					self:SwitchValue(true, group[3], 8 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[3], 8 * rounded_diff_y)
				end
			elseif self.data[v].selected_group == 4 and v == third_person_parameters then -- TP Strapped Orientation
				if diff_y < 0 then
					self:SwitchValue(true, group[3], 8 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[3], 8 * rounded_diff_y)
				end
			elseif self.data[v].selected_group == 16 then -- UI orientation
				if diff_y < 0 then
					self:SwitchValue(true, group[3], round_idp(0.02 * rounded_diff_y, 4))
				elseif diff_y > 0 then
					self:SwitchValue(false, group[3], round_idp(0.02 * rounded_diff_y, 4))
				end
			elseif self.data[v].selected_group == 17 then -- Item Position
				if diff_y < 0 then
					self:SwitchValue(true, group[3], 2 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[3], 2 * rounded_diff_y)
				end
			elseif self.data[v].selected_group == 18 then -- Item Orientation
				if diff_y < 0 then
					self:SwitchValue(true, group[3], 8 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[3], 8 * rounded_diff_y)
				end
			elseif 	self.data[v].selected_group == 21 or 
				self.data[v].selected_group == 20 or 
				self.data[v].selected_group == 19 then  -- Last 3 groups with single value
				if diff_y < 0 then
					self:SwitchValue(true, group[1], round_idp(0.2 * rounded_diff_y, 4))
				elseif diff_y > 0 then
					self:SwitchValue(false, group[1], round_idp(0.2 * rounded_diff_y, 4))
				end
			else  -- Everything else
				if diff_y < 0 then
					self:SwitchValue(true, group[3], 1 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, group[3], 1 * rounded_diff_y)
				end
			end
		end
	elseif self.drag_mode == false then
		if self.mouse_hold and (self.mouse_hold == DIK_keys.MOUSE_1 or self.mouse_hold == DIK_keys.MOUSE_2) then
			if self.data[v].selected_group == 2 then -- Hands orientation
				if diff_y < 0 then
					self:SwitchValue(true, self.data[v].selected, 8 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, self.data[v].selected, 8 * rounded_diff_y)
				end
			elseif self.data[v].selected_group == 4 and v == third_person_parameters then -- TP Strapped Orientation
				if diff_y < 0 then
					self:SwitchValue(true, self.data[v].selected, 8 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, self.data[v].selected, 8 * rounded_diff_y)
				end	
			elseif self.data[v].selected_group == 16 then -- UI orientation
				if diff_y < 0 then
					self:SwitchValue(true, self.data[v].selected, round_idp(0.02 * rounded_diff_y, 4))
				elseif diff_y > 0 then
					self:SwitchValue(false, self.data[v].selected, round_idp(0.02 * rounded_diff_y, 4))
				end
			elseif 	self.data[v].selected_group == 21 or 
					self.data[v].selected_group == 20 or 
					self.data[v].selected_group == 19 then  -- Last 3 groups with single value
				if diff_y < 0 then
					self:SwitchValue(true, self.data[v].selected, round_idp(0.2 * rounded_diff_y, 4))
				elseif diff_y > 0 then
					self:SwitchValue(false, self.data[v].selected, round_idp(0.2 * rounded_diff_y, 4))
				end
			else  -- Everything else
				if diff_y < 0 then
					self:SwitchValue(true, self.data[v].selected, 1 * rounded_diff_y)
				elseif diff_y > 0 then
					self:SwitchValue(false, self.data[v].selected, 1 * rounded_diff_y)
				end
			end
		end
	end

	SetCursorPosition(self.pos)
end


---------------< Callbacks >---------------
function WpnHudEditor:OnButtonCopy()
	local v = self.active_table
	_cache[v] = _cache[v] or {}
	_cache_i[v] = _cache_i[v] or {}
	copy_table(_cache[v], self.data[v].value)
	copy_table(_cache_i[v], self.data[v].value_i)
	
	self:Send_MSG("Copied values")
end

function WpnHudEditor:OnButtonPaste()
	local v = self.active_table
	if (_cache and _cache_i and _cache[v] and _cache_i[v]) then
		self:Reset(false, true)
		self:Send_MSG("Applied copied values")
	else
		self:Send_MSG("No values are copied yet!")
	end
end

function WpnHudEditor:SaveCacheDbg()
	local section = self.section
	local hud_section = ini_sys:r_string_ex(section,"hud")
	local prefix = utils_xml.is_widescreen() and "_16x9" or ""
	local all_prefix = self.btn_ratio:GetCheck()
	local ini_cc = ui_debug_launcher.ini_cc
	
	local function saveParams()
		local to_save = {}
		for par,v in pairs(parameters) do
			local value, value_def
			if (v.typ == 2) then
				value = self.data[parameters].value_i[par][1] ..",".. self.data[parameters].value_i[par][2] ..",".. self.data[parameters].value_i[par][3]
				value_def = v.def[1] ..",".. v.def[2] ..",".. v.def[3]
			elseif (v.typ == 3) then
				value = self.data[parameters].value_i[par][1] ..",".. self.data[parameters].value_i[par][2] ..",".. self.data[parameters].value_i[par][3] ..",".. self.data[parameters].value_i[par][4]
				value_def = v.def[1] ..",".. v.def[2] ..",".. v.def[3] ..",".. v.def[4]
			else
				value = self.data[parameters].value_i[par][1]
				value_def = v.def
			end
			
			value = tostring(value)
			value_def = tostring(value_def)
			local par_str = (v.hud and not v.no_16x9) and (par_str) or par
			local old_value = v.hud and ini_sys:r_string_ex(hud_section, par_str) or ini_sys:r_string_ex(section, par)
			local c_sec = v.hud and hud_section or section
			local c_par = par_str
			
			if (value ~= old_value) and (value ~= value_def) then
				if (to_save[c_sec] == nil) then to_save[c_sec] = {} end
				to_save[c_sec][c_par] = value
			end
		end
		
		if is_empty(to_save) then
			self:Print(nil, "No HUD values are modified for %s", section)
			return
		end
		
		local params_wide = {
			["hands_position"] = true,
			["hands_orientation"] = true,
			["aim_hud_offset_pos"] = true,
			["aim_hud_offset_rot"] = true,
			["gl_hud_offset_pos"] = true,
			["gl_hud_offset_rot"] = true,
			["aim_hud_offset_alt_pos"] = true,
			["aim_hud_offset_alt_rot"] = true,
			["lowered_hud_offset_pos"] = true,
			["lowered_hud_offset_rot"] = true,
			["strafe_hud_offset_pos"] = true,
			["strafe_hud_offset_rot"] = true,
			["strafe_aim_hud_offset_pos"] = true,
			["strafe_aim_hud_offset_rot"] = true,
		}
		
		for k, v in pairs(to_save) do
			for k1, v1 in pairs(v) do
				ini_cc:w_value(k, k1, v1)
				if all_prefix then
					if params_wide[k1] then
						ini_cc:w_value(k, k1 .. "_16x9", v1)
					end
				end
			end
		end

		return true
	end

	local function saveThirdPersonParams()
		local to_save = {}
		for par,v in pairs(third_person_parameters) do
			local value, value_def
			if (v.typ == 2) then
				value = self.data[third_person_parameters].value_i[par][1] ..",".. self.data[third_person_parameters].value_i[par][2] ..",".. self.data[third_person_parameters].value_i[par][3]
				value_def = v.def[1] ..",".. v.def[2] ..",".. v.def[3]
			elseif (v.typ == 3) then
				value = self.data[third_person_parameters].value_i[par][1] ..",".. self.data[third_person_parameters].value_i[par][2] ..",".. self.data[third_person_parameters].value_i[par][3] ..",".. self.data[third_person_parameters].value_i[par][4]
				value_def = v.def[1] ..",".. v.def[2] ..",".. v.def[3] ..",".. v.def[4]
			else
				value = self.data[third_person_parameters].value_i[par][1]
				value_def = v.def
			end
			
			value = tostring(value)
			value_def = tostring(value_def)
			local par_str = par
			local old_value = ini_sys:r_string_ex(section, par)
			local c_sec = section
			local c_par = par_str
			
			if (value ~= old_value) and (value ~= value_def) then
				if (to_save[c_sec] == nil) then to_save[c_sec] = {} end
				to_save[c_sec][c_par] = value
			end
		end
		
		if is_empty(to_save) then
			self:Print(nil, "No Third Person values are modified for %s", section)
			return
		end
		
		for k, v in pairs(to_save) do
			for k1, v1 in pairs(v) do
				ini_cc:w_value(k, k1, v1)
			end
		end

		return true
	end

	local res = saveParams()
	res = saveThirdPersonParams() or res
	if res then
		ini_cc:save()
		self:Print(nil, "%s section is saved in cache_dbg.ltx", section)
	else
		self:Print(nil, "%s no changes were made", section)
	end
end

function WpnHudEditor:CleanCacheDbg()
	local path = getFS():update_path('$game_config$', '') .. "cache_dbg.ltx"
	local ini_io = io.open(path, 'w')
	ini_io:close()
	ui_debug_launcher.ini_cc = ini_file_ex("cache_dbg.ltx",true)
	self:Print(nil, "cache_dbg.ltx file cleaned")
end

function WpnHudEditor:OnButtonSave()
	if self.save_mode then
		return self:SaveCacheDbg()
	end
	local section = self.section
	local hud_section = ini_sys:r_string_ex(section,"hud")
	local prefix = utils_xml.is_widescreen() and "_16x9" or ""
	local all_prefix = self.btn_ratio:GetCheck()
	
	local to_save = {}
	for par,v in pairs(parameters) do
		local value, value_def
		if (v.typ == 2) then
			value = self.data[parameters].value_i[par][1] ..",".. self.data[parameters].value_i[par][2] ..",".. self.data[parameters].value_i[par][3]
			value_def = v.def[1] ..",".. v.def[2] ..",".. v.def[3]
		elseif (v.typ == 3) then
			value = self.data[parameters].value_i[par][1] ..",".. self.data[parameters].value_i[par][2] ..",".. self.data[parameters].value_i[par][3] ..",".. self.data[parameters].value_i[par][4]
			value_def = v.def[1] ..",".. v.def[2] ..",".. v.def[3] ..",".. v.def[4]
		else
			value = self.data[parameters].value_i[par][1]
			value_def = v.def
		end
		
		value = tostring(value)
		value_def = tostring(value_def)
		local par_str = (v.hud and not v.no_16x9) and (par..prefix) or par
		local old_value = v.hud and ini_sys:r_string_ex(hud_section, par_str) or ini_sys:r_string_ex(section, par)
		local c_sec = v.hud and hud_section or section
		local c_par = par_str
		
		if (value ~= old_value) and (value ~= value_def) then
			if (to_save[c_sec] == nil) then to_save[c_sec] = {} end
			to_save[c_sec][c_par] = value
		end
	end
	
	if is_empty(to_save) then
		self:Print(nil, "No HUD values are modified for [%s]", section)
		return
	end
	
	local function file_exists(path)
		return io.open(path) ~= nil
	end
	
	local save_done
	local ini_cc = ui_debug_launcher.ini_cc
	local function on_execute(path,filename,quit)
	
		if is_empty(to_save) then
			return
		end
				
		local fullpath = path.."\\"..filename
		local ltx = io.open(fullpath,"rb")
		if (ltx) then
			local data = ltx:read("*all")
			ltx:close()
			if (data) then
				for sec,v in pairs(to_save) do
					if (string.find(data,"["..sec.."]",nil,true)) then
						ltx = utils_data.cfg_file(fullpath, true)
						if (ltx) then
							for par,val in pairs(v) do
								local p = { par }
								if all_prefix then
									local p2 = par
									if (prefix == "_16x9") then
										p2 = string.gsub(p2, "_16x9", "")
									else
										p2 = p2 .. "_16x9"
									end
									p[2] = p2
								end
								
								for i=1,#p do
									ltx:SetValue(sec, p[i], val)
									
									-- Cache values for the first time so you can return to it upon reseting values
									local cached_val = ini_cc:r_value(sec, p[i])
									if not (cached_val and cached_val ~= "") then
										local val_old = ini_sys:r_string_ex(sec, p[i])
										ini_cc:w_value(sec, p[i], val_old)
									end
									
									printf("% WpnHudEditor | saving [%s]->[%s]->[%s]",sec, p[i], val)
								end
							end
							
							ltx:SaveExt()
							to_save[sec] = nil
							save_done = true
							
							self:Print(nil, "Applied and saved the new values for [%s]\\nFile: %s", sec, t_dir .. filename)
							printf("% WpnHudEditor | saved changes for {%s}", fullpath)
						end
					end
				end
			end
		end
	end
	
	local sp = getFS():update_path('$game_config$', t_dir)
	sp = string.sub(sp,0,string.len(sp)-1)
	lua_ext.recurse_subdirectories_and_execute(sp,{"ltx"},on_execute)
	
	-- Reload system_ini() to adapt the new values in game
	reload_ini_sys()
	
	self:Reset()
	
	if (not save_done) then
		self:Print(nil, "No changes are made on [%s].\\nKeep in mind that configs must be unpacked before applying changes!", section)
	else
		-- Cache original values
		ini_cc:save()
		
		-- Remove cached HUD model from engine, so it updates to the new values
		hud_adjust.remove_hud_model(section)
		
		-- Close the UI
		self:Close()
		
		local str = strformat( "Changes are saved to [%s]", section)
		actor_menu.set_msg(1, str,5)
		
		-- Clean memory of this section to adapt the new changes
		_memo[section] = nil
		_memo_i[section] = nil
	end
end

function WpnHudEditor:OnButtonAlign()
	if self._h:IsShown() then
		self._h:Show(false)
		self._w:Show(false)
		exec_console_cmd("hud_crosshair off")
		print_dbg("! WpnHudEditor | Hide alignments")
	else
		self._h:Show(true)
		self._w:Show(true)
		exec_console_cmd("hud_crosshair on")
		print_dbg("- WpnHudEditor | Show alignments")
	end
end

function WpnHudEditor:OnButtonResume()
	self:Close()
	
	-- Resume normal hud behavior
	hud_adjust.enabled(false)
	adjust_active = false
	
	actor_menu.set_msg(1, "HUD adjust mode is stopped",5)
	
	--ui = nil
end

function WpnHudEditor:CleanMemo()
	empty_table(_memo)
	empty_table(_memo_i)
	self:Reset(false)
	self:Send_MSG("Cleared memory!")
end

function WpnHudEditor:SwitchParam(state, vert)

	local v = self.active_table
	local function get_param_index(state, vert)
	
		--// Vertical movement
		if vert then
			local jumps = ((jump == jump_3) and 3) or ((jump == jump_2) and 2) or 1
			
			if state then
				self.data[v].selected_group = self.data[v].selected_group + jumps
			else
				self.data[v].selected_group = self.data[v].selected_group - jumps
			end
			
			if (self.data[v].selected_group > #self.data[v].cnt_group) then
				self.data[v].selected_group = 1
			elseif (self.data[v].selected_group < 1) then
				self.data[v].selected_group = #self.data[v].cnt_group
			end
			
			return self.data[v].cnt_group[self.data[v].selected_group][1]
		
		--// Horizental movement
		else
			print_dbg("selected_group: %s", self.data[v].selected_group)
			local group = self.data[v].cnt_group[self.data[v].selected_group]
			if group then
				local first = group[1]
				local last = group[#group]
				if state and (self.data[v].selected < last) then
					self.data[v].selected = self.data[v].selected + 1
				elseif (not state) and (self.data[v].selected > first) then
					self.data[v].selected = self.data[v].selected - 1
				end
			else
				printe("! group doesn't exist for selected_group: %s", self.data[v].selected_group)
			end
			return self.data[v].selected
		end
	end
	
	if (not self.data[v].selected) or (not self.data[v].selected_group) then
		self.data[v].selected = _selected[v] or 1
		self.data[v].selected_group = _selected_group[v] or 1
	else
		self.data[v].par_hl[self.data[v].selected]:Show(false)
		self.data[v].selected = get_param_index(state, vert)
	end

	self.data[v].par_hl[self.data[v].selected]:Show(true)
	_selected[v] = self.data[v].selected
	_selected_group[v] = self.data[v].selected_group
end

function WpnHudEditor:SwitchParamByIndex(group, index)
	local v = self.active_table

	self.data[v].par_hl[self.data[v].selected]:Show(false)
	self.data[v].selected_group = group
	self.data[v].selected = index
	self.data[v].par_hl[self.data[v].selected]:Show(true)

	_selected[v] = self.data[v].selected
	_selected_group[v] = self.data[v].selected_group
end

function WpnHudEditor:SwitchValue(state, selected, extra_k)
	local v = self.active_table
	if not extra_k then extra_k = 1 end
	if not (selected) then
		return
	end
	
	local n = selected
	local typ = self.data[v].typ[n]
	local parent = self.data[v].parent[n]
	local val = self.data[v].value[n]
	
	local new_val
	if typ ~= 0 then
		local input_val = self.data[v].par[n]:GetText()
		local curr_val = (not self:IsInvalidValue(n,typ,input_val)) and tonumber(input_val)
		if (not curr_val) then
			self:Send_MSG("Couldn't read previous input for parameter (%s)", self.data[v].name[n])
			return
		end
		curr_val = round_idp(curr_val, precision)
		
		local max_val = v[parent].max
		local min_val = v[parent].min
		local step = v[parent].step * jump * extra_k
	
		if state then
			curr_val = curr_val + step
		else
			curr_val = curr_val - step
		end
		local precision = precision
		if curr_val > 100 then
			precision = precision - 2
		elseif curr_val > 10 then
			precision = precision - 1
		end
		curr_val = round_idp(curr_val, precision)
		new_val = clamp(curr_val, min_val, max_val)
	else
		local curr_val = self.data[v].par[n]:GetText()
		if (not curr_val) then
			return
		end
		
		if not (self.data[v].par_list_n[n]) then
			return
		end
		
		if (not self.data[v].index[n]) then
			for i=1,#self.data[v].par_list_n[n] do
				if (self.data[v].par_list_n[n][i] == curr_val) then
					self.data[v].index[n] = i
					break
				end
			end
			if (not self.data[v].index[n]) then
				return
			end
		end
		
		local num = #self.data[v].par_list_n[n]
		if state then
			self.data[v].index[n] = (self.data[v].index[n] < num) and (self.data[v].index[n] + 1) or self.data[v].index[n]
		else
			self.data[v].index[n] = (self.data[v].index[n] > 0) and (self.data[v].index[n] - 1) or self.data[v].index[n]
		end
		
		local txt = self.data[v].par_list_n[n][self.data[v].index[n]]
		if self:IsInvalidValue(n,0,txt) then
			self:Send_MSG("Invalid path/section for parameter (%s)", self.data[v].name[n])
			return
		end
		
		new_val = txt
	end
	
	if new_val then
		self.data[v].value[n] = new_val
		self.data[v].par[n]:SetText(new_val)
		self:SetParameterValue(n,new_val)
		self:ApplyParameterValue(typ,parent,v)
		-- self:Send_MSG(self.data[v].name[n] .. " := " .. self.data[v].value[n], 4)
	else
		self:Send_MSG("No value can be set for (%s)",self.data[v].name[n])
	end
end

function WpnHudEditor:SwitchValueGroup(state, selected_group)
	local v = self.active_table
	if (not selected_group) then
		return
	end
	print_dbg("/ WpnHudEditor | selected_group: %s", selected_group)
	local group = self.data[v].cnt_group[selected_group]
	local size = (#group > 3) and 3 or #group -- no need for alpha value
	for i=1,size do
		self:SwitchValue(state, group[i])
	end
end

function WpnHudEditor:OnInput(cnt)
	local v = self.active_table
	local val = self.data[v].par[cnt]:GetText()
	local typ = self.data[v].typ[cnt]
	local parent = self.data[v].parent[cnt]
	
	if self:IsInvalidValue(cnt,typ,val) then
		self:Send_MSG("Error with input for parameter (%s)", self.data[v].name[cnt])
		return
	end
	
	if (typ == 0) then
		val = val or ""
	else
		val = tonumber(val)
		val = round_idp(val, precision)
	end
	
	self.data[v].value[cnt] = val
	self:SetParameterValue(cnt,val)
	self:ApplyParameterValue(typ,parent,v)
end

function WpnHudEditor:Close()
	local v = self.active_table
	if v ~= parameters then
		self.data[v].scroll_par:Show(false)
	end
	self.weapon_cobj = nil
	self.active_table = parameters
	local v = self.active_table
	self.data[v].scroll_par:Show(true)
	self.third_person_mode = false

	self:ResetSelects()

	self:StopCam()
	self:DisableWCT(false)

	self:HideDialog()
	self:Show(false)

	--ui = nil
	
	if adjust_active then
		actor_menu.set_msg(1, "HUD adjust mode is still active",5)
	end
	
	exec_console_cmd("hud_crosshair " .. (self.crosshair and "on" or "off"))
	
	UnregisterScriptCallback("on_key_release",on_key_release)
	UnregisterScriptCallback("on_key_hold",on_key_hold)
	
	Unregister_UI("WpnHudEditor")
	
	if (level.present()) then
		printf("- main_menu off")
		exec_console_cmd("main_menu off")
	end
end

local K_M1      = DIK_keys.MOUSE_1
local K_M2      = DIK_keys.MOUSE_2
local K_M3      = DIK_keys.MOUSE_3
local E_PRESS   = ui_events.WINDOW_KEY_PRESSED
local E_RELEASE = ui_events.WINDOW_KEY_RELEASED
function WpnHudEditor:OnKeyboard(dik, keyboard_action)
	local v = self.active_table
	local res = CUIScriptWnd.OnKeyboard(self,dik,keyboard_action)
	if (res == false) then
		local bind = dik_to_bind(dik)
		-- Mouse
		if dik == K_M1 or dik == K_M2 or (dik == K_M3 and self.third_person_mode) then
			if (keyboard_action == E_PRESS) then
				-- printf("mouse hold")
				self.mouse_hold = dik
				self.disable_drag = false
			elseif (keyboard_action == E_RELEASE) then
				-- printf("mouse release")
				self.disable_drag = true
				self.pos = nil
				self.mouse_hold = nil
			end
		elseif keyboard_action == ui_events.WINDOW_KEY_PRESSED then
			if dik == DIK_keys.DIK_NUMPAD8 then
				self:SwitchValue(true, self.data[v].selected)
			elseif dik == DIK_keys.DIK_NUMPAD2 then
				self:SwitchValue(false, self.data[v].selected)
			elseif dik == DIK_keys.DIK_NUMPAD9 then
				self:SwitchValueGroup(true, self.data[v].selected_group)
			elseif dik == DIK_keys.DIK_NUMPAD3 then
				self:SwitchValueGroup(false, self.data[v].selected_group)
			elseif dik == DIK_keys.DIK_NUMPADENTER then
				self.save_mode = not self.save_mode
				self:Print(nil, self.save_mode == true and "save to cache_dbg.ltx" or "vanilla save")

			elseif dik == DIK_keys.DIK_NUMPAD1 then
				self:CleanCacheDbg()
				
			elseif dik == DIK_keys.DIK_UP then
				self:SwitchParam(false, true)
			elseif dik == DIK_keys.DIK_DOWN then
				self:SwitchParam(true, true)
			elseif dik == DIK_keys.DIK_RIGHT then
				self:SwitchParam(true, false)
			elseif dik == DIK_keys.DIK_LEFT then
				self:SwitchParam(false, false)
				
			elseif dik == DIK_keys.DIK_NUMPAD5 then
				self:OnButtonCopy()
			elseif dik == DIK_keys.DIK_NUMPAD6 then
				self:OnButtonPaste()
			elseif dik == DIK_keys.DIK_G then
				self:OnButtonAlign()
				
			elseif dik == DIK_keys.DIK_DELETE then
				self:CleanMemo()
			elseif dik == DIK_keys.DIK_H then
				self:ShowHint()
			elseif dik == DIK_keys.DIK_ESCAPE then
				self:Close()
			end
		end
	end
	return res
end

function WpnHudEditor:OnButtonThirdPerson()
	if not db.actor:active_item() then
		self:Print(nil, "Actor has no current item, abort")
		return
	end
	if not (
		level.set_cam_custom_position_direction
		and level.remove_cam_custom_position_direction
	) then
		self:Print(nil, "Missing camera functions from modded exes, TP mode is unavailable")
		return
	end
	self.third_person_mode = not self.third_person_mode

	local v = self.active_table
	self.data[v].scroll_par:Show(false)

	if self.third_person_mode then
		self.active_table = third_person_parameters
		self:ResetSelects(true)
		hud_adjust.enabled(false)

		dummy_npc = alife_create("sim_default_stalker_0", db.actor:position(), db.actor:level_vertex_id(), db.actor:game_vertex_id())
		CreateTimeEvent("ui_debug_wpn_hud_dummy", "ui_debug_wpn_hud_dummy_npc", 0, function()
			local obj = level.object_by_id(dummy_npc.id)
			if obj then
				db.storage[obj:id()] = db.storage[obj:id()] or {}
				db.storage[obj:id()].ui_debug_wpn_hud_dummy = {
					state = self.dummy_npc_states[1][2]
				}
				obj:iterate_inventory(function(owner, item)
					alife_release_id(item:id())
				end, obj)
				local weapon_sec = db.actor:active_item():section()
				local weapon = alife_create_item(weapon_sec, obj)
				CreateTimeEvent("ui_debug_wpn_hud_dummy", "ui_debug_wpn_hud_dummy_weapon", 0, function()
					local w = level.object_by_id(weapon.id)
					if w then
						self.weapon = w
						self.weapon_cobj = w:cast_Weapon()
						self:ApplyThirdPersonParameterValue()
						return true
					end
					return false
				end) 
				self:ResetNpcCam()
				return true
			end
			return false
		end)

		-- self.weapon_cobj = db.actor:active_item():cast_Weapon()
	else
		self.active_table = parameters
		self.weapon_cobj = nil
		self.weapon = nil
		self:StopCam()
		hud_adjust.enabled(true)
	end

	local v = self.active_table
	self.data[v].scroll_par:Show(true)
end

-- NPC Dummy
actid = 198122
evaid = 198122

class "evaluator_stalker_ui_debug_wpn_hud_dummy" (property_evaluator)
function evaluator_stalker_ui_debug_wpn_hud_dummy:__init(npc,name,storage) super (nil, name)
	self.st = storage
end

function evaluator_stalker_ui_debug_wpn_hud_dummy:evaluate()
	--utils_data.debug_write("eva_panic")
	local npc = self.object
	local id = npc:id()
	db.storage[id] = db.storage[id] or {}
	local st = db.storage[id]
	-- printf("checking dummy_npc %s", npc:name())
	if st.ui_debug_wpn_hud_dummy then
		return true
	end
	return false
end

class "action_stalker_ui_debug_wpn_hud_dummy" (action_base)
function action_stalker_ui_debug_wpn_hud_dummy:__init (npc,name,storage) super (nil,name)
	self.st = storage
end

function action_stalker_ui_debug_wpn_hud_dummy:initialize()
	action_base.initialize(self)
	-- local npc = self.object
	-- npc:set_desired_position()
	-- npc:set_desired_direction()
	self.first_update = true
end

function action_stalker_ui_debug_wpn_hud_dummy:execute()
	--utils_data.debug_write(strformat("action_stalker_ui_debug_wpn_hud_dummy:execute start"))
	action_base.execute(self)

	local npc = self.object	
	--printf("enemy = %s",enemy and enemy:name())
	
	-- ensure and enforce path type
	-- if (npc:path_type() ~= game_object.level_path) then 
	-- 	npc:set_path_type(game_object.level_path)
	-- end

	-- printf("executing dummy_npc %s", npc:name())

	npc:set_desired_position()
	npc:set_desired_direction()
	npc:set_dest_level_vertex_id(npc:level_vertex_id())

	state_mgr.set_state(npc, db.storage[npc:id()].ui_debug_wpn_hud_dummy.state, nil, nil, {
		-- look_position = self.st.lvid and level.vertex_position(self.st.lvid) or npc:position(),
		-- look_object = db.actor,
		-- look_dir = self.st.lvid and level.vertex_position(self.st.lvid):sub(npc:position()):normalize() or npc:direction(),
	}, {
		fast_set = true,
		animation = true,
	})

	-- First update force movement 
	if self.first_update then
		-- npc:clear_animations()
		-- npc:movement_enabled(false)
		-- npc:set_movement_type(move.stand)
		-- npc:set_body_state(move.standing)
		-- npc:set_mental_state(anim.danger)
		self.first_update = false
	end
end

function action_stalker_ui_debug_wpn_hud_dummy:finalize()
    action_base.finalize(self)
    self.first_update = true
	db.storage[self.object:id()].ui_debug_wpn_hud_dummy = nil
	self.object:clear_animations()
	self.object:movement_enabled(true)
end

function setup_generic_scheme(npc,ini,scheme,section,stype,temp)
	local st = xr_logic.assign_storage_and_bind(npc,ini,"stalker_ui_debug_wpn_hud_dummy",section,temp)
end

function add_to_binder(npc,ini,scheme,section,storage,temp)
	if not npc then return end
	local manager = npc:motivation_action_manager()
	if not manager then return end
	
	if not npc:alive() then
		manager:add_evaluator(evaid,property_evaluator_const(false))
		temp.needs_configured = false
		return 
	end

	local evaluator = evaluator_stalker_ui_debug_wpn_hud_dummy(npc,"eva_stalker_ui_debug_wpn_hud_dummy",storage)
	temp.action = action_stalker_ui_debug_wpn_hud_dummy(npc,"act_stalker_ui_debug_wpn_hud_dummy",storage)
	
	if not evaluator or not temp.action then return end
	manager:add_evaluator(evaid,evaluator)
	
	temp.action:add_precondition(world_property(stalker_ids.property_alive,true))
	temp.action:add_precondition(world_property(stalker_ids.property_danger, false))
	temp.action:add_precondition(world_property(evaid,true))
	
	temp.action:add_effect(world_property(evaid,false))
	
	manager:add_action(actid,temp.action)
	
	--xr_logic.subscribe_action_for_events(npc, storage, temp.action)
end

function configure_actions(npc,ini,scheme,section,stype,temp)
	if not npc then return end
	local manager = npc:motivation_action_manager()
	if not manager or not temp.action then return end

	temp.action:add_precondition(world_property(xr_evaluators_id.sidor_wounded_base,false))
	-- temp.action:add_precondition(world_property(xr_evaluators_id.wounded_exist,false))

	-- if (_G.schemes["rx_ff"]) then 
	-- 	temp.action:add_precondition(world_property(rx_ff.evaid,false))
	-- end
	if (_G.schemes["gl"]) then
		temp.action:add_precondition(world_property(rx_gl.evid_gl_reload,false))
	end
	-- if (_G.schemes["facer"]) then
	-- 	temp.action:add_precondition(world_property(xrs_facer.evid_facer,false))
	-- 	temp.action:add_precondition(world_property(xrs_facer.evid_steal_up_facer,false))
	-- end

	local action
	local p = {xr_danger.actid, stalker_ids.action_combat_planner, stalker_ids.action_danger_planner, xr_actions_id.state_mgr + 2, xr_actions_id.alife}
	
	for i=1,#p do
		--printf("ACTION_ALIFE_ID(permaban_material.configure_actions): " .. tostring(p[i]))
		action = manager:action(p[i])
		if (action) then
			action:add_precondition(world_property(evaid,false))
		else
			printf("axr_panic: no action id p[%s]",i)
		end
	end
end 

function disable_generic_scheme(npc,scheme,stype)
	local st = db.storage[npc:id()][scheme]
	if st then
		st.enabled = false
	end
end

function npc_add_precondition(action)
	if not action then return end
	action:add_precondition(world_property(evaid,false))
end

LoadScheme("ui_debug_wpn_hud", "stalker_ui_debug_wpn_hud_dummy", modules.stype_stalker)

function on_enemy_eval(obj, enemy, flags)
	if dummy_npc and (obj:id() == dummy_npc.id or enemy:id() == dummy_npc.id) then
        flags.override = true
        flags.result = false
	end
end

 function npc_on_before_hit(npc,shit,bone_id,flags)
 	if dummy_npc and npc:id() == dummy_npc.id then
 		flags.ret_value = false
 	end
 end

function on_game_start()
	local function on_localization_change()
		GUI = nil -- clear ui to force initing again
	end
	RegisterScriptCallback("on_localization_change",on_localization_change)
	RegisterScriptCallback("on_enemy_eval", on_enemy_eval)
	RegisterScriptCallback("npc_on_before_hit", npc_on_before_hit)
end