--------------------------------------------------------------------------------
-- Surge manager class ---------------------------------------------------------
-- Made by Peacemaker ----------------------------------------------------------
-- 05.03.07 --------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Edited for AtmosFear 3 ------------------------------------------------------
-- by Cromm Cruac --------------------------------------------------------------
-- 25.06.2011 ------------------------------------------------------------------
--------------------------------------------------------------------------------
-- Edited by Alundaio for Call of Chernobyl

--[[
	Tronex
	2019/9/13
	Modified for Anomaly 1.5
--]]

-------------------
local alife, math_random, pairs, tostring = alife,  math.random, pairs, tostring
-------------------

---------------------------------------------------------------------
-- class instance
SurgeManager = nil
function get_surge_manager()
	SurgeManager = SurgeManager or CSurgeManager()
	return SurgeManager
end
---------------------------------------------------------------------

local a_ini = ini_file("alife.ltx")
local normal_time_factor = a_ini:r_float_ex("alife","time_factor") or 6
local surge_time_factor = 10

local surge_shock_pp_eff 	= 1
local earthquake_cam_eff 	= 2
local sleep_cam_eff 		= 3
local sleep_fade_pp_eff		= 4

local prev_sec 				= -1
local prev_game_sec 		= -1
local currentPPEfactor 		= 0.001
local _tmr

local snd_surge1 = sound_object('characters_voice\\scenario\\zaton\\zat_a2_stalker_barmen_surge_phase_1')
local snd_surge2 = sound_object('characters_voice\\scenario\\zaton\\zat_a2_stalker_barmen_surge_phase_2')
local snd_surge3 = sound_object('characters_voice\\scenario\\zaton\\zat_a2_stalker_barmen_after_surge')

local presurge_played		= {0, 0, 0, 0, 0, 0}

--[[Amount of time before a surge in in-game seconds (6x real life seconds)
	Note that the script updates events only once per real life second]]--
local presurge_time			= 360

local function main_loop()
	local tg = time_global()
	
	if (_tmr and tg < _tmr) then 
		return false
	end
	_tmr = tg + 1000
	
	if not (db.actor and db.actor.afterFirstUpdate) then 
		return false
	end
	
	get_surge_manager():update()
	psi_storm_manager.get_psi_storm_manager():update()

	if level.get_time_factor() ~= normal_time_factor and not is_started() and not psi_storm_manager.is_started() then
		if is_finished() and psi_storm_manager.is_finished() then
			level.set_time_factor(normal_time_factor)
		end
	end
	
	return false
end

local function on_level_changing()
	local tm = task_manager.get_task_manager()
	local task_info = tm.task_info["faction_base_defense"]
	if (task_info and task_info.status ~= "completed" and task_info.status ~= "fail") then 
		stop_surge()
		tm:set_task_cancelled("faction_base_defense")
	end
end

local function actor_on_sleep(hours)
	get_surge_manager().time_forwarded = true
	psi_storm_manager.get_psi_storm_manager().time_forwarded = true
	
	if(is_started() and level_weathers.get_weather_manager().weather_fx) then
		level.stop_weather_fx()
	end
	level_weathers.get_weather_manager():forced_weather_change()
end

function on_game_start()
	AddUniqueCall(main_loop)
	RegisterScriptCallback("on_level_changing",on_level_changing)
	RegisterScriptCallback("actor_on_sleep",actor_on_sleep)
end
	
local enable_debug = false
function print_dbg(fmt,...)
	if enable_debug then
		printf("Surge manager | " .. fmt,...)
	end
end

local function file_exists(filename)
    local file = io.open(filename, "r")
    if (file) then
        file:close()
        return true
    end
    return false
end

-- ###############################################################################################
--                                  SURGE MANAGER
-- ###############################################################################################

class "CSurgeManager"
function CSurgeManager:__init()
	self.ini = ini_file("misc\\surge_manager.ltx")
	self.blowout_sounds = {	
						begin01			=sound_object("ambient\\blowout\\blowout_begin"),
						begin02			=sound_object("ambient\\blowout\\blowout_begin_02"),
						impact01		=sound_object("ambient\\blowout\\blowout_impact"),
						impact02		=sound_object("ambient\\blowout\\blowout_impact_02"),
						wave01			=sound_object("ambient\\blowout\\blowout_wave_01"),
						wave02			=sound_object("ambient\\blowout\\blowout_wave_02_short"),
						wave03			=sound_object("ambient\\blowout\\blowout_wave_03_short"),
						wave04			=sound_object("ambient\\blowout\\blowout_wave_04"),
						body_tear		=sound_object("anomaly\\anomaly_body_tear_1"),
						siren			=sound_object("ambient\\blowout\\blowout_siren"),
						crow0			=sound_object("ambient\\blowout\\cut\\close"),
						crow1			=sound_object("ambient\\blowout\\cut\\closemedium"),
						crow2			=sound_object("ambient\\blowout\\cut\\medium"),
						crow3			=sound_object("ambient\\blowout\\cut\\prettyfar"),
						crow4			=sound_object("ambient\\blowout\\cut\\far"),
						crow5			=sound_object("ambient\\blowout\\cut\\veryfar")
					}
	self.blowout_waves 	= {}
	self.body_tears 	= {}
end

function CSurgeManager:initialize()
	--[[
	self.levels_respawn = empty_table(self.levels_respawn)
	for level,v in pairs(level_weathers.valid_levels) do
		self.levels_respawn[level] = false
	end
	--]]
	
	--utils_data.debug_write("CSurgeManager:initialize() start")
	
	self.aspectRatio = 1
	if(device().width/device().height>(1024/768+0.01)) then
		self.aspectRatio = 0.8
	end
	
	if not (self._state_loaded) then -- because state_load called too early, we wait till actor_on_load to truly init and we do not want to overwrite loaded values
		self.last_surge_time = game.get_game_time()
		self.inited_time = game.get_game_time()
		self.started = false
		self.finished = true
		self.game_time_factor=level.get_time_factor()
		self.task_given = nil
	end
	
	if not (self._delta) then
		local freq = ui_options.get("alife/event/emission_frequency")
		self._delta = math_random(math.floor(freq/2)*3600, freq*3600)
	end
	
	self.hitFactor = 0
	self.surge_time = 222
	
	self:init_surge_covers()

	local ini = self.ini
	self.condlist = ini:r_string_to_condlist("settings","condlist")
	self.survive = ini:r_string_to_condlist("settings","survive")

	self.surge_message = ""
	self.surge_task_sect = ""
	
	--printf("level=%s   artefact_respawn_levels=%s",level.name(),m_data.artefact_respawn_levels[level.name()])
	
	--utils_data.debug_write("CSurgeManager:initialize() end")
end

function CSurgeManager:start(manual)
-- manual is used to set inited_time to current in-game date
-- sets inited_time for the surge + prepare values
-- skip surge in special cases

	--utils_data.debug_write("CSurgeManager:start()")
	if not (self._state_loaded) then 
		self:initialize()
	end
	
	self.game_time_factor = level.get_time_factor()

	local Y, M, D, h, m, s, ms = 0, 0, 0, 0, 0, 0, 0
	Y, M, D, h, m, s, ms = self.last_surge_time:get(Y, M, D, h, m, s, ms)
	if (manual or not self.inited_time) then
		self.inited_time = game.get_game_time()
	else
		self.inited_time:set(Y, M, D, h, m, s + self._delta, ms)
	end
	
	local flags = {allow = true}
	SendScriptCallback("on_before_surge",flags)
	
	local level_name = level.name()
	if (level_weathers.valid_levels[level_name] ~= true or (not ui_options.get("alife/event/emission_state")) or flags.allow == false) then
		self:skip_surge()
		return
	end
	
	-- Generators is emission source and Deserted Hospital has nowhere to hide (almost all the map is inside anyway).
	if (level_name == "l13_generators" or level_name == "l11_hospital" or has_alife_info("bar_arena_fight")) then
		self.skip_message = true
		self:skip_surge()
		return
	end
	
	local diff_sec = math.ceil(game.get_game_time():diffSec(self.inited_time)/level.get_time_factor())
	if (diff_sec+6 > self.surge_time)then
		self.skip_message = true
		self:skip_surge()
	else
	
		-- heli_combat flag
		save_var(db.actor,"heli_enemy_flag",nil)
		
		self.started = true
		self.finished = false
		self.task_given = nil
		self:finalize()
		self.blowout_waves = empty_table(self.blowout_waves)
		self.objects_to_kill = empty_table(self.objects_to_kill)
		self.stages = empty_table(self.stages)
		self.body_tears = empty_table(self.body_tears)
		self.hitFactor=0
		level.set_time_factor(surge_time_factor)
		self.zombie_count = 0
		SendScriptCallback("actor_on_interaction", "anomalies", nil, "emission_start")
	end
