Divergent/mods/NPCs Die in Emissions/gamedata/scripts/surge_manager.script

-- 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
--]]

-- Edited by demonized, 2022
-- Cleanup and reformat
-- NPC Die in Emissions
-- Faster emissions

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 presurge_played = { false, false, false, false, false }

--[[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 = 0

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.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: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 = ""

	-- Stages of emission in real seconds, start is 0
	-- Siren
	self.siren_sec = 25

	-- Blowout warning
	self.blowout_warning_sec = 30
	
	-- Blowout impact sound
	self.blowout_impact_sec = 47

	-- Start rumble
	self.rumble_sec = 50

	-- First earthquake
	self.first_earthquake_sec = 80

	-- Second warning
	self.second_message_sec = 90

	-- Earthquakes
	self.earthquakes1_sec = 100
	self.earthquakes2_sec = self.earthquakes1_sec + 2
	self.earthquakes3_sec = self.earthquakes1_sec + 4
	self.earthquakes4_sec = self.earthquakes1_sec + 6

	-- First wave sound
	self.first_wave_sound_sec = 108

	-- First wave
	self.first_wave_sec = 120

	-- Second wave sound
	self.second_wave_sound_sec = self.first_wave_sound_sec + 48

	-- Second wave
	self.second_wave_sec = self.first_wave_sec + 48

	-- Earthquakes fade
	self.earthquakes1_fade_sec = self.second_wave_sec + 32
	self.earthquakes2_fade_sec = self.earthquakes1_fade_sec + 2
	self.earthquakes3_fade_sec = self.earthquakes1_fade_sec + 6
	self.earthquakes4_fade_sec = self.earthquakes1_fade_sec + 9
	self.earthquakes5_fade_sec = self.earthquakes1_fade_sec + 14

	-- End message
	self.end_message_sec = self.earthquakes5_fade_sec + 5

	-- After sound sec
	self.after_sound_sec = self.earthquakes5_fade_sec + 3

	-- Total surge time based on upper times
	self.surge_time = self.end_message_sec - 3

	-- Options
	-- Turn to zombies right after first wave (false - vanilla behaviour - only after second)
	self.zombie_at_first_wave = true 
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

	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")
		or has_alife_info("lttz_dp_active")
	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

	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.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)

	presurge_played = { false, false, false, false, false }
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 = { false, false, false, false, false }

	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():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
		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()
	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 has_alife_info("lttz_dp_active")
			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()
			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)

	--DEBUG
	local g_time = game.get_game_time()
	-- printf("until blowout: %s", self._delta - g_time:diffSec(self.last_surge_time))

	--Plays sound before a blowout
	if self._delta - g_time:diffSec(self.last_surge_time) < presurge_time and not presurge_played[1] then
		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 self._delta - g_time:diffSec(self.last_surge_time) < presurge_time - 60 and not presurge_played[2] then
		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 self._delta - g_time:diffSec(self.last_surge_time) < presurge_time - 120 and not presurge_played[3] then
		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 self._delta - g_time:diffSec(self.last_surge_time) < presurge_time - 180 and not presurge_played[4] then
		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 self._delta - g_time:diffSec(self.last_surge_time) < presurge_time - 240 and not presurge_played[5] then
		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

	if not self.started then
		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

		-- 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
	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
			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
			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 >= self.siren_sec) and (self.stages["siren"] ~= true) and (warn == "siren" 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 >= self.blowout_warning_sec then
			print_dbg("diff_sec>=%s | blowout warning", diff_sec)
			if self.task_given ~= true then
				--[[if (warn=="radio" or warn =="radio_siren") then
					local level_name = level.name()
					if (level_name == "zaton") then
						if not (utils_obj.npc_in_zone(db.actor,"zat_a2_sr_noweap")) then
							xr_sound.set_sound_play(AC_ID, "zat_a2_stalker_barmen_surge_phase_1")
						end
					elseif (level_name == "jupiter") then
						if not (utils_obj.npc_in_zone(db.actor,"jup_a6_sr_noweap")) then
							xr_sound.set_sound_play(AC_ID, "jup_a6_stalker_medik_phase_1")
						end
					elseif (level_name == "l03_agroprom") then
						xr_sound.set_sound_play(AC_ID, "kovalsky_surge_phase_1")
					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 >= self.blowout_impact_sec) and (self.stages["impact"] ~= true) then
			print_dbg("diff_sec>=%s | blowout impact", diff_sec)
			if (rnd_sound % 2) ~= 0 then
				self:play_blowout_sound("impact01")
			else
				self:play_blowout_sound("impact02")
			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 >= self.rumble_sec) 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 >= self.rumble_sec) and (diff_sec <= self.rumble_sec + 25) 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, self.rumble_sec * 5, (self.rumble_sec + 25) * 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 >= self.first_earthquake_sec) 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 >= self.second_message_sec) and not self.second_message_given then
			print_dbg("diff_sec>=%s | second message", diff_sec)
			--[[if (warn=="radio" or warn=="radio_siren") then
				local level_name = level.name()
				if(level_name == "zaton" and not utils_obj.npc_in_zone(db.actor,"zat_a2_sr_noweap")) then
					xr_sound.set_sound_play(AC_ID, "zat_a2_stalker_barmen_surge_phase_2")
				elseif(level_name == "jupiter" and not utils_obj.npc_in_zone(db.actor,"jup_a6_sr_noweap")) 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")
				end
			end]]
			self.second_message_given = true
			--self.debugMessages[2]:SetText("second message given at: "..tostring(diff_sec))
		end

		-- earthquakes
		if (diff_sec >= self.earthquakes1_sec) 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 >= self.earthquakes2_sec) 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 >= self.earthquakes3_sec) 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 >= self.earthquakes4_sec) 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 >= self.first_wave_sound_sec) and (self.stages["1stwavesnd"] == nil) then
				print_dbg("diff_sec>=%s | 1st wave sound", diff_sec)
				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 >= self.first_wave_sec) 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 >= self.second_wave_sound_sec) and (self.stages["2ndwavesnd"] == nil) then
				print_dbg("diff_sec>=%s | 2nd wave sound", diff_sec)
				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 >= self.second_wave_sec) 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 >= self.earthquakes1_fade_sec) 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 >= self.earthquakes2_fade_sec) 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 >= self.earthquakes3_fade_sec) 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 >= self.earthquakes4_fade_sec) 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 >= self.earthquakes5_fade_sec) 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 >= self.earthquakes1_fade_sec) and (diff_sec <= self.earthquakes5_fade_sec) 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, self.earthquakes1_fade_sec * 5, self.earthquakes5_fade_sec * 5, 1, 0))
			xr_sound.set_volume_sound_looped(
				AC_ID,
				"surge_earthquake_sound_looped",
				fade(diff_game_sec, self.earthquakes1_fade_sec * 5, self.earthquakes5_fade_sec * 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 >= self.earthquakes5_fade_sec) 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 >= self.end_message_sec) and (self.stages["endmessage"] == nil) then
			print_dbg("diff_sec>=%s | end message", diff_sec)
			--[[if (level) and (warn=="radio" or warn=="radio_siren") then
				if(level.name()=="zaton" and not utils_obj.npc_in_zone(db.actor,"zat_a2_sr_noweap")) then
					xr_sound.set_sound_play(AC_ID, "zat_a2_stalker_barmen_after_surge")
				elseif(level.name()=="jupiter"and not utils_obj.npc_in_zone(db.actor,"jup_a6_sr_noweap")) 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")
				end
			end]]
			--self.debugMessages[2]:SetText("end message at: "..tostring(diff_sec))
			self.stages["endmessage"] = true
		end

		-- after sound
		if (diff_sec >= self.after_sound_sec) 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 >= self.first_wave_sound_sec) and (diff_sec < self.earthquakes4_fade_sec) 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 >= self.first_wave_sound_sec) and (diff_sec <= self.first_wave_sec) and self.effector_set then
				self.hitFactor = fade(diff_sec, self.first_wave_sound_sec, self.first_wave_sec, 0.1, 1)
			end

			if (diff_sec >= self.first_wave_sec) and (diff_sec <= self.second_wave_sound_sec) and self.effector_set then
				self.hitFactor = fade(diff_sec, self.first_wave_sec, self.second_wave_sound_sec, 1, 0.3)
			end

			if (diff_sec >= self.second_wave_sound_sec) and (diff_sec <= self.second_wave_sec) and self.effector_set then
				self.hitFactor = fade(diff_sec, self.second_wave_sound_sec, self.second_wave_sec, 0.3, 1)
			end

			if (diff_sec >= self.second_wave_sec) and (diff_sec <= self.earthquakes1_fade_sec) and self.effector_set then
				self.hitFactor = fade(diff_sec, self.second_wave_sec, self.earthquakes1_fade_sec, 1, 0.3)
			end

			if (diff_sec >= self.earthquakes1_fade_sec) and (diff_sec <= self.earthquakes4_fade_sec) and self.effector_set then
				self.hitFactor = fade(diff_sec, self.earthquakes1_fade_sec, self.earthquakes4_fade_sec, 0.3, 0.001)
			end

			if (diff_sec >= self.earthquakes4_fade_sec) and self.effector_set then
				self.hitFactor = 0
				level.remove_pp_effector(surge_shock_pp_eff)
				self.effector_set = false
			end

			print_dbg("sec %s, hit factor %s", diff_sec, self.hitFactor)

			-- setting effector
			local PPEfactor
			local hitPower
			if not (GetEvent("current_safe_cover")) then
				PPEfactor = self.hitFactor
				hitPower = self.hitFactor / 30
				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 not level_environment.is_actor_immune() 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 -- Commenting that bit
						if 1 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 == "explode" then
						print_dbg("diff_sec>=%s | explode", diff_sec)
						self:kill_objects_at_pos(wave_pos.z, fate)
					end

					if (fate == "turn_to_zombie") and (self.zombie_at_first_wave or 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 not level_environment.is_actor_immune() 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 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
							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 = "red"
	elseif power >= 0.6 then
		indik = "orange"
	elseif power >= 0.4 then
		indik = "yellow"
	elseif power >= 0.1 then
		indik = "green"
	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:set_grace_threshold(npc)
	local id = npc:id()
	db.storage[id].surge_cover_grace_threshold_time = time_global()
end

function CSurgeManager:check_grace_threshold(npc)
	local id = npc:id()
	local gt = db.storage[id].surge_cover_grace_threshold_time or 0
	return ((time_global() - gt) < 1500)
end

function CSurgeManager:kill_objects_at_pos(surge_pos, fate, delay)
	-- if (level_environment.is_actor_immune()) 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
				and not (id == AC_ID and level_environment.is_actor_immune()) -- npc is actor and not immune
				and not surge_manager_ignore_npc.ignore_npc[npc:section()] -- not important npc (immune)
				and not self:pos_in_cover(npc_pos) -- not in cover
				and not self:check_grace_threshold(npc)
			then
				se_npc = sim:object(id)
				if se_npc then
					if fate == "turn_to_zombie" then
						squad_id = se_npc.group_id
						squad = squad_id and squad_id ~= 65535 and sim:object(squad_id)
						if not self:pos_in_cover(npc_pos) then -- if stalker is not inside
							print_dbg("kill_objects_at_pos | make npc zombie [%s]", se_npc:name())
							self:turn_to_zombie(se_npc, squad)
						else
							if self:pos_in_cover(npc_pos) then
								self:set_grace_threshold(npc)
								print_dbg("cant make npc zombie %s, in cover", se_npc:name())
							end
						end
					else
						if not self:pos_in_cover(npc_pos) then -- if stalker is not inside
							if fate == "explode" then
								print_dbg("kill_objects_at_pos | explode [%s]", se_npc:name())
								self:explode(se_npc)
							elseif fate == "kill_at_wave" or fate == "kill_at_end" then
								print_dbg("kill_objects_at_pos | kill npc [%s]", se_npc:name())
								if delay then
									CreateTimeEvent("delay_kill", id, math_random(1, 3), make_dead, id)
								else
									npc:kill(npc)
								end
							end
						else
							if self:pos_in_cover(npc_pos) then
								self:set_grace_threshold(npc)
								print_dbg("cant kill %s, in cover", se_npc:name())
							end
							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
				end
			else
				if not IsStalker(npc) then
					print_dbg("cant kill %s, must be stalker", npc:name())
				end
				if not npc:alive() then
					print_dbg("cant kill %s, must be alive", npc:name())
				end
				if not (comm ~= "monolith") then
					print_dbg("cant kill %s, is monolith (immune)", npc:name())
				end
				if not (comm ~= "zombied") then
					print_dbg("cant kill %s, is zombied (immune)", npc:name())
				end
				if not (not get_object_story_id(id)) then
					print_dbg("cant kill %s, is story npc", npc:name())
				end
				if not ((surge_pos == false) or (surge_pos and npc_pos.z > surge_pos)) then
					print_dbg(
						"cant kill %s, npc is behind emission wave, npc pos %s, wave pos %s",
						npc:name(),
						npc_pos.z,
						surge_pos
					)
				end
				if not not (id == AC_ID and level_environment.is_actor_immune()) then
					print_dbg("cant kill %s, npc is actor and immune", npc:id())
				end
				if not not surge_manager_ignore_npc.ignore_npc[npc:section()] then
					print_dbg("cant kill %s, is important, section %s", npc:name(), npc:section())
				end
				if npc_pos and self:pos_in_cover(npc_pos) then
					self:set_grace_threshold(npc)
					print_dbg(
						"cant kill npc [%s] | in_cover: %s",
						npc:name(),
						npc_pos and self:pos_in_cover(npc_pos, true)
					)
				end
			end
		end
	end
end

function CSurgeManager:kill_actor_at_pos(pos) -- kill player at end
	if level_environment.is_actor_immune() 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"
				and not level_environment.is_actor_immune()
			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 (level_environment.is_actor_immune()) 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"
			and not level_environment.is_actor_immune()
		then
			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 se_obj then return end
	-- 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

	local pos = se_obj.position
	local lvid = se_obj.m_level_vertex_id
	local gvid = se_obj.m_game_vertex_id

	if squad then
		squad:remove_npc(se_obj.id, true)
	else
		alife():release(se_obj)
	end

	alife_create(zombie_type, pos, lvid, gvid)
end

function CSurgeManager:explode(se_obj, squad)
	-- 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

	-- alife():release(se_obj)
	if not squad then
		alife():release(se_obj)
		return
	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