function monster_is_alive(actor, npc, p)
    local npc1

    if p and p[1] then
  npc1 = get_story_object_id(p[1])
    else
  return false
    end

    if npc1 == nil then
  return false
    end

    npc1 = alife (): object(npc1)

    if npc1 and IsMonster(npc1) and npc1:alive() then
  return true
    end

    return false
end

on_info = {=monster_is_alive(storyid_монстра)}

--TS MOD для COP-- накопировано и накнопано Tonny S. (aka Tonny на AMK-форуме)
--часть функций или их частей выковыряна из AMK, скриптов SAK и др.

--[[--
для использования авторазряжалки следует:
- в скрипте bind_stalker.script:
- function actor_binder:net_spawn(data)
в конец добавить
ts_mod_cop.ts_on_net_spawn()    --TS_MOD--

- function actor_binder:take_item_from_box(box, item)
в конец добавить
ts_mod_cop.ts_on_item_take(item)    --TS_MOD--

- function actor_binder <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> n_item_take (obj)
в конец добавить
ts_mod_cop.ts_on_item_take(item)    --TS_MOD--

- function actor_binder <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> n_item_drop (obj)
ts_mod_cop.ts_on_item_drop(obj)    --TS_MOD--

- в скрипте _g.script
- function start_game_callback()
в конец добавить
ts_mod_cop.ts_init_module()  --TS_MOD--

Внимание! если будет ругаться, можно закомментить/удалить
function ts_remove_stuff()
она для удаления оружия, для SGM мода
--]]--

local notest_time = 0

local weapon_classes_w_ammo = {}

--список аммо для каждой секции. по сути кэш
local weapon_ammo = {}

local ts_weapon_remove_radius=280

local tmp_vint = 0
local ts_hud = nil
local ts_hud_timeout = 0

--лог в текстовый файл
function ts_log(src,msg)

local g_time = game.get_game_time()
local t = game.CTime()

t:set(2012,1,1,0,0,1,1)
local t_diff = g_time:diffSec(t)

local f=io.open("ts_log.txt","a")
--local c_time = time_global()
f:write(string.format("(%s)=%s=>%s" ,t_diff,src,msg),"\n" )
f:close()

--[[--
if get_console() then
local msg_no_ws = string.gsub("=="..src.."==>"..msg, "%s", "_")
get_console():execute(msg_no_ws)
end
--]]--

end

-- упрощённый вызов новости
function ts_tip(news_caption, msg, showtime, timeout)
--local news_caption = "Сообщение"
local news_text
local texture = "ui_iconsTotal_grouping"

if msg then
news_text = msg
else
news_text = "#системная ошибка. перезагрузите ваш PDA"
end

if timeout == nil then timeout = 0 end
if showtime == nil then showtime = 5 end
if timeout == 0 then xr_sound.set_sound_play(db.actor:id(),"pda_tips") end
db.actor:give_game_news(news_caption, news_text, texture, timeout*1000, showtime*1000)
end

function ts_init_module()

weapon_classes_w_ammo = {
[clsid.wpn_vintorez_s]    = true,
[clsid.wpn_ak74_s]     = true,
[clsid.wpn_lr300_s]    = true,
[clsid.wpn_hpsa_s]     = true,
[clsid.wpn_pm_s]     = true,
[clsid.wpn_shotgun_s]    = true,
[clsid.wpn_auto_shotgun_s]  = true,
[clsid.wpn_bm16_s]     = true,
[clsid.wpn_svd_s]     = true,
[clsid.wpn_svu_s]     = true,
[clsid.wpn_rg6_s]     = true,
[clsid.wpn_rpg7_s]     = true,
[clsid.wpn_val_s]     = true,
[clsid.wpn_walther_s]    = true,
[clsid.wpn_usp45_s]    = true,
[clsid.wpn_groza_s]    = true,
[clsid.wpn_knife_s]    = false,
[clsid.wpn_grenade_f1_s]   = false,
[clsid.wpn_grenade_rgd5_s]   = false,
[clsid.wpn_grenade_launcher]  = true,
[clsid.wpn_grenade_fake]   = false}

