[1866]; – номер секции, он не должен повторяться.Если у вас чистый all то номер будет 1866
; cse_abstract properties
section_name = physic_object
name = zaton_radio; – уникальное имя
position = 131.13690185547,-6.1206126213074,177.25036621094; - координаты
direction = 0,2.40000009536743,0

; cse_alife_object properties
game_vertex_id = 296 ;– координаты вертикс
distance = 0.400000005960464
level_vertex_id = 1189961; - координаты уровня
object_flags = 0xffffff3a
custom_data = < [logic]
cfg = scripts\zaton_radio.ltx ;– путь к логике
END

; cse_visual properties
visual_name = dynamics\el_tehnika\priemnik_gorizont ;– путь визуалу модели ogf причем заметьте что ogf т.е. формат писать не надо

; cse_ph_skeleton properties
skeleton_flags = 1

; cse_alife_object_physic properties
physic_type = 0x3
mass = 10
fixed_bones = link

[logic]
active = ph_sound

[ph_sound]
snd = music_radio
looped = false
min_idle = 300
max_idle = 500
random = true

ph_snd_themes = {}
ph_snd_themes["music_radio"] = {
"characters_voice\\scenario\\zaton_radio\\zaton_5",
"characters_voice\\scenario\\zaton_radio\\zaton_4",
"characters_voice\\scenario\\za ton_radio\\zaton_3",
"characters_voice\\scenario\\zaton_radio\\zaton_2",
"characters_voice\\scenario\\zaton_radio\\zaton_1"
}

load_scheme("ph_sound", "ph_sound", stype_item)

---------------------------------------------------------------------------------------------------------------------
-- Схема озвучки
-- автор: Диденко Руслан (Stohe)
-- update: Чугай Александр (Chugai)
----------------------------------------------------------------------------------------------------------------------
key_by_id = {}
group_idle = {}

--function printf()
--end

function get_sound(path, tt, npc)
if path == nil then return nil end
if path.exec == nil then
-- чтение настроек темы
tt.into_id = path.into_id
tt.into_max = path.max_ids[npc:id()].into_max
tt.into_last = nil

tt.rnd_id = path.rnd_id
tt.rnd_max = path.max_ids[npc:id()].rnd_max
tt.rnd_last = nil

tt.min_snd = path.min_snd
tt.max_snd = path.max_snd
tt.rnd_snd = path.rnd_snd
else
get_sound(path.types[path.exec(path.types, npc)], tt, npc)
end
end
-- Формирование ключа персонажа
function get_key(npc)
local key

-- формирование ключа
local overrides = xr_logic.generic_scheme_overrides(npc)
if overrides and
overrides.soundgroup
then
key = overrides.soundgroup
else
key = utils.to_str(npc:id())
end

-- апдейт таблиц :smile: не менять!
if xr_sound.key_by_id[npc:id()] ~= key then
if xr_sound.group_idle[xr_sound.key_by_id[npc:id()]] ~= nil then
xr_sound.group_idle[xr_sound.key_by_id[npc:id()]].num_in_group = xr_sound.group_idle[xr_sound.key_by_id[npc:id()]].num_in_group - 1
end
xr_sound.key_by_id[npc:id()] = key
if xr_sound.group_idle[key] == nil then
xr_sound.group_idle[key] = {num_in_group = 1}
else
xr_sound.group_idle[key].num_in_group = xr_sound.group_idle[key].num_in_group + 1
end
end
return key
end

------------------------------------------------------------------------------------------------------------------------------- ----
-- Установка и распарсивание тем в файлы.
-----------------------------------------------------------------------------------------------------------------------------------
f unction set_sound(npc, sound, now, into_timeout)
-- printf("*SND* [%s] try to change SND to [%s]", npc:name(), tostring(sound))

local npc_id = npc:id()
if (db.sound[npc_id] == nil or
db.sound[npc_id].theme ~= sound) or
now == true
then
-- if db.sound[npc_id] == nil then
-- printf("*SND* change SND [_] to [%s] for [%s]", tostring(sound), npc:name())
-- else
-- printf("*SND* change SND [%s] to [%s] for [%s]", tostring(db.sound[npc_id].theme), tostring(sound), npc:name())
-- end
-- Туточки надобно распарсить имена тем в их id
if sound == nil then sound = "" end
if db.sound[npc_id] == nil then db.sound[npc_id] = {} end
db.sound[npc_id].theme = sound
db.sound[npc_id].snd = parse_names(sound)
if db.sound[npc_id].last_snd == nil then
db.sound[npc_id].last_snd = {}
else