end

function CSurgeManager:new_surge_time(reset)
	if reset then
		self.last_surge_time = game.get_game_time()
	end
	
	--utils_data.debug_write("CSurgeManager:new_surge_time()")
	
	local freq = ui_options.get("alife/event/emission_frequency")
	self._delta = math_random(math.floor(freq/2)*3600, freq*3600)

	local g_time = game.get_game_time()
	local psi_manager = psi_storm_manager and psi_storm_manager.get_psi_storm_manager()
	local last_psi_storm_time = psi_manager and psi_manager.last_psi_storm_time or game.get_game_time()
	local psi_storm_start = psi_manager and math.floor(psi_manager._delta - g_time:diffSec(last_psi_storm_time)) or 0
	local psi_storm_end = psi_manager and math.floor(psi_manager._delta+3600 - g_time:diffSec(last_psi_storm_time)) or 0
	local surge_start = math.floor(self._delta - g_time:diffSec(self.last_surge_time))
	local surge_end = math.floor(self._delta+3600 - g_time:diffSec(self.last_surge_time))
	if ((surge_end > psi_storm_start) and (surge_end < psi_storm_end)) then
		--1h earlier
		self._delta=self._delta-3600
	end
	if ((surge_start > psi_storm_start) and (surge_start < psi_storm_end)) then
		--1h later
		self._delta=self._delta+3600
	end
end

function CSurgeManager:skip_surge()
	if not (self.inited_time) then 
		self.inited_time = game.get_game_time()
	end
	if not (self.last_surge_time) then 
		self.last_surge_time = game.get_game_time()
	end
	local Y, M, D, h, m, s, ms = 0, 0, 0, 0, 0, 0, 0
	Y, M, D, h, m, s, ms = self.inited_time:get(Y, M, D, h, m, s, ms)
	self.last_surge_time:set(Y, M, D, h, m, s + self.surge_time, ms)

	self:new_surge_time(false)

	self.started 			= false
	self.finished 			= true

	--[[
	self.levels_respawn = empty_table(self.levels_respawn)
	for level,v in pairs(level_weathers.valid_levels) do
		self.levels_respawn[level] = true
	end
	--]]

	self.surge_message 		= ""
	self.surge_task_sect 	= ""
	self.task_given 		= false

	self.effector_set			= false
	self.second_message_given 	= false
	self.ui_disabled			= false
	self.blowout_sound			= false
	self.wave_sound 			= false
	prev_sec					= 0

	SendScriptCallback("actor_on_interaction", "anomalies", nil, "emission_end")
	
	if (self.skip_message and ui_options.get("alife/event/emission_state")) then
		news_manager.send_tip(db.actor, "st_surge_while_asleep", nil, "recent_surge", nil, nil)
		SendScriptCallback("actor_on_interaction", "anomalies", nil, "emissions")
		game_statistics.increment_statistic("emissions")
		self.skip_message = nil
		--release_body_manager.get_release_body_manager():clear(true)
	end
	
	-- hide indicators
	self:displayIndicators(0)

	level.set_time_factor(self.game_time_factor)
end

function CSurgeManager:end_surge(manual)

	if (self.started == true) then 
		game_statistics.increment_statistic("emissions")
		self:kill_all_unhided()
		SendScriptCallback("actor_on_interaction", "anomalies", nil, "emissions")
		SendScriptCallback("actor_on_interaction", "anomalies", nil, "emission_end")
	end
	
	self.last_surge_time 	= game.get_game_time()
	self.started 			= false
	self.finished 			= true

	self:new_surge_time(false)

	self.surge_message 		= ""
	self.surge_task_sect 	= ""
	self.task_given 		= nil
	
	presurge_played = {0, 0, 0, 0, 0}

	if(self.blowout_sound) then
		xr_sound.stop_sound_looped(AC_ID, "blowout_rumble")
	end
	if(self.wave_sound) then
		xr_sound.stop_sound_looped(AC_ID, "blowout_particle_wave_looped")
	end
	for k,wave in pairs(self.blowout_waves) do
		if wave.effect:playing() then
			self:kill_wave(k)
		end
	end
	for k,snd in pairs(self.blowout_sounds) do
		if snd ~= nil and snd:playing() then
			snd:stop()
		end
	end
	if(self.second_message_given) then
		xr_sound.stop_sound_looped(AC_ID, "surge_earthquake_sound_looped")
	end

	if(manual or (self.time_forwarded and level_weathers.get_weather_manager().weather_fx)) then
		level.stop_weather_fx()
--		level_weathers.get_weather_manager():select_weather(true)
		level_weathers.get_weather_manager():forced_weather_change()
	end

	self.effector_set 			= false
	self.second_message_given 	= false
	self.ui_disabled  			= false
	self.blowout_sound			= false
	self.wave_sound			= false
	prev_sec				= 0
	self.hitFactor=0

	level.remove_pp_effector(surge_shock_pp_eff)
	level.remove_cam_effector(earthquake_cam_eff)
	-- hide indicators
	self:displayIndicators(0)

	level.set_time_factor(self.game_time_factor)

	for k,v in pairs(db.signal_light) do
		v:stop_light()
		v:stop()
	end
end

function CSurgeManager:pos_in_cover(pos,by_name)
	if not (self.covers) then 
		return
	end
	local sr
	for name,condlist in pairs(self.covers) do 
		--if (db.actor_inside_zones[name]) then 
			--return true
		--end
		
		sr = db.zone_by_name[name]
		if (sr and sr:inside(pos)) then
			if by_name then
				return name
			end
			return true
		end
	end
	return false
end 

function CSurgeManager:init_surge_covers() -- collect safe zones list, if not done yet
	if (self.covers) then 
		return 
	end 
	self.covers = {}
	local ini = self.ini
	for i = 0, ini:line_count("list")-1 do
		temp1, id, temp2 = ini:r_line("list", i, "", "")
		self.covers[id] = ini:r_string_to_condlist(id,"condlist") or xr_logic.parse_condlist(nil,"surge_manager","covers","true")
	end
end

function CSurgeManager:hit_power(power,hit_type)
	local hit_types={"burn", "shock", "chemical_burn", "radiation", "telepatic"}
	local suit_factors={10,1,5,33,10}
	local drug_factors={1,1,5,33,10}
	local artefact_factors={10,5,10,10,10}

	local suit_protection = db.actor:get_current_outfit_protection(hit_type)*suit_factors[hit_type+1]
	local helmet_protection = 0
	local helmet = db.actor:item_in_slot(12)
	if helmet ~= nil then
		helmet_protection = ini_sys:r_float_ex(helmet:section(),hit_types[hit_type+1].."_protection")*suit_factors[hit_type+1]
	end

	local g_time
	-- DRUG PROTECTIONS CHECK
	local expiration = load_var(db.actor,"drug_psy_blockade_expiration")
	if (expiration) then
		g_time = utils_data.CTimeToSec(game.get_game_time())
		if g_time<expiration then
			self.drug_telepatic_protection = ini_sys:r_float_ex("drug_psy_blockade","boost_telepat_protection")
		else
			self.drug_telepatic_protection = nil
		end
	end
	
	expiration = load_var(db.actor,"drug_radioprotector_expiration")
	if (expiration) then
		g_time = g_time or utils_data.CTimeToSec(game.get_game_time())
		if g_time<expiration then
			self.drug_radiation_protection = ini_sys:r_float_ex("drug_radioprotector","boost_radiation_protection")
		else
			self.drug_radiation_protection = nil
		end
	end
	
	expiration = load_var(db.actor,"drug_antidot_expiration")
	if (expiration) then
		g_time = g_time or utils_data.CTimeToSec(game.get_game_time())
		if g_time<expiration then
			self.drug_chemical_burn_protection = ini_sys:r_float_ex("drug_antidot","boost_chemburn_protection")
		else
			self.drug_chemical_burn_protection = nil
		end
	end
	
	local drug_protection = 0
	if hit_type == 2 and self.drug_chemical_burn_protection ~= nil then
		drug_protection=self.drug_chemical_burn_protection*drug_factors[hit_type+1]
	elseif hit_type == 3 and self.drug_radiation_protection ~= nil then
		drug_protection=self.drug_radiation_protection*drug_factors[hit_type+1]
	elseif hit_type == 4 and self.drug_telepatic_protection ~= nil then
		drug_protection=self.drug_telepatic_protection*drug_factors[hit_type+1]
	end
	protection = (suit_protection + helmet_protection + drug_protection)
	if protection > 1 then
		protection = 1
	end
	hit_power=power*(1-protection)
	return hit_power