--for k,v in pairs(weapon_classes_w_ammo) do

end

function is_weapon_w_ammo(object)
local id = get_clsid(object)
if id then
return weapon_classes_w_ammo[id] == true
else
ts_log("is_weapon_w_ammo","ERR.is_weapon_w_ammo:id=nil")
return false
end
end

function ts_get_weapon_ammo_type(sobj)
local stpk=net_packet()
stpk:w_begin(0)
sobj:STATE_Write(stpk)
local size=stpk:w_tell()

stpk:r_seek(size-2)

return stpk:r_u8()
end

--взято с OGSM
function spawn_ammo_in_inv(spawn_item,number,npc)
if npc==nil then
npc=db.actor
end
if number > 0 then
return create_ammo(spawn_item,
npc <img src="/.s/sm/23/tongue.gif" border="0" align="absmiddle" alt="tongue" /> osition(),
npc:level_vertex_id(),
npc:game_vertex_id(),
npc:id(),
number)
end
end

function ts_ammo_discharge(wpn)
local    name = wpn:name()
local    ammo_count = wpn:get_ammo_in_magazine()
if ammo_count>0 then
local ammo_type = ts_get_weapon_ammo_type( alife() <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> bject(wpn:id()) )
--ts_log("ts_ammo_discharge", name.." => ammo_count="..ammo_count.." ammo_type="..ammo_type)
local section_ammo = ts_ammo_by_num(wpn:section(),ammo_type)
if section_ammo~=nil and string.find(section_ammo,"ammo") then
local str1 = string.format("боеприпас %s (%d)",string.sub(section_ammo,6,30), ammo_count)
--ts_log("ts_ammo_discharge",str1)
ts_tip("Патроны",str1)
--add_hud("hud_event","Патроны: "..str1)
--ts_hud_msg(str1,3)
spawn_ammo_in_inv(section_ammo, ammo_count, nil)
wpn:unload_magazine()
else
if section_ammo == nil then
section_ammo = "<nil>"
end
ts_log("ts_ammo_discharge","Ammo section fail: "..section_ammo)
end

end
end

function parse_names_mod( s )
local t = {}

--отсечка коментария
local pos = string.find(s,";")
local ps = ""
if pos ~= nil and pos > 0 then
ps = string.sub(s,1, pos - 1)
else
ps = s
end

for name in string.gfind( ps, "([%w_.\\-]+)%p*" ) do
table.insert( t, name )
end

return t
end

--найти аммо по номеру
function ts_ammo_by_num(section,num)

local ammo_list

if weapon_ammo[section] ~= nil and weapon_ammo[section] ~= "" then
ammo_list = weapon_ammo[section]
--ts_log("ts_ammo_by_num",section.." => Found: "..ammo_list)
else
local ltx = system_ini()
ammo_list = ltx:r_string(section,"ammo_class")
weapon_ammo[section] = ammo_list
--ts_log("ts_ammo_by_num",section.." => Loaded: "..ammo_list)
end

local t=parse_names_mod(ammo_list)

local cnt = table.getn(t)

if cnt == 0 then
return nil
elseif num >= cnt then
return t[1]
else
return t[num+1]
end

--for n,v in pairs(parse_names(ammo_list)) do
--    ts_log("ts_ammo_by_num","....."..n.." -> "..v)
--end

end

function ts_remove_weapons()
local actorpos = db.actor <img src="/.s/sm/23/tongue.gif" border="0" align="absmiddle" alt="tongue" /> osition()
local c_rem = 0
local c_all = 0
local dist = 0
local obj = 0
local sec_name = ""
local obj_logic = 0
local names = " "
for a=1,65534 do
obj = alife() <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> bject(a)

if obj and isWeapon(obj) and obj.parent_id and obj.parent_id == 65535 and get_object_story_id(obj.id) == nil
and (level.object_by_id(obj.id) == nil or level.object_by_id(obj.id) <img src="/.s/sm/23/tongue.gif" border="0" align="absmiddle" alt="tongue" /> arent() == nil) then