local snd_table = {}
local t = 0
for k,v in pairs(db.sound[npc_id].snd) do
snd_table[t] = {}
get_sound(sound_theme.theme[v], snd_table[t], npc)
t = t + 1
end
for k,v in pairs(snd_table) do
if v.into_id then db.sound[npc_id].last_snd[v.into_id] = nil end
if v.rnd_id then db.sound[npc_id].last_snd[v.rnd_id] = nil end
end

end
-- Устанавливаем входную паузу
local key = get_key(npc)
xr_sound.group_idle[key].begin = time_global()
if into_timeout then
xr_sound.group_idle[key].idle = into_timeout
else
xr_sound.group_idle[key].idle = 0
end

if now == true then
stop_play_sound(npc)
end
end
end

function play_sound(npc, themes, timeout)
-- нужно составить список тем
local snd_table = {}
local t = 0
for k,v in pairs(themes) do
snd_table[t] = {}
if sound_theme.theme[v] ~= nil then
snd_table[t].theme = v
get_sound(sound_theme.theme[v], snd_table[t], npc)
else
abort("ERROR: ILLEGAL PLAY SOUND!!! %s for %s", v, npc:name())
end
t = t + 1
end
--printf("*")
--print_table(snd_table)
if t == 0 then return end
-- из списка тем выбираем одну.
local snd = snd_table[math.random(0, t-1)]
if snd ~= nil then
--printf("!")
--print_table(snd)
if snd.min_snd == nil then return end
local npc_id = npc:id()
local group_table = xr_sound.group_idle[get_key(npc)]
group_table.idle = math.random(snd.min_snd, snd.max_snd)*1000
if group_table.last_snd == nil then
group_table.last_snd = {}
end
-- необходимо ли нам играть into или rnd звуки
if snd.into_max ~= nil and
snd.into_max > 0
then
if db.sound[npc_id].last_snd[snd.into_id] == snd.into_max - 1 then
if snd.into_cycled == true then
db.sound[npc_id].last_snd[snd.into_id] = nil
else
return
end
end

-- играем входные
if db.sound[npc_id].last_snd[snd.into_id] == nil then db.sound[npc_id].last_snd[snd.into_id] = -1 end

--printf("*SND* play seq [%s] for [%s]", db.sound[npc_id].last_snd[snd.into_id]+1, npc:name())
process_tutor_on_sound(snd.theme)
npc:play_sound(snd.into_id, 1, 0, 1, 0, db.sound[npc_id].last_snd[snd.into_id]+1)
db.sound[npc_id].last_snd[snd.into_id] = db.sound[npc_id].last_snd[snd.into_id] + 1
--printf("*SND* play seq [%s] for [%s]", db.sound[npc_id].last_snd[snd.into_id], npc:name())
return
end
if snd.rnd_max ~= nil and
snd.rnd_max > 0
then
-- играем рандомные
local s = 0
if snd.rnd_max == 1 then
s = 0
else
-- Если прошлый раз проигрывался такой же набор тем
-- то учитывать последний звук для группы.
-- if db.sound[npc_id].last_snd[snd.rnd_id] ~= nil then
if group_table.last_snd[snd.rnd_id] ~= nil then
s = math.random(0, snd.rnd_max-2)
if s >= group_table.last_snd[snd.rnd_id] then s = s + 1 end
else
s = math.random(0, snd.rnd_max-1)
end
end

if timeout == nil then
timeout = 0
end
--printf("*SND* play rnd [%s] for [%s]", s, npc:name())
process_tutor_on_sound(snd.theme)
npc:play_sound(snd.rnd_id, timeout+1, timeout, 1, 0, s)
--db.sound[npc_id].last_snd[snd.rnd_id] = s
group_table.last_snd[snd.rnd_id] = s
end
end
end

function get_last_IDS(npc, theme)
local last_table = db.sound[npc:id()].last_snd
local snd_table = {}
if sound_theme.theme[theme] ~= nil then
get_sound(sound_theme.theme[theme], snd_table, npc)
end
printf("LAST INTO ID for [%s] = [%s], max [%s]", theme, last_table[snd_table.into_id], snd_table.into_max)
return last_table[snd_table.into_id], snd_table.into_max
end