end

function CSurgeManager:start_wave(num,inited_time)
	if inited_time==nil then
		inited_time=prev_game_sec
	end
	local actor_pos=db.actor:position()
	local effect=particles_object("crommcruac\\blowout_wave_blend")
	local inited_pos= vector():set(actor_pos.x, actor_pos.y/2, actor_pos.z+250)
	self.blowout_waves[num]={effect=effect,inited_time=inited_time,inited_pos=inited_pos}
	self.blowout_waves[num].effect:play_at_pos(inited_pos)
	if not(self.wave_sound) then
		xr_sound.play_sound_looped(AC_ID, "blowout_particle_wave_looped")
		xr_sound.set_volume_sound_looped(AC_ID, "blowout_particle_wave_looped", 0)
		self.wave_sound=true
	end
end

function CSurgeManager:finalize()
	for k,v in pairs(self.blowout_waves) do
		if (v.effect and v.effect:playing()) then 
			v.effect:stop()
		end
	end
	for k,v in pairs(self.body_tears) do 
		if (v:playing()) then 
			v:stop()
		end
	end
end 

function CSurgeManager:kill_wave(num)
	if self.blowout_waves[num] then
		self.blowout_waves[num].effect:stop_deffered()
		self.blowout_waves[num]=nil
	end
end

function fade(currentTime,startTime,endTime,startValue,endValue)
	local totalFadeTime=endTime-startTime
	local totalFadeValue=endValue-startValue
	local elapsedFadeTime=currentTime-startTime
	local currentValue=(totalFadeValue*elapsedFadeTime)/totalFadeTime+startValue
	if (totalFadeValue<0) then
		if (currentValue>startValue) then
			currentValue=startValue
		end
		if (currentValue<endValue) then
			currentValue=endValue
		end
	else
		if (currentValue>endValue) then
			currentValue=endValue
		end
		if (currentValue<startValue) then
			currentValue=startValue
		end
	end
	return currentValue
end

function play_sound_radius(sndobj, radius, min, max)
	local rnd_pos = db.actor:position()
	local rnd_angle = math.random(min, max)
	rnd_pos.x = rnd_pos.x + (math.cos(rnd_angle) * radius)
	rnd_pos.z = rnd_pos.z + (math.sin(rnd_angle) * radius)
	if(sndobj:playing()) then
		sndobj:stop()
	end
	sndobj:play_at_pos(db.actor, rnd_pos)
	printf("played sound at x=%s z=%s", rnd_pos.x, rnd_pos.z)
end

----------------------------------
--	Update
----------------------------------
function CSurgeManager:update()
	--utils_data.debug_write("CSurgeManager:update()")

	if not (self._state_loaded) then 
		print_dbg('self._state_loaded is not loaded -> initialize')
		self:initialize()
		return
	end 
	
	if not (self.first_update) then 
		print_dbg('first update')
		self.first_update = true
		
		local flags = {allow = true}
		SendScriptCallback("on_before_surge",flags)
	
		-- end surge if level is not valid
		local level_name = level.name()
		if (level_name == "l13_generators"
		or level_name == "l11_hospital"
		or has_alife_info("bar_arena_fight")
		or flags.allow == false
		or level_weathers.valid_levels[level_name] ~= true)
		then
			print_dbg('level is not valid')
			if (self.started) then
				self:end_surge()
			-- else
				-- self:skip_surge()
			end
			return
		end
		
		local diff_sec = math.ceil(game.get_game_time():diffSec(self.inited_time)/level.get_time_factor())
		print_dbg('diff_sec 1 = %s',diff_sec)
		if (diff_sec > self.surge_time)then
			print_dbg('diff_sec > self.surge_time')
			self:skip_surge()
			return
		end
	end
	
	SetEvent("surge", "state", self.started)

	if (not self.started) then
		--print_dbg('not started')
		local g_time = game.get_game_time()
		if (self.time_forwarded) then
			local diff = math.abs(self._delta - g_time:diffSec(self.last_surge_time))
			if (diff < 3600) then
				self._delta = 3*3600 + g_time:diffSec(self.last_surge_time)
			end
			self.time_forwarded = false
			print_dbg('time forwarded')
		end
		
		--Plays sound before a blowout
		if(math.abs(self._delta - g_time:diffSec(self.last_surge_time)) < presurge_time) then
			if(presurge_played[1] ~= true) then
				--self.blowout_sounds["presurge"]:play(db.actor)
				play_sound_radius(self.blowout_sounds["crow5"], 1000, 140, 220)
				play_sound_radius(self.blowout_sounds["crow4"], 1000, 140, 220)
				printf("Played far crows")
				presurge_played[1] = true
			end
			if(math.abs(self._delta - g_time:diffSec(self.last_surge_time)) < (presurge_time - 60) and presurge_played[2] ~= true) then
				--self.blowout_sounds["presurge"]:play(db.actor)
				play_sound_radius(self.blowout_sounds["crow3"], 1000, 100, 260)
				play_sound_radius(self.blowout_sounds["crow2"], 1000, 100, 260)
				printf("Played medium crows")
				presurge_played[2] = true
			end
			if(math.abs(self._delta - g_time:diffSec(self.last_surge_time)) < (presurge_time - 120) and presurge_played[3] ~= true) then
				--self.blowout_sounds["presurge"]:play(db.actor)
				play_sound_radius(self.blowout_sounds["crow1"], 1000, 0, 360)
				play_sound_radius(self.blowout_sounds["crow0"], 1000, 0, 360)
				printf("Played close crows")
				presurge_played[3] = true
			end
			if(math.abs(self._delta - g_time:diffSec(self.last_surge_time)) < (presurge_time - 180) and presurge_played[4] ~= true) then
				--self.blowout_sounds["presurge"]:play(db.actor)
				play_sound_radius(self.blowout_sounds["crow2"], 1000, 280, 440)
				play_sound_radius(self.blowout_sounds["crow3"], 1000, 280, 440)
				printf("Played medium crows")
				presurge_played[4] = true
			end
			if(math.abs(self._delta - g_time:diffSec(self.last_surge_time)) < (presurge_time - 240) and presurge_played[5] ~= true) then
				--self.blowout_sounds["presurge"]:play(db.actor)
				play_sound_radius(self.blowout_sounds["crow4"], 1000, 320, 400)
				play_sound_radius(self.blowout_sounds["crow5"], 1000, 320, 400)
				printf("Played far crows")
				presurge_played[5] = true
			end
		end
		--DEBUG
		--printf("until blowout: %s", math.abs(self._delta - g_time:diffSec(self.last_surge_time)))
		
		-- return if next surge time hasn't been reached yet
		if (g_time:diffSec(self.last_surge_time) < self._delta) then
			--print_dbg('next surge time hasnt been reached yet')
			return
		end
		
		if (self.condlist and xr_logic.pick_section_from_condlist(db.actor, nil, self.condlist) == "false") then
			return
		end
		
		print_dbg('start')
		self:start()
		return
	end
	
	local diff_sec = math.ceil(game.get_game_time():diffSec(self.inited_time)/level.get_time_factor())
	if (diff_sec >= self.surge_time) then 
		print_dbg('diff_sec 2 = %s', diff_sec)
		if (load_var(db.actor,"surge_immuned",false) ~= true) then -- special surged immuned for tasks
			self:end_surge()
			return
		else 
			print_dbg('start surge')
			self:start(true)
		end
	end
	
	local diff_game_sec = math.ceil(game.get_game_time():diffSec(self.inited_time)/2)
	print_dbg('diff_game_sec = %s', diff_game_sec)