c_all = c_all + 1

sec_name = obj:section_name()
obj_logic = obj:spawn_ini()

if sec_name and (string.find(sec_name,"wpn_") or string.find(sec_name,"gren") )
and (obj_logic == nil or (obj_logic ~= nil and not obj_logic:section_exist("secret"))) then
dist = actorpos:distance_to(obj.position)
local l_obj = level.object_by_id(obj.id)
if (l_obj) and (l_obj:condition()<98) and (dist > ts_weapon_remove_radius) then
names = names..sec_name.." "
remove_item_by_id(obj.id)
c_rem = c_rem + 1
end
end
end
end
ts_log("ts_remove_weapons","Removed: "..c_rem.." from "..c_all..names)
--ts_tip("System.cleaner","Removed: "..c_rem.." from "..c_all)
--ts_hud_msg("System.cleaner: Removed "..c_rem.." from "..c_all,3)
end

function ts_remove_stuff()

ts_remove_weapons()
ts_weapon_remove_radius = 350
end

function ts_on_net_spawn()
--ts_log("ts_on_net_spawn","..")
notest_time = 0

--ts_init_module() -- перенесено в _g.script

end

function test_discharge_weapon(ItemObj)
--ts_log("test_discharge_weapon")
if ItemObj == nil then
return false
end

if notest_time == 0 then
notest_time = game.time()+6000
elseif notest_time>game.time() then
return false
elseif is_weapon_w_ammo(ItemObj) then
local ItemId  = ItemObj:id()

local PistolSlot = db.actor:item_in_slot(1)
if PistolSlot then
IdPistol = PistolSlot:id()
end

local AutomaticSlot = db.actor:item_in_slot(2)
if AutomaticSlot then
IdAutomat = AutomaticSlot:id()
end

if ItemId ~= IdPistol and ItemId ~= IdAutomat then
ts_ammo_discharge(ItemObj)
end
end
end

function ts_on_item_take(obj)
if notest_time>game.time() then
return false
end

--ts_log("ts_on_item_take","...")
if obj ~= nil then
--  ts_log("ts_on_item_take",obj:name())
test_discharge_weapon(obj)
end
end

function ts_on_item_drop(obj)
if notest_time>game.time() then
return false
end

--ts_log("ts_on_item_drop","...")
if obj ~= nil then
--  ts_log("ts_on_item_drop",obj:name())
test_discharge_weapon(obj)
end
end

function init(obj)
    xr_motivator.AddToMotivator(obj)
end

function actor_init(npc)
    npc:bind_object(actor_binder(npc))
end

----------------------------------------------------------------------------------------------------------------------
class "actor_binder" (object_binder)
----------------------------------------------------------------------------------------------------------------------
function actor_binder:__init (obj) super(obj)
    db.actor_binder = self
    --alun_utils.debug_write("actor init start")
    self.bCheckStart = false
    --self.last_level_name = "nil" -- Not used for anything
    self.deimos_intensity = nil

    self.last_detective_achievement_spawn_time  = nil
    self.last_mutant_hunter_achievement_spawn_time    = nil

    bind_stalker_ext.actor_on_init(self)
    
    self.weather_manager = level_weathers.get_weather_manager()
    --alun_utils.debug_write("actor init end")
end

----------------------------------------------------------------------------------------------------------------------
function actor_binder:net_spawn(data)
    --printf("actor net spawn")
    --alun_utils.debug_write("actor net spawn start")
    level.show_indicators()
    self.bCheckStart = true
    self.weapon_hide = false -- спрятано или нет оружие при разговоре.
    self.weapon_hide_in_dialog = false
    if object_binder.net_spawn(self,data) == false then
  return false
    end
    db.add_actor(self.object)
    db.add_enemy(self.object)
    db.actor.deimos_intensity = self.deimos_intensity
    self.deimos_intensity = nil
    if self.st.disable_input_time == nil then
  level.enable_input()
    end
    death_manager.init_drop_settings()
    self.task_manager = task_manager.get_task_manager()
    self.spawn_frame = device().frame
    self.already_jumped = false
    self.loaded = false
    bind_stalker_ext.actor_on_net_spawn(self)
    self.weather_manager:reset()
    --alun_utils.debug_write("actor net spawn end")
    
    return true
end
----------------------------------------------------------------------------------------------------------------------
function actor_binder:net_destroy()
    --alun_utils.debug_write("actor net destroy start")
    
    xr_sound.stop_sounds_by_id(self.object:id())

    if(actor_stats.remove_from_ranking~=nil)then
  actor_stats.remove_from_ranking(self.object:id())
    end
    
    level.show_weapon(true)
    db.del_actor(self.object)
    db.delete_enemy(self.object)

    -- remove callbacks
    local t = {
    -- vanilla
    callback.inventory_info,
    callback.on_item_take,
    callback.on_item_drop,
    callback.task_state,
    callback.trade_sell_buy_item,
    callback.take_item_from_box,
    callback.use_object,
    
    -- coc
    callback.hit,
    callback.key_press,
    callback.key_release,
    callback.key_hold,
    callback.actor_before_death,
    callback.on_attach_vehicle,
    callback.on_detach_vehicle,
    callback.on_use_vehicle,
    callback.weapon_jammed,
    callback.weapon_zoom_in,
    callback.weapon_zoom_out
    }
    for i=1,#t do
  if (t[i]) then
   self.object:set_callback(t[i])
  end
    end

    if(_G.amb_vol~=0) then
  get_console():execute("snd_volume_eff "..tostring(_G.amb_vol))
  _G.amb_vol = 0
    end
    if(_G.mus_vol~=0) then
     get_console():execute("snd_volume_music "..tostring(_G.mus_vol))
  _G.mus_vol = 0
    end
    if sr_psy_antenna.psy_antenna then
  sr_psy_antenna.psy_antenna:destroy()
  sr_psy_antenna.psy_antenna = false
    end
    
    bind_stalker_ext.actor_on_net_destroy(self)

    object_binder.net_destroy(self)
    
    --alun_utils.debug_write("actor net destroy end")
end
----------------------------------------------------------------------------------------------------------------------
function actor_binder:reinit()
    object_binder.reinit(self)
    
    --alun_utils.debug_write("actor reinit")
    
    local npc_id = self.object:id()
    db.storage[npc_id] = empty_table(db.storage[npc_id])
    self.st = db.storage[npc_id]

    
  local t = {
    -- vanilla
    ["inventory_info"]    = bind_stalker_ext.actor_on_info_callback,
    ["on_item_take"]    = bind_stalker_ext.actor_on_item_take,
    ["on_item_drop"]    = bind_stalker_ext.actor_on_item_drop,
    ["task_state"]     = bind_stalker_ext.actor_on_task_callback,
    ["trade_sell_buy_item"]  = bind_stalker_ext.actor_on_trade,
    ["take_item_from_box"]  = bind_stalker_ext.actor_on_item_take_from_box,
    ["use_object"]    = bind_stalker_ext.actor_on_item_use,
    
    -- coc
    ["hit"]      = bind_stalker_ext.actor_on_hit_callback,
    ["key_press"]    = bind_stalker_ext.on_key_press,
    ["key_release"]    = bind_stalker_ext.on_key_release,
    ["key_hold"]    = bind_stalker_ext.on_key_hold,
    ["actor_before_death"]  = bind_stalker_ext.actor_on_before_death,
    ["on_attach_vehicle"]  = bind_stalker_ext.actor_on_attach_vehicle,
    ["on_detach_vehicle"]  = bind_stalker_ext.actor_on_detach_vehicle,
    ["on_use_vehicle"]   = bind_stalker_ext.actor_on_use_vehicle,
    ["weapon_jammed"]   = bind_stalker_ext.actor_on_weapon_jammed,
    ["weapon_zoom_in"]   = bind_stalker_ext.actor_on_weapon_zoom_in,
    ["weapon_zoom_out"]   = bind_stalker_ext.actor_on_weapon_zoom_out
    }
    for cb,func in pairs(t) do
  if (callback[cb] and func) then
   self.object:set_callback(callback[cb],func,self)
  end
    end
end

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

function actor_binder:update(delta)
    object_binder.update(self, delta)
    --alun_utils.debug_write("actor update START")
    if not (db.actor:alive()) then
  return
    end
    
    if self.bCheckStart then -- first update after netspawn
  bind_stalker_ext.actor_on_first_update(self,delta)
  --printf("SET DEFAULT INFOS")
  if not has_alife_info("global_dialogs") then
   self.object:give_info_portion("global_dialogs")
  end
  if not has_alife_info("level_changer_icons") then
   self.object:give_info_portion("level_changer_icons")
  end
  pda.fill_primary_objects()
  self.object:activate_slot(self.loaded_active_slot or 0)
  self.bCheckStart = nil
  db.actor.afterFirstUpdate = true
    end
    
    self.task_manager:update()

    -- DEBUG slowdown
    --slowdown.update()
    
    game_stats.update (delta, self.object)

    -- апдейт погоды
    self.weather_manager:update()

    --' Апдейт саундменеджера
    xr_sound.update(self.object:id())

    -- Обновление отключения ввода с клавиатуры.
    if (self.st.disable_input_time ~= nil and game.get_game_time():diffSec(self.st.disable_input_time) >= self.st.disable_input_idle) then
  level.enable_input()
  self.st.disable_input_time = nil
    end

    -- Апдейт прятание оружия игрока во время диалога
    if self.object:is_talking() then
  if self.weapon_hide_in_dialog == false then
   self.object:hide_weapon()
   --printf("hiding weapon!!!")
   self.weapon_hide_in_dialog = true
  end
    else              
  if self.weapon_hide_in_dialog == true then
   --printf("restoring weapon!!!")
   self.object:restore_weapon()
   self.weapon_hide_in_dialog = false
  end
    end

    -- обновление пси-антенны
    if sr_psy_antenna.psy_antenna then
  sr_psy_antenna.psy_antenna:update(delta)
    end

    -- Апдейт доступности для симуляции.
    simulation_objects.get_sim_obj_registry():update_avaliability(alife():actor())

    bind_stalker_ext.actor_on_update(self,delta)
    
    local tg = time_global()
    if (self.last_update and tg < self.last_update) then
  --alun_utils.debug_write("actor update END")
  return
    end
    self.last_update = tg + 3000

    pda.fill_sleep_zones()
    new_tasks.task_spec()

    treasure_manager.get_treasure_manager():update()
    
    --alun_utils.debug_write("actor update END")
end
----------------------------------------------------------------------------------------------------------------------
function actor_binder:save(packet)
    set_save_marker(packet, "save", false, "actor_binder")
    object_binder.save(self, packet)
    set_save_marker(packet, "save", true, "actor_binder")
    
    if (USE_MARSHAL) then
  if (utils.level_changing()) then
   alun_utils.save_var(db.actor,"heli_enemy_flag",false)
   SendScriptCallback("on_level_changing")
  end
  self:save_state(alife_storage_manager.get_state())
  return
    end
    --alun_utils.debug_write("--------------- actor_binder:save -------- Start")
    set_save_marker(packet, "save", false, "actor_binder")

    if (utils.level_changing()) then
  alun_utils.save_var(db.actor,"heli_enemy_flag",false)
    end
    
    --alundaio
    alun_utils.w_stpk(packet,"u8",level.get_game_difficulty(), "game difficulty")
    alun_utils.w_stpk(packet,"CTime",self.st.disable_input_time, "disable input time")

    xr_logic.pstor_save_all(self.object, packet)
    self.weather_manager:save(packet)
    
    sr_psy_antenna.save( packet )

    alun_utils.w_stpk(packet,"bool",SIMBOARD.simulation_started, "sim started")

    xr_sound.actor_save(packet)
    --alun_utils.w_stpk(packet,"stringZ",self.last_level_name,"last level name")
    xr_statistic.save(packet)
    treasure_manager.get_treasure_manager():save(packet)
    task_manager.get_task_manager():save(packet)
    packet:w_u8(self.object:active_slot())

    alun_utils.w_stpk(packet,"CTime",self.last_detective_achievement_spawn_time, "detective spawn time")
    alun_utils.w_stpk(packet,"CTime",self.last_mutant_hunter_achievement_spawn_time, "hunter spawn time")

    bind_stalker_ext.actor_on_save(self,packet)

    --alun_utils.debug_write("--------------- actor_binder:save -------- End")
end

function actor_binder:load(reader)
    set_save_marker(reader, "load", false, "actor_binder")
    object_binder.load(self, reader)
    set_save_marker(reader, "load", true, "actor_binder")
    if (USE_MARSHAL) then
  self:load_state(alife_storage_manager.get_state())
  bind_stalker_ext.actor_on_load(self,reader)
  return
    end
    --alun_utils.debug_write("actor_binder:load start")

    local game_difficulty_by_num = {
    [0] = "gd_novice",
    [1] = "gd_stalker",
    [2] = "gd_veteran",
    [3] = "gd_master"
    }
    local dif = game_difficulty_by_num[reader:r_u8()]
    if not (dif) then
  abort("actor_binder:load save corrupted!")
  return
    end
    get_console():execute("g_game_difficulty "..dif)
    self.st.disable_input_time = utils.r_CTime(reader,"bind_stalker")

    xr_logic.pstor_load_all(self.object, reader)
    self.weather_manager:load(reader)

    sr_psy_antenna.load(reader)
    SIMBOARD.simulation_started = reader:r_bool()

    xr_sound.actor_load(reader)
    --[[
    local n = reader:r_stringZ()
    if(n~="nil") then
  self.last_level_name = n
    end
    --]]
    xr_statistic.load(reader)
    treasure_manager.get_treasure_manager():load(reader)
    task_manager.get_task_manager():load(reader)

    self.loaded_active_slot = reader:r_u8()

    local stored_achievement_time = reader:r_bool()
    if stored_achievement_time == true then
  self.last_detective_achievement_spawn_time = utils.r_CTime(reader,"bind_stalker")
    end
    stored_achievement_time = reader:r_bool()
    if stored_achievement_time == true then
  self.last_mutant_hunter_achievement_spawn_time = utils.r_CTime(reader,"bind_stalker")
    end

    --alun_utils.debug_write("actor_binder:load end")
end

----------------------------------------------------------------------------------------------------------------------
function actor_binder:save_state(m_data)
    --alun_utils.debug_write(strformat("actor_binder:save_state BEFORE"))
    m_data.actor_binder = {}
    m_data.actor_binder.game_difficulty = level.get_game_difficulty()
    m_data.actor_binder.disable_input_time = self.st.disable_input_time
    m_data.actor_binder.simulation_started = SIMBOARD.simulation_started
    --m_data.actor_binder.last_level_name = self.last_level_name
    m_data.actor_binder.active_slot = self.object:active_slot()
    m_data.actor_binder.last_detective_achievement_spawn_time = self.last_detective_achievement_spawn_time
    m_data.actor_binder.last_mutant_hunter_achievement_spawn_time = self.last_mutant_hunter_achievement_spawn_time
    
    if (sr_psy_antenna.psy_antenna and sr_psy_antenna.psy_antenna.global_state ~= 0 and not utils.level_changing()) then
  sr_psy_antenna.psy_antenna:save_state(m_data)
    end
    
    xr_statistic.save_state(m_data)
    inventory_upgrades.save_state(m_data)
    xr_sound.actor_save_state(m_data)
    task_manager.save_state(m_data)
    level_weathers.get_weather_manager():save_state(m_data)
    surge_manager.save_state(m_data)
    psi_storm_manager.save_state(m_data)
    
    db.storage[0].pstor = db.storage[0].pstor or {}
    --alun_utils.debug_write(strformat("actor_binder:save_state AFTER"))
end

function actor_binder:load_state(m_data)
    if not (m_data.actor_binder) then
  return
    end
    --alun_utils.debug_write(strformat("actor_binder:load_state %s BEFORE",self.object:name()))
    --alun_utils.debug_write("actor_binder:load_state")
    local game_difficulty_by_num = {
    [0] = "gd_novice",
    [1] = "gd_stalker",
    [2] = "gd_veteran",
    [3] = "gd_master"
    }
    get_console():execute("g_game_difficulty "..game_difficulty_by_num[m_data.actor_binder.game_difficulty or 3])
    self.st.disable_input_time = m_data.actor_binder.disable_input_time
    SIMBOARD.simulation_started = m_data.actor_binder.simulation_started
    --self.last_level_name = m_data.actor_binder.last_level_name
    self.loaded_active_slot = m_data.actor_binder.active_slot or 0
    self.last_detective_achievement_spawn_time = m_data.actor_binder.last_detective_achievement_spawn_time
    self.last_mutant_hunter_achievement_spawn_time = m_data.actor_binder.last_mutant_hunter_achievement_spawn_time
    
    if (sr_psy_antenna.psy_antenna) then
  sr_psy_antenna.psy_antenna:load_state(m_data)
    end
    
    xr_statistic.load_state(m_data)
    inventory_upgrades.load_state(m_data)
    xr_sound.actor_load_state(m_data)
    task_manager.load_state(m_data)
    level_weathers.get_weather_manager():load_state(m_data)
    surge_manager.load_state(m_data)
    psi_storm_manager.load_state(m_data)
    
    if (m_data.pstor_all and m_data.pstor_all[0]) then
  db.storage[0].pstor = m_data.pstor_all[0]
  m_data.pstor_all[0] = nil
    end

    if (m_data.pstor_ctime and m_data.pstor_ctime[0]) then
  db.storage[0].pstor_ctime = m_data.pstor_ctime[0]
  m_data.pstor_ctime[0] = nil
    end
    
    m_data.actor_binder = nil
    --alun_utils.debug_write(strformat("actor_binder:load_state %s AFTER",self.object:name()))
end

----------------------------------------------------------------------------------------------------------------------
function actor_binder:take_item_from_box(box, item)
    local box_name = box:name()
    ts_mod_cop.ts_on_item_take(item)    --TS_MOD--
end

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

function actor_binder <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> n_item_drop (obj)
    ts_mod_cop.ts_on_item_drop(obj)    --TS_MOD--
end
----------------------------------------------------------------------------------------------------------------------

function actor_binder <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> n_item_take (obj)
    printf("on_item_take [%s]", obj:name())
    if isArtefact(obj) then
  local anomal_zone = bind_anomaly_zone.parent_zones_by_artefact_id[obj:id()]
  if anomal_zone ~= nil then
   anomal_zone <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> n_artefact_take(obj)
  else
   bind_anomaly_zone.artefact_ways_by_id[obj:id()] = nil
  end
  local artefact = obj:get_artefact()
  artefact:FollowByPath("NULL",0,vector():set(500,500,500))
  xr_statistic.inc_founded_artefacts_counter(obj:id())
--[[
  local s_art = alife() <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> bject(obj:id())
  if(s_art) then
   xr_statistic.inc_founded_artefacts_counter(s_art:section_name())
  else
   xr_statistic.inc_founded_artefacts_counter()
  end
]]
    end
    treasure_manager.get_treasure_manager() <img src="/.s/sm/23/surprised.gif" border="0" align="absmiddle" alt="surprised" /> n_item_take(obj:id())
    
    ts_mod_cop.ts_on_item_take(obj)    --TS_MOD--
end

if xr_condition.monster_is_alive(nil,nil,{"storyid_монстра"}) then "действие"