function load_sound(npc)
sound_theme.load_sound(npc)
end

function process_tutor_on_sound(theme)
end

--' Actor sound player
local actor_sound = {}
function set_actor_sound(sound)
printf("*ACTOR SND* try to change SND to [%s]", tostring(sound))
if actor_sound.theme ~= sound then
--' Туточки надобно распарсить имена тем в их id
if sound == nil then sound = "" end
actor_sound.theme = sound
actor_sound.begin = nil

this.set_actor_sound_factor(1)
end
end

function set_actor_sound_factor(factor)
local theme = sound_theme.actor_theme[actor_sound.theme]
if theme ~= nil then
actor_sound.min_snd = theme.min_snd * factor
actor_sound.max_snd = theme.max_snd * factor
end
end

function update_actor()
local theme = sound_theme.actor_theme[actor_sound.theme]
if theme == nil then return end

if table.getn(theme.sounds) == 0 then
return
end

if actor_sound.begin == nil or
time_global() - actor_sound.begin >= actor_sound.idle
then
actor_sound.begin = time_global()

--' Тут надо отыграть звук
local sound = theme.sounds[math.random(table.getn(theme.sounds))]
if sound ~= nil then
sound:play(db.actor, 0, sound_object.s2d)
end
actor_sound.idle = math.random(actor_sound.min_snd, actor_sound.max_snd)
end
end

--' Таблица для хранения созданных саунд обжектов.
sound_object_by_theme = {}
--' type = [random|seq|looped]
function get_sound_object(theme, t_type)
if sound_theme.ph_snd_themes[theme] == nil then
abort("ph_snd_themes for theme %s", tostring(theme))
return
end

if sound_object_by_theme[theme] == nil then
sound_object_by_theme[theme] = {}
end

if t_type == nil then
t_type = "random"
end

--' Выбор следующего айдишника
local play_id = -1
local table_size = table.getn(sound_theme.ph_snd_themes[theme])
if sound_object_by_theme[theme].last_id == nil then
if t_type == "random" then
if table_size >= 2 then
play_id = math.random(1, table_size)
else
play_id = 1
end
else
play_id = 1
end
else
if t_type == "random" then
if table_size >= 2 then
play_id = math.random(1, table_size - 1)
if play_id >= sound_object_by_theme[theme].last_id then play_id = play_id + 1 end
else
play_id = 1
end
else
if sound_object_by_theme[theme].last_id < table_size then
play_id = sound_object_by_theme[theme].last_id + 1
else
if type == "looped" then
play_id = 1
end
end
end
end

printf("SOUND_OBJECT: selected id [%s] for theme [%s], type [%s], size [%s]", tostring(play_id), tostring(theme), tostring(type), table_size)

if play_id == -1 then
return
end
--' Проверяем создан ли у нас соответствующий саунд обжект или его надо создать
if sound_object_by_theme[theme][play_id] == nil then
if type(sound_theme.ph_snd_themes[theme][play_id]) == "table" then
sound_object_by_theme[theme][play_id.."_r"] = get_safe_sound_object(sound_theme.ph_snd_themes[theme][play_id][1].."_r")
sound_object_by_theme[theme][play_id.."_l"] = get_safe_sound_object(sound_theme.ph_snd_themes[theme][play_id][1].."_l")
else
sound_object_by_theme[theme][play_id] = get_safe_sound_object(sound_theme.ph_snd_themes[theme][play_id])
end
end

sound_object_by_theme[theme].last_id = play_id

--' Возвращаем саунд обжект
if type(sound_theme.ph_snd_themes[theme][play_id]) == "table" then
return sound_object_by_theme[theme][play_id.."_r"], sound_object_by_theme[theme][play_id.."_l"]
else
return sound_object_by_theme[theme][play_id]
end
end

local sound_object_by_path = {}
--' Обертка вокруг функции, возвращающий звуковой объект.
function get_safe_sound_object(path)
if sound_object_by_path[path] == nil then
sound_object_by_path[path] = sound_object(path)
end
return sound_object_by_path[path]
end

function stop_all_sound_object()
for k,v in pairs(sound_object_by_path) do
if v:playing() then
v:stop()
end
end
end
function clear_all_sound_object()
sound_object_by_theme = {}
end