------------------------------------update here--------------------------------

	--printf("diff_sec = %s",diff_sec)
	if (prev_sec ~= diff_sec) then
		prev_sec = diff_sec
		
		SetEvent("surge", "time", diff_sec)
		
		if (not ui_options.get("alife/event/emission_state")) then
			--printf("Surge stopped because of level!")
			print_dbg('stop surge because option')
			self:end_surge()
			return
		end
		
		local rnd_sound= math.random(1,4)
		
		-- blowout begins -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=0 and self.stages['beginning'] ~= true) then
			print_dbg('diff_sec>=%s | blowout begins',diff_sec)
			if (level.get_time_hours() >= 5 and level.get_time_hours() <= 20) then
				level.set_weather_fx("fx_blowout_day")
			else
				level.set_weather_fx("fx_blowout_night")
			end
			if (rnd_sound % 2) ~= 0 then
				self:play_blowout_sound("begin01")
			else
				self:play_blowout_sound("begin02")
			end
			--xr_sound.set_sound_play(AC_ID, "blowout_begin")
			self.stages['beginning']=true
			--self.debugMessages[2]:SetText("blowout launched at: "..tostring(diff_sec).." rnd: "..tostring(rnd_sound))
		end
		
		-- siren warning -----------------------------------------------------------------------------------------------------------------------------------------
		local warn = ui_options.get("alife/event/emission_warning")
		if (diff_sec>=25) and (self.stages['siren'] ~= true) and (warn == "siren" or warn == "siren_radio" or warn == "radio_siren") then
			print_dbg('diff_sec>=%s | siren warning',diff_sec)
			self:play_siren_sound()
			self.stages['siren']=true
		end
		
		-- blowout warning -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=30) then
			print_dbg('diff_sec>=%s | blowout warning',diff_sec)
			if (self.task_given ~= true) then
				if (warn == "siren" or warn == "siren_radio" or warn == "radio_siren") then
					if (level.name() == "zaton") then
						xr_sound.set_sound_play(AC_ID, "zat_a2_stalker_barmen_surge_phase_1")
					elseif (level.name() == "jupiter") then
						xr_sound.set_sound_play(AC_ID, "jup_a6_stalker_medik_phase_1")
					elseif (level.name() == "l03_agroprom") then
						xr_sound.set_sound_play(AC_ID, "kovalsky_surge_phase_1")
					elseif (level.name() ~= nil) then
						snd_surge1:play(db.actor,0,sound_object.s2d)
					end
				end
				self:launch_rockets()

				if (load_var(db.actor,"surge_immuned",false) ~= true) then -- special surged immuned for tasks
					printf("opt_blowout_task",ui_options.get("alife/event/emission_task"))
					if ui_options.get("alife/event/emission_task") then
						self:give_surge_hide_task()
					end
				end
				self.task_given = true
				--self.debugMessages[2]:SetText("task given at: "..tostring(diff_sec))
			end
		end
		
		-- blowout impact -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=47) and (self.stages['impact'] ~= true) then
			print_dbg('diff_sec>=%s | blowout impact',diff_sec)
			if (rnd_sound % 2) ~= 0 then
				--xr_sound.set_sound_play(AC_ID, "blowout_hit_1")
				self:play_blowout_sound("impact01")
			else
				self:play_blowout_sound("impact02")
				--xr_sound.set_sound_play(AC_ID, "blowout_hit_2")
			end
			self.stages['impact']=true
			--self.debugMessages[2]:SetText("impact launched at: "..tostring(diff_sec).." rnd: "..tostring(rnd_sound))
		end
		
		-- start rumble -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=50) and (self.stages['rumble']==nil) and not(self.blowout_sound) then
			print_dbg('diff_sec>=%s | blowout rumble',diff_sec)
			xr_sound.play_sound_looped(AC_ID, "blowout_rumble")
			xr_sound.set_volume_sound_looped(AC_ID, "blowout_rumble", 0.25)
			self.stages['rumble']=true
			self.blowout_sound = true
			--self.debugMessages[2]:SetText("rumble launched at: "..tostring(diff_sec))
		end
		
		-- rumble sound fade in -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=50) and (diff_sec<=75) and (self.stages['rumble']~=nil) and (self.blowout_sound) then
			print_dbg('diff_sec>=%s | blowout rumble sound fade in',diff_sec)
			xr_sound.set_volume_sound_looped(AC_ID, "blowout_rumble", fade(diff_game_sec,50*5,75*5,0.25,1))
			--self.debugMessages[3]:SetText("rumble vol: "..tostring(fade(diff_game_sec,50*5,75*5,0.25,1)))
		end
		
		-- 1st earthquake -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=80) and (self.stages['quake20']==nil) then
			print_dbg('diff_sec>=%s | 1st earthquake',diff_sec)
			--self.debugMessages[2]:SetText("eathquake started at: "..tostring(diff_sec))
			level.add_cam_effector("camera_effects\\earthquake_20.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake20']=true
			--self.debugMessages[2]:SetText("quake20 at: "..tostring(diff_sec))
		end
		
		-- second message -----------------------------------------------------------------------------------------------------------------------------------------
		if(diff_sec>=90) and not(self.second_message_given) then
			print_dbg('diff_sec>=%s | second message',diff_sec)
			if (warn == "siren" or warn =="siren_radio" or warn =="radio_siren") then
				if (level.name() == "zaton") then
					xr_sound.set_sound_play(AC_ID, "zat_a2_stalker_barmen_surge_phase_2")
				elseif(level.name() == "jupiter") then
					xr_sound.set_sound_play(AC_ID, "jup_a6_stalker_medik_phase_2")
				elseif (level.name() == "l03_agroprom") then
					xr_sound.set_sound_play(AC_ID, "kovalsky_surge_phase_2")
				elseif (level.name() ~= nil) then
					snd_surge2:play(db.actor,0,sound_object.s2d)
				end
			end
			self.second_message_given = true
			--self.debugMessages[2]:SetText("second message given at: "..tostring(diff_sec))
		end
		
		-- earthquakes -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=100) and (self.stages['quake40']==nil) then
			print_dbg('diff_sec>=%s | earthquakes quake40',diff_sec)
			xr_sound.play_sound_looped(AC_ID, "surge_earthquake_sound_looped")
			level.remove_cam_effector(earthquake_cam_eff)
			level.add_cam_effector("camera_effects\\earthquake_40.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake40']=true
			--self.debugMessages[2]:SetText("quake40 at: "..tostring(diff_sec))
		end
		if (diff_sec>=102) and (self.stages['quake60']==nil) then
			print_dbg('diff_sec>=%s | earthquakes quake60',diff_sec)
			level.remove_cam_effector(earthquake_cam_eff)
			level.add_cam_effector("camera_effects\\earthquake_60.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake60']=true
			--self.debugMessages[2]:SetText("quake60 at: "..tostring(diff_sec))
		end
		if (diff_sec>=104) and (self.stages['quake80']==nil) then
			print_dbg('diff_sec>=%s | earthquakes quake80',diff_sec)
			level.remove_cam_effector(earthquake_cam_eff)
			level.add_cam_effector("camera_effects\\earthquake_80.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake80']=true
			--self.debugMessages[2]:SetText("quake80 at: "..tostring(diff_sec))
		end
		if (diff_sec>=106) and (self.stages['quake100']==nil) then
			print_dbg('diff_sec>=%s | earthquakes quake100',diff_sec)
			level.remove_cam_effector(earthquake_cam_eff)
			level.add_cam_effector("camera_effects\\earthquake.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake100']=true
			--self.debugMessages[2]:SetText("quake100 at: "..tostring(diff_sec))
		end
		
		if (load_var(db.actor,"surge_immuned",false) ~= true) then -- special surged immuned for tasks
			-- 1st wave sound -----------------------------------------------------------------------------------------------------------------------------------------
			if(diff_sec>=108) and (self.stages['1stwavesnd']==nil)  then
				print_dbg('diff_sec>=%s | 1st wave sound',diff_sec)
				--xr_sound.set_sound_play(AC_ID, "blowout_wave_1")
				if rnd_sound==1 then
					self:play_blowout_sound("wave01")
				elseif rnd_sound==2 then
					self:play_blowout_sound("wave02")
				elseif rnd_sound==3 then
					self:play_blowout_sound("wave03")
				elseif rnd_sound==4 then
					self:play_blowout_sound("wave04")
				end
				self.stages['1stwavesnd']=true
				--self.debugMessages[2]:SetText("1st wave snd at: "..tostring(diff_sec).." rnd: "..tostring(rnd_sound))
			end
			-- 1st wave -----------------------------------------------------------------------------------------------------------------------------------------
			if(diff_sec>=120) and (self.stages['1stwave']==nil)  then
				print_dbg('diff_sec>=%s | 1st wave',diff_sec)
				self:start_wave(1,diff_game_sec)
				self.stages['1stwave']=true
				--self.debugMessages[2]:SetText("1st wave at: "..tostring(diff_sec))
			end
			-- 2nd wave sound -----------------------------------------------------------------------------------------------------------------------------------------
			if(diff_sec>=156) and (self.stages['2ndwavesnd']==nil)  then
				print_dbg('diff_sec>=%s | 2nd wave sound',diff_sec)
				--xr_sound.set_sound_play(AC_ID, "blowout_wave_1")
				if rnd_sound==1 then
					self:play_blowout_sound("wave01")
				elseif rnd_sound==2 then
					self:play_blowout_sound("wave02")
				elseif rnd_sound==3 then
					self:play_blowout_sound("wave03")
				elseif rnd_sound==4 then
					self:play_blowout_sound("wave04")
				end
				self.stages['2ndwavesnd']=true
				--self.debugMessages[2]:SetText("2nd wave snd at: "..tostring(diff_sec))
			end
			-- 2nd wave -----------------------------------------------------------------------------------------------------------------------------------------
			--if(diff_sec>=2) and (self.stages['2ndwave']==nil)  then
			if(diff_sec>=168) and (self.stages['2ndwave']==nil)  then
				print_dbg('diff_sec>=%s | 2nd wave',diff_sec)
				self:start_wave(2,diff_game_sec)
				self.stages['2ndwave']=true
				--self.debugMessages[2]:SetText("2nd wave at: "..tostring(diff_sec))
			end
		end
		
		-- earthquakes fade-----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=200) and (self.stages['quake100']==true) then
			print_dbg('diff_sec>=%s | earthquakes fade quake100',diff_sec)
			level.remove_cam_effector(earthquake_cam_eff)
			level.add_cam_effector("camera_effects\\earthquake_80.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake100']=false
			--self.debugMessages[2]:SetText("quake80 at: "..tostring(diff_sec))
		end
		if (diff_sec>=202) and (self.stages['quake80']==true) then
			print_dbg('diff_sec>=%s | earthquakes fade quake80',diff_sec)
			level.remove_cam_effector(earthquake_cam_eff)
			level.add_cam_effector("camera_effects\\earthquake_60.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake80']=false
			--self.debugMessages[2]:SetText("quake60 at: "..tostring(diff_sec))
		end
		if (diff_sec>=206) and (self.stages['quake60']==true) then
			print_dbg('diff_sec>=%s | earthquakes fade quake60',diff_sec)
			level.remove_cam_effector(earthquake_cam_eff)
			level.add_cam_effector("camera_effects\\earthquake_40.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake60']=false
			--self.debugMessages[2]:SetText("quake40 at: "..tostring(diff_sec))
		end
		if (diff_sec>=209) and (self.stages['quake40']==true) then
			print_dbg('diff_sec>=%s | earthquakes fade quake40',diff_sec)
			level.remove_cam_effector(earthquake_cam_eff)
			level.add_cam_effector("camera_effects\\earthquake_20.anm", earthquake_cam_eff, true, "", 0, false)
			self.stages['quake40']=false
			--self.debugMessages[2]:SetText("quake20 at: "..tostring(diff_sec))
		end
		if (diff_sec>=214) and (self.stages['quake20']==true) and (self.stages['quakeended']==nil) then
			print_dbg('diff_sec>=%s | earthquakes fade quake20',diff_sec)
			level.remove_cam_effector(earthquake_cam_eff)
			self.stages['quakeended']=true
			--self.debugMessages[2]:SetText("eathquake ended at: "..tostring(diff_sec))
		end
		
		-- rumble and quake sound fade out -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=200) and (diff_sec<=214) and (self.stages['rumble']~=nil) and (self.blowout_sound) then
			print_dbg('diff_sec>=%s | rumble and quake sound fade out',diff_sec)
			xr_sound.set_volume_sound_looped(AC_ID, "blowout_rumble", fade(diff_game_sec,200*5,214*5,1,0))
			xr_sound.set_volume_sound_looped(AC_ID, "surge_earthquake_sound_looped", fade(diff_game_sec,200*5,214*5,1,0))
			--self.debugMessages[3]:SetText("rumble vol: "..tostring(fade(diff_game_sec,200*5,214*5,1,0)))
		end
		
		-- rumble and quake sound stop -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=214) and (self.stages['rumble']==true) and (self.blowout_sound) then
			print_dbg('diff_sec>=%s | rumble and quake sound stop',diff_sec)
			xr_sound.stop_sound_looped(AC_ID, "blowout_rumble")
			xr_sound.stop_sound_looped(AC_ID, "surge_earthquake_sound_looped")
			--self.debugMessages[2]:SetText("sounds stopped at: "..tostring(diff_sec))
			self.stages['rumble']=false
		end
		
		-- end message -----------------------------------------------------------------------------------------------------------------------------------------
		if (diff_sec>=212) and (self.stages['endmessage']==nil) then
			print_dbg('diff_sec>=%s | end message',diff_sec)
			if (level) and (warn == "siren" or warn =="siren_radio" or warn =="radio_siren") then
				if(level.name()=="zaton") then
					xr_sound.set_sound_play(AC_ID, "zat_a2_stalker_barmen_after_surge")
				elseif(level.name()=="jupiter") then
					xr_sound.set_sound_play(AC_ID, "jup_a6_stalker_medik_after_surge")
				elseif (level.name() == "l03_agroprom") then
					xr_sound.set_sound_play(AC_ID, "kovalsky_after_surge")
				elseif (level.name() ~= nil) then
					snd_surge3:play(db.actor,0,sound_object.s2d)
				end
			end
			--self.debugMessages[2]:SetText("end message at: "..tostring(diff_sec))
			self.stages['endmessage']=true
		end
		
		-- after sound -----------------------------------------------------------------------------------------------------------------------------------------
		if(diff_sec>=220) and (self.stages['endsnd']==nil)  then
			print_dbg('diff_sec>=%s | after sound',diff_sec)
			xr_sound.set_sound_play(AC_ID, "blowout_hit_3")
			self.stages['endsnd']=true
			--self.debugMessages[2]:SetText("ending snd at: "..tostring(diff_sec))
		end
	end
	
--------------------------------- update every 2 game sec -----------------------------------
	if (prev_game_sec ~= diff_game_sec) then
		prev_game_sec = diff_game_sec
		if (diff_sec < self.surge_time) then
			print_dbg('diff_sec>=%s | effectors',diff_sec)
			local actor_pos = db.actor:position()
			-- hitFactor changes -----------------------------------------------------------------------------------------------------------------------------------------
			--self.debugMessages[3]:SetText("hitFactor: "..tostring(self.hitFactor))
			--self.debugMessages[4]:SetText("psy_health="..tostring(db.actor.psy_health))
			--if (diff_sec>=8) and (diff_sec<210) and not(self.effector_set) then
			if (diff_sec>=108) and (diff_sec<210) and not(self.effector_set) then
				level.add_pp_effector("psychic.ppe", surge_shock_pp_eff, true)
				level.set_pp_effector_factor(surge_shock_pp_eff, 0.001)
				self.effector_set=true
			end
			--if (diff_sec>=8) and (diff_sec<=14) and (self.effector_set) then
			if (diff_sec>=108) and (diff_sec<=114) and (self.effector_set) then
				self.hitFactor=fade(diff_game_sec,8*5,14*5,0.001,1)
			end
			--if (diff_sec>=14) and (diff_sec<=20) and (self.effector_set) then
			if (diff_sec>=114) and (diff_sec<=120) and (self.effector_set) then
				self.hitFactor=fade(diff_game_sec,14*5,20*5,1,0.3)
			end
			if (diff_sec>=156) and (diff_sec<=162) and (self.effector_set) then
				self.hitFactor=fade(diff_game_sec,156*5,162*5,0.3,1)
			end
			if (diff_sec>=162) and (diff_sec<=168) and (self.effector_set) then
				self.hitFactor=fade(diff_game_sec,162*5,168*5,1,0.3)
			end
			if (diff_sec>=200) and (diff_sec<=210) and (self.effector_set) then
				self.hitFactor=fade(diff_game_sec,200*5,210*5,0.3,0.001)
			end
			if (diff_sec>=210) and (self.effector_set) then
				self.hitFactor=0
				level.remove_pp_effector(surge_shock_pp_eff)
				self.effector_set=false
			end

			-- setting effector
			local PPEfactor
			local hitPower
			if not (GetEvent("current_safe_cover")) then
				PPEfactor = self.hitFactor
				hitPower = self.hitFactor/50
				if PPEfactor < 0.001 then PPEfactor = 0.001 end
				--self.debugMessages[6]:SetText("outside")
			else
				PPEfactor = 0.002
				hitPower = 0
				--self.debugMessages[6]:SetText("in cover")
			end
			currentPPEfactor = currentPPEfactor+(PPEfactor - currentPPEfactor) * 0.1
			if (load_var(db.actor,"surge_immuned",false) ~= true) then
				if (self.effector_set) then
					level.set_pp_effector_factor(surge_shock_pp_eff, currentPPEfactor)
					self:displayIndicators(currentPPEfactor)
					if (db.actor:alive() and character_community(db.actor) ~= "actor_monolith") then
						local h = hit()
						h.type = hit.telepatic
						h.power = self:hit_power(hitPower, h.type)
						h.impulse = 0.0
						h.direction = VEC_Z
						h.draftsman = db.actor
						if (self.survive and xr_logic.pick_section_from_condlist(db.actor, nil, self.survive) == "true") then
							if(db.actor.health<=h.power) then
								if (db.actor.health-0.05 > 0.05) then
									h.power = 0.05
								else
									h.power = 0
								end
							end
						end
						print_dbg('diff_sec>=%s | hit actor',diff_sec)
						db.actor:hit(h)
					end
				end
			end
			--self.debugMessages[5]:SetText("PPE: "..tostring(currentPPEfactor))
			--self.debugMessages[7]:SetText("hitPower: "..tostring(hitPower))

			-- Waves
			local wavevol=0
			local fate = ui_options.get("alife/event/emission_fate") or "kill_at_wave"
			for k,wave in pairs(self.blowout_waves) do
				if wave.effect:playing() then
					local wave_pos= vector():set(actor_pos.x, actor_pos.y/2, wave.inited_pos.z-(diff_game_sec-wave.inited_time)*3)
					wave.effect:move_to(wave_pos,VEC_ZERO)
					local wavevoltemp = (250 - math.abs(actor_pos.z-wave_pos.z))/250
					if (wavevoltemp > wavevol) then
						wavevol = wavevoltemp
					end

					if wave_pos.z < actor_pos.z - 250 then
						wave.effect:stop_deffered()
						if (k==2) then
							--kill all remaining npcs

							if fate == "turn_to_zombie" or fate == "explode" then
								print_dbg('diff_sec>=%s | turn_to_zombie',diff_sec)
								self:kill_objects_at_pos(-10000,fate)
							end
						end
					end
					
					self:kill_crows_at_pos(wave_pos.z)
					
					if fate == "kill_at_wave" then
						if (prev_sec == prev_game_sec/5) then
							print_dbg('diff_sec>=%s | kill_objects_at_pos',diff_sec)
							self:kill_objects_at_pos(wave_pos.z,fate)
						end
					end
					
					if (fate == "turn_to_zombie" or fate == "explode") and k==2 then
						print_dbg('diff_sec>=%s | turn_to_zombie',diff_sec)
						self:kill_objects_at_pos(wave_pos.z, fate)
					end
					
					if (wave_pos.z < actor_pos.z) then
						if k==1
						and not GetEvent("current_safe_cover")
						and (character_community(db.actor) ~= "actor_monolith")
						and (character_community(db.actor) ~= "actor_zombied")
						then
				            local h = hit()
				            h.type = hit.telepatic
				            h.power = self:hit_power(2, h.type)+0.5
				            h.impulse = 0.0
				            h.direction = VEC_Z
				            h.draftsman = db.actor
							if (xr_logic.pick_section_from_condlist(db.actor, nil, self.survive)=="true") then
								if(db.actor.health<=h.power) then
									if (db.actor.health-0.05 > 0.05) then
										h.power = 0.05
									else
										h.power = 0
									end
								end
							end
				            if (load_var(db.actor,"surge_immuned",false) ~= true) then
								print_dbg('diff_sec>=%s | hit actor 2',diff_sec)
			                	db.actor:hit(h)
			                end
							self.stages['1stwavehit']=true;
							--self.debugMessages[2]:SetText("first wave hit at: "..tostring(diff_sec)..' with strength: '..h.power)
						end
						
						if (k==2 and self.stages['2ndwavehit']==nil) then
							if fate=="kill_at_end" then
								print_dbg('diff_sec>=%s | kill_at_end',diff_sec)
								self:kill_all_unhided()
							else
								if (load_var(db.actor,"surge_immuned",false) ~= true) then
									if not (level_environment.is_actor_immune()) then 
										print_dbg('diff_sec>=%s | kill_actor_at_pos',diff_sec)
										self:kill_actor_at_pos(wave_pos.z)
									end
								end
							end
							self.stages['2ndwavehit']=true
							--self.debugMessages[2]:SetText("second wave hit at: "..tostring(diff_sec))
						end
					end
				end
			end
			if (self.wave_sound) then
				--self.debugMessages[1]:SetText("wave vol: "..tostring(wavevol))
				xr_sound.set_volume_sound_looped(AC_ID, "blowout_particle_wave_looped", wavevol)
			end
		end
	end
end


----------------------------------
--	Effects
----------------------------------
function CSurgeManager:displayIndicators(power)
	local hud = get_hud()
	if not (hud) then 
		return 
	end
	local indik
	if power>=0.8 then indik=nil
	elseif power>=0.6 then indik=nil
	elseif power>=0.4 then indik=nil
	elseif power>=0.1 then indik=nil
	else indik=nil end
	local aspectRatio=""
	if self.aspectRatio~=1 then
		aspectRatio="_16"
	end
	local indikName="atm_indik_psi_"..tostring(indik)..aspectRatio
	local currentIndikName="atm_indik_psi_"..tostring(currentIndik)..aspectRatio

	--remove indik if 0
	if not indik and currentIndik~=nil then
		local hudIndikRem = hud:GetCustomStatic(currentIndikName)
		if hudIndikRem then
			hud:RemoveCustomStatic(currentIndikName)
		end
		currentIndik=nil
		return
	end
	-- display different indik
	if currentIndik~=indik then
		-- first remove existing one
		if currentIndik~=nil then
			local hudIndik = hud:GetCustomStatic(currentIndikName)
			if hudIndik then
				hud:RemoveCustomStatic(currentIndikName)
			end
		end
		-- now display new one
		if indik then
			hud:AddCustomStatic(indikName,true)
			currentIndik=indik
		end
	end
	--self.debugMessages[8]:SetText("indik="..currentIndikName)
end

function CSurgeManager:play_blowout_sound(id)
	local snd_obj=self.blowout_sounds[id]
	if snd_obj ~= nil and snd_obj:playing() then
		snd_obj:stop()
	end
	if snd_obj ~= nil then
		snd_obj:play(db.actor)
		snd_obj.volume = 1
		--self.debugMessages[12]:SetText("playing: "..tostring(id))
	end
end

function CSurgeManager:play_siren_sound()
	local snd_obj=self.blowout_sounds["siren"]
	if (snd_obj == nil) then 
		return  
	end 
	
	local snd_position
	if snd_obj:playing() then
		snd_obj:stop()
	end
	if(level.name()=="zaton") then
		snd_position= vector():set(115,8,184)
	elseif(level.name()=="jupiter") then
		snd_position= vector():set(-50,16,198)
	else
		snd_position= vector():set(147,15,-187)
	end

	snd_obj:play_at_pos(db.actor, snd_position)
	snd_obj.volume = 1
end

function CSurgeManager:launch_rockets()
	for k,v in pairs(db.signal_light) do
		if not(v:is_flying()) then
			v:launch()
		end
	end
end

function surge_callback()
	level.add_cam_effector("camera_effects\\surge_01.anm", sleep_cam_eff, false, "surge_manager.surge_callback2")
--	level.stop_weather_fx()
--	level.change_game_time(0,0,15)
--	level_weathers.get_weather_manager():forced_weather_change()
end

function surge_callback2()
	xr_effects.enable_ui(db.actor, nil)
--[[
	level.enable_input()
	level.show_indicators()
	db.actor:restore_weapon()
]]--
end


----------------------------------
--	NPC fate
----------------------------------
function make_dead_crow(id,powr)
	local crow = id and level.object_by_id(id)
	if(crow and crow:alive() and powr) then
		crow:hit(powr)
	end
	return true
end

function make_dead(id)
	local obj = id and db.storage[id] and db.storage[id].object --level.object_by_id(id)
	if (obj and obj:alive()) then
		obj:kill(obj)
	else
		local se_obj = id and alife_object(id)
		if (se_obj and se_obj:alive()) then
			se_obj:kill()
		end
	end

	return true
end

function CSurgeManager:kill_crows_at_pos(pos,delay) -- hit all crows if their pos is bigger than "pos"
	local h = hit()
	h.type = hit.fire_wound
	h.power = 0.9
	h.impulse = 0.0
	h.direction = VEC_Z
	h.draftsman = db.actor
	for k,id in pairs(bind_crow.crow_storage) do
		if delay then
			CreateTimeEvent("delay_kill_crow",id,math_random(1,3),make_dead_crow,id,h)
		else
			local crow = level.object_by_id(id)
			if (crow and crow:alive() and pos < crow:position().z) then
				crow:hit(h)
			end
		end
	end
end

function CSurgeManager:kill_objects_at_pos(surge_pos, fate, delay)
	if (load_var(db.actor,"surge_immuned",false) == true) then 
		return 
	end
	
	local can_kill = (fate == "kill_at_wave") or (fate == "turn_to_zombie") or (fate == "explode") or (fate == "kill_at_end")
	if (not can_kill) then
		print_dbg('kill_objects_at_pos | cant kill because fate is [%s]',fate)
		return
	end
	print_dbg("kill_objects_at_pos | pos: %s - fate: %s - delay: %s", surge_pos, fate, delay)
	
	local id, comm, npc_pos, se_npc, npc, squad, squad_id, smart, surge_smart
	local board = SIMBOARD
	local sim = alife()
	for i=1, #db.OnlineStalkers do
		id = db.OnlineStalkers[i]
		npc = db.storage[id] and db.storage[id].object or level.object_by_id(id)
		if npc then
			comm = npc:character_community()
			npc_pos = npc:position()
			
			if npc_pos
			and IsStalker(npc)                         							-- must be stalker
			and npc:alive()                            							-- must be alive
			and (comm ~= "monolith")                   							-- not monolith (immune)
			and (comm ~= "zombied")                    							-- not zombied (immune)
			and (not get_object_story_id(id))          							-- not story npc
			and ((surge_pos == false) or (surge_pos and npc_pos.z > surge_pos)) -- npc is behind emission wave
			then
				se_npc = sim:object(id)
				squad_id = se_npc.group_id
				squad = squad_id and sim:object(squad_id)
				
				if se_npc and squad then
					smart = board and squad.smart_id and board.smarts[squad.smart_id] and board.smarts[squad.smart_id].smrt
					surge_smart = smart and smart.props and (tonumber(smart.props["surge"]) > 0)
					if not (surge_smart or self:pos_in_cover(npc_pos)) then -- if stalker is not in a safe smart or not inside
						print_dbg('kill_objects_at_pos | kill npc [%s]',se_npc:name())
						if (fate == "turn_to_zombie") then
							self:turn_to_zombie(se_npc,squad)
						elseif (fate == "explode") then
							self:explode(se_npc,squad)
						elseif (fate == "kill_at_wave") or (fate == "kill_at_end") then
							if delay then
								CreateTimeEvent("delay_kill",id,math_random(1,3),make_dead,id)
							else
								npc:kill(npc)
							end
						end
					else
						print_dbg('kill_objects_at_pos | cant kill npc [%s] | surge_smart: %s - in_cover: %s',se_npc:name(), surge_smart, self:pos_in_cover(npc_pos,true))
					end
				end
			else
				print_dbg('kill_objects_at_pos | cant kill npc [%s] | behind emission wave: %s',npc:name(), ((surge_pos == false) or (surge_pos and npc_pos and npc_pos.z > surge_pos)))
			end
		end
	end
end

function CSurgeManager:kill_actor_at_pos(pos) -- kill player at end
	if (load_var(db.actor,"surge_immuned",false) == true) then 
		return 
	end
	if(db.actor and db.actor:alive() and db.actor:position().z>pos) then
		if not (GetEvent("current_safe_cover")) then
			xr_effects.disable_ui_only(db.actor, nil)
			if (xr_logic.pick_section_from_condlist(get_story_object("actor"), nil, self.survive)~="true") then
				local fate = ui_options.get("alife/event/emission_fate") or "kill_at_wave"
				self:kill_objects_at_pos(false, fate, true)
				db.actor:kill(db.actor)
				self.ui_disabled = true
				return
			else
				level.add_cam_effector("camera_effects\\surge_02.anm", sleep_cam_eff, false, "surge_manager.surge_callback")
				level.add_pp_effector("surge_fade.ppe", sleep_fade_pp_eff, false)
				--db.actor:change_health(-0.05)
				self:end_surge(true)
			end
		end
	end
end

function CSurgeManager:kill_all_unhided() -- called only when "kill_at_end" is active, turn to zombie + explode + kill with delay, kill actor
	if (load_var(db.actor,"surge_immuned",false) == true) then 
		return 
	end
	
	-- delay hit for crows
	self:kill_crows_at_pos(false,true)
	
	-- delay kill for online npcs
	local fate = ui_options.get("alife/event/emission_fate") or "kill_at_wave"
	self:kill_objects_at_pos(false, fate, true)

	
	if (level_environment.is_actor_immune()) then 
		return 
	end
	
	-- don't kill actor if he isn't on a valid level
	local sim,gg = alife(),game_graph()
	local actor_level = sim:level_name(gg:vertex(sim:actor().m_game_vertex_id):level_id())
	if (self.indoor_levels and self.indoor_levels[actor_level] or level_weathers.valid_levels[actor_level] ~= true) then 
		return 
	end
	
	if (db.actor and db.actor:alive() and not GetEvent("current_safe_cover")) then
		--[[
		if has_alife_info("anabiotic_in_process") then
			local counter_name = "actor_marked_by_zone_cnt"
			local cnt_value = load_var(db.actor, counter_name, 0)
			save_var(db.actor, counter_name, cnt_value + 1)
		end
		]]
			
		xr_effects.disable_ui_only(db.actor, nil)

		
		if (xr_logic.pick_section_from_condlist(get_story_object("actor"), nil, self.survive) ~= "true") then
			local fate = ui_options.get("alife/event/emission_fate") or "kill_at_wave"
			self:kill_objects_at_pos(false, fate, true)
			db.actor:kill(db.actor)
			
			return
		else
			level.add_cam_effector("camera_effects\\surge_02.anm", sleep_cam_eff, false, "surge_manager.surge_callback")
			level.add_pp_effector("surge_fade.ppe", sleep_fade_pp_eff, false)
			--db.actor.health = db.actor.health-0.05
		end
	end
end

function CSurgeManager:turn_to_zombie(se_obj,squad)
	if not (squad) then
		se_obj:kill()
		return 
	end
	
	self.zombie_count = self.zombie_count and self.zombie_count + 1 or 0
	if (self.zombie_count > 12) then
		se_obj:kill()
		return
	end
	
	local zombie_type
	local section_number = string.sub(se_obj:section_name(), -1)
	if section_number=="4" then
		zombie_type="sim_default_zombied_4"
	elseif section_number=="3" then
		zombie_type="sim_default_zombied_3"
	elseif section_number=="2" or section_number=="1" then
		zombie_type="sim_default_zombied_2"
	else
		zombie_type="sim_default_zombied_1"
	end
	
	squad:remove_npc(se_obj.id, true)
	alife_create(zombie_type,se_obj.position,se_obj.m_level_vertex_id,se_obj.m_game_vertex_id)
end

function CSurgeManager:explode(se_obj,squad)
	if not (squad) then 
		se_obj:kill()
		return 
	end

	-- play body tear and scary sound
	self.body_tears[se_obj.id]=particles_object("anomaly2\\body_tear_0"..math.random(1,2))
	self.body_tears[se_obj.id]:play_at_pos(se_obj.position)

	local snd_obj = self.blowout_sounds["body_tear"]
	if (snd_obj) then
		if (snd_obj:playing()) then
			snd_obj:stop()
		end

		snd_obj:play_at_pos(db.actor, se_obj.position)
		snd_obj.volume = 1
	end
	
	squad:remove_npc(se_obj.id, true)
end


----------------------------------
--	Task
----------------------------------
function CSurgeManager:give_surge_hide_task()
	if (self.surge_message ~= "empty") then
		local mess = ""
		if (self.surge_message == "") then
			local time = 0
			mess = game.translate_string("hide_from_surge_message")
		else
			mess = game.translate_string(self.surge_message)
		end
	end
	if (self.surge_task_sect ~= "empty") then
		if (self.surge_task_sect == "") then
			task_manager.get_task_manager():give_task("hide_from_surge")
		else
			task_manager.get_task_manager():give_task(self.surge_task_sect)
		end
	end
end

function get_task_descr()
	if GetEvent("current_safe_cover")  then
		return game.translate_string("hide_from_surge_descr_2_a")
	end
	
	return game.translate_string("hide_from_surge_descr_1_a")
end

function get_task_target()
	if GetEvent("current_safe_cover") then
		return nil
	end
	
	return GetEvent("nearest_safe_cover")
end

function set_surge_task(tsk)
	get_surge_manager().surge_task_sect = tsk
end


----------------------------------
--	Data management
----------------------------------
function actor_on_save(binder,packet)
	if (USE_MARSHAL) then 
		return 
	end 
	-- initialize to set default values if not loaded
	local mgr = SurgeManager
	if not (mgr._state_loaded) then 
		mgr:initialize()
		mgr._state_loaded = true
	end
	set_save_marker(packet, "save", false, "SurgeHide")

	utils_data.w_stpk(packet,"bool",mgr.finished,"CSurgeManager:finished")
	utils_data.w_stpk(packet,"bool",mgr.started,"CSurgeManager:started")
	utils_data.w_stpk(packet,"CTime",mgr.last_surge_time,"CSurgeManager:last_surge_time")

	if(mgr.started) then
		utils_data.w_stpk(packet,"CTime",mgr.inited_time,"CSurgeManager:inited_time")
		utils_data.w_stpk(packet,"bool",mgr.task_given,"CSurgeManager:task_given")
		utils_data.w_stpk(packet,"bool",mgr.effector_set,"CSurgeManager:effector_set")
		utils_data.w_stpk(packet,"bool",mgr.second_message_given,"CSurgeManager:second_message_given")
		utils_data.w_stpk(packet,"bool",mgr.ui_disabled,"CSurgeManager:ui_disabled")
		utils_data.w_stpk(packet,"bool",mgr.blowout_sound,"CSurgeManager:blowout_sound")

		--utils_data.w_stpk(packet,"stringZ",mgr.surge_message,"CSurgeManager:surge_message")
		--utils_data.w_stpk(packet,"stringZ",mgr.surge_task_sect,"CSurgeManager:surge_task_sect")

		utils_data.w_stpk(packet,"u32",mgr.game_time_factor,"CSurgeManager:game_time_factor")
	end
	utils_data.w_stpk(packet,"u32",mgr._delta,"CSurgeManager:_delta")

	set_save_marker(packet, "save", true, "SurgeHide")
end 

function actor_on_load(binder,packet)
	--printf("actor on load")
	local mgr = get_surge_manager()
	if not (mgr._state_loaded) then 
		mgr:initialize()
		mgr._state_loaded = true
	end
	if (USE_MARSHAL) then 
		return 
	end 
	set_save_marker(packet, "load", false, "SurgeHide")
	mgr.finished = packet:r_bool()
	mgr.started = packet:r_bool()

	mgr.last_surge_time = utils_data.r_CTime(packet,"surge_manager") or game.get_game_time()
	if(mgr.started) then
		mgr.inited_time = utils_data.r_CTime(packet,"surge_manager") or game.get_game_time()
		mgr.task_given = packet:r_bool()
		mgr.effector_set = packet:r_bool()
		mgr.second_message_given = packet:r_bool()
		mgr.ui_disabled = packet:r_bool()
		mgr.blowout_sound = packet:r_bool()

		--mgr.surge_message = packet:r_stringZ()
		--mgr.surge_task_sect = packet:r_stringZ()
		mgr.game_time_factor = packet:r_u32()
		mgr:finalize()
		mgr.blowout_waves = empty_table(mgr.blowout_waves)
		mgr.objects_to_kill = empty_table(mgr.objects_to_kill)
		mgr.stages = empty_table(mgr.stages)
		mgr.body_tears = empty_table(mgr.body_tears)
	end
	mgr._delta = packet:r_u32()
	set_save_marker(packet, "load", true, "SurgeHide")
end

function save_state(m_data)
	--utils_data.debug_write("SurgeManager:save_state BEFORE")
	m_data.SurgeManager = {}

	local mgr = get_surge_manager()
	if not (mgr._state_loaded) then 
		mgr:initialize()
		mgr._state_loaded = true
	end
	
	m_data.SurgeManager.finished = mgr.finished == nil and true or mgr.finished
	m_data.SurgeManager.started = mgr.started == nil and false or mgr.started
	m_data.SurgeManager.last_surge_time = mgr.last_surge_time and utils_data.CTime_to_table(mgr.last_surge_time) or game.get_game_time()

	if(mgr.started) then
		m_data.SurgeManager.inited_time = utils_data.CTime_to_table(mgr.inited_time) or game.get_game_time()
		--m_data.SurgeManager.levels_respawn = mgr.levels_respawn
		m_data.SurgeManager.task_given = mgr.task_given
		m_data.SurgeManager.effector_set = mgr.effector_set
		m_data.SurgeManager.second_message_given = mgr.second_message_given
		m_data.SurgeManager.ui_disabled = mgr.ui_disabled
		m_data.SurgeManager.blowout_sound = mgr.blowout_sound
		m_data.SurgeManager.game_time_factor = mgr.game_time_factor
	end
	m_data.SurgeManager._delta = mgr._delta
	--utils_data.debug_write("SurgeManager:save_state AFTER")
end 

function load_state(m_data)
	if not (m_data.SurgeManager) then 
		return
	end
	--utils_data.debug_write("SurgeManager:load_state BEFORE")
	local mgr = get_surge_manager()
	mgr:initialize()
	mgr.finished = m_data.SurgeManager.finished
	mgr.started = m_data.SurgeManager.started
	mgr.last_surge_time = m_data.SurgeManager.last_surge_time and utils_data.CTime_from_table(m_data.SurgeManager.last_surge_time) or game.get_game_time()
	if (mgr.started == true and mgr.finished == false) then
		mgr.inited_time = m_data.SurgeManager.inited_time and utils_data.CTime_from_table(m_data.SurgeManager.inited_time) or game.get_game_time()
		mgr.task_given = m_data.SurgeManager.task_given or false
		mgr.effector_set = m_data.SurgeManager.effector_set or false
		mgr.second_message_given = m_data.SurgeManager.second_message_given or false
		mgr.ui_disabled = m_data.SurgeManager.ui_disabled or false
		mgr.blowout_sound = m_data.SurgeManager.blowout_sound or false
		mgr.game_time_factor = m_data.SurgeManager.game_time_factor or level.get_time_factor()
		mgr:finalize()
		mgr.blowout_waves = empty_table(mgr.blowout_waves)
		mgr.objects_to_kill = empty_table(mgr.objects_to_kill)
		mgr.stages = empty_table(mgr.stages)
		mgr.body_tears = empty_table(mgr.body_tears)
	else 
		mgr.started = false
		mgr.finished = true
	end
	mgr._delta = m_data.SurgeManager._delta
	mgr._state_loaded = true
	
	m_data.SurgeManager = nil
	--utils_data.debug_write("SurgeManager:load_state BEFORE")
end


----------------------------------
--	Utilities
----------------------------------
function start_surge(p)
	get_surge_manager():start(true)
end

function stop_surge()
	if(get_surge_manager().started) then
		get_surge_manager():end_surge(true)
	end
end

function is_started()
	return get_surge_manager().started
end

function is_finished()
	return not get_surge_manager().started
end

function is_loaded()
	return get_surge_manager()._state_loaded == true
end


function actor_in_cover()
	return GetEvent("current_safe_cover") and true or false
end

function npc_in_cover(npc)
	return get_surge_manager():pos_in_cover(npc:position())
end

function job_in_surge_cover(se_obj,job)
	if not (job.alife_task) then 
		return false 
	end 
	return get_surge_manager():pos_in_cover(job.alife_task:position())
end


function set_surge_message(mess)
	get_surge_manager().surge_message = mess
end

function is_killing_all()
	local mgr = get_surge_manager()
	if(mgr.started and mgr.ui_disabled) then
		return true
	end
	return false
end

function sound_started()
	return get_surge_manager().started and get_surge_manager().blowout_sound
end