--[[
	Tronex
	Last edit: 2018/5/22
	PDA radio/music player
	
	==============================================================================================
	Codes/comments with ( --< can be expanded for more channels >-- ) tag can be edited to add more radio channels
	Creating new radio channel require editing the other XML and DDS files as well.
	Using (radio_vol = soundObject.volume) will cause a crash if you didn't give the object a volume value
	Sounds start always at maxed volume before going down if you declare a volume value before playing the sound
	Don't use (play_no_feedback) method, it has no controls
	volume values changes give fractions (for example 0.2 change is actually 0.20000003278255)
	Codes/comments with ( --< can be expanded for more channels >-- ) tag can be edited to add more radio channels
	==============================================================================================
--]]
------------------------------------------------------------
-- Controls
------------------------------------------------------------
-- Files links & controls
local ini_radio    		 = ini_file("plugins\\radio_zone_fm.ltx")		-- File control: reading the ltx file that controls the hotkeys
local num_of_ch          = 0									--< can be expanded for more channels >--- Number of Radio channels 
local num_of_noise       = 8									-- File control: number of files with name (white_noise_heavy_horror_)
local num_of_mixdown     = 4									-- File control: number of files with name (radio_mixdown)
local path_radio_ch      = {} 									-- File control: the path to channel x tracks
local path_radio_session = {} 									-- File control: the path to channel x sessions
local radio_ch_names = {}
local radio_frequencies = {}

local ini_channels = ini_file_ex("plugins\\placeable_radio\\base.ltx")
local i = 1
for _, section in pairs(ini_channels:get_sections()) do
    path_radio_ch[i] = ini_channels:r_string_ex(section, "program")
	path_radio_session[i] = ini_channels:r_string_ex(section, "intermission")
	radio_ch_names[i] = ini_channels:r_string_ex(section, "name")
	radio_frequencies[i] = ini_channels:r_string_ex(section, "frequency")
	
	num_of_ch = num_of_ch + 1
	i = i + 1
end

local fileList, count, file									-- Variables for file reading


-- Volume controls
local radio_vol = 0.5										-- In-game control: Radio volume - first value
local vol_max   = 0.98										-- In-game control: Max volume value (1.1 - anything beyond 1.0 has no additional effect)
local vol_min   = 0.12										-- In-game control: Min volume value (0.1 - still hearable)
local vol_step  = 0.2										-- In-game control: Volume change per click
local psi_vol   = 0											-- This value get subtracted from the main volume value, it become >0 on emissions to reduce the total radio volume

-- Others
local safety_lock     = false									-- become "true" after making change. while true, it prevents any possible additional changes done by user for a brief amount of time until the code is over. basically a safety procedure to prevent codes from interfering with each others (locked = true, free to go = false)
local white_noise_now = 1										-- Current index of the white noise
local psi_start_lock  = false									-- used to separate stages of for emission noise effects
local psi_time        = time_global() or 0						-- period between radio volume shifts for emission/underground noise effects
local indoor_lvls     = {}										-- Table: contains names of underground levels
local gini            = game_ini()
local levels          = utils_data.collect_section(gini,"level_maps_single")
for i=1,#levels do
	wthr = gini:r_string_ex(levels[i],"weathers")
	if (wthr == "indoor") then
		indoor_lvls[levels[i]] = true
	end
end


-- Hotkeys
local opt = {}
function update_settings()
	opt.emission_noise         = ui_options.get("sound/radio/emission_intereferences")
	opt.underground_noise      = ui_options.get("sound/radio/underground_intereferences")
	opt.display_names          = ui_options.get("sound/radio/display_tracks")
end

------------------------------------------------------------
-- Binder
------------------------------------------------------------
function init(obj)
    obj:bind_object(placeable_radio_wrapper(obj).binder)
