Rage/Divergent
Rage
/
Divergent
1
0
Fork 0
Code Issues Pull Requests Actions Releases Wiki Activity
Divergent/mods/Beefs NVGs - Improved/gamedata/scripts/item_device.script

1003 lines
27 KiB
Plaintext
Raw Permalink Blame History

--[[
Tronex
2019/12/7
Device binder
This script manage devices power consumption, by binding online devices to the device_binder below. Providing consistant check/management
Engine handles turning devices functionality off when their power go below a certain point (power_critical), while some are script conrtrolled
See "items\settings\devices.ltx" for configurations
--]]
local enable_debug = false
--------------------------------------------------------------------------------
-- Controls
--------------------------------------------------------------------------------
dev_consumption = {} -- [sec] = {...} | Power consumption of device per stage
dev_consumption_act = {} -- [sec] = {...} | Power consumption of device per action (stage 2)
dev_consumption_tot = {} -- [sec] = num | Total power consumption of a device
dev_critical = {} -- [sec] = num | Power limit, devices go off when their power go below this value
local dev_condition = {} -- [id] = con | Table to store/reload condition of online devices
local dev_event_loss = {} -- [id] = num | Table to trace power lost on device event activity
local dev_inv = {} -- [id] = bool | Table to trace devices in inventory
local dev_slot = {} -- [id] = bool | Table to trace devices in slots
local dev_type = {
["D_PDA"] = "PDA",
["DET_SIMP"] = "DET",
["DET_ADVA"] = "DET",
["DET_ELIT"] = "DET",
["DET_SCIE"] = "DET",
["D_DSMETR"] = "DET",
["D_CUSTOM"] = "DET",
["D_FLALIT"] = "FLASH",
["TORCH_S"] = "TORCH",
["II_ATTCH"] = "OTHR",
}
-- device sections
devices = {}
device_battery = nil
device_geiger = nil
device_npc_pda = {}
local amper_factor
-- Condition States
local c_limit
local c_zero
local c_full
local temp_con = {}
-- PDA
local pda_active = false
-- Torch
local torch_active = false
-- Night-visions
nv_state = false -- make nv_state a global variable so we can access it from beefs_nvgs
nv_discharged = false
local KEYBIND_NV_UP
local KEYBIND_NV_DOWN
local w_multi = 1024/(device().width)
local h_multi = 768/(device().height)
local nv_eff = {}
local nv_hud = { x = 0, y = 0, height = (device().height * h_multi), weight = (device().width * w_multi) } -- HUD dimensions/position
local ppe_effects = { -- PPE effects used for each NV. lum and id used for their ppe effects
["nightvision_1"] = { id = 3301, lum = 0.2 , ui = "wpn\\hud_nvg_gen1" },
["nightvision_2"] = { id = 3302, lum = 0.5 , ui = "wpn\\hud_nvg_gen2" },
["nightvision_3"] = { id = 3303, lum = 1.0 , ui = "wpn\\hud_nvg_gen3" },
--["nightvision_bluer"] = { id = 3304, lum = 1.0 , ui = "wpn\\hud_nvg_gen1_test" },
}
-- Dosimeter
local rad_unit = game.translate_string("st_msv")
local holding_shift = false
dosimeter_env_rads_mode = false
local rad_zones = {
["zone_field_radioactive"] = true,
["zone_field_radioactive_weak"] = true,
["zone_field_radioactive_average"] = true,
["zone_field_radioactive_strong"] = true,
["zone_radioactive"] = true,
["zone_radioactive_weak"] = true,
["zone_radioactive_average"] = true,
["zone_radioactive_strong"] = true,
}
function initialize()
local ini_device = ini_file("items\\settings\\devices.ltx")
device_battery = ini_device:r_sec_ex("settings","battery","batteries_dead")
device_geiger = ini_device:r_sec_ex("settings","geiger","detector_geiger")
-- We clear battery from devices list, and put it in its own category
_ITM["battery"] = {}
_ITM["battery"][device_battery] = true
if _ITM["device"][device_battery] then
_ITM["device"][device_battery] = nil
end
c_limit = ini_device:r_float_ex("settings","condition_limit") or 0.05
c_zero = ini_device:r_float_ex("settings","condition_zero") or 0.0001
c_full = ini_device:r_float_ex("settings","condition_full") or 0.9999
amper_factor = ini_device:r_float_ex("settings","amper_factor") or 1000
local n = ini_device:line_count("power_consumption")
for i=0,n-1 do
local result, sec, value = ini_device:r_line_ex("power_consumption",i,"","")
if ini_sys:section_exist(sec) and value then
dev_critical[sec] = ini_sys:r_float_ex(sec,"power_critical") or c_limit
dev_consumption[sec] = {}
local t = str_explode(value,",")
for j=1,#t do
local cons = tonumber(t[j]) or 0
if (t[j] == "p") or (cons > 0) then
dev_consumption[sec][j] = cons
dev_consumption_tot[sec] = dev_consumption_tot[sec] and (dev_consumption_tot[sec] + cons) or cons
print_dbg("dev_consumption [%s][%s] = %s", sec, j, cons)
end
end
dev_consumption_act[sec] = {}
local value_e = ini_device:r_string_ex("power_consumption_event",sec)
if value_e then
t = str_explode(value_e,",")
for j=1,#t do
local cons = tonumber(t[j]) or 0
if cons > 0 then
dev_consumption_act[sec][j] = cons
dev_consumption_tot[sec] = dev_consumption_tot[sec] and (dev_consumption_tot[sec] + cons) or cons
print_dbg("dev_consumption_act [%s][%s] = %s", sec, j, cons)
end
end
end
else
printe("!ERROR item_device | reading from items\\settings\\devices.ltx | section [%s] or power consumption values don't exist", sec)
end
end
n = ini_device:line_count("npc_pda")
for i=0,n-1 do
local result, sec, value = ini_device:r_line_ex("npc_pda",i,"","")
if ini_sys:section_exist(sec) then
device_npc_pda[sec] = true
end
end
end
function print_dbg(txt, ...)
if enable_debug then
printf("item_device | %s | " .. txt, time_global(), ...)
end
end
--------------------------------------------------------------------------------
-- Callbacks
--------------------------------------------------------------------------------
local function process_pda_info(npc,info_id)
-- add this function to bind_stalker info_callback function
-- battery.process_pda_infoportion(info_id)
local actor = db.actor
if actor then
if info_id == "ui_pda" then
-- PDA opened
-- set flag to indicate PDA is open
pda_active = true
hide_hud_inventory()
--news_manager.send_tip(actor, "Opening PDA", nil, nil, 5000)
actor:disable_info_portion("ui_pda_hide")
elseif info_id == "ui_pda_hide" then
-- PDA closed
-- remove flag to indicate PDA is closed
pda_active = false
--news_manager.send_tip(actor, "Closing PDA", nil, nil, 5000)
actor:disable_info_portion("ui_pda")
end
end
end
local function on_item_drag_dropped(obj_b, obj_d, slot_from, slot_to)
-- Check capability
if not (slot_from == EDDListType.iActorBag and (slot_to == EDDListType.iActorBag or slot_to == EDDListType.iActorSlot)) then
return
end
local sec_b = obj_b:section() -- battery
local sec_d = obj_d:section() -- device
if (sec_b == device_battery) and dev_consumption[sec_d] then
local con_b = obj_b:condition()
local con_d = obj_d:condition()
if (con_d > con_b) then
actor_menu.set_msg(1, game.translate_string("ui_st_battery_more_power"))
return
end
if (con_d > dev_critical[sec_d]) then
alife_create_item(device_battery, db.actor, {cond = con_d})
end
alife_release(obj_b)
obj_d:set_condition(con_b)
actor_effects.play_item_fx(device_battery)
utils_obj.play_sound("interface\\inv_batt")
end
end
local function on_key_hold(key)
if (key == DIK_keys["DIK_LSHIFT"]) then
holding_shift = true
end
end
local function on_key_release(key)
if (key == DIK_keys["DIK_LSHIFT"]) then
holding_shift = false
return
end
local bind = dik_to_bind(key)
-- Night-Vision
if (bind == key_bindings.kNIGHT_VISION) then
local torch = db.actor:item_in_slot(10)
set_nightvision(torch and torch:section(), not nv_state)
elseif (key == KEYBIND_NV_UP) then
z_beefs_nvgs.brightness_up()
elseif (key == KEYBIND_NV_DOWN) then
z_beefs_nvgs.brightness_down()
-- Dosimeter keybind
elseif (bind == key_bindings.kCUSTOM14) then
local obj_geiger = db.actor:object(device_geiger)
if obj_geiger and drain_device_on_event(obj_geiger, device_geiger, 2) then
if (holding_shift) then
dosimeter_env_rads_mode = not dosimeter_env_rads_mode
dosimeter_mode_string = dosimeter_env_rads_mode and game.translate_string("st_environment_rads") or game.translate_string("st_actor_rads")
actor_menu.set_msg(1, game.translate_string("st_dosimeter_mode")..": "..dosimeter_mode_string , 3)
return
end
local rads = dosimeter_env_rads_mode and math.floor(level.get_env_rads()*2500) or math.floor(db.actor.radiation*10000*0.387)
actor_menu.set_msg(1, tostring(rads) .. " " .. rad_unit , 2 )
utils_obj.play_sound("detectors\\geiger_1")
end
end
end
local function on_anomaly_touch(obj, flags)
if obj then
-- Don't play gieger sound if player don't have a geiger counter
if rad_zones[obj:section()] then
if game_difficulties.get_game_factor("notify_geiger") then
local obj_geiger = device_geiger and db.actor:object(device_geiger)
if not (obj_geiger and drain_device_on_event(obj_geiger, device_geiger, 1)) then
flags.ret_value = false
return
end
end
-- Anomaly detector
elseif (not game_difficulties.get_game_factor("notify_anomaly")) then
flags.ret_value = false
return
end
end
flags.ret_value = true
end
local function on_trade_opened()
local function search(temp , item)
if IsItem("device",item:section()) then
temp_con[item:id()] = item:condition()
item:set_condition(c_full)
end
end
db.actor:iterate_inventory(search,nil)
local pda = db.actor:item_in_slot(8)
if pda and (not temp_con[pda:id()]) then
temp_con[pda:id()] = pda:condition()
pda:set_condition(c_full)
end
local det = db.actor:item_in_slot(9)
if det and (not temp_con[det:id()]) then
temp_con[det:id()] = det:condition()
det:set_condition(c_full)
end
local torch = db.actor:item_in_slot(10)
if torch and (not temp_con[torch:id()]) then
temp_con[torch:id()] = torch:condition()
torch:set_condition(c_full)
end
end
local function on_trade_closed()
for k,v in pairs(temp_con) do
local obj = level.object_by_id(k)
if obj then
local p = obj:parent()
if (p and p:id() == AC_ID) then
alife_process_item(obj:section(),k, {cond = v})
end
end
end
temp_con = empty_table(temp_con)
end
local function item_rack(obj)
local sec = obj:section()
if dev_consumption[sec] then
local id = obj:id()
dev_inv[id] = true
dev_slot[id] = nil
print_dbg("[%s] moved to inv", obj:name())
end
end
local function item_slot(obj)
local sec = obj:section()
if dev_consumption[sec] then
local id = obj:id()
dev_inv[id] = nil
dev_slot[id] = true
print_dbg("[%s] moved to slot", obj:name())
end
end
local function item_out(obj)
local sec = obj:section()
if dev_consumption[sec] then
local id = obj:id()
-- Hack to turn off dropped NV device. TODO: adjust the device process function to overcome this hack
if dev_slot[id] and nv_state then
local cls = ini_sys:r_string_ex(sec,"class")
if (dev_type[cls] == "TORCH") then
set_nightvision(sec,false)
end
end
dev_inv[id] = nil
dev_slot[id] = nil
print_dbg("[%s] moved out", obj:name())
end
end
local function actor_on_first_update()
for i=1,13 do
local obj = db.actor:item_in_slot(i)
if obj and IsItem("device",obj:section()) then
item_slot(obj)
end
end
-- Restore torch state
local torch = db.actor:item_in_slot(10)
if torch and torch:torch_enabled() then
torch_active = torch:id()
end
end
local function se_device_on_unregister(se_obj, typ)
--local sec = se_obj:section_name()
--if ini_sys:r_string_ex(sec,"script_binding") == "item_device.bind" then
local id = se_obj.id
dev_condition[id] = nil
dev_inv[id] = nil
dev_slot[id] = nil
--end
end
local function save_state(mdata)
mdata.device_condition = dev_condition
end
local function load_state(mdata)
dev_condition = mdata.device_condition or {}
end
local function on_option_change()
KEYBIND_NV_UP = z_beefs_nvgs_mcm.get_config("keybind_nv_up")
KEYBIND_NV_DOWN = z_beefs_nvgs_mcm.get_config("keybind_nv_down")
end
function on_game_start()
if (USE_MARSHAL) then
RegisterScriptCallback("save_state",save_state)
RegisterScriptCallback("load_state",load_state)
end
RegisterScriptCallback("server_entity_on_unregister",se_device_on_unregister)
RegisterScriptCallback("actor_on_feeling_anomaly",on_anomaly_touch)
RegisterScriptCallback("on_key_press",on_key_press)
RegisterScriptCallback("on_key_release",on_key_release)
RegisterScriptCallback("on_key_hold",on_key_hold)
RegisterScriptCallback("ActorMenu_on_item_drag_drop",on_item_drag_dropped)
RegisterScriptCallback("actor_on_info_callback",process_pda_info)
RegisterScriptCallback("ActorMenu_on_trade_started",on_trade_opened)
RegisterScriptCallback("ActorMenu_on_trade_closed",on_trade_closed)
RegisterScriptCallback("actor_on_first_update",actor_on_first_update)
RegisterScriptCallback("actor_on_item_take",item_rack)
RegisterScriptCallback("actor_item_to_ruck",item_rack)
RegisterScriptCallback("actor_on_item_drop",item_out)
RegisterScriptCallback("actor_item_to_slot",item_slot)
RegisterScriptCallback("on_option_change", on_option_change)
on_option_change()
initialize()
end
--------------------------------------------------------------------------------
-- Item property
--------------------------------------------------------------------------------
function menu_battery(obj)
local p = obj:parent()
if not (p and p:id() == AC_ID) then return end
local sec = obj:section()
local con = obj:condition()
if (sec ~= device_battery) and dev_critical[sec] and (con > dev_critical[sec]) then
return game.translate_string("st_item_unpack_battery")
end
end
function func_battery(obj)
local p = obj:parent()
if not (p and p:id() == AC_ID) then
return
end
local sec = obj:section()
local con = obj:condition()
if ini_sys:section_exist(device_battery) then
alife_create_item(device_battery, db.actor, {cond = con})
alife_process_item(sec, obj:id(), {cond = c_zero})
-- Play effect
actor_effects.play_item_fx(device_battery)
utils_obj.play_sound("interface\\inv_batt")
end
end
--------------------------------------------------------------------------------
-- Utilities
--------------------------------------------------------------------------------
function drain_device_on_event(obj, sec, idx, custom_loss)
if (not obj) then
--callstack()
--printe("! bind device.drain_device_on_event | no object pass")
return
end
sec = sec or obj:section()
if (not dev_critical[sec]) then
return
end
-- Device goes off on critical power, no draining
local cond = obj:condition()
if cond < dev_critical[sec] then
return false
end
local loss = dev_consumption_act[sec] and dev_consumption_act[sec][idx] or 0
if custom_loss then
loss = custom_loss
end
local id = obj:id()
if dev_event_loss[id] then
dev_event_loss[id] = dev_event_loss[id] + loss
else
dev_event_loss[id] = loss
end
return true -- if drain happened
end
function drain_device(obj, sec, loss, loss_add)
if not (obj and loss and loss ~= 0) then
return
end
sec = sec or obj:section()
-- Device goes off on critical power, no draining
local cond = obj:condition()
if cond < dev_critical[sec] then
--print_dbg("[%s] power is too low: %s", obj:name(), cond)
return false
end
if loss_add then
loss = loss + loss_add
end
-- Set up new power
local factor = game_difficulties.get_eco_factor("battery_consumption")
loss = loss * factor
loss = loss / amper_factor
local cond_n = cond - loss
cond_n = clamp(cond_n, c_zero, c_full)
obj:set_condition(cond_n)
--print_dbg("[%s] | power loss: %s | remaining power: %s", obj:name(), loss, cond_n)
return true -- if drain happened
end
function can_toggle_torch()
return db.actor:item_in_slot(10) and true or false
end
function toggle_torch()
local torch = db.actor:item_in_slot(10)
local id = torch and torch:id()
if id then
if torch_active == id then
torch_active = false
else
torch_active = id
end
else
torch_active = false
end
end
function is_torch_active()
return torch_active
end
function set_nightvision_HUD(bShow)
local hud = get_hud()
local drk = hud:GetCustomStatic("nv_tunnel")
local wnd
if (bShow == false) or (db.actor:is_talking()) then
if (drk ~= nil) then
hud:RemoveCustomStatic("nv_tunnel")
drk = nil
end
return
end
if (drk == nil) then
hud:AddCustomStatic("nv_tunnel",true)
drk = hud:GetCustomStatic("nv_tunnel")
wnd = drk:wnd()
if (wnd ~= nil) then
wnd:SetWndPos(vector2():set(nv_hud.x , nv_hud.y))
wnd:SetWndSize(vector2():set(nv_hud.weight , nv_hud.height))
wnd:SetAutoDelete(true)
end
end
if (drk ~= nil) then
wnd = drk:wnd()
local torch = db.actor:item_in_slot(10)
local torch_sec = torch and torch:section()
if torch_sec then
nv_eff[torch_sec] = nv_eff[torch_sec] or ini_sys:r_string_ex(torch_sec,"nv_effect")
local ppe = ppe_effects[nv_eff[torch_sec]]
if ppe then
--wnd:InitTexture(ppe.ui)
end
end
end
end
function set_nightvision(section,state)
if (not section) then
return
end
nv_eff[section] = nv_eff[section] or ini_sys:r_string_ex(section,"nv_effect")
if ppe_effects[nv_eff[section]] then
if state and (not nv_state) then
local ppe = ppe_effects[nv_eff[section]]
level.add_pp_effector(nv_eff[section] .. ".ppe", ppe.id, true)
utils_obj.play_sound("interface\\inv_nv_start")
nv_state = true
game.set_nv_lumfactor(ppe.lum)
elseif (not state) and nv_state then
local ppe = ppe_effects[nv_eff[section]]
level.remove_pp_effector(ppe.id)
utils_obj.play_sound("interface\\inv_nv_off")
nv_state = false
game.set_nv_lumfactor(0)
end
set_nightvision_HUD(nv_state)
end
end
function is_nv_active()
return nv_state
end
function set_pda_glitch(obj, val)
if (not obj) then
return
end
local curr_val = obj:psy_factor()
obj:set_psy_factor( clamp( (curr_val + val), 0, 1 ) )
end
function is_pda_active()
return pda_active
end
function is_pda_charged(actor_only)
local pda = db.actor:item_in_slot(8)
if (not pda) then
return false
end
if actor_only and device_npc_pda[pda:section()] then
return false
end
return is_device_charged( pda )
end
function is_device_charged(obj, sec, cond)
sec = obj and obj:section() or sec
cond = obj and obj:condition() or cond
return sec and cond and dev_critical[sec] and cond > dev_critical[sec]
end
function get_power_critical(sec)
return dev_critical[sec]
end
function get_power_consumption(sec)
return dev_consumption[sec] and dev_consumption[sec][1]
end
function pda_warning()
--Return true if PDA is equipped and works
if (is_pda_charged() or is_pda_active()) then return true end
--Show not equipped or battery empty message
local obj = db.actor:item_in_slot(8)
if (obj) then
actor_menu.set_msg(1, game.translate_string("st_pda_no_power") , 3 )
else
actor_menu.set_msg(1, game.translate_string("st_pda_no_active") , 3 )
end
return false
end
--------------------------------------------------------------------------------
-- Class "device_binder"
--------------------------------------------------------------------------------
function bind(obj)
obj:bind_object(device_binder(obj))
end
class "device_binder" (object_binder)
function device_binder:__init(obj) super(obj)
self.first_update = nil
end
local nv_glitch_state = false
function device_binder:update(delta)
object_binder.update(self, delta)
local obj = self.object
local id = obj:id()
local sec = obj:section()
local parent = obj:parent()
if not self.first_update then
self.first_update = true
-- Process devices belongs to others
if parent and (parent:id() ~= AC_ID) then
-- Process devices belongs to stalkers
if IsStalker(parent) then
-- Set up profiles of spawned PDA
if device_npc_pda[sec] and (not se_load_var(id, obj:name(), "info")) then
ui_pda_npc_tab.register_pda(parent, sec, id)
end
--[[ if stalker is not a trader, set custom power
if utils_obj.is_trader(parent) then
local cond_set = (math.random(30,70)/100)
alife_process_item( sec , id , {cond = cond_set} )
end
--]]
end
end
-- set up stored power for device on first update
if dev_condition[id] then
obj:set_condition(dev_condition[id])
--print_dbg("[%s] power restored from save: %s", obj:name(), dev_condition[id])
end
return
end
-- store updated device power
local cond = obj:condition()
dev_condition[id] = cond
-- only process device power if it belongs to actor
if (parent and (parent:id() == AC_ID) and (self.type ~= false)) then
-- set type
if (self.type == nil) then
local cls = ini_sys:r_string_ex(sec,"class")
if dev_type[cls] then
self.type = dev_type[cls]
--print_dbg("[%s] type detected: %s", obj:name(), dev_type[cls])
else
self.type = false
--print_dbg("[%s] type not found", obj:name())
end
end
-- night-vision/light management
if (self.type == "TORCH") then
self:process_torch(id, sec, cond)
end
if dev_consumption[sec] and (cond > dev_critical[sec]) then
-- No need to process unequipped devices
if dev_slot[id] then
if (self.N_V) then
-- Emissions: the closer the wave, the higher the psi influnces
if GetEvent("surge", "state") then
local surge_time = GetEvent("surge", "time") or 0
local val_glitch = (surge_time > 168) and normalize(surge_time, 220, 168) or normalize(surge_time, 20, 168)
z_beefs_nvgs.nvg_glitch( clamp(val_glitch,0.0,0.9) )
nv_glitch_state = true
-- Psi-storms: huge spike when a vortex hits the ground
elseif GetEvent("psi_storm", "state") then
if GetEvent("psi_storm", "vortex") then
z_beefs_nvgs.nvg_glitch(0.9)
nv_glitch_state = true
else
z_beefs_nvgs.nvg_glitch(0.2)
nv_glitch_state = true
end
-- NVG doesn't get affected in normal cases
else
if nv_glitch_state then
z_beefs_nvgs.nvg_glitch(0.0)
nv_glitch_state = false
end
end
end
-- Light flicker on event for flashlights
if (self.type == "FLASH") then
self:process_flicker()
end
-- Glitch effect on event for PDA
if (self.type == "PDA") then
self:process_glitch(id, sec, cond)
end
end
-- drain device power if its active
self:process_power(id, sec, cond)
end
end
end
function device_binder:process_power(id, section, condition)
local power_loss = 0
local in_hand = false
for num, consumption in pairs(dev_consumption[section]) do
-- Device active in hand
if num == 1 then
local obj = db.actor:active_detector() or db.actor:active_item()
if obj and obj:id() == id then
power_loss = power_loss + consumption
in_hand = true
end
-- Device active in slot
elseif num == 2 and dev_slot[id] and (not in_hand) then
power_loss = power_loss + consumption
-- Device is emitting light
if dev_consumption_act[section] and (self.type == "TORCH") and self.object:torch_enabled() then
power_loss = power_loss + (dev_consumption_act[section][1] or 0)
end
-- Device has night vision active
if dev_consumption_act[section] and self.N_V and nv_state then
power_loss = power_loss + (dev_consumption_act[section][2] or 0)
end
-- Device active in inventory
elseif num == 3 and dev_inv[id] and (not in_hand) then
power_loss = power_loss + consumption
end
end
-- Power loss on event
if dev_event_loss[id] and (dev_event_loss[id] > 0) then
power_loss = power_loss + dev_event_loss[id]
dev_event_loss[id] = 0
end
-- Consume power
drain_device(self.object, section, power_loss)
end
function device_binder:process_torch(id, section, condition)
-- Night-Vision state management
if nv_state then
if dev_slot[id] then
self.N_V = true -- indicator for device having active NV
else
-- if NV device moved out of slot, turn NV off
if self.N_V then
set_nightvision(section,false)
end
self.N_V = nil
end
-- if NV device ran out of power, turn NV off
if (self.N_V and (condition <= dev_critical[section])) then
nv_discharged = true
set_nightvision(section,false)
self.N_V = nil
end
-- disable NV info if NV is off
elseif self.N_V and (not nv_state) then
set_nightvision(section,false)
self.N_V = nil
end
-- Torch state management
if torch_active == id then
if dev_slot[id] and (condition > dev_critical[section]) then
if (not self.object:torch_enabled()) then
self.object:enable_torch(true)
end
else
if (self.object:torch_enabled()) then
self.object:enable_torch(false)
end
torch_active = false
--actor_menu.set_notification(nil, "ui_inGame2_notify_low_battery", 10)
end
else
if (self.object:torch_enabled()) then
self.object:enable_torch(false)
end
end
-- Torch light flicker on event
if self.object:torch_enabled() then
self:process_flicker()
end
end
function device_binder:process_glitch(id, section, condition)
-- Emissions: the closer the wave, the higher the psi influnces
if GetEvent("surge", "state") then
local surge_time = GetEvent("surge", "time") or 0
local val_glitch = (surge_time > 168) and normalize(surge_time, 220, 168) or normalize(surge_time, 20, 168)
self.object:set_psy_factor( clamp(val_glitch,0,1) )
-- Psi-storms: huge spike when a vortex hits the ground
elseif GetEvent("psi_storm", "state") then
if GetEvent("psi_storm", "vortex") then
self.object:set_psy_factor(1)
else
self.object:set_psy_factor(0.2)
end
-- PDA doesn't get affected in normal cases
else
self.object:set_psy_factor(0)
end
end
function device_binder:process_flicker(force)
local flicker = level_environment.get_light_flicker()
if force then
flicker = force
end
if (self.flicker == nil) then
self.flicker = false
end
if (self.flicker ~= flicker) then
--print_dbg("[%s] flicker: %s", self.object:name(), flicker)
if flicker then
local ca = "light_flicker"
local on_off_chance = math.random(25,50)
local on_off_time = math.random(0.3,0.9)
local fps = math.random(20,30)
self.object:set_color_animator(ca,true,on_off_chance,on_off_time,fps)
--printf("~ Torch set anim")
else
--printf("~ Torch reset anim")
self.object:reset_color_animator()
end
end
self.flicker = flicker
end
function device_binder:reload(section)
object_binder.reload(self, section)
end
function device_binder:reinit()
object_binder.reinit(self)
end
function device_binder:net_spawn(se_abstract)
if not(object_binder.net_spawn(self, se_abstract)) then
return false
end
return true
end
function device_binder:net_destroy()
-- if NV device disappear, turn off NV. duh?
if self.N_V then
self.N_V = nil
set_nightvision(self.object:section(),false)
end
-- if working torch device disappear, clear id
if torch_active == self.object:id() then
torch_active = false
end
-- if light source is flickering, turn it off
if self.flicker then
self:process_flicker(false)
end
--print_dbg("[%s] destroyed: %s", self.object:name())
object_binder.net_destroy(self)
end
function device_binder:save(stpk)
end
function device_binder:load(stpk)
end
Reference in New Issue View Git Blame Copy Permalink