end
--------------------------------------------------------------------------------
-- Class "placeable_radio_wrapper"
--------------------------------------------------------------------------------
class "placeable_radio_wrapper" (bind_hf_base.hf_binder_wrapper)
-- Class constructor
function placeable_radio_wrapper:__init(obj) super(obj)
	-- Radio
	self.radio_ch    = {}										-- Multi-dimensional table: Radio channels, every channel has its tracks
	self.radio_ch_out = {}										-- Similar, used for outer radios
	self.radio_index = {}										-- Multi-dimensional table: Radio channels indexes, every channel index has its track indexes
	self.radio_now   = {}										-- Table: to determine the current track for each channel
	for x = 1, num_of_ch do										-- Reading the files for radio channels
		self.radio_ch[x] = {}
		self.radio_ch_out[x] = {}
		self.radio_index[x] = {}
		self.radio_now[x] = 1
		fileList = getFS():file_list_open("$game_sounds$", path_radio_ch[x], bit_or(FS.FS_ListFiles, FS.FS_RootOnly))		-- Reading the file list in channel x
		count = fileList and fileList:Size() or 0																			-- Get the number of files per channel x
		if (count > 0) then
			for i = 1, count do
				file = fileList:GetAt(i - 1):sub(1, -5)								-- Get red off the extension
				self.radio_ch[x][i] = sound_object(path_radio_ch[x] .. file)				-- Creating sound objects, every track in every channel
				self.radio_ch_out[x][i] = sound_object(path_radio_ch[x] .. file)
				self.radio_index[x][i] = i												-- Creating track index
			end
		else																		-- if no files found
			self.radio_ch[x][1] = sound_object("radio\\no_sound")							-- assign no sound, a small hack to prevent the game from crashing
			self.radio_ch_out[x][1] = sound_object("radio\\no_sound")
			self.radio_index[x][1] = 1
		end
	end
	self.radio_state         = false							-- Radio on/off state (off = false, on = true)
	self.radio_selected      = 1								-- Selected Radio channel (0 means nothing is selected)
	self.radio_hotkey_switch = false							-- Safety switch for (Play/Stop Radio) Hotkey


	-- Radio sessions
	self.radio_session      = {}								-- Multi-dimensional table: Radio channels commercial sessions, every channel has its sessions
	self.radio_session_out  = {}								-- Similar, used for outer radios
	self.radio_session_now  = {}								-- Current session per channel
	self.radio_session_lock = {}								-- Boolean table: used to make sure that only 1 session is being played between tracks
	for x = 1, num_of_ch do										-- assign sound files for sessions
		self.radio_session[x] = {}
		self.radio_session_out[x] = {}
		self.radio_session_now[x] = 1
		self.radio_session_lock[x] = false
		fileList = getFS():file_list_open("$game_sounds$", path_radio_session[x], bit_or(FS.FS_ListFiles, FS.FS_RootOnly))	-- Reading the file list in channel x sessions
		count = fileList and fileList:Size() or 0				-- Get the number of files per channel x
		if (count > 0) then
			for i = 1, count do
				file = fileList:GetAt(i - 1):sub(1, -5)
				self.radio_session[x][i] = sound_object(path_radio_session[x] .. file)
				self.radio_session_out[x][i] = sound_object(path_radio_session[x] .. file)
			end
		else
			self.radio_session[x][1] = sound_object("radio\\no_sound")
			self.radio_session_out[x][1] = sound_object("radio\\no_sound")
		end
	end
	-- Sound effects
	self.snd_radio_mixdown            = {}
	self.snd_white_noise_heavy_horror = {}
	self.snd_radio_on                 = sound_object("radio\\interact\\radio_on")
	self.snd_radio_off                = sound_object("radio\\interact\\radio_off")
	self.snd_white_noise_light        = sound_object("radio\\white_noise\\white_noise_light")
	self.snd_white_noise_heavy        = sound_object("radio\\white_noise\\white_noise_heavy")
	self.snd_white_noise_heavy_start  = sound_object("radio\\white_noise\\white_noise_heavy_fade_in")
	self.snd_white_noise_heavy_end    = sound_object("radio\\white_noise\\white_noise_heavy_fade_out")
	for i = 1, num_of_mixdown do
		self.snd_radio_mixdown[i] = sound_object("radio\\interact\\radio_mixdown_" .. tostring(i))
		self.snd_radio_mixdown[i].volume = 2
	end
	for i = 1, num_of_noise do
		self.snd_white_noise_heavy_horror[i] = sound_object("radio\\white_noise\\White_noise_heavy_horror_" .. tostring(i))
	end
	self.snd_radio_on.volume  = 2
	self.snd_radio_off.volume = 2

	self.object:set_tip_text(game.translate_string("st_interact"))
end
-- Class update
function placeable_radio_wrapper:update(delta)
	-- self.object:set_callback(callback.use_object, placeable_radio_wrapper.use_callback, self)

	if not self.init then
		local phys = self.object:get_physics_shell()
		if phys then
			phys:apply_force(0, 1, 0)
			self.init = true
		end
	end

	-- Radio (no channel) part
	if self.radio_state and (self.radio_selected == 0) then
		if not self.snd_white_noise_light:playing() then
			self.snd_white_noise_light:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
			self.snd_white_noise_light.volume = 0.4
		end
	else
		self.snd_white_noise_light:stop()
	end

	-- Consume power from PDA if radio/player is ON
	-- change obj:condition()


	if (not safety_lock) then
		-- Radio part
		if (not self:is_snd_playing()) then
			for i=1,num_of_ch do
				if (not self.radio_ch[i][self.radio_now[i]]:playing()) and (not self.radio_session[i][self.radio_session_now[i]]:playing()) then	 	-- if no track and no session is playing in channel (i)
					if (math.random(3) == 1) and (not self.radio_session_lock[i]) then		-- chance of playing a session between tracks (%30)
						self.radio_session_now[i] = math.random(#self.radio_session[i])	-- pick a session from channel i
						self.radio_session[i][self.radio_session_now[i]]:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)	-- play it
						self.radio_session_lock[i] = true
					else	-- if no session is picked, go for radio tracks
						self.radio_now[i] = self:radio_pick (self.radio_index[i], #self.radio_ch[i])	-- pick a track from channel i
						self.radio_ch[i][self.radio_now[i]]:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)	-- play it
						self.radio_session_lock[i] = false
					end
				end
				
				if self.radio_state and (self.radio_selected == i) then												
					self.radio_ch[i][self.radio_now[i]].volume = radio_vol - psi_vol
					self.radio_session[i][self.radio_session_now[i]].volume = radio_vol - psi_vol
				else
					self.radio_ch[i][self.radio_now[i]].volume = 0
					self.radio_session[i][self.radio_session_now[i]].volume = 0
				end
			end
		end
	end

	-- Emission part
	if opt.emission_noise then
		if  xr_conditions.surge_started() or psi_storm_manager.is_started() then 
			if not psi_start_lock then 	-- lock to make sure this condition happen once per emission
				psi_start_lock = true
				self.snd_white_noise_heavy_start:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
			end
			if (not self.snd_white_noise_heavy_start:playing()) and (not self.snd_white_noise_heavy_horror[white_noise_now]:playing()) then
				white_noise_now = math.random(#self.snd_white_noise_heavy_horror)
				self.snd_white_noise_heavy_horror[white_noise_now]:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
			end
			if (math.floor(psi_time + 1500) < time_global()) then
				psi_time = time_global()
				psi_vol = math.random(2,8)/10
			end
		elseif psi_start_lock then
			if (xr_conditions.surge_complete() or psi_storm_manager.is_finished()) and (not self.snd_white_noise_heavy_horror[white_noise_now]:playing()) and (not self.snd_white_noise_heavy_start:playing()) and (not self.snd_white_noise_heavy_end:playing()) then -- if emission ended AND start/end sound are not playing AND emission lock is on 
				self.snd_white_noise_heavy_end:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
				psi_start_lock = false
				psi_vol = 0
			end
		end
	else
		self.snd_white_noise_heavy_horror[white_noise_now]:stop()
		self.snd_white_noise_heavy_start:stop()
		self.snd_white_noise_heavy_end:stop()
		psi_start_lock = false
		psi_vol = 0
	end

	-- Underground part
	if indoor_lvls[level.name()] then
		if opt.underground_noise then
			if (not self.snd_white_noise_heavy:playing()) then
				self.snd_white_noise_heavy:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
			end
			if (math.floor(psi_time + 1500) < time_global()) then
				psi_time = time_global()
				psi_vol = math.random(5,8)/10
			end
		else
			psi_vol = 0
		end
	end

	if self.radio_state then 
		self.snd_white_noise_heavy_horror[white_noise_now].volume = radio_vol
		self.snd_white_noise_heavy_start.volume = radio_vol
		self.snd_white_noise_heavy_end.volume = radio_vol
		self.snd_white_noise_heavy.volume = radio_vol
	else
		self.snd_white_noise_heavy_horror[white_noise_now].volume = 0
		self.snd_white_noise_heavy_start.volume = 0
		self.snd_white_noise_heavy_end.volume = 0
		self.snd_white_noise_heavy.volume = 0
	end
end

function placeable_radio_wrapper:use_callback()
    hide_hud_inventory()
	start_radio_dialog(self.object:id())
end

function placeable_radio_wrapper:use_callback_simple()
    if self.radio_state then
		self:action_radio_stop()
	else
		self:action_radio_start()
	end
end

------------------------------------------------------------
-- Functionality
------------------------------------------------------------
function placeable_radio_wrapper:action_radio_ch(n) -- Rule: Switch to Channel (n)
	if self.radio_state and (not safety_lock) and (not self:is_snd_playing()) and (self.radio_selected ~= n) then
		safety_lock = true
		-- get_ui():SwitchChannel(n)
		self:radio_setVolume(0) -- set volume 0 to the previous channel
		self.radio_selected = n
		--snd_click:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
		self.snd_radio_mixdown[math.random(#self.snd_radio_mixdown)]:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
		safety_lock = false

		return true
	end
	return false
end

function placeable_radio_wrapper:action_radio_v_down() -- Rule: Reduce the radio volume
	if (radio_vol > vol_min) and self.radio_state and (not safety_lock) and (not self:is_snd_playing()) then
		safety_lock = true
		--snd_click:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
		radio_vol = radio_vol - vol_step
		self:radio_setVolume(radio_vol - psi_vol)
		safety_lock = false
	end
end

function placeable_radio_wrapper:action_radio_v_up() -- Rule: Increase the radio volume
	if (radio_vol < vol_max) and self.radio_state and (not safety_lock) and (not self:is_snd_playing()) then
		safety_lock = true
		--snd_click:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
		radio_vol = radio_vol + vol_step
		self:radio_setVolume(radio_vol - psi_vol)
		safety_lock = false
	end
end

function placeable_radio_wrapper:action_radio_stop() -- Rule: Stop the radio
	if self.radio_state and (not safety_lock) and (not self:is_snd_playing()) then
		safety_lock = true
		self.radio_state = false
		--snd_click:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
		self.snd_radio_off:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
		self:radio_setVolume(0)
		safety_lock = false
	end
end

function placeable_radio_wrapper:action_radio_start() -- Rule: Start the radio

	if (not self.radio_state)
	and (not safety_lock)
	and (not self:is_snd_playing())
	then
		safety_lock = true
		self.radio_state = true
		--snd_click:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
		self.snd_radio_on:play_at_pos(self.object, self.object:position(), 0, sound_object.s3d)
		self:radio_setVolume(radio_vol - psi_vol)
		safety_lock = false
	end
end

----------------------------------------------------------------------------------------

function placeable_radio_wrapper:is_snd_playing() -- Rule: check if some interacting sound is currently playing | it prevents any changes done by the player until that sound is over (no sound interfering)
	if self.snd_radio_on:playing() or self.snd_radio_off:playing() then
		return true	
	end
	for j = 1, #self.snd_radio_mixdown do
		if self.snd_radio_mixdown[j]:playing() then
			return true
		end
	end
	return false
end

function placeable_radio_wrapper:radio_setVolume(radio_vol) -- Rule: set volume for selected channel
	-- This might seem unnecessary at first glance since the volume get modified always through (actor_on_update) callback
	-- but tests showed that volume changes slowly, not instantly. 
	-- with bigger code snippets between the sound play and volume change, its even slower. 
	-- This function make things faster for volume changes.
	
	if (self.radio_selected ~= 0) then
		self.radio_ch[self.radio_selected][self.radio_now[self.radio_selected]].volume = radio_vol
		self.radio_session[self.radio_selected][self.radio_session_now[self.radio_selected]].volume = radio_vol
	end
end

function placeable_radio_wrapper:radio_pick(radio_index_i, number_of_tracks) -- Rule: pick a random index for radio channels, get rid of the picked index afterwards so it doesn't get chosen again until a new cycle is called
	if (#radio_index_i == 0) then
		for i=1,number_of_tracks do	
			radio_index_i[i] = i
		end
	end
	local j = math.random(#radio_index_i)
	local k = radio_index_i[j]
	table.remove(radio_index_i, j)
	return k
end

function placeable_radio_wrapper:get_playing_object(i) -- called from ph_sound to play current track on the radio on radio objects
	local sound_obj = self.radio_session_out[i][self.radio_session_now[i]]
	if (self.radio_session[i][self.radio_session_now[i]]:playing()) then
		return sound_obj
	end
	
	sound_obj = self.radio_ch_out[i][self.radio_now[i]]
	if (self.radio_ch[i][self.radio_now[i]]:playing()) then
		return sound_obj
	end
	
	return
end

------------------------------------------------------------
-- GUI
------------------------------------------------------------
local SINGLETON = nil

function start_radio_dialog(obj_id) -- get called from pressing the tab
	SINGLETON = SINGLETON or UIFurnitureRadio()
	SINGLETON:TestAndShow(obj_id)
end

class "UIFurnitureRadio" (CUIScriptWnd)

function UIFurnitureRadio:__init() super()
	self.snd_click = sound_object("radio\\interact\\click")

	self.radio_display_ch = {}
	-- for i=1,num_of_ch do
	-- 	self.radio_display_ch[i] = false -- If true, it will display channel i red marker 
	-- end
	self.frequency_min = 88
	self.frequency_max = 110
	self.frequency_min_x = 14
	self.frequency_max_x = 397

	self.frequency = 88

	self:InitControls()
	self:InitCallbacks()
end

function UIFurnitureRadio:__finalize() 
	SINGLETON = nil
end

function UIFurnitureRadio:TestAndShow(obj_id)
    self.obj_id = obj_id
	self:ShowDialog(true)
	Register_UI("UIFurnitureRadio","ui_radio_dialog")
end

function UIFurnitureRadio:Pickup()
	local obj = get_object_by_id(self.obj_id)
	local item_section = ini_sys:r_string_ex(obj:section(), "item_section") or "device_gas_lamp"
	-- local condition = obj:binded_object().fuel
	alife_create_item(item_section, db.actor)
	-- local item = alife():create(item_section, db.actor:position(), 1, db.actor:game_vertex_id(), db.actor:id())
	-- get_object_by_id(item.id):set_condition(obj:binded_object().fuel)

	alife_release(obj)
	self:Close()
end

function UIFurnitureRadio:InitControls() -- Rule: Prepare the UI	
	local xml = CScriptXmlInit()
	xml:ParseFile("ui_furniture_radio.xml")
	
	
	-- Main frame
	self:SetWndRect(Frect():set(0, 0, 1024, 768))
	xml:InitFrame("background", self)

	self.btn_pickup = xml:Init3tButton("btn_pickup", self)
	self:Register(self.btn_pickup, "btn_pickup")

	self.btn_close = xml:Init3tButton("btn_close", self)
	self:Register(self.btn_close, "btn_close")
	
	-- Radio channels
	self.frequency_bg = xml:InitStatic("interface_radio_bg", self)
	self.frequency_needle = xml:InitStatic("interface_radio_needle", self.frequency_bg)

	self.btn_radio_ch = {}

	self.list_channel = xml:InitComboBox("list_channel", self)
	self:Register(self.list_channel, "list_channel")
	
	for i=1,num_of_ch do
		self.list_channel:AddItem(game.translate_string(radio_ch_names[i]), i)
	end
	
	local index = prevChannel or 1
	self.list_channel:SetText(game.translate_string(radio_ch_names[index]))
	
	-- Radio buttons
	self.btn_radio_v_down = xml:Init3tButton("btn_radio_v_down", self)
	self:Register(self.btn_radio_v_down, "btn_radio_v_down")
	
	self.btn_radio_v_up = xml:Init3tButton("btn_radio_v_up", self)
	self:Register(self.btn_radio_v_up, "btn_radio_v_up")
		
	self.btn_radio_stop = xml:Init3tButton("btn_radio_stop", self)
	self:Register(self.btn_radio_stop, "btn_radio_stop")
	
	self.btn_radio_start = xml:Init3tButton("btn_radio_start", self)
	self:Register(self.btn_radio_start, "btn_radio_start")
end

function UIFurnitureRadio:InitCallbacks()
	-- Radio
	-- for i=1,num_of_ch do
	-- 	self:AddCallback("btn_radio_ch_" .. i, ui_events.BUTTON_CLICKED, self["On_Radio_Channel_" .. i], self)
	-- end
	self:AddCallback("btn_close",  ui_events.BUTTON_CLICKED, self.Close, self)
	self:AddCallback("btn_pickup",    ui_events.BUTTON_CLICKED, self.Pickup,   self)

	self:AddCallback("list_channel", ui_events.LIST_ITEM_SELECT, self.OnSelectChannel, self)
	self:AddCallback("btn_radio_stop",    ui_events.BUTTON_CLICKED, self.On_Radio_Stop,        self)
	self:AddCallback("btn_radio_start",   ui_events.BUTTON_CLICKED, self.On_Radio_Start,       self)
	self:AddCallback("btn_radio_v_down",  ui_events.BUTTON_CLICKED, self.On_Radio_Volume_Down, self)
	self:AddCallback("btn_radio_v_up",    ui_events.BUTTON_CLICKED, self.On_Radio_Volume_Up,   self)
end

function UIFurnitureRadio:Update()	-- Rule: called automatically to update the PDA UI
	CUIScriptWnd.Update(self)
	
	local pos = vector2():set(0, 0)
	local range_freq = self.frequency_max - self.frequency_min
	local percent = (self.frequency - self.frequency_min) / range_freq

	local ui_range = self.frequency_max_x - self.frequency_min_x
	pos.x = self.frequency_min_x + (ui_range * percent) - (self.frequency_needle:GetWidth()/2)
	self.frequency_needle:SetWndPos(pos)
end

function UIFurnitureRadio:SwitchChannel(freq)
	self.frequency = freq
end

function UIFurnitureRadio:OnKeyboard(dik, keyboard_action)
	local res = CUIScriptWnd.OnKeyboard(self,dik,keyboard_action)
	if (res == false) then
		local bind = dik_to_bind(dik)
		if keyboard_action == ui_events.WINDOW_KEY_PRESSED then
		
			if dik == DIK_keys.DIK_ESCAPE then
				self:Close()
			end

		end
	end

	return res
end

function UIFurnitureRadio:Close()
	if (self:IsShown()) then
		self:HideDialog()
	end
	--self.object:give_info_portion("tutorial_sleep")
	
	Unregister_UI("UIFurnitureRadio")
end

-- Callbacks
function UIFurnitureRadio:OnSelectChannel()
	local channel_id = self.list_channel:CurrentID()
	
	local wrapper = bind_hf_base.get_wrapper(self.obj_id)
	local result = wrapper:action_radio_ch(channel_id)
	if result then
		self:SwitchChannel(radio_frequencies[channel_id])
		self.snd_click:play(db.actor, 0, sound_object.s2d)
	end
end

function UIFurnitureRadio:On_Radio_Channel_1()
	local wrapper = bind_hf_base.get_wrapper(self.obj_id)
	local result = wrapper:action_radio_ch(1)
	if result then
		self:SwitchChannel(1)
		self.snd_click:play(db.actor, 0, sound_object.s2d)
	end
end

function UIFurnitureRadio:On_Radio_Channel_2()
	local wrapper = bind_hf_base.get_wrapper(self.obj_id)
	local result = wrapper:action_radio_ch(2)
	if result then
		self:SwitchChannel(2)
		self.snd_click:play(db.actor, 0, sound_object.s2d)
	end
end
--< can be expanded for more channels >-- you need to make new function for each new channel

function UIFurnitureRadio:On_Radio_Volume_Down()
	local wrapper = bind_hf_base.get_wrapper(self.obj_id)
	wrapper:action_radio_v_down()
	self.snd_click:play(db.actor, 0, sound_object.s2d)
end	

function UIFurnitureRadio:On_Radio_Volume_Up()
	local wrapper = bind_hf_base.get_wrapper(self.obj_id)
	wrapper:action_radio_v_up()
	self.snd_click:play(db.actor, 0, sound_object.s2d)
end

function UIFurnitureRadio:On_Radio_Stop()
	local wrapper = bind_hf_base.get_wrapper(self.obj_id)
	wrapper:action_radio_stop()
	self.snd_click:play(db.actor, 0, sound_object.s2d)
end

function UIFurnitureRadio:On_Radio_Start()
	local wrapper = bind_hf_base.get_wrapper(self.obj_id)
	wrapper:action_radio_start()
	self.snd_click:play(db.actor, 0, sound_object.s2d)
end


function on_game_start()
	local function on_game_load()
		update_settings()
	end
	RegisterScriptCallback("on_option_change",update_settings)
	RegisterScriptCallback("on_game_load",on_game_load